A client for MCP servers over Streamable HTTP or stdio, on both protocol eras.

{:ok, session} = Sake.Client.connect("https://mcp.example.com/mcp", headers: [{"authorization", "Bearer ..."}])
{:ok, tools, session} = Sake.Client.list_tools(session)
{:ok, result, session} = Sake.Client.call_tool(session, "search", %{"query" => "x"})

The client is functional: every call returns the updated session. Pass on_input: to answer elicitation requests, sampling: to answer sampling requests (fn params, session -> {:ok, result} | {:error, error} end), roots: to share roots (a list of %{"uri" => ..., "name" => ...} maps, or a function of the session that returns one), on_notification: (a function of a method and its params) to see the progress and log notifications of a call, log_level: (a level name such as "info") to have the server send log messages at or above it (see set_log_level/2), and auth: to have the client run the MCP authorization flow itself on a 401 (see Sake.Client.Auth); without it, a 401 comes back as {:error, {:unauthorized, %Sake.Auth.Challenge{}}}, or, when its challenge is RFC 9470's insufficient_user_authentication (the person must sign in more strongly or more recently), as {:error, {:insufficient_user_authentication, %Sake.Auth.Challenge{}}}.

On the modern protocol the client declares the tasks extension, so a server may answer a tool call with a task; call_tool/3 follows it to the end (task_timeout:, in ms, default five minutes), and call_tool_async/3 hands it back instead. tasks: false leaves the extension out.

max_response_size: (bytes, default 16 MiB) caps what the client reads of one HTTP response: a JSON body, or one Server-Sent Event still being received. A server that sends more ends the request with {:error, :response_too_large}.

ui: true declares MCP Apps (see Sake.UI), on both eras, for a client that renders them: the server then lists its app-only tools and UI resources, and each Sake.Tool.Spec from list_tools/1 carries the ui:// URI of its app in ui and who may call it in visibility.

{:stdio, command, args} in place of a URL launches the server as a subprocess and talks to it over its standard input and output:

{:ok, session} = Sake.Client.connect({:stdio, "npx", ["-y", "@modelcontextprotocol/server-everything"]})

Stdio options: env: (a map or list of name-value pairs; a nil value unsets the variable), cd:, stderr: (:inherit, the default, shares this VM's standard error; :ignore discards it), probe_timeout: (ms to wait for an answer to the modern probe before falling back to initialize, default 10 000), close_timeout: (ms close/1 waits for the server to exit before killing it, default 5 000).

Sake.Test connects the client to a server in the same VM, with the server itself as the transport, for the server's tests (see guides/testing.md).

With opentelemetry_api in the host, each request is a CLIENT span and carries the current trace context in its _meta, so the server's spans join the caller's trace; the span of call_tool/3 covers the whole call, its retries with the client's input and a task's polls included. Each request is also the telemetry span [:sake, :client, :request], with method, era, protocol_version and transport in the metadata and error_type (nil on success) on :stop. See guides/observability.md.