@try-works/dsh-tool-mode 0.0.0-stage → 0.5.45

package/lib/mcp/host-binding.js

@@ -0,0 +1,280 @@
+/**
+ * Binding the MCP surface to the real DSH tool registry (MCP-08, MCP-09, MCP-12).
+ *
+ * Two requirements shape this module, and both are about where data comes from
+ * rather than what it looks like:
+ *
+ * - **MCP-09**: DSH's model-facing `schemas()` projection INTENTIONALLY omits the
+ *   output schema, so an export built from it would publish a tool with no declared
+ *   result shape. The canonical schemas therefore come from the CONTRACTS, which is
+ *   the only place that has them; `schemas()` is never consulted for a schema.
+ * - **MCP-08**: invocation goes through the host's `execute` path with a
+ *   server-issued call identity and the caller's abort signal. Resolving a tool and
+ *   calling it directly would bypass the grant, the receipt and the result policy —
+ *   the three things the host path exists to apply — so this module is given an
+ *   executor rather than a registry to reach into.
+ *
+ * §16.4 defines the payload derivation precisely: an implementation returns the
+ * domain payload with the reserved root `meta` OMITTED, and the payload schema is
+ * the final tool schema with only that property and its required entry removed.
+ * Everything else is preserved, because a schema that quietly dropped more would
+ * under-declare the result.
+ *
+ * @module @try-works/dsh-tool-mode/mcp/host-binding
+ */
+import { Ajv } from 'ajv';
+import Ajv2020 from 'ajv/dist/2020.js';
+import { redactText } from "./../receipt.js";
+import { normalizeCachePolicy } from "./protocol.js";
+import { accountInvocation, classifyOutcome, PhaseTimer, } from "../invocation-accounting.js";
+/** The reserved root field the host authors, never the implementation. */
+const RESERVED_META = 'meta';
+/**
+ * Two JSON-Schema dialects are in play: the host's contracts are draft-07 while
+ * extension-declared output schemas may declare 2020-12 (laya does). Compiling a
+ * 2020-12 schema with the draft-07 compiler throws "no schema with key or ref", which
+ * turned three LISTED tools into permanent call failures. The dialect is read from the
+ * schema's own `$schema`, never guessed.
+ */
+const draft7 = new Ajv({ allErrors: true, strict: false, allowUnionTypes: true });
+const draft2020 = new Ajv2020({ allErrors: true, strict: false, allowUnionTypes: true });
+const payloadValidators = new Map();
+/** The compiler that speaks the schema's declared dialect. */
+function compilerFor(schema) {
+    const declared = schema?.$schema;
+    return typeof declared === 'string' && declared.includes('2020-12') ? draft2020 : draft7;
+}
+/**
+ * Derive the payload schema from a contract's final output schema (§16.4).
+ *
+ * Only the reserved `meta` property and its `required` entry are removed. The rest
+ * of the schema — including constraints on the remaining properties — is preserved
+ * verbatim, because removing anything else would advertise a looser result than the
+ * contract actually enforces.
+ * @param outputSchema - the contract's output schema, including `meta`.
+ * @returns the payload schema.
+ */
+export function derivePayloadSchema(outputSchema) {
+    const clone = structuredClone(outputSchema);
+    if (typeof clone.properties === 'object' && clone.properties !== null) {
+        delete clone.properties[RESERVED_META];
+    }
+    if (Array.isArray(clone.required)) {
+        clone.required = clone.required.filter(entry => entry !== RESERVED_META);
+    }
+    return clone;
+}
+/** Render Ajv errors as bounded, path-qualified text. */
+function renderValidationErrors(errors) {
+    return (errors ?? [])
+        .map(error => `${error.instancePath || '(root)'} ${error.message ?? 'is invalid'}`)
+        .slice(0, 8)
+        .join('; ');
+}
+/** Validator for the externally advertised payload schema. */
+function payloadValidator(contract) {
+    const payloadSchema = derivePayloadSchema(contract.outputSchema);
+    /**
+     * Cache by the SCHEMA, not by `contract.contract`: an extension-published tool's
+     * contract is synthesized by the host and has no contract id, so every extension
+     * shared the key `undefined` and the FIRST compiled validator validated later calls.
+     * That is the cross-tool leak where multimodal_embed was rejected against
+     * decision_choose's schema.
+     */
+    const key = JSON.stringify(payloadSchema);
+    const existing = payloadValidators.get(key);
+    if (existing !== undefined)
+        return existing;
+    const validate = compilerFor(payloadSchema).compile(payloadSchema);
+    payloadValidators.set(key, validate);
+    return validate;
+}
+/**
+ * Convert a host result into the MCP payload shape and validate it.
+ *
+ * Host-native results may include the reserved `meta` envelope because the DSH tool contract
+ * validates that full value. MCP §16.4 publishes the payload schema with `meta` removed, so the
+ * external value must be the same payload with only that reserved field omitted. A malformed host
+ * result is returned as a tool error rather than a success-shaped `structuredContent`.
+ */
+function payloadForMcp(contract, value) {
+    const payload = typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? Object.fromEntries(Object.entries(value).filter(([key]) => key !== RESERVED_META))
+        : value;
+    const validate = payloadValidator(contract);
+    if (!validate(payload)) {
+        return { ok: false, reason: `tool result violates the advertised MCP output schema: ${renderValidationErrors(validate.errors)}` };
+    }
+    return { ok: true, value: payload };
+}
+/**
+ * Build the MCP host surface over a DSH tool surface.
+ *
+ * @param options - the host surface and this server's identity.
+ * @returns the MCP host the dispatch layer consumes.
+ */
+export function createMcpHost(options) {
+    // P26-14: validate the configured policy before any request can read it. This keeps
+    // the private/0 default when unset and refuses a non-private scope / bad TTL.
+    const cachePolicy = normalizeCachePolicy(options.cachePolicy);
+    let counter = 0;
+    return {
+        serverInfo: options.serverInfo,
+        cachePolicy,
+        ...options.catalogFacts === undefined ? {} : { catalogFacts: options.catalogFacts },
+        listTools() {
+            const out = [];
+            for (const published of options.surface.published) {
+                // MCP-12: a tool that cannot be exported faithfully is withheld entirely,
+                // with its reason recorded. Exporting a partial tool would tell a client the
+                // tool exists and then fail in a way the client cannot interpret.
+                if (published.notExportableReason !== undefined) {
+                    options.onWithheld?.(published);
+                    continue;
+                }
+                out.push({
+                    name: published.toolName,
+                    description: published.contract.description,
+                    // Both schemas come from the CONTRACT. `schemas()` omits output, so using
+                    // it here would publish a tool with no declared result shape (MCP-09).
+                    inputSchema: published.contract.inputSchema,
+                    outputSchema: derivePayloadSchema(published.contract.outputSchema),
+                    // Nothing in this binding imports from another MCP server, so no tool is
+                    // a re-export (MCP-13).
+                    importedFromMcp: false,
+                });
+            }
+            return out;
+        },
+        /**
+         * Why a known tool is absent from the catalog, when the host recorded it.
+         *
+         * `callTool` already explains a withheld name when it is reached directly; the
+         * dispatcher needs the same fact BEFORE it can decide the name is unknown, or
+         * the protocol layer turns the explanation into a generic invalid-params error.
+         * Confidential tools are deliberately omitted: their existence must not leak.
+         */
+        withheldReason(name) {
+            if (options.confidentialTools?.includes(name) === true)
+                return undefined;
+            return options.surface.withheld?.get(name);
+        },
+        async callTool(name, args, signal, caller) {
+            if (options.confidentialTools?.includes(name) === true) {
+                return {
+                    structured: null,
+                    text: `"${name}" is blocked by the operator confidentiality policy (MCP-11)`,
+                    isError: true,
+                };
+            }
+            const definition = options.surface.published.find(tool => tool.toolName === name);
+            // A tool that is not EXPORTABLE must not be callable either. Looking only for
+            // its presence in `published` would let a client invoke by name exactly the
+            // tool the export deliberately withheld — defeating MCP-12 through the back
+            // door, since a client that guessed the name would get a partial result the
+            // export refused to promise.
+            if (definition === undefined || definition.notExportableReason !== undefined) {
+                // A name the host KNOWS but withheld explains itself; only a name it has
+                // never heard of may say "unknown tool" (slice 3).
+                const recorded = definition?.notExportableReason ?? options.surface.withheld?.get(name);
+                return {
+                    structured: null,
+                    text: recorded === undefined
+                        ? `unknown tool ${JSON.stringify(name)}`
+                        : `tool ${JSON.stringify(name)} is withheld: ${recorded}`,
+                    isError: true,
+                };
+            }
+            /**
+             * ACCOUNTING, wrapped around the dispatch (OBS-02).
+             *
+             * The timer measures the external call's own phases and the outcome is classified
+             * from what was OBSERVED, not assumed — a cancelled external call must not be
+             * recorded as a failure, so the abort state is read from the caller's own signal.
+             * The CALLER'S grant identity rides the record (SEC-04): identity only, never the
+             * payload, so the operator can tell which client called.
+             */
+            const callId = `mcp_${Date.now().toString(36)}_${(++counter).toString(36)}`;
+            const timer = new PhaseTimer();
+            timer.begin('inference');
+            let outcome;
+            try {
+                outcome = await options.surface.execute({
+                    name,
+                    arguments: args,
+                    signal,
+                    // Server-issued, monotonically increasing. A caller-supplied identity would
+                    // let a caller forge a receipt (BASE-05).
+                    callId,
+                    ...caller === undefined ? {} : { caller },
+                });
+            }
+            catch (error) {
+                options.onAccounted?.(accountInvocation({
+                    receiptId: callId,
+                    timings: timer.finish(),
+                    failureClass: classifyOutcome({ ok: false, aborted: signal.aborted }),
+                    reason: error instanceof Error ? redactText(error.message) : String(error),
+                    input: args,
+                    engineVersion: options.engineVersion ?? 'unknown',
+                    ...caller === undefined ? {} : { grantId: caller.grantId, clientId: caller.clientId },
+                }), name);
+                throw error;
+            }
+            // CORRELATION (the round-65 review's finding): the contract payload's
+            // reserved meta carries the NATIVE receipt id the host dispatch issued, so
+            // the external accounting joins the native ring by that id when the result
+            // carries one — the two rings are no longer unjoinable. A value without
+            // meta (a tool that predates the meta contract) falls back to the
+            // server-issued id.
+            const nativeReceiptId = (() => {
+                const meta = outcome.value?.meta;
+                return typeof meta?.receiptId === 'string' ? meta.receiptId : callId;
+            })();
+            options.onAccounted?.(accountInvocation({
+                receiptId: nativeReceiptId,
+                timings: timer.finish(),
+                failureClass: classifyOutcome({
+                    ok: outcome.isError !== true,
+                    aborted: signal.aborted,
+                    refused: outcome.isError === true,
+                }),
+                ...outcome.isError === true && outcome.message !== undefined ? { reason: redactText(outcome.message) } : {},
+                input: args,
+                // An error carries no result, so nothing crossed the boundary as output.
+                output: outcome.isError === true ? undefined : outcome.value,
+                engineVersion: options.engineVersion ?? 'unknown',
+                ...caller === undefined ? {} : { grantId: caller.grantId, clientId: caller.clientId },
+            }), name);
+            if (outcome.isError) {
+                return {
+                    structured: null,
+                    // Bounded by the dispatch layer when it becomes a tool-error result.
+                    text: outcome.message ?? 'the tool failed without reporting a reason',
+                    isError: true,
+                };
+            }
+            const payload = payloadForMcp(definition.contract, outcome.value ?? null);
+            if (!payload.ok) {
+                return { structured: null, text: payload.reason, isError: true };
+            }
+            return {
+                structured: payload.value,
+                text: renderBounded(payload.value),
+            };
+        },
+    };
+}
+/**
+ * Render a bounded, model-readable representation of a canonical value.
+ *
+ * Bounded because a result is copied into a model's context, and an unbounded
+ * rendering of a large value would consume it silently.
+ * @param value - the canonical value.
+ * @returns the text rendering.
+ */
+function renderBounded(value) {
+    const text = typeof value === 'string' ? value : JSON.stringify(value ?? null);
+    return text.length > 100_000 ? `${text.slice(0, 100_000)}…(truncated)` : text;
+}
+//# sourceMappingURL=host-binding.js.map

