@zeroroot-ai/gibson-mcp 0.1.0

package/dist/resources.d.ts

@@ -0,0 +1,63 @@
+import type { Gibson } from "./session.js";
+/**
+ * Ambient knowledge and session coordinates, as MCP resources.
+ *
+ * A host with a hook surface injects the ambient block itself: Claude Code
+ * reads it at SessionStart, the opencode plugin at `system.transform`. A
+ * host with no hook surface has nowhere to put it, so the same block is also
+ * an MCP resource the model can read and a prompt it can call. One lookup
+ * either way: the block is computed once per connection and cached, because
+ * it is prompt overhead on every session.
+ *
+ * `gibson://session` carries the live-mission coordinates a session-end hook
+ * needs to checkpoint the transcript (`PutSessionContext`). A hook runs as
+ * its own process and cannot reach this server, so it reads the same
+ * coordinates from the state file; the resource is for a host that can ask
+ * the server directly.
+ */
+export declare const AMBIENT_URI = "gibson://ambient";
+export declare const SESSION_URI = "gibson://session";
+export declare const DEFAULT_AMBIENT_QUERY = "memories, prior findings and security facts for this codebase";
+export interface ResourceContents {
+    uri: string;
+    mimeType: string;
+    text: string;
+}
+export interface ResourceDefinition {
+    uri: string;
+    name: string;
+    title: string;
+    description: string;
+    mimeType: string;
+    read(): Promise<ResourceContents>;
+}
+export interface PromptDefinition {
+    name: string;
+    title: string;
+    description: string;
+    arguments: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    get(args: Record<string, string>): Promise<{
+        description: string;
+        messages: {
+            role: "user";
+            content: {
+                type: "text";
+                text: string;
+            };
+        }[];
+    }>;
+}
+/** The session's ambient block, computed once and kept. */
+export interface AmbientSource {
+    block(query?: string): Promise<string>;
+}
+export declare function ambientSource(gibson: Gibson, env: NodeJS.ProcessEnv): AmbientSource;
+/** What a session-end hook needs to checkpoint a transcript. */
+export declare function sessionCoordinates(gibson: Gibson): Record<string, unknown>;
+export declare function resources(gibson: () => Gibson, ambient: AmbientSource): ResourceDefinition[];
+/** The ambient block as a prompt, for a host with no hook surface. */
+export declare function ambientPrompt(ambient: AmbientSource): PromptDefinition;

package/dist/resources.js

