client

func (*Client) CallTool ¶

func (c *Client) CallTool(
	ctx context.Context,
	request mcp.CallToolRequest,
) (*mcp.CallToolResult, error)

CallTool invokes a tool on the server.

func (*Client) CancelTask ¶

func (c *Client) CancelTask(
	ctx context.Context,
	request mcp.CancelTaskRequest,
) (*mcp.CancelTaskResult, error)

CancelTask returns canceled task result

func (*Client) Close ¶

func (c *Client) Close() error

Close shuts down the client and closes the transport.

func (*Client) Complete ¶

func (c *Client) Complete(
	ctx context.Context,
	request mcp.CompleteRequest,
) (*mcp.CompleteResult, error)

Complete requests completion suggestions from the server.

func (*Client) Discover ¶

func (c *Client) Discover(ctx context.Context, request mcp.DiscoverRequest) (*mcp.DiscoverResult, error)

Discover asks the server which protocol versions it supports, what its capabilities are, and who it is, without performing the legacy initialize handshake (SEP-2575).

Servers implementing protocol version 2026-07-28 or later must support this method. Against an older server it fails, which is how Client.Initialize detects that it must fall back to the handshake.

func (*Client) GetClientCapabilities ¶

func (c *Client) GetClientCapabilities() mcp.ClientCapabilities

GetClientCapabilities returns the client capabilities.

func (*Client) GetPrompt ¶

func (c *Client) GetPrompt(
	ctx context.Context,
	request mcp.GetPromptRequest,
) (*mcp.GetPromptResult, error)

GetPrompt gets a prompt and renders it with the provided arguments.

func (*Client) GetServerCapabilities ¶

func (c *Client) GetServerCapabilities() mcp.ServerCapabilities

GetServerCapabilities returns the server capabilities.

func (*Client) GetSessionId ¶

func (c *Client) GetSessionId() string

GetSessionId returns the session ID of the transport. If the transport does not support sessions, it returns an empty string.

func (*Client) GetTask ¶

func (c *Client) GetTask(
	ctx context.Context,
	request mcp.GetTaskRequest,
) (*mcp.GetTaskResult, error)

GetTask returns task with current status

func (*Client) GetTransport ¶

func (c *Client) GetTransport() transport.Interface

GetTransport gives access to the underlying transport layer. Cast it to the specific transport type and obtain the other helper methods.

func (*Client) Initialize ¶

func (c *Client) Initialize(
	ctx context.Context,
	request mcp.InitializeRequest,
) (*mcp.InitializeResult, error)

Initialize establishes the connection with the server.

It must be called after Start, and before any request methods.

Protocol version 2026-07-28 removed the initialize handshake (SEP-2575), so this method first probes the server with server/discover. When the probe succeeds the connection is stateless and every subsequent request carries its own protocol metadata; the returned InitializeResult is rendered from the discovery response so that callers observe the same value in both eras.

When the probe fails without identifying a modern server, the server is taken to be legacy, and the classic initialize handshake is performed instead. A successful discovery or an UnsupportedProtocolVersionError with a supported list identifies a modern server; negotiation failures are returned to the caller rather than falling back to the legacy handshake.

func (*Client) IsInitialized ¶

func (c *Client) IsInitialized() bool

IsInitialized returns true if the client has been initialized.

func (*Client) IterPrompts ¶

func (c *Client) IterPrompts(
	ctx context.Context,
	request mcp.ListPromptsRequest,
) iter.Seq2[mcp.Prompt, error]

IterPrompts returns an iterator that lazily fetches pages of prompts from the server. Each iteration starts from the cursor in the original request. Pages are fetched on demand as the iterator is consumed; breaking out of the loop stops further requests.

If an error occurs while fetching a page, the iterator yields a single (zero-value, error) pair and then stops.

func (*Client) IterResourceTemplates ¶

func (c *Client) IterResourceTemplates(
	ctx context.Context,
	request mcp.ListResourceTemplatesRequest,
) iter.Seq2[mcp.ResourceTemplate, error]

IterResourceTemplates returns an iterator that lazily fetches pages of resource templates from the server. Each iteration starts from the cursor in the original request. Pages are fetched on demand as the iterator is consumed; breaking out of the loop stops further requests.

If an error occurs while fetching a page, the iterator yields a single (zero-value, error) pair and then stops.

func (*Client) IterResources ¶

func (c *Client) IterResources(
	ctx context.Context,
	request mcp.ListResourcesRequest,
) iter.Seq2[mcp.Resource, error]

IterResources returns an iterator that lazily fetches pages of resources from the server. Each iteration starts from the cursor in the original request. Pages are fetched on demand as the iterator is consumed; breaking out of the loop stops further requests.

If an error occurs while fetching a page, the iterator yields a single (zero-value, error) pair and then stops.

func (*Client) IterTools ¶

func (c *Client) IterTools(
	ctx context.Context,
	request mcp.ListToolsRequest,
) iter.Seq2[mcp.Tool, error]

IterTools returns an iterator that lazily fetches pages of tools from the server. Each iteration starts from the cursor in the original request. Pages are fetched on demand as the iterator is consumed; breaking out of the loop stops further requests.

If an error occurs while fetching a page, the iterator yields a single (zero-value, error) pair and then stops.

Example:

for tool, err := range client.IterTools(ctx, mcp.ListToolsRequest{}) {
    if err != nil {
        return err
    }
    fmt.Println(tool.Name)
}

func (*Client) ListPrompts ¶

