@spec assign(t(), Enumerable.t()) :: t()

Assigns a value or multiple values to the frame.

Examples

frame = Frame.assign(frame, :status, :active)
frame = Frame.assign(frame, %{status: :active, count: 5})
frame = Frame.assign(frame, status: :active, count: 5)

@spec assign_new(t(), key :: atom(), value_fun :: (-> term())) :: t()

Assigns a value to the frame only if the key doesn't already exist.

The value is computed lazily using the provided function.

Examples

frame = Frame.assign_new(frame, :timestamp, fn -> DateTime.utc_now() end)

@spec authenticated?(t()) :: boolean()

Returns true if the request carries validated OAuth 2.1 claims.

Examples

Frame.authenticated?(frame)
# => true

@spec authorization(t()) :: Anubis.Server.Context.auth_claims() | nil

Returns the OAuth 2.1 claims from the current request context, or nil if no authorization is configured or the transport is STDIO.

Examples

case Frame.authorization(frame) do
  nil -> # no auth configured
  claims -> claims.sub
end

@spec clear_components(t()) :: t()

Clears all runtime-registered components

@spec client_extension(t(), String.t()) :: map() | nil

Returns the settings the client declared for the extension id under capabilities.extensions, or nil when it did not declare that extension.

An empty map means the extension is supported with no settings.

Examples

case Frame.client_extension(frame, "io.modelcontextprotocol/ui") do
  %{"mimeTypes" => types} when is_list(types) -> "text/html;profile=mcp-app" in types
  _ -> false
end

@spec client_supports?(t(), String.t()) :: boolean()

Whether the client declared capability ("elicitation", "sampling", "roots", ...) for the current request.

@spec from_saved(map()) :: t()

Reconstructs Frame from a previously saved map.

Restored: assigns, pagination_limit, resource_subscriptions. Runtime-only fields (tools, resources, prompts, resource_templates) are initialized empty — their validator functions are not serializable. context is left as the default struct and will be set by Session before each callback invocation.

@spec get_components(t()) :: [server_component_t()]

Retrieves all runtime-registered components as a flat list

@spec has_all_scopes?(t(), [String.t()]) :: boolean()

Returns true if the bearer token grants all of the given scopes.

Examples

Frame.has_all_scopes?(frame, ["tools:read", "tools:write"])
# => true

@spec has_scope?(t(), String.t()) :: boolean()

Returns true if the bearer token grants the given scope.

Examples

Frame.has_scope?(frame, "tools:read")
# => true

@spec input_response(t(), String.t()) :: map() | nil

Returns the client's answer to the input request under key, or nil.

Examples

case Frame.input_response(frame, "confirm") do
  %{"action" => "accept", "content" => content} -> content
  _not_answered -> nil
end

@spec input_responses(t()) :: %{required(String.t()) => map()}

Returns the answers the client sent to an Anubis.Server.InputRequired, keyed as its input requests were. Empty when the request carries none.

@spec new(assigns :: map()) :: t()

Creates a new frame with optional initial assigns.

Examples

iex> Frame.new()
%Frame{assigns: %{}}

iex> Frame.new(%{user: "alice"})
%Frame{assigns: %{user: "alice"}}

@spec progress_token(t()) :: String.t() | integer() | nil

Returns the progressToken the client sent with the request being served, or nil when it asked for no progress.

Examples

if token = Frame.progress_token(frame) do
  Anubis.Server.send_progress(token, 50, total: 100)
end

@spec put_pagination_limit(t(), non_neg_integer()) :: t()

Sets the pagination limit for listing operations.

Examples

frame = Frame.put_pagination_limit(frame, 10)
frame.pagination_limit
# => 10

@spec register_prompt(t(), String.t(), [prompt_opt]) :: t()
when prompt_opt:
       {:description, String.t() | nil}
       | {:arguments, map() | nil}
       | {:title, String.t() | nil}
       | {:scopes, [String.t()]}

Registers a prompt definition at runtime.

@spec register_resource(t(), String.t(), [resource_opt]) :: t()
when resource_opt:
       {:title, String.t() | nil}
       | {:name, String.t() | nil}
       | {:description, String.t() | nil}
       | {:mime_type, String.t() | nil}
       | {:meta, map() | nil}
       | {:scopes, [String.t()]}

Registers a resource definition with a fixed URI.

For parameterized resources, use register_resource_template/3 instead.

@spec register_resource_template(t(), String.t(), [resource_template_opt]) :: t()
when resource_template_opt:
       {:title, String.t() | nil}
       | {:name, String.t()}
       | {:description, String.t() | nil}
       | {:mime_type, String.t() | nil}
       | {:meta, map() | nil}
       | {:scopes, [String.t()]}

Registers a resource template definition using a URI template (RFC 6570).

Examples

frame = Frame.register_resource_template(frame, "file:///{path}",
  name: "project_files",
  title: "Project Files",
  description: "Access files in the project directory"
)

@spec register_tool(t(), String.t(), [tool_opt]) :: t()
when tool_opt:
       {:description, String.t() | nil}
       | {:input_schema, map() | nil}
       | {:output_schema, map() | nil}
       | {:title, String.t() | nil}
       | {:annotations, map() | nil}
       | {:task_support, Anubis.Server.Component.Tool.task_support()}
       | {:scopes, [String.t()]}

Registers a tool definition at runtime.

@spec request_meta(t()) :: map()

Returns the _meta of the request being served, or an empty map.

@spec request_state(t()) :: term()

Returns the verified state a handler attached with Anubis.Server.InputRequired.state/2, or nil when the request carries none.

@spec resource_subscribed?(t(), uri :: String.t()) :: boolean()

Returns whether this session has an active subscription for the given URI.

@spec scopes(t()) :: [String.t()]

Returns the list of granted scopes from the bearer token.

Returns an empty list when no authorization is present.

Examples

Frame.scopes(frame)
# => ["tools:read", "tools:write"]

@spec subject(t()) :: String.t() | nil

Returns the sub (subject) claim from the bearer token, or nil.

Examples

Frame.subject(frame)
# => "user-id-123"

@spec subscribe_resource(t(), uri :: String.t()) :: t()

Records that this session has subscribed to updates for the given resource URI.

Idempotent — subscribing twice to the same URI is a no-op. Per the MCP spec, the URI does not need to refer to a currently-registered resource.

@spec to_saved(t()) :: map()

Serializes Frame for persistent storage.

Only assigns and pagination_limit are persisted. The following fields are runtime-only and excluded from serialization:

• tools — runtime-registered tool definitions (includes validator functions)
• resources — runtime-registered resource definitions
• prompts — runtime-registered prompt definitions
• resource_templates — runtime-registered resource template definitions
• context — rebuilt by Session before each callback invocation

Compile-time components (registered via the component macro) are always available from the server module and do not need persistence.

@spec unsubscribe_resource(t(), uri :: String.t()) :: t()

Removes a previously-recorded subscription for the given URI.