mcp

func AnnotatedReadOnlyConcurrencyPolicy ¶

func AnnotatedReadOnlyConcurrencyPolicy(_, _ string, annotations sdkmcp.ToolAnnotations, _ toolcontract.Invocation) (key string, concurrent bool)

AnnotatedReadOnlyConcurrencyPolicy opts explicitly read-only MCP tools into conflict-free concurrent execution. Missing, false, or contradictory annotations remain exclusive.

This is only scheduling advice: it neither authorizes a call nor bypasses a caller's approval policy. MCP annotations are untrusted hints, so callers should use this policy only for servers whose descriptors they are willing to trust for execution ordering.

func DiscoverTools ¶

func DiscoverTools(ctx context.Context, sources []ToolSource, config ToolDiscoveryConfig) ([]toolcontract.Tool, error)

DiscoverTools reads each live session's current catalog and projects every remote descriptor into a Scope tool. It does not cache or own the sessions.

package main

import (
	"context"
	"fmt"

	"github.com/Tangerg/scope/mcp"
)

func main() {
	tools, err := mcp.DiscoverTools(context.Background(), nil, mcp.ToolDiscoveryConfig{})
	if err != nil {
		panic(err)
	}

	fmt.Println(len(tools))
}

Output:
0

func Elicit ¶

func Elicit(ctx context.Context, params sdkmcp.ElicitParams) (*sdkmcp.ElicitResult, error)

Elicit asks the connected client to surface a structured prompt to the end user and returns their response. Useful when a tool needs runtime clarification it could not have asked for at schema-design time (auth confirmation, ambiguous filename, ...).

Returns ErrNoServerSession when called outside an MCP dispatch. Underlying RPC errors propagate as-is.

Example — structured response:

res, err := mcp.Elicit(ctx, sdkmcp.ElicitParams{
    Message: "Choose a deployment target",
    RequestedSchema: map[string]any{
        "type": "object",
        "properties": map[string]any{
            "env": map[string]any{
                "type": "string",
                "enum": []string{"staging", "prod"},
            },
        },
        "required": []string{"env"},
    },
})
if err != nil { return "", err }
if res.Action != "accept" { return "user canceled", nil }
env, _ := res.Content["env"].(string)

func PromptMessagesToChat ¶

func PromptMessagesToChat(messages []*sdkmcp.PromptMessage) ([]chat.Message, error)

PromptMessagesToChat converts MCP prompt messages into Core chat messages. Text, image, audio, resource-link, and embedded-resource content retain their semantic shape; malformed or unsupported content returns an error instead of disappearing from the prompt.

func Register ¶

func Register(server *sdkmcp.Server, tools ...toolcontract.Tool) error

Register installs every tool.Tool in tools onto server using the low-level [(*sdkmcp.Server).AddTool] API.

Registration is all-or-nothing: definitions are snapshotted, duplicate names within the batch are rejected, and every tool is built before any is added. A bad entry mid-list therefore never leaves the server half-registered, and handlers use the same identity the server advertised even when a Tool implementation is mutable. Structured details are handed to the SDK as raw JSON, preserving numeric precision and the distinction between explicit null and absent details.

The generic sdkmcp.AddTool[In, Out] form is deliberately avoided: tools already supply a hand-authored JSON schema, and the generic API would otherwise reflect over a Go In type and overwrite it.

func ReportProgress ¶

func ReportProgress(ctx context.Context, progress float64, total *float64, message string) error

ReportProgress sends a progress notification back to the client. progress should increase monotonically; total is optional and may be left nil when the work size is unknown. message is a free-form human-readable status string.

The originating client must have included a progressToken in its tools/call request — otherwise this helper returns nil without sending a notification (the spec mandates that servers only emit progress when explicitly opted in). Errors propagate from the underlying *sdkmcp.ServerSession.NotifyProgress.

Example:

func (t *longTool) Call(ctx context.Context, invocation tool.Invocation) (chat.ToolOutput, error) {
    for i := range 100 {
        // ... work ...
        _ = mcp.ReportProgress(ctx, float64(i+1), new(100.0),
            fmt.Sprintf("processed %d/100", i+1))
    }
    return "done", nil
}

func RequestMetaFromContext ¶

func RequestMetaFromContext(ctx context.Context) sdkmcp.Meta

RequestMetaFromContext returns a shallow copy of metadata stored by WithRequestMeta, or nil. The returned nested values must remain immutable. Its signature matches RequestMetaFunc:

config := mcp.ToolDiscoveryConfig{RequestMeta: mcp.RequestMetaFromContext}

func WithRequestMeta ¶

func WithRequestMeta(ctx context.Context, meta sdkmcp.Meta) context.Context

WithRequestMeta copies the top-level map so its keys may be reused or changed by the caller. Nested maps, slices, and other reference values remain shared; callers must keep them immutable while this context or its derived contexts may be read.