agentfootprint 10.2.0 → 10.3.1

package/dist/types/lib/traceToolNames.d.ts

@@ -0,0 +1,38 @@
+/**
+ * traceToolNames — the two facts about the trace toolpack that are needed
+ * BEFORE the pack is loaded.
+ *
+ * `.selfExplain()` mounts the pack lazily (9.94.0): the toolpack module —
+ * eleven tools over a finished trace, the largest single module on the
+ * library's default graph — is reached through `import()` the first time
+ * the self-explain skill is active on an iteration, never at build time and
+ * never for an agent that did not enable it (see `selfExplain.ts` ·
+ * `buildSelfExplainToolProvider`). Two things the builder needs cannot wait
+ * for that load, and they live here so that reading them costs nothing:
+ *
+ *   - `TRACE_TOOL_NAMES` — the names the pack can mount, which `build()`
+ *     reserves synchronously (a consumer tool sharing a name would silently
+ *     shadow the trace tool);
+ *   - `NO_COMPLETED_RUN_MESSAGE` — the model-visible answer every trace tool
+ *     gives before a turn has finished, which the delegate-mode `explain_run`
+ *     tool returns without loading the pack at all.
+ *
+ * `traceToolpack.ts` re-exports `TRACE_TOOL_NAMES` and `lazyToolpack.ts`
+ * re-exports `NO_COMPLETED_RUN_MESSAGE`, so every existing import path still
+ * resolves — this module only changes what a static import of them COSTS.
+ */
+/**
+ * The tool names this pack can mount. The Agent builder reserves these at
+ * `.selfExplain()` build time — the tools slot dedupes by name with
+ * first-occurrence-wins, so a consumer tool sharing a name would silently
+ * shadow the trace tool AND the skill body would instruct the model into
+ * the wrong one. Exported so the reservation list is DERIVED from the pack
+ * rather than typed out beside it (a second list is a list that drifts).
+ *
+ * The pack itself asserts, at test time, that what it mounts is exactly
+ * this list (test/trace-toolpack/selfExplainAgent.test.ts).
+ */
+export declare const TRACE_TOOL_NAMES: readonly ["run_overview", "find_context_errors", "find_in_trace", "trace_node", "trace_slice", "backtrack", "who_wrote", "get_value", "inspect_tool_call", "inspect_tool_run", "inspect_subflow", "read_narrative"];
+/** Model-visible answer when no completed run is available yet. */
+export declare const NO_COMPLETED_RUN_MESSAGE: string;
+//# sourceMappingURL=traceToolNames.d.ts.map

package/dist/types/lib/traceToolNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceToolNames.d.ts","sourceRoot":"","sources":["../../../src/lib/traceToolNames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,qNAanB,CAAC;AAEX,mEAAmE;AACnE,eAAO,MAAM,wBAAwB,QAEa,CAAC"}

package/dist/types/locales/timeAsk.d.ts

@@ -2,7 +2,7 @@
  * locales/timeAsk — the time ask's sentences, for the PERSON answering it
  * (time design § 6.2, TQ7).
  *
- * The library validates a time field's answer (`core/time/ask.ts` ·
+ * The library validates a time field's answer (`time/ask.ts` ·
  * `checkTimeAnswer`), so a refused answer needs a reason — and the reason is a
  * sentence a person reads on the re-ask (`InputRefusal.reason`), never text
  * for the model. It lives here, as data, so an app can translate or reword
@@ -25,7 +25,7 @@
  * Only a check the app armed can produce one of these: a field with a
  * `format`, or the choices of a reading under `.time()`.
  */
-import type { TimeAskMessages } from '../core/time/ask.js';
+import type { TimeAskMessages } from '../time/ask.js';
 /** The time ask's English sentences — one per `TIME_ASK_MESSAGE_KEYS` key. */
 export declare const defaultTimeAskMessages: TimeAskMessages;
 //# sourceMappingURL=timeAsk.d.ts.map