func (c *Client) ListPrompts(
	ctx context.Context,
	request mcp.ListPromptsRequest,
) (*mcp.ListPromptsResult, error)

ListPrompts lists all prompts by following paginated responses.

func (*Client) ListPromptsByPage ¶

func (c *Client) ListPromptsByPage(
	ctx context.Context,
	request mcp.ListPromptsRequest,
) (*mcp.ListPromptsResult, error)

ListPromptsByPage manually lists prompts by page.

func (*Client) ListResourceTemplates ¶

func (c *Client) ListResourceTemplates(
	ctx context.Context,
	request mcp.ListResourceTemplatesRequest,
) (*mcp.ListResourceTemplatesResult, error)

ListResourceTemplates lists all resource templates by following paginated responses.

func (*Client) ListResourceTemplatesByPage ¶

func (c *Client) ListResourceTemplatesByPage(
	ctx context.Context,
	request mcp.ListResourceTemplatesRequest,
) (*mcp.ListResourceTemplatesResult, error)

ListResourceTemplatesByPage manually lists resource templates by page.

func (*Client) ListResources ¶

func (c *Client) ListResources(
	ctx context.Context,
	request mcp.ListResourcesRequest,
) (*mcp.ListResourcesResult, error)

ListResources lists all resources by following paginated responses.

func (*Client) ListResourcesByPage ¶

func (c *Client) ListResourcesByPage(
	ctx context.Context,
	request mcp.ListResourcesRequest,
) (*mcp.ListResourcesResult, error)

ListResourcesByPage manually list resources by page.

func (*Client) ListTasks ¶

func (c *Client) ListTasks(
	ctx context.Context,
	request mcp.ListTasksRequest,
) (*mcp.ListTasksResult, error)

ListTasks lists all tasks by following paginated responses.

func (*Client) ListTasksByPage ¶

func (c *Client) ListTasksByPage(
	ctx context.Context,
	request mcp.ListTasksRequest,
) (*mcp.ListTasksResult, error)

ListTasksByPage lists one page of tasks.

func (*Client) ListTools ¶

func (c *Client) ListTools(
	ctx context.Context,
	request mcp.ListToolsRequest,
) (*mcp.ListToolsResult, error)

ListTools lists all tools by following paginated responses.

func (*Client) ListToolsByPage ¶

func (c *Client) ListToolsByPage(
	ctx context.Context,
	request mcp.ListToolsRequest,
) (*mcp.ListToolsResult, error)

ListToolsByPage manually lists tools by page.

func (*Client) Listen ¶

func (c *Client) Listen(ctx context.Context, filter mcp.SubscriptionFilter) error

Listen opens a subscriptions/listen stream for the given notification types and blocks until the context is cancelled or the server closes the stream.

Notifications are delivered to the handlers registered with Client.OnNotification, exactly as they were on earlier protocol versions.

Listen is only available on connections using protocol version 2026-07-28 or later. On a legacy connection it returns an error: notifications arrive on the transport's own stream there, with no opt-in required.

func (*Client) ListenAsync ¶

func (c *Client) ListenAsync(
	ctx context.Context,
	filter mcp.SubscriptionFilter,
	onError func(error),
) (stop func(), err error)

ListenAsync opens a subscriptions/listen stream in the background and returns a function that closes it.

It is the convenient form of Client.Listen for callers that only want the notifications to start flowing. Errors from the stream are reported to onError, which may be nil.

func (*Client) OnConnectionLost ¶

func (c *Client) OnConnectionLost(handler func(error))

OnConnectionLost registers a handler function to be called when the connection is lost. This is useful for handling HTTP2 idle timeout disconnections that should not be treated as errors.

func (*Client) OnNotification ¶

func (c *Client) OnNotification(
	handler func(notification mcp.JSONRPCNotification),
)

OnNotification registers a handler function to be called when notifications are received. Multiple handlers can be registered and will be called in the order they were added. Handlers registered during dispatch receive subsequent notifications.

func (*Client) PendingSubscriptionFilter ¶

func (c *Client) PendingSubscriptionFilter() mcp.SubscriptionFilter

PendingSubscriptionFilter returns the filter that the next Client.Listen call would use, accumulated from Client.Subscribe calls.

func (*Client) ProtocolVersion ¶

func (c *Client) ProtocolVersion() string

ProtocolVersion returns the protocol version in effect for this client, or "" before the connection has been established.

func (*Client) ReadResource ¶

func (c *Client) ReadResource(
	ctx context.Context,
	request mcp.ReadResourceRequest,
) (*mcp.ReadResourceResult, error)

ReadResource reads the contents of a resource from the server.

func (*Client) RootListChanges ¶

func (c *Client) RootListChanges(
	ctx context.Context,
) error

RootListChanges sends a roots list-changed notification to the server.

func (*Client) Start ¶

func (c *Client) Start(ctx context.Context) error

Start initiates the connection to the server. Must be called before using the client.

func (*Client) TaskResult ¶

func (c *Client) TaskResult(
	ctx context.Context,
	request mcp.TaskResultRequest,
) (*mcp.TaskResultResult, error)

TaskResult returns finished task result

func (*Client) WaitForTask ¶

func (c *Client) WaitForTask(
	ctx context.Context,
	request mcp.GetTaskRequest,
	fallbackPollInterval time.Duration,
) (*mcp.GetTaskResult, error)

WaitForTask polls a task until it reaches a terminal state or the context is done. The server-provided poll interval takes precedence over fallbackPollInterval.