package/lib/mcp/http.d.ts

@@ -0,0 +1,180 @@
+/**
+ * The loopback HTTP transport (MCP-02, MCP-03, SEC-02, P26-05..P26-08, P26-15).
+ *
+ * `P26-15` is decisive about the shape of this: *"Plain unauthenticated loopback is
+ * not this product's default."* So the endpoint requires a credential, and because
+ * the OAuth 2.1 resource-server profile is NOT implemented, the credential is
+ * offered explicitly as **custom static-token authentication** and makes no OAuth
+ * conformance claim. The requirement permits that mode while forbidding the claim;
+ * implementing half of OAuth and calling it OAuth would be the failure it names.
+ *
+ * The handler is a pure function of a request description rather than a socket
+ * listener. Every security property here — the loopback check, Host and Origin
+ * validation, size limits, authentication — is then testable without binding a
+ * port, which matters because these are exactly the paths a socket-based test
+ * would leave to manual checking.
+ *
+ * @module @try-works/dsh-tool-mode/mcp/http
+ */
+import type { McpHost } from './server.ts';
+import { type LocalOAuthServer } from './oauth.ts';
+import { type RateLimitPolicy } from './rate-limit.ts';
+import { type ClientGrantConfig } from './client-grant.ts';
+/** How the endpoint authenticates. */
+export interface StaticTokenAuth {
+    /**
+     * The scheme this endpoint implements.
+     *
+     * Named `static-token` rather than `oauth` so nothing downstream can mistake it
+     * for the OAuth profile, and so a log or a status report that prints this value
+     * cannot imply a conformance that was never tested.
+     */
+    readonly scheme: 'static-token';
+    /** The accepted token, compared in constant time. */
+    readonly token: string;
+    /** The caller identity recorded for the grant, for receipts and audit. */
+    readonly clientId: string;
+    /**
+     * The durable credential store holding GENERATED static-token credentials (SEC-01).
+     *
+     * When present, a presented bearer token is also checked against the stored
+     * credentials (constant-time over the whole registry), and the matched client's
+     * OWN identity drives grants, receipts and rate limiting — never the configured
+     * primary `clientId`. Absent keeps the single-token behavior.
+     */
+    readonly registry?: import('./credential-store.ts').ClientCredentialStore;
+}
+/** The OAuth 2.1 resource-server scheme (P26-15). */
+export interface OAuthResourceServerAuth {
+    /**
+     * The scheme this endpoint implements: the local embedded authorization server
+     * issues HS256 credentials and this endpoint verifies them per RFC 6750, with
+     * audience and scope validation and per-client revocation.
+     */
+    readonly scheme: 'oauth-resource-server';
+    /** The embedded server: verifier, issuer and revocation registry. */
+    readonly server: LocalOAuthServer;
+    /** The scope a caller must hold to reach the MCP endpoint. */
+    readonly requiredScope?: readonly string[];
+}
+/** The union of supported authentication schemes. */
+export type HttpAuth = StaticTokenAuth | OAuthResourceServerAuth;
+/** Transport configuration. */
+export interface HttpTransportConfig {
+    /** Path the endpoint serves. */
+    readonly path: string;
+    /** Bind address; only a loopback address is admitted. */
+    readonly host: string;
+    /** Port. */
+    readonly port: number;
+    /** Maximum request body size in bytes (SEC-02). */
+    readonly maxBodyBytes: number;
+    /**
+     * Origins permitted to call from a browser.
+     *
+     * Empty by default, which refuses every browser origin. SEC-02 requires
+     * unapproved origins to be REJECTED, so an empty list is a working configuration
+     * rather than a missing one, and CORS is not used as authentication anywhere.
+     */
+    readonly allowedOrigins: readonly string[];
+    readonly auth: HttpAuth;
+    /**
+     * Per-client request rate limiting (AT-12).
+     *
+     * Absent means the DEFAULT policy applies — 60 requests per client per minute — so
+     * the transport is bounded by default rather than only when someone remembers to ask.
+     * A policy overrides the default; `false` disables limiting explicitly. The count is
+     * keyed on the AUTHENTICATED client identity (the static-token `clientId` or the OAuth
+     * subject), never on the socket address, and an unauthenticated request never moves a
+     * counter — counting auth failures would leak credential existence through 429 timing.
+     */
+    readonly rateLimit?: RateLimitPolicy | false;
+    /**
+     * Per-client external grants (SEC-04).
+     *
+     * After authentication, each client's grant is DERIVED here — from this
+     * configuration, the authenticated identity and the live published surface — and
+     * travels with the call as caller identity. Absent means the default: every client
+     * is granted exactly the live surface, recorded under its own `external:<clientId>`
+     * grant identity. A request body can never supply or extend a grant (BASE-05).
+     */
+    readonly grants?: ClientGrantConfig;
+}
+/** A conservative default: loopback, the illustrative port, a small body cap,
+ * and the default per-client rate limit (AT-12). */
+export declare const DEFAULT_HTTP_CONFIG: Omit<HttpTransportConfig, 'auth'>;
+/** One HTTP request, described rather than received. */
+export interface HttpRequestDescription {
+    readonly method: string;
+    /** The request path, without query. */
+    readonly path: string;
+    /** Lower-cased header names to values. */
+    readonly headers: Readonly<Record<string, string | undefined>>;
+    /** The raw body. */
+    readonly body: string;
+    /** The peer address, as the socket reports it. */
+    readonly remoteAddress: string;
+}
+/** One HTTP response. */
+export interface HttpResponseDescription {
+    readonly status: number;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body: string;
+}
+/** Whether an address is loopback. */
+export declare function isLoopback(address: string): boolean;
+/**
+ * Shared, guarded Fetch/stream core. The Node adapter's toNodeHandler is NOT
+ * used directly: its early 413 has a different wire envelope, it does not watch
+ * IncomingMessage.aborted, and its close/drain listeners are not removed.
+ * Use its official bounded Request conversion only AFTER our unchanged gate.
+ */
+export declare function createHttpStreamHandler(config: HttpTransportConfig, host: McpHost): (request: HttpRequestDescription, signal?: AbortSignal) => Promise<Response>;
+/** Finite, materializing test facade; production sockets use the stream core. */
+export declare function createHttpHandler(config: HttpTransportConfig, host: McpHost): (request: HttpRequestDescription) => Promise<HttpResponseDescription>;
+/**
+ * Whether this transport may claim OAuth conformance.
+ *
+ * The static-token scheme may not; the oauth-resource-server scheme may, because
+ * it verifies HS256 credentials, audience, expiry and scope against the embedded
+ * server and answers RFC 6750 challenges — a conformant subset, not an invention.
+ * The claim is per-DEPLOYMENT, which is what a status report needs: a host using
+ * static tokens must still report false.
+ * @param auth - the live auth configuration.
+ * @returns whether the live scheme may claim the OAuth 2.1 resource-server profile.
+ */
+export declare function claimsOAuthConformance(auth: HttpAuth): boolean;
+/**
+ * The authentication profile this transport reports.
+ *
+ * A machine-readable statement of what is actually implemented, so a client or an
+ * operator can tell custom authentication from the OAuth profile without reading
+ * the source.
+ * @param auth - the live auth configuration.
+ * @returns the auth profile description.
+ */
+export declare function authProfile(auth: HttpAuth): Record<string, unknown>;
+/** A bound endpoint. */
+export interface BoundEndpoint {
+    /** The address actually bound, which for port 0 is the one the OS chose. */
+    readonly host: string;
+    readonly port: number;
+    /** The full URL clients should use. */
+    readonly url: string;
+    /** Stop serving and release the port. */
+    close(): Promise<void>;
+}
+/**
+ * Bind the endpoint on loopback.
+ *
+ * The bind address is validated rather than trusted: a configuration naming a
+ * routable address is REFUSED at startup rather than silently exposing the endpoint,
+ * because a server that logs a warning and binds anyway is a server that is exposed.
+ * @param config - the transport configuration.
+ * @param host - the MCP surface.
+ * @param options - an optional pre-built server module, so a test can drive a fake.
+ * @returns the bound endpoint.
+ * @throws Error when the bind address is not loopback.
+ */
+export declare function startHttpServer(config: HttpTransportConfig, host: McpHost): Promise<BoundEndpoint>;
+//# sourceMappingURL=http.d.ts.map

package/lib/mcp/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/mcp/http.ts"],"names":[],"mappings":"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"}