package/dist/types/locales/timeAsk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timeAsk.d.ts","sourceRoot":"","sources":["../../../src/locales/timeAsk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,8EAA8E;AAC9E,eAAO,MAAM,sBAAsB,EAAE,eAwBnC,CAAC"}
+{"version":3,"file":"timeAsk.d.ts","sourceRoot":"","sources":["../../../src/locales/timeAsk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEtD,8EAA8E;AAC9E,eAAO,MAAM,sBAAsB,EAAE,eAwBnC,CAAC"}

package/dist/types/mcp/connectionRefusals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectionRefusals.d.ts","sourceRoot":"","sources":["../../../src/mcp/connectionRefusals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAKzE;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,gBAAgB,GAAG,oBAAoB,EAC7C,IAAI,EAAE,MAAM,GACX,IAAI,CA6BN"}

package/dist/types/mcp/elicitation.d.ts

@@ -0,0 +1,85 @@
+/**
+ * mcp/elicitation — a typed ask carried as an MCP elicitation, and the
+ * elicitation's answer carried back (time design § 6.1).
+ *
+ * Pattern: Adapter, pure, both directions in one file so they cannot drift.
+ *          `elicitationOf` maps a pending `AwaitingInput` onto the MCP
+ *          elicitation request (`message` + a flat `requestedSchema` of
+ *          primitive properties, the MCP specification revision of
+ *          2025-06-18); `answerFromElicitation` maps the client's `content`
+ *          back to the `InputResponse` `agent.resume` takes. Nothing is
+ *          checked here that the resume door checks: the answer goes through
+ *          `tools/inputRequest.ts` · `applyInputResponse` like any other, and a
+ *          refused time answer comes back as a re-ask to elicit again.
+ * Role:    mcp (the transport). Reads `tools/inputRequest.ts` types only.
+ * Emits:   N/A.
+ *
+ * ## The mapping
+ *
+ * MCP's elicitation schema holds strings (with a `format` of `date-time`
+ * among a few), numbers, booleans and string choices (`enum` + `enumNames`).
+ * It has no range, so a time field becomes the properties a person can fill:
+ *
+ * | Field | Properties |
+ * |-------|------------|
+ * | `string` / `number` / `boolean` | `<id>`, as typed; a string's `enum` with its `labels` as `enumNames` |
+ * | `format: 'instant'` | `<id>`: `{ type: 'string', format: 'date-time' }` |
+ * | `format: 'zone'` | `<id>`: a string |
+ * | `format: 'time-range'` | `<id>.from` and `<id>.to`: two `date-time` strings, joined back as `from/to` |
+ * | a `format` field with choices | `<id>`: the choices, labelled; unless `strict`, ALSO the free-entry properties above (`<id>.other` for an instant or a zone) — answer one or the other |
+ *
+ * Only the fields still open are asked (a supplied value is known). A
+ * property is `required` only when it is the one way to answer a missing
+ * field. A number or boolean with `enum` has no MCP spelling and is refused,
+ * never widened; so is a field id that collides with a generated name.
+ *
+ * @example
+ * ```ts
+ * const out = await agent.run({ message });
+ * if (isInputPause(out)) {
+ *   const request = elicitationOf(out.awaitingInput);
+ *   const reply = await mcpClientSession.elicit(request); // { action: 'accept', content }
+ *   if (reply.action === 'accept')
+ *     await agent.resume(out.checkpoint, answerFromElicitation(out.awaitingInput, reply.content));
+ * }
+ * ```
+ */
+import { type AwaitingInput, type InputResponse } from '../tools/inputRequest.js';
+/** One primitive property of an elicitation's `requestedSchema`. */
+export type ElicitationProperty = {
+    readonly type: 'string';
+    readonly description?: string;
+    readonly format?: 'date-time';
+    readonly enum?: readonly string[];
+    readonly enumNames?: readonly string[];
+} | {
+    readonly type: 'number';
+    readonly description?: string;
+} | {
+    readonly type: 'boolean';
+    readonly description?: string;
+};
+/** The MCP `elicitation/create` request's params. */
+export interface ElicitationRequest {
+    readonly message: string;
+    readonly requestedSchema: {
+        readonly type: 'object';
+        readonly properties: Readonly<Record<string, ElicitationProperty>>;
+        readonly required?: readonly string[];
+    };
+}
+/**
+ * The MCP elicitation for a pending typed ask: its question (after the
+ * refusal's reason, on a re-ask) and one property per way to answer each open
+ * field. Throws `InputRequestError` on a field MCP cannot carry.
+ */
+export declare function elicitationOf(awaiting: AwaitingInput): ElicitationRequest;
+/**
+ * The `InputResponse` an accepted elicitation's `content` names — each open
+ * field's value, a time range's two properties joined as `from/to`. Throws
+ * `InputRequestError` on a property the elicitation did not ask, on a choice
+ * AND a free entry for one field, and on half a range. The values are judged
+ * by `agent.resume`, as any answer is.
+ */
+export declare function answerFromElicitation(awaiting: AwaitingInput, content: unknown): InputResponse;
+//# sourceMappingURL=elicitation.d.ts.map

package/dist/types/mcp/elicitation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elicitation.d.ts","sourceRoot":"","sources":["../../../src/mcp/elicitation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH,OAAO,EAEL,KAAK,aAAa,EAElB,KAAK,aAAa,EAEnB,MAAM,0BAA0B,CAAC;AAElC,oEAAoE;AACpE,MAAM,MAAM,mBAAmB,GAC3B;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1D;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhE,qDAAqD;AACrD,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,eAAe,EAAE;QACxB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;QACxB,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC;QACnE,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;KACvC,CAAC;CACH;AAoDD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,aAAa,GAAG,kBAAkB,CAkCzE;AAQD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,OAAO,GAAG,aAAa,CAwC9F"}

package/dist/types/mcp/gatewayTransport.d.ts

@@ -0,0 +1,156 @@
+/**
+ * gatewayTransport — an MCP transport whose auth headers are vended per
+ * request, not per connection.
+ *
+ *   const gateway = await mcpClient({
+ *     name: 'gateway',
+ *     transport: gatewayTransport({ url, credentials, service: 'gateway' }),
+ *   });
+ *
+ * ── Why this exists ──────────────────────────────────────────────────────────
+ * The `http` transport takes headers once and reuses them for the life of the
+ * connection. That is right for a static API key and wrong for anything with an
+ * expiry: a standing agent outlives its bearer token, and the failure mode is a
+ * burst of 401s an hour into a session that worked perfectly when you tested
+ * it. Managed gateways — AgentCore's among them — hand out exactly that kind of
+ * token, so "get a fresh one before each request" is not an optimisation, it is
+ * the only way the connection stays up.
+ *
+ * Nothing here is vendor-specific. It is the {@link CredentialProvider} port on
+ * one side and Streamable HTTP on the other; who vends is your choice.
+ *
+ * ── The secrecy invariant, and how it is kept ────────────────────────────────
+ * **A vended token is used once and dropped.** It is not cached between
+ * requests, not stored on the transport object, not put in an event payload,
+ * not written to a log, and not included in any error this module throws —
+ * including the errors it throws WHILE holding one. A test asserts that: a
+ * hostile logger subscribed to everything the library can say never sees the
+ * header value.
+ *
+ * That is why the vend happens inside `fetch` rather than at construction. A
+ * token resolved at construction has to live somewhere for the connection to
+ * use it later, and "somewhere" is what leaks.
+ *
+ * Pattern: Adapter + Decorator over `fetch`. Role: Layer-3 tool integration.
+ */
+import { type CredentialProvider } from '../identity/types.js';
+import type { McpGatewayTransport } from './types.js';
+/** Options for {@link gatewayTransport}. */
+export interface GatewayTransportOptions {
+    /** The MCP endpoint URL. */
+    readonly url: string;
+    /** Who vends the token — any `CredentialProvider`. */
+    readonly credentials: CredentialProvider;
+    /**
+     * The downstream service id the provider understands. Default `'gateway'`.
+     * `staticTokens({ gateway: '...' })` and `agentCoreIdentity()` both key on it.
+     */
+    readonly service?: string;
+    /** OAuth scopes to request, when the provider uses them. */
+    readonly scopes?: readonly string[];
+    /** `machine` (2-legged, the default) or `user` (3-legged, on behalf of a user). */
+    readonly mode?: 'machine' | 'user';
+    /**
+     * Extra headers sent alongside the vended ones. Applied FIRST, so a vended
+     * auth header always wins. **Put no secrets here** — these are held for the
+     * life of the transport, which is what the vended ones exist to avoid.
+     */
+    readonly headers?: Readonly<Record<string, string>>;
+    /**
+     * Your own `fetch`, called UNDERNEATH the per-request vending (9.32.0).
+     *
+     * ── The gap this closes ──────────────────────────────────────────────────
+     * Some gateways do not authenticate with a bearer alone. A managed identity
+     * path may want a client certificate (mTLS) or a proof-of-possession
+     * signature over the request itself (DPoP) — things computed FROM the
+     * request, which no header fixed at construction can express. Until this
+     * existed the only workaround was to abandon this transport for the generic
+     * `http` one, which has a `fetch` seam and fixes its headers at connect
+     * time — so a caller traded away token rotation to get a client certificate.
+     * That is a bad trade, and it was the shape an independent field trial
+     * reported (2026-08-13): *"exposes bearer-credential, header and scope
+     * options, but no certificate, DPoP or custom-fetch seam."*
+     *
+     * ── The composition, and its order ───────────────────────────────────────
+     * The credential is vended FIRST and applied to the request; your function is
+     * then called with that request. So a signer sees the final headers and has
+     * the last word over the bytes, exactly as it does on the `http` transport —
+     * and the vending still happens on every request, so rotation is not lost.
+     *
+     * **Zero vendor code lives here.** This library ships no signer, no
+     * certificate loader and no DPoP implementation; a scheme this repo has never
+     * heard of works on the day you write it. Whatever you do inside is between
+     * you and the server.
+     *
+     * ── What the secrecy invariant still guarantees ──────────────────────────
+     * Your function sees the request it is asked to send, headers included —
+     * which is what makes signing possible and is the whole point of the seam.
+     * What is still true is everything this module controls: the vended value is
+     * never cached, never stored on the transport, and never enters an event, an
+     * error or a log. A `fetch` you inject that logs its own headers is
+     * publishing your credential, and that is your decision to make in your code
+     * rather than something this library can do behind you.
+     *
+     * @example  mTLS, through an agent you own
+     *   gatewayTransport({
+     *     url, credentials, service: 'gateway',
+     *     fetch: (input, init) => fetch(input, { ...init, dispatcher: mtlsAgent }),
+     *   })
+     *
+     * @example  Proof-of-possession over the request
+     *   gatewayTransport({
+     *     url, credentials,
+     *     fetch: async (input, init) => {
+     *       const headers = new Headers(init?.headers);
+     *       headers.set('dpop', await sign(init?.method ?? 'POST', String(input)));
+     *       return fetch(input, { ...init, headers });
+     *     },
+     *   })
+     */
+    readonly fetch?: FetchLike;
+}
+/**
+ * Describe an MCP connection whose auth headers are vended per request.
+ *
+ * @example  A managed gateway with a token vault behind it
+ *   import { agentCoreIdentity } from 'agentfootprint/security';
+ *   import { gatewayTransport, mcpClient } from 'agentfootprint/providers';
+ *
+ *   const gateway = await mcpClient({
+ *     name: 'gateway',
+ *     transport: gatewayTransport({
+ *       url: process.env.GATEWAY_MCP_URL!,
+ *       credentials: agentCoreIdentity({ region: 'us-west-2' }),
+ *       service: 'gateway',
+ *     }),
+ *   });
+ *   const agent = Agent.create({ provider, model }).tools(await gateway.tools()).build();
+ */
+export declare function gatewayTransport(options: GatewayTransportOptions): McpGatewayTransport;
+/**
+ * Raised when the provider needs a human to authorize before it can vend.
+ *
+ * The URL is carried so the caller can surface it (pause the run, show a
+ * link); **the token is not, because there is not one yet** — that is the whole
+ * meaning of this error.
+ */
+export declare class GatewayAuthorizationRequiredError extends Error {
+    readonly code: "ERR_GATEWAY_AUTHORIZATION_REQUIRED";
+    /** Send the user here, then retry. */
+    readonly authorizationUrl: string;
+    constructor(service: string, authorizationUrl: string);
+}
+/** Just the part of `fetch` this module needs, so it is trivially injectable in tests. */
+export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+/**
+ * Build the `fetch` the MCP SDK will use: one that vends a credential, applies
+ * it to this one request, and keeps nothing.
+ *
+ * Exported for tests — the secrecy invariant is asserted against this function
+ * directly, because that is where a leak would happen and driving a whole SDK
+ * to reach it would test less while looking like it tested more.
+ *
+ * @internal
+ */
+export declare function createVendingFetch(transport: McpGatewayTransport, baseFetch?: FetchLike): FetchLike;
+//# sourceMappingURL=gatewayTransport.d.ts.map

package/dist/types/mcp/gatewayTransport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gatewayTransport.d.ts","sourceRoot":"","sources":["../../../src/mcp/gatewayTransport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACnF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,4CAA4C;AAC5C,MAAM,WAAW,uBAAuB;IACtC,4BAA4B;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,sDAAsD;IACtD,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAC;IACzC;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,4DAA4D;IAC5D,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,mFAAmF;IACnF,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkDG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;CAC5B;AAID;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,mBAAmB,CAatF;AAED;;;;;;GAMG;AACH,qBAAa,iCAAkC,SAAQ,KAAK;IAC1D,QAAQ,CAAC,IAAI,uCAAiD;IAC9D,sCAAsC;IACtC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;gBAEtB,OAAO,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM;CAUtD;AAED,0FAA0F;AAC1F,MAAM,MAAM,SAAS,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AAEjG;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,mBAAmB,EAC9B,SAAS,GAAE,SAA6C,GACvD,SAAS,CAuBX"}

package/dist/types/mcp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mcp/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAGzC,OAAO,EAAE,mBAAmB,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAChG,OAAO,EACL,gBAAgB,EAChB,iCAAiC,EACjC,KAAK,uBAAuB,GAC7B,MAAM,uBAAuB,CAAC;AAI/B,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,YAAY,EACV,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,iBAAiB,EACjB,SAAS,EACT,gBAAgB,EAChB,aAAa,EACb,oBAAoB,EACpB,MAAM,EACN,mBAAmB,EACnB,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,qBAAqB,EACrB,sBAAsB,EACtB,YAAY,GACb,MAAM,YAAY,CAAC"}

package/dist/types/mcp/mcpClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpClient.d.ts","sourceRoot":"","sources":["../../../src/mcp/mcpClient.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAGH,OAAO,KAAK,EACV,SAAS,EACT,gBAAgB,EAEhB,oBAAoB,EAKrB,MAAM,YAAY,CAAC;AAkBpB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,gBAAgB,GAAG,oBAAoB,GAAG,OAAO,CAAC,SAAS,CAAC,CAiDjG"}

package/dist/types/mcp/mcpServe.d.ts

@@ -0,0 +1,87 @@
+/**
+ * mcpServe — expose your agentfootprint tools AS an MCP server.
+ *
+ *   const handle = await mcpServe([lookupTool, refundTool], {
+ *     name: 'support-desk',
+ *     version: '1.0.0',
+ *   });
+ *
+ *   // …later
+ *   await handle.close();
+ *
+ * Over HTTP the handle also reports the socket it bound, so `port: 0`
+ * ("any free port") is usable from the outside:
+ *
+ *   const handle = await mcpServe(tools, {
+ *     transport: { transport: 'http', port: 0, host: '127.0.0.1' },
+ *   });
+ *   connect(`http://127.0.0.1:${handle.port}/mcp`);
+ *
+ * `mcpClient` pulls someone else's tools in. This pushes yours out, so
+ * the tool you already wrote, tested and governed can be called by any
+ * MCP client — a desktop host, another team's agent, an IDE — without
+ * being rewritten against a second tool interface.
+ *
+ * Pattern: Adapter (GoF), pointed the other way. `mcpClient` translates
+ *          MCP → `Tool`; this translates `Tool` → MCP. Same SDK, same
+ *          lazy-require discipline, mirrored lifecycle (`close()`).
+ *
+ * ── The one promise worth stating plainly ────────────────────────────
+ * A served tool is THE SAME OBJECT you passed in. `mcpServe` holds your
+ * `Tool` by reference and calls `tool.execute(args, ctx)` — it never
+ * copies the schema and re-implements the body, never unwraps a
+ * decorator, never reaches past a wrapper to an inner tool. So whatever
+ * governance you composed around that tool — a permission check inside
+ * `execute`, a redaction step, an audit hook — is still the thing that
+ * runs when a remote client calls it. Serving is not a second door into
+ * your tool; it is the same door with a longer corridor.
+ *
+ * Two demands the library CANNOT keep over MCP are refused at
+ * construction rather than silently dropped:
+ *   - `checkIn` (human consent before the tool runs) needs a pause
+ *     channel that a request/response protocol does not have.
+ *   - `needs` (declare-and-push credentials) needs a provider; without
+ *     one the tool would run with `ctx.credential` undefined.
+ *
+ * ── Declarations travel; execution does not (9.71.0) ─────────────────
+ * A served tool's DECLARATIONS — `argumentsFrom`, `resultKind`, `owner`,
+ * `resultClass`, `resultCeiling` — are written into MCP's own `_meta` bag
+ * under one namespaced key, so an agentfootprint client arms the checks and
+ * rails that read them exactly as it would for a local `defineTool`. The
+ * execution-side fields never go: see `toolExtras.ts` for the bar and the
+ * reasoning. A tool declaring none of the five lists exactly as before.
+ *
+ * ── Schemas ──────────────────────────────────────────────────────────
+ * Tools already carry JSON Schema in `schema.inputSchema`, and MCP's
+ * `tools/list` wants JSON Schema, so the mapping is the identity
+ * function. That is also why this builds on the SDK's low-level
+ * `Server` rather than its `McpServer` convenience wrapper — the latter
+ * takes zod schemas, which would mean converting a JSON Schema you
+ * already have into zod (a new dependency) to convert it straight back.
+ */
+import type { Tool } from '../tools/tools.js';
+import type { McpServeHandle, McpServeOptions } from './types.js';
+/**
+ * Serve `tools` over MCP. Resolves once the transport is connected (for
+ * `http`, once the socket is listening), so holding the handle means the
+ * server is live.
+ *
+ * @throws at construction when `tools` is empty, when two tools share a
+ *   name, when a tool declares `checkIn`, or when a tool declares `needs`
+ *   without `opts.credentials` — see the module header. Also throws when
+ *   `@modelcontextprotocol/sdk` is not installed.
+ */
+export declare function mcpServe(tools: readonly Tool[], opts?: McpServeOptions): Promise<McpServeHandle>;
+/**
+ * Sentinels handed to an injected `_server` in place of the SDK's zod
+ * schemas. Exported so a test can tell the two handlers apart.
+ * @internal
+ */
+export declare const LIST_TOOLS_SENTINEL: Readonly<{
+    method: "tools/list";
+}>;
+/** @internal @see LIST_TOOLS_SENTINEL */
+export declare const CALL_TOOL_SENTINEL: Readonly<{
+    method: "tools/call";
+}>;
+//# sourceMappingURL=mcpServe.d.ts.map

package/dist/types/mcp/mcpServe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpServe.d.ts","sourceRoot":"","sources":["../../../src/mcp/mcpServe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAMH,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,mBAAmB,CAAC;AAMpE,OAAO,KAAK,EAIV,cAAc,EACd,eAAe,EAEhB,MAAM,YAAY,CAAC;AAYpB;;;;;;;;;GASG;AACH,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,IAAI,GAAE,eAAoB,GACzB,OAAO,CAAC,cAAc,CAAC,CAyMzB;AAiPD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;EAA0C,CAAC;AAC3E,yCAAyC;AACzC,eAAO,MAAM,kBAAkB;;EAA0C,CAAC"}

package/dist/types/mcp/mockMcpClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockMcpClient.d.ts","sourceRoot":"","sources":["../../../src/mcp/mockMcpClient.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAGjF,sDAAsD;AACtD,MAAM,WAAW,WAAW;IAC1B,oCAAoC;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2DAA2D;IAC3D,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACxD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACnD;;;;;;;;OAQG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC7B;;;;OAIG;IACH,OAAO,EAAE;QAAE,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;KAAE,KAC5D,OAAO,CAAC,MAAM,GAAG,iBAAiB,CAAC,CAAC;CAC1C;AAED,MAAM,WAAW,oBAAoB;IACnC,uEAAuE;IACvE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,SAAS,WAAW,EAAE,CAAC;IACvC;mFAC+E;IAC/E,QAAQ,CAAC,UAAU,CAAC,EAAE,gBAAgB,CAAC,YAAY,CAAC,CAAC;CACtD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAqCtE"}

package/dist/types/mcp/sdkLoadFailure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdkLoadFailure.d.ts","sourceRoot":"","sources":["../../../src/mcp/sdkLoadFailure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,4DAA4D;IAC5D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,gDAAgD;IAChD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,mBAAmB,GAAG,MAAM,CAU/E"}

package/dist/types/mcp/throttleRetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttleRetry.d.ts","sourceRoot":"","sources":["../../../src/mcp/throttleRetry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAIH;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AAI3F,yEAAyE;AACzE,MAAM,WAAW,iBAAiB;IAChC,0DAA0D;IAC1D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,mEAAmE;IACnE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,sDAAsD;IACtD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;4DACwD;IACxD,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;6EACyE;IACzE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,gEAAgE;AAChE,MAAM,WAAW,oBAAoB;IACnC,gEAAgE;IAChE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;;;OAQG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,iBAAiB,KAAK,IAAI,CAAC;CACtD;AAED;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,oBAAoB,CAAC;AA4B7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,aAAa,GAAG,SAAS,EAChC,MAAM,EAAE,eAAe,GAAG,SAAS,GAClC,aAAa,GAAG,SAAS,CAyC3B;AAID;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAOpF"}

package/dist/types/mcp/toolExtras.d.ts

@@ -0,0 +1,195 @@
+/**
+ * toolExtras — agentfootprint's own tool DECLARATIONS, carried over MCP.
+ *
+ * A `Tool` is two different things at once. Half of it is EXECUTION — the
+ * handler, the credential it needs, the human it wants to check in with. The
+ * other half is DECLARATION — flat, inert facts about the tool that no code
+ * runs and every consumer-side rail READS: where its arguments come from, what
+ * kind of artifact its result is, who owns it, what class of answer it gives,
+ * how big a result is too big.
+ *
+ * Over MCP only the execution half used to cross. A tool served by `mcpServe`
+ * arrived at a client as a name, a description and an input schema, so every
+ * rail that reads a declaration went quiet for it: the dangling-reference and
+ * unsupported-argument checks never armed, placement minted
+ * `tool-result/<name>` that no `wants` could spend, and the identity joins had
+ * no subject. An MCP server could be somebody's whole tool catalogue and still
+ * be a second-class citizen of every check this library ships.
+ *
+ * ── The carrier ─────────────────────────────────────────────────────────
+ * MCP's own extensibility bag: `Tool._meta`, under ONE namespaced key
+ * ({@link MCP_TOOL_EXTRAS_KEY}). `_meta` is declared on the spec's `Tool`
+ * object (`@modelcontextprotocol/sdk` types it as
+ * `z.record(z.string(), z.unknown()).optional()` on `ToolSchema`), so it
+ * survives the SDK's own `tools/list` validation in both directions and needs
+ * no new protocol, no side channel and no version negotiation. A server that
+ * has never heard of agentfootprint sends no bag; a client that has never
+ * heard of it ignores the key.
+ *
+ * ── What may travel, and the bar ────────────────────────────────────────
+ * **A declaration a consumer-side check or rail reads; nothing that governs
+ * execution.** Every field below passes it. `needs` (credentials), `checkIn`
+ * (human consent) and the session hooks do NOT and never will: they govern how
+ * a tool RUNS, and the tool runs on the server. Sending them would tell a
+ * client to hold a gate that the only executor of the tool has already held,
+ * or — worse — that nobody is holding at all. `mcpServe` already refuses to
+ * serve a `checkIn` tool for exactly that reason; this list is the same law,
+ * stated on the way out.
+ *
+ * ── The asymmetry that matters ──────────────────────────────────────────
+ * SERVING validates nothing new: the tool was built by `defineTool`, which
+ * already refused every malformed declaration at definition time.
+ *
+ * INGEST validates everything and THROWS NOTHING. A bag comes from a server
+ * this process does not control, and one server's typo must not take down a
+ * bulk register of forty tools. So each field is judged by the SAME rule
+ * `defineTool` enforces (literally the same exported assert), and a field that
+ * fails is warned about once — naming the server, the tool, the field and the
+ * rule — and DROPPED. The tool still registers, without that one declaration.
+ * That is the honest outcome: the rail it would have armed stays unarmed, and
+ * the developer is told which rail and why.
+ */
+import { type Tool, type ToolOwner, type ToolResultCeiling, type ToolResultColumns } from '../tools/tools.js';
+import type { ToolResultClass } from '../semantics/types.js';
+import { type AskOrAssume, type ToolPeriod } from '../tools/declare.js';
+import { type TimeContext } from '../time/wire.js';
+/**
+ * The single `_meta` key every agentfootprint declaration travels under.
+ *
+ * Namespaced so it can never collide with another vendor's `_meta` entry, and
+ * a CONSTANT so there is exactly one spelling in the codebase — the
+ * `branchSegment.ts` precedent upstream: one owner of the grammar, and nobody
+ * else may write the string.
+ */
+export declare const MCP_TOOL_EXTRAS_KEY = "agentfootprint";
+/**
+ * The declarations that cross an MCP boundary — the plain-data half of a
+ * `Tool`, in the shape the receiving side puts straight back onto a `Tool`.
+ *
+ * Every field is optional and ABSENT MEANS ABSENT: a tool that declares
+ * nothing sends no bag at all, and a tool that declares two sends two keys,
+ * never five with three empty placeholders. "Said nothing" and "said empty"
+ * are different statements everywhere else in this library, and they are
+ * different here.
+ *
+ * @see MCP_TOOL_EXTRAS_KEY for the `_meta` key it rides under.
+ */
+export interface McpToolExtras {
+    /** Where this tool's arguments come from — see {@link Tool.argumentsFrom}.
+     *  Arms the dangling-reference and unsupported-argument checks. */
+    readonly argumentsFrom?: readonly string[];
+    /** The artifact kind a PLACED result is minted under — see
+     *  {@link Tool.resultKind}. What makes a placed result spendable by `wants`. */
+    readonly resultKind?: string;
+    /**
+     * What this tool's ROWS contain (9.78.0) — see {@link Tool.resultColumns}.
+     * Arms the write seam's `column-type-mismatch` and `missing-column` checks.
+     *
+     * It clears the bar this file states, and by the widest margin of the eight.
+     * It is a flat, inert fact about the RESULT that a consumer-side check
+     * reads; it governs nothing about how the tool runs, and the tool runs on
+     * the server. It is also the field case for carrying declarations at all: a
+     * remote catalogue of rowset tools is exactly where a numeric column
+     * arriving as text goes unnoticed, because the consumer holding the chart
+     * has no way to know what the producer meant. Leaving it behind would arm
+     * the check for local tools and leave every MCP tool a second-class citizen
+     * of it — the whole defect `toolExtras` was built to end.
+     */
+    readonly resultColumns?: ToolResultColumns;
+    /** The identity edge integrity checks join on — see {@link Tool.owner}. */
+    readonly owner?: ToolOwner;
+    /** The declared class of this tool's results — see {@link Tool.resultClass}. */
+    readonly resultClass?: ToolResultClass;
+    /** The author's refusing ceiling on this tool's result — see
+     *  {@link Tool.resultCeiling}. */
+    readonly resultCeiling?: ToolResultCeiling;
+    /** The named ingredient tools this tool is composed of (9.76.0) — see
+     *  {@link Tool.composedOf}. Feeds the receiving agent's build-time drift
+     *  gate. */
+    readonly composedOf?: readonly string[];
+    /** Whether this tool's procedure can raise an approval gate (9.76.0) — see
+     *  {@link Tool.gates}. Read by composition-time checks that must keep a
+     *  gating tool out of a fan-out branch. */
+    readonly gates?: boolean;
+    /**
+     * The per-argument rules (the inputs layer, honesty layer 2) — see
+     * {@link Tool.askOrAssume}. It passes this file's bar: the fill and the
+     * batch ask happen in the CLIENT's own loop before the call
+     * is sent — exactly as the client applies a served `resultCeiling` — and
+     * nothing about how the server runs the tool changes. The FIRST extra
+     * judged against the tool's schema, which is why the origin carries the
+     * listed tool's `inputSchema`. A client that ignores `_meta` sees the
+     * author's `required` and sends the value, or the server applies its own
+     * default.
+     */
+    readonly askOrAssume?: AskOrAssume;
+    /** Which arguments set the period the answer covers, the forms they take
+     *  and the facts about the source — see {@link Tool.period}. Judged
+     *  against the listed tool's own `inputSchema` and the KEPT `askOrAssume`
+     *  (every argument a form names must carry a kept rule). A host tool
+     *  written in another language declares the same object, field for field. */
+    readonly period?: ToolPeriod;
+}
+/**
+ * The `_meta` bag a `tools/call` request carries for a call handed
+ * `ctx.time` (the time layer, `time/wire.ts` · `TimeContext`): the
+ * same object, under the one namespaced key — so a host tool in another
+ * process can declare the `period.queried` its read covered without parsing
+ * its own argument.
+ */
+export declare function callMetaOf(time: TimeContext): Readonly<Record<string, unknown>>;
+/**
+ * The call's time a `tools/call` request carried in its `_meta` bag, read —
+ * or `undefined` when it carried none, or one this runtime cannot read (a
+ * different version, a malformed field): never repaired, never guessed. What
+ * `mcpServe` hands a served tool as `ctx.time`.
+ */
+export declare function callTimeOf(meta: unknown): TimeContext | undefined;
+/**
+ * The declarations on `tool`, ready to be written into an MCP `_meta` bag —
+ * or `undefined` when the tool declares none, so `mcpServe` can leave `_meta`
+ * off the listing entirely rather than sending an empty object.
+ *
+ * Copied verbatim, never inferred or defaulted. This is the SERVE side, and
+ * the values were already vetted by `defineTool`.
+ */
+export declare function toolExtrasOf(tool: Tool): McpToolExtras | undefined;
+/** Where a rejected declaration came from, for the warning that names it. */
+export interface McpToolExtrasOrigin {
+    /** The client's logical name — `mcpClient({ name })`. */
+    readonly server: string;
+    /** The tool the bag was attached to. */
+    readonly tool: string;
+    /**
+     * The listed tool's own `inputSchema` — what `askOrAssume` and `period` are
+     * judged against (each ruled property by its OWN schema). Absent → those
+     * two fields are judged against an empty schema, so every rule is dropped
+     * with a warning rather than trusted unjudged.
+     */
+    readonly inputSchema?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Read an MCP `Tool._meta` bag into declarations a `Tool` can carry.
+ *
+ * **Never throws.** Everything here is somebody else's data:
+ *
+ *   - no `_meta`, no `agentfootprint` key, or a non-object under it → `{}`,
+ *     and the ingest is byte-identical to every release before this existed;
+ *   - a field the receiving side does not know → ignored in silence (a NEWER
+ *     server talking to an OLDER client is not an error, and warning about it
+ *     would make every upgrade noisy at the wrong end);
+ *   - a field this library DOES know but cannot honour → warned once and
+ *     dropped, and the rest of the bag still lands.
+ *
+ * The rule each field is judged by is the exported assert `defineTool` itself
+ * calls, so a declaration that would have been refused at definition time is
+ * refused here too, with the same sentence.
+ */
+export declare function readToolExtras(meta: unknown, origin: McpToolExtrasOrigin): McpToolExtras;
+/**
+ * Forget every warning issued so far.
+ * @internal test seam — the ledger is process-wide and warn-ONCE, so a test
+ *   proving the warning fires must be able to start from silence.
+ */
+export declare function _resetToolExtrasWarnings(): void;
+//# sourceMappingURL=toolExtras.d.ts.map

package/dist/types/mcp/toolExtras.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolExtras.d.ts","sourceRoot":"","sources":["../../../src/mcp/toolExtras.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,OAAO,EASL,KAAK,IAAI,EACT,KAAK,SAAS,EACd,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACvB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAqB,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC3F,OAAO,EAA0C,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE3F;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,aAAa;IAC5B;uEACmE;IACnE,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C;oFACgF;IAChF,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAC3C,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC;IAC3B,gFAAgF;IAChF,QAAQ,CAAC,WAAW,CAAC,EAAE,eAAe,CAAC;IACvC;sCACkC;IAClC,QAAQ,CAAC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAC3C;;gBAEY;IACZ,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC;;+CAE2C;IAC3C,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAC;IACnC;;;;iFAI6E;IAC7E,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,CAAC;CAC9B;AAID;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAE/E;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,WAAW,GAAG,SAAS,CAGjE;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,aAAa,GAAG,SAAS,CAclE;AAED,6EAA6E;AAC7E,MAAM,WAAW,mBAAmB;IAClC,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC1D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,mBAAmB,GAAG,aAAa,CAwDxF;AA+ED;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C"}

package/dist/types/mcp/toolResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolResult.d.ts","sourceRoot":"","sources":["../../../src/mcp/toolResult.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEtE,KAAK,UAAU,GAAG,WAAW,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC,CAAC;AAE9D,mFAAmF;AACnF,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAMrE;AAED,wEAAwE;AACxE,wBAAgB,cAAc,CAC5B,MAAM,EAAE,iBAAiB,EACzB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,IAAI,GAAE,UAAmB,GACxB,OAAO,CAkDT"}

package/dist/types/mcp/transportUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transportUrl.d.ts","sourceRoot":"","sources":["../../../src/mcp/transportUrl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,CAyB7D"}