@@ -0,0 +1,98 @@
+import { z } from "zod";
+import { ambientBlock } from "./ambient.js";
+/**
+ * Ambient knowledge and session coordinates, as MCP resources.
+ *
+ * A host with a hook surface injects the ambient block itself: Claude Code
+ * reads it at SessionStart, the opencode plugin at `system.transform`. A
+ * host with no hook surface has nowhere to put it, so the same block is also
+ * an MCP resource the model can read and a prompt it can call. One lookup
+ * either way: the block is computed once per connection and cached, because
+ * it is prompt overhead on every session.
+ *
+ * `gibson://session` carries the live-mission coordinates a session-end hook
+ * needs to checkpoint the transcript (`PutSessionContext`). A hook runs as
+ * its own process and cannot reach this server, so it reads the same
+ * coordinates from the state file; the resource is for a host that can ask
+ * the server directly.
+ */
+export const AMBIENT_URI = "gibson://ambient";
+export const SESSION_URI = "gibson://session";
+export const DEFAULT_AMBIENT_QUERY = "memories, prior findings and security facts for this codebase";
+export function ambientSource(gibson, env) {
+    const defaultQuery = env.ZEROCOOL_AMBIENT_QUERY ?? DEFAULT_AMBIENT_QUERY;
+    let cached;
+    return {
+        block: (query) => {
+            const knowledge = gibson.knowledge;
+            if (!knowledge)
+                return Promise.resolve("");
+            // Only the default query is cached. A model that asks its own question
+            // wants an answer to that question, not the session's opening block.
+            if (query && query !== defaultQuery)
+                return ambientBlock(knowledge, query);
+            cached ??= ambientBlock(knowledge, defaultQuery);
+            return cached;
+        },
+    };
+}
+/** What a session-end hook needs to checkpoint a transcript. */
+export function sessionCoordinates(gibson) {
+    return {
+        source: gibson.source,
+        posture: gibson.mode,
+        agent_name: gibson.agentName,
+        ...(gibson.settings.platformURL ? { platform_url: gibson.settings.platformURL } : {}),
+        ...(gibson.settings.tenant ? { tenant: gibson.settings.tenant } : {}),
+        ...(gibson.settings.targetId ? { target_id: gibson.settings.targetId } : {}),
+        ...(gibson.live
+            ? {
+                mission_id: gibson.live.missionId,
+                work_id: gibson.live.workId,
+                callback_endpoint: gibson.live.harness.endpoint,
+                callback_insecure: gibson.settings.callbackInsecure,
+            }
+            : {}),
+        ...(gibson.runId ? { run_id: gibson.runId } : {}),
+    };
+}
+export function resources(gibson, ambient) {
+    return [
+        {
+            uri: AMBIENT_URI,
+            name: "gibson_ambient",
+            title: "Gibson ambient knowledge",
+            description: "One GraphRAG lookup for this session: the memories, prior findings and security facts the " +
+                "tenant already holds about this codebase. Read it once at the start of a session. Empty " +
+                "when the session has no platform.",
+            mimeType: "text/markdown",
+            read: async () => ({ uri: AMBIENT_URI, mimeType: "text/markdown", text: await ambient.block() }),
+        },
+        {
+            uri: SESSION_URI,
+            name: "gibson_session",
+            title: "Gibson session coordinates",
+            description: "How this session is connected: the check-in source, the posture, and the mission, run and " +
+                "callback endpoint a session-end hook needs to checkpoint the transcript.",
+            mimeType: "application/json",
+            read: async () => ({ uri: SESSION_URI, mimeType: "application/json", text: `${JSON.stringify(sessionCoordinates(gibson()), null, 2)}\n` }),
+        },
+    ];
+}
+/** The ambient block as a prompt, for a host with no hook surface. */
+export function ambientPrompt(ambient) {
+    return {
+        name: "gibson_ambient",
+        title: "Gibson prior context",
+        description: "Load what this tenant's Gibson graph already knows about this codebase. Use it at the start of a session, or with a question of your own.",
+        arguments: [{ name: "query", description: "What to look for. Defaults to the session's opening lookup.", required: false }],
+        get: async (args) => {
+            const query = z.string().optional().parse(args.query);
+            const block = await ambient.block(query);
+            return {
+                description: "Prior context from the Gibson knowledge graph",
+                messages: [{ role: "user", content: { type: "text", text: block || "The Gibson knowledge graph holds nothing for this codebase yet." } }],
+            };
+        },
+    };
+}

package/dist/rpc.d.ts

@@ -0,0 +1,80 @@
+import { type DescMethod, type DescService } from "@bufbuild/protobuf";
+import { type Transport } from "@connectrpc/connect";
+import type { TaskHarness } from "@zeroroot-ai/sdk";
+import type { ToolDefinition } from "./registry.js";
+/**
+ * One MCP tool per RPC of every service the SDK produces (gibson#1706,
+ * decision 2). No curated subset and no hand-written list: the table comes
+ * from the descriptors, so an SDK bump moves the tool set.
+ *
+ * Naming is `<service>_<method>` in snake case, e.g.
+ * `harness_callback_service_world_view`. The service prefix is what keeps
+ * these apart from the helper tools, which are named after the helper
+ * (`world_view`, `remember`, `submit_finding`).
+ */
+/** Where an RPC is reached. */
+export interface RpcChannels {
+    /**
+     * The component's own transport, from the check-in. Absent in a dispatched
+     * run, which holds only a task grant.
+     */
+    session?: Transport;
+    /** The task-scoped callback harness. Absent in the component posture. */
+    task?: TaskHarness;
+}
+/** The fully-qualified name of the context message every callback RPC carries. */
+export declare const CONTEXT_INFO = "gibson.harness.v1.ContextInfo";
+/**
+ * `LLMCompleteWithTools` -> `llm_complete_with_tools`. An acronym run stays
+ * one word, so `LLMComplete` is not `l_l_m_complete`.
+ */
+export declare function snake(name: string): string;
+export declare function toolNameFor(service: DescService, method: DescMethod): string;
+/**
+ * Which transport an RPC rides.
+ *
+ * A `gibson.harness.v1` RPC is a callback: it belongs on the task harness,
+ * under the grant of the dispatch it serves. Everything else is the daemon's
+ * own surface and rides the component transport. Either one may be absent,
+ * so each falls back to the other rather than losing the tool: a dispatched
+ * run has no component transport, and the callback endpoint is the same
+ * daemon.
+ */
+export declare function transportFor(service: DescService, channels: RpcChannels): Transport | undefined;
+export interface RpcToolOptions {
+    channels: RpcChannels;
+    /** Messages a server-streaming RPC returns before it truncates. */
+    streamLimit: number;
+}
+/**
+ * Build every RPC tool that has a transport to ride.
+ *
+ * A posture with neither transport (standalone) gets none: an RPC tool with
+ * no daemon behind it would answer every call with a dial error, which reads
+ * to a model like a broken platform rather than an unconnected session.
+ */
+export declare function rpcTools(opts: RpcToolOptions): ToolDefinition[];
+/** An empty request message, for a test that needs one. */
+export declare function emptyRequest(method: DescMethod): unknown;
+/** What the generated table says about one service. */
+export interface ServiceDoc {
+    service: DescService;
+    methods: {
+        method: string;
+        description: string;
+    }[];
+}
+/** What a drift comparison found. Empty on both sides means no drift. */
+export interface Drift {
+    /** RPCs the descriptors have and the table does not. */
+    missing: string[];
+    /** Entries the table has and the descriptors do not. */
+    extra: string[];
+}
+/**
+ * Compare a generated table against the descriptors it claims to describe.
+ *
+ * The guard and its test both call this, so what CI enforces and what the
+ * test proves are one function rather than two spellings of one intention.
+ */
+export declare function driftBetween(table: ServiceDoc[]): Drift;

package/dist/rpc.js

@@ -0,0 +1,184 @@
+import { create, fromJson, toJson } from "@bufbuild/protobuf";
+import { createClient } from "@connectrpc/connect";
+import { GENERATED_SERVICES } from "./generated/tools.js";
+import { requestSchema } from "./schema.js";
+import { failure, json } from "./tools/result.js";
+/** The fully-qualified name of the context message every callback RPC carries. */
+export const CONTEXT_INFO = "gibson.harness.v1.ContextInfo";
+/** The proto package whose services are served on the callback endpoint. */
+const CALLBACK_PACKAGE = "gibson.harness.v1.";
+/**
+ * `LLMCompleteWithTools` -> `llm_complete_with_tools`. An acronym run stays
+ * one word, so `LLMComplete` is not `l_l_m_complete`.
+ */
+export function snake(name) {
+    return name
+        .replace(/([A-Za-z0-9])([A-Z][a-z])/g, "$1_$2")
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .toLowerCase();
+}
+export function toolNameFor(service, method) {
+    return `${snake(service.name)}_${snake(method.name)}`;
+}
+/**
+ * Which transport an RPC rides.
+ *
+ * A `gibson.harness.v1` RPC is a callback: it belongs on the task harness,
+ * under the grant of the dispatch it serves. Everything else is the daemon's
+ * own surface and rides the component transport. Either one may be absent,
+ * so each falls back to the other rather than losing the tool: a dispatched
+ * run has no component transport, and the callback endpoint is the same
+ * daemon.
+ */
+export function transportFor(service, channels) {
+    const callback = service.typeName.startsWith(CALLBACK_PACKAGE);
+    const preferred = callback ? channels.task?.transport : channels.session;
+    return preferred ?? (callback ? channels.session : channels.task?.transport);
+}
+/** The `context` field a callback request carries, when it has one. */
+function contextField(input) {
+    const field = input.fields.find((f) => f.fieldKind === "message" && f.message.typeName === CONTEXT_INFO);
+    return field?.jsonName;
+}
+function describe(service, method, comment, streamLimit) {
+    const head = `${service.name}.${method.name}`;
+    const body = comment || `No comment in the proto for this RPC of ${service.typeName}.`;
+    const tail = method.methodKind === "server_streaming"
+        ? ` Server-streaming: returns up to ${streamLimit} messages as a JSON array, with truncated: true when the limit was reached.`
+        : method.methodKind === "client_streaming" || method.methodKind === "bidi_streaming"
+            ? " Takes an array of request messages in `requests`."
+            : "";
+    return `${head}: ${body}${tail}`;
+}
+/** The input schema, which for a streaming-request RPC wraps the messages in an array. */
+function inputSchemaFor(method) {
+    const body = requestSchema(method.input);
+    if (method.methodKind === "client_streaming" || method.methodKind === "bidi_streaming") {
+        return {
+            type: "object",
+            properties: { requests: { type: "array", items: body, description: `Request messages of type ${method.input.typeName}.` } },
+            required: ["requests"],
+        };
+    }
+    return body;
+}
+async function collect(stream, output, limit) {
+    const messages = [];
+    for await (const message of stream) {
+        if (messages.length >= limit)
+            return { messages, truncated: true };
+        messages.push(toJson(output, message));
+    }
+    return { messages, truncated: false };
+}
+/**
+ * Build every RPC tool that has a transport to ride.
+ *
+ * A posture with neither transport (standalone) gets none: an RPC tool with
+ * no daemon behind it would answer every call with a dial error, which reads
+ * to a model like a broken platform rather than an unconnected session.
+ */
+export function rpcTools(opts) {
+    const out = [];
+    for (const entry of GENERATED_SERVICES) {
+        const service = entry.service;
+        const transport = transportFor(service, opts.channels);
+        if (!transport)
+            continue;
+        const comments = new Map(entry.methods.map((m) => [m.method, m.description]));
+        // The descriptor is the source of truth for what exists; the generated
+        // table only supplies the prose. A method the table has not seen still
+        // becomes a tool, and the drift test is what says the table is stale.
+        const client = createClient(service, transport);
+        for (const method of service.methods) {
+            out.push(rpcTool(service, method, client, comments.get(method.localName) ?? "", opts));
+        }
+    }
+    return out;
+}
+function rpcTool(service, method, client, comment, opts) {
+    const contextKey = contextField(method.input);
+    const streaming = method.methodKind === "client_streaming" || method.methodKind === "bidi_streaming";
+    return {
+        name: toolNameFor(service, method),
+        description: describe(service, method, comment, opts.streamLimit),
+        inputSchema: inputSchemaFor(method),
+        handler: async (args, ctx) => decode(service, method, client, contextKey, streaming, args, ctx, opts),
+    };
+}
+async function decode(service, method, client, contextKey, streaming, args, ctx, opts) {
+    const fill = (raw) => {
+        // Every callback RPC resolves the harness from ContextInfo and refuses a
+        // request without one. The grant already names the mission and the task,
+        // so the server fills it when the caller left it out; a caller that sets
+        // it keeps what it wrote.
+        if (!contextKey || raw[contextKey] || !opts.channels.task)
+            return raw;
+        return { ...raw, [contextKey]: { ...opts.channels.task.context } };
+    };
+    let messages;
+    try {
+        if (streaming) {
+            const list = args.requests;
+            if (!Array.isArray(list))
+                return failure(`${method.name} needs requests`, "This RPC takes a stream of requests. Pass them as an array in `requests`.");
+            messages = list.map((raw) => fromJson(method.input, fill(raw)));
+        }
+        else {
+            messages = [fromJson(method.input, fill(args))];
+        }
+    }
+    catch (e) {
+        return failure(`${method.name}: invalid request`, `${e.message}\n\nThe request must be canonical protojson for ${method.input.typeName}.`);
+    }
+    const call = client[method.localName];
+    if (!call)
+        return failure(`${method.name} is unavailable`, `The generated client for ${service.typeName} has no ${method.localName}.`);
+    const options = { signal: ctx.signal };
+    if (method.methodKind === "unary") {
+        const res = await call(messages[0], options);
+        return json(toJson(method.output, res));
+    }
+    if (method.methodKind === "server_streaming") {
+        const { messages: out, truncated } = await collect(call(messages[0], options), method.output, opts.streamLimit);
+        return json({ messages: out, truncated });
+    }
+    // Client-streaming and bidi both take the requests as an async iterable.
+    const source = (async function* () {
+        for (const m of messages)
+            yield m;
+    })();
+    if (method.methodKind === "client_streaming") {
+        const res = await call(source, options);
+        return json(toJson(method.output, res));
+    }
+    const { messages: out, truncated } = await collect(call(source, options), method.output, opts.streamLimit);
+    return json({ messages: out, truncated });
+}
+/** An empty request message, for a test that needs one. */
+export function emptyRequest(method) {
+    return create(method.input);
+}
+/**
+ * Compare a generated table against the descriptors it claims to describe.
+ *
+ * The guard and its test both call this, so what CI enforces and what the
+ * test proves are one function rather than two spellings of one intention.
+ */
+export function driftBetween(table) {
+    const missing = [];
+    const extra = [];
+    for (const entry of table) {
+        const declared = new Set(entry.methods.map((m) => m.method));
+        const real = new Set(entry.service.methods.map((m) => m.localName));
+        for (const name of real) {
+            if (!declared.has(name))
+                missing.push(`${entry.service.typeName}.${name}`);
+        }
+        for (const name of declared) {
+            if (!real.has(name))
+                extra.push(`${entry.service.typeName}.${name}`);
+        }
+    }
+    return { missing: missing.sort(), extra: extra.sort() };
+}

package/dist/schema.d.ts

@@ -0,0 +1,31 @@
+import { ScalarType, type DescEnum, type DescMessage } from "@bufbuild/protobuf";
+import type { JsonSchema } from "./registry.js";
+/**
+ * A JSON Schema for a proto request message, walked from its descriptor.
+ *
+ * The schema describes canonical protojson, because that is what the tool
+ * decodes with `fromJson`: camelCase keys, 64-bit integers as decimal
+ * strings, bytes as base64, enums as their value names, timestamps as
+ * RFC3339. `fromJson` also accepts the proto field name and a bare number
+ * for an enum, so a model that writes either still succeeds; the schema
+ * names one spelling so the model has one to copy.
+ *
+ * The walk is bounded. A message that reaches {@link MAX_DEPTH} or that
+ * appears twice on the path becomes a bare object with its proto type named
+ * in the description. Without a bound, a self-referential message (a graph
+ * node, a mission definition) has no finite schema, and the daemon's larger
+ * request types would each produce hundreds of kilobytes that every
+ * `tools/list` then carries.
+ */
+export declare const MAX_DEPTH = 5;
+export declare function scalarSchema(t: ScalarType): Record<string, unknown>;
+export declare function enumSchema(e: DescEnum): Record<string, unknown>;
+export declare function messageSchema(desc: DescMessage, path?: string[]): Record<string, unknown>;
+/**
+ * The tool input schema for a request message.
+ *
+ * `additionalProperties` stays open at the top level: `fromJson` runs with
+ * `ignoreUnknownFields` off, so a wrong key is refused with the server's own
+ * wording rather than by a schema check that says less.
+ */
+export declare function requestSchema(desc: DescMessage): JsonSchema;

package/dist/schema.js

@@ -0,0 +1,143 @@
+import { ScalarType } from "@bufbuild/protobuf";
+/**
+ * A JSON Schema for a proto request message, walked from its descriptor.
+ *
+ * The schema describes canonical protojson, because that is what the tool
+ * decodes with `fromJson`: camelCase keys, 64-bit integers as decimal
+ * strings, bytes as base64, enums as their value names, timestamps as
+ * RFC3339. `fromJson` also accepts the proto field name and a bare number
+ * for an enum, so a model that writes either still succeeds; the schema
+ * names one spelling so the model has one to copy.
+ *
+ * The walk is bounded. A message that reaches {@link MAX_DEPTH} or that
+ * appears twice on the path becomes a bare object with its proto type named
+ * in the description. Without a bound, a self-referential message (a graph
+ * node, a mission definition) has no finite schema, and the daemon's larger
+ * request types would each produce hundreds of kilobytes that every
+ * `tools/list` then carries.
+ */
+export const MAX_DEPTH = 5;
+/** Proto types with a JSON form of their own, which no field walk can describe. */
+const WELL_KNOWN = {
+    "google.protobuf.Timestamp": { type: "string", format: "date-time", description: "RFC 3339 timestamp, e.g. 2026-09-01T12:00:00Z." },
+    "google.protobuf.Duration": { type: "string", description: 'Seconds with up to nine fractional digits, ending in "s", e.g. "1.5s".' },
+    "google.protobuf.Struct": { type: "object", description: "Free-form JSON object." },
+    "google.protobuf.Value": { description: "Any JSON value." },
+    "google.protobuf.ListValue": { type: "array", description: "Any JSON array." },
+    "google.protobuf.Any": { type: "object", description: 'A packed message: {"@type": "type.googleapis.com/<proto type>", ...fields}.' },
+    "google.protobuf.FieldMask": { type: "string", description: "Comma-separated field paths." },
+    "google.protobuf.Empty": { type: "object", description: "No fields." },
+    "google.protobuf.BoolValue": { type: "boolean" },
+    "google.protobuf.StringValue": { type: "string" },
+    "google.protobuf.BytesValue": { type: "string", contentEncoding: "base64" },
+    "google.protobuf.DoubleValue": { type: "number" },
+    "google.protobuf.FloatValue": { type: "number" },
+    "google.protobuf.Int32Value": { type: "integer" },
+    "google.protobuf.UInt32Value": { type: "integer" },
+    "google.protobuf.Int64Value": { type: "string", description: "64-bit integer as a decimal string." },
+    "google.protobuf.UInt64Value": { type: "string", description: "64-bit integer as a decimal string." },
+    // A TypedValue is a oneof over eight kinds, and the daemon carries them in
+    // free-form maps. Any JSON value is the honest description.
+    "gibson.common.v1.TypedValue": { description: "Any JSON value: string, number, boolean, null, array or object." },
+};
+export function scalarSchema(t) {
+    switch (t) {
+        case ScalarType.DOUBLE:
+        case ScalarType.FLOAT:
+            return { type: "number" };
+        case ScalarType.INT32:
+        case ScalarType.UINT32:
+        case ScalarType.SINT32:
+        case ScalarType.FIXED32:
+        case ScalarType.SFIXED32:
+            return { type: "integer" };
+        case ScalarType.INT64:
+        case ScalarType.UINT64:
+        case ScalarType.SINT64:
+        case ScalarType.FIXED64:
+        case ScalarType.SFIXED64:
+            return { type: "string", description: "64-bit integer as a decimal string. A JSON number is also accepted." };
+        case ScalarType.BOOL:
+            return { type: "boolean" };
+        case ScalarType.STRING:
+            return { type: "string" };
+        case ScalarType.BYTES:
+            return { type: "string", contentEncoding: "base64", description: "Base64-encoded bytes." };
+        default:
+            return {};
+    }
+}
+export function enumSchema(e) {
+    return {
+        type: "string",
+        enum: e.values.map((v) => v.name),
+        description: `One of ${e.typeName}. The number is also accepted.`,
+    };
+}
+function singular(field, path) {
+    switch (field.fieldKind) {
+        case "scalar":
+            return scalarSchema(field.scalar);
+        case "enum":
+            return enumSchema(field.enum);
+        case "message":
+            return messageSchema(field.message, path);
+        default:
+            return {};
+    }
+}
+function fieldSchema(field, path) {
+    switch (field.fieldKind) {
+        case "list": {
+            const items = field.listKind === "scalar"
+                ? scalarSchema(field.scalar)
+                : field.listKind === "enum"
+                    ? enumSchema(field.enum)
+                    : messageSchema(field.message, path);
+            return { type: "array", items };
+        }
+        case "map": {
+            const values = field.mapKind === "scalar"
+                ? scalarSchema(field.scalar)
+                : field.mapKind === "enum"
+                    ? enumSchema(field.enum)
+                    : messageSchema(field.message, path);
+            // protojson writes every map key as a string, whatever the proto key type.
+            return { type: "object", additionalProperties: values };
+        }
+        default:
+            return singular(field, path);
+    }
+}
+export function messageSchema(desc, path = []) {
+    const known = WELL_KNOWN[desc.typeName];
+    if (known)
+        return { ...known };
+    if (path.includes(desc.typeName)) {
+        return { type: "object", description: `${desc.typeName}, which contains itself. Pass its protojson form.` };
+    }
+    if (path.length >= MAX_DEPTH) {
+        return { type: "object", description: `${desc.typeName}, nested past depth ${MAX_DEPTH}. Pass its protojson form.` };
+    }
+    const next = [...path, desc.typeName];
+    const properties = {};
+    for (const field of desc.fields) {
+        const schema = fieldSchema(field, next);
+        const oneof = field.oneof ? `One of the ${field.oneof.name} group; set at most one of them.` : "";
+        const existing = typeof schema.description === "string" ? schema.description : "";
+        const description = [existing, oneof].filter(Boolean).join(" ");
+        properties[field.jsonName] = description ? { ...schema, description } : schema;
+    }
+    return { type: "object", properties, additionalProperties: false };
+}
+/**
+ * The tool input schema for a request message.
+ *
+ * `additionalProperties` stays open at the top level: `fromJson` runs with
+ * `ignoreUnknownFields` off, so a wrong key is refused with the server's own
+ * wording rather than by a schema check that says less.
+ */
+export function requestSchema(desc) {
+    const body = messageSchema(desc);
+    return { ...body, type: "object" };
+}

package/dist/server.d.ts

@@ -0,0 +1,22 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { ToolRegistry } from "./registry.js";
+import type { PromptDefinition, ResourceDefinition } from "./resources.js";
+/** The package version, read from package.json beside dist. */
+export declare function packageVersion(): string;
+export declare const SERVER_NAME = "gibson";
+export interface ServerBinding {
+    registry: ToolRegistry;
+    /** Text the host shows the model once, at initialize. */
+    instructions?: string;
+    /** Readable resources: the ambient block and the session coordinates. */
+    resources?: ResourceDefinition[];
+    /** Prompts, for a host with no hook surface to inject the ambient block. */
+    prompts?: PromptDefinition[];
+}
+/**
+ * Bind one MCP protocol server to a transport. Every server reads the same
+ * registry: the stdio path has one, the HTTP path has one per session. A
+ * registry change reaches each attached server as `tools/list_changed`.
+ */
+export declare function attachServer(binding: ServerBinding, transport: Transport): Promise<Server>;