agentfootprint 10.3.0 → 10.4.0

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

@@ -0,0 +1,186 @@
+/**
+ * throttleRetry — when an MCP server says "too many requests", wait and ask again.
+ *
+ * ── Why this exists ──────────────────────────────────────────────────────────
+ * Managed MCP gateways enforce per-principal rate limits. A throttled
+ * `tools/call` is not a fault, it is the endpoint working as designed — and
+ * before 8.11.0 it arrived at the model as a thrown tool error, which the model
+ * reads as **"this tool is broken"**. It then apologises, picks a different
+ * tool, or invents an answer. A designed, transient, self-clearing condition
+ * was being turned into a wrong answer.
+ *
+ * ── Why retrying a 429 is safe, and why the policy is 429-ONLY ───────────────
+ * **A 429 is a pre-execution rejection.** The rate limiter refused the request
+ * at the edge; the server never ran the tool. Retrying therefore cannot
+ * double-execute anything — which is exactly what is NOT true of a 500 or a
+ * timeout, where the call may have half-run and a retry could charge a card
+ * twice.
+ *
+ * That asymmetry is the whole license for this module, so the policy must never
+ * widen. Only HTTP 429 retries here. Not 5xx, not network errors, not timeouts
+ * — those belong to a caller who knows whether the specific tool is idempotent,
+ * and this seam does not. A property test pins the boundary.
+ *
+ * The loop takes its question as a {@link RetryDecision}, so the one other
+ * refusal a service DOCUMENTS as pre-execution — AgentCore Runtime's "session
+ * operation in progress" — reuses this loop rather than growing a second one.
+ * That decision is applied only by that vendor's own transport; what
+ * `mcpClient` and `retryingFetch` retry is still a 429 and nothing else.
+ *
+ * ── Why it lives at the fetch seam and not around `Tool.execute` ─────────────
+ * Because `Retry-After` is only reachable here. The MCP SDK reads the response,
+ * throws `StreamableHTTPError(status, text)` and drops the `Response` — so by
+ * the time a throttle reaches `Tool.execute` the header is gone and the status
+ * survives only as `err.code`. A retry wrapper around the tool could guess a
+ * backoff; only a wrapper around `fetch` can honour the number the server
+ * actually asked for. Honouring it is also what keeps a fleet of agents from
+ * synchronising into a thundering herd.
+ *
+ * ── Ordering: retry OUTSIDE, signing and vending INSIDE ──────────────────────
+ * The wrapper composes over the caller's `fetch` (a SigV4/DPoP signer) or over
+ * `createVendingFetch` (a per-request credential). Sitting outside means every
+ * attempt is signed afresh and vended afresh — signatures expire, and a token
+ * that would have died during the wait is simply never the one reused. The
+ * gateway secrecy invariant is untouched: each attempt vends, applies, drops.
+ *
+ * Pattern: Decorator over `fetch`. Role: Layer-3 tool transport.
+ */
+/**
+ * The fetch shape the MCP SDK's `fetch` hook uses — deliberately NARROWER
+ * than `gatewayTransport`'s `FetchLike` (no `Request` input), because that is
+ * exactly what `StreamableHTTPClientTransport` declares and what
+ * `McpHttpTransport.fetch` promises a consumer. A wider `FetchLike` still
+ * passes in: a function that accepts more inputs satisfies a contract that
+ * supplies fewer.
+ */
+export type ThrottleFetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
+/** Reported to {@link ThrottleRetryOptions.onRetry} before each wait. */
+export interface ThrottleRetryInfo {
+    /** The attempt about to START. `2` is the first retry. */
+    readonly attempt: number;
+    /** Ceiling in force for this call, including the first attempt. */
+    readonly maxAttempts: number;
+    /** How long we are about to wait, in milliseconds. */
+    readonly waitMs: number;
+    /** What the server's `Retry-After` asked for, when it sent one. Absent
+     *  means the wait below is our own jittered backoff. */
+    readonly retryAfterMs?: number;
+    /** The endpoint being retried. Carries no credential: the URL is the URL
+     *  the transport was built with, never a signed or tokenised variant. */
+    readonly url: string;
+}
+/** Fine-tuning for {@link McpClientOptions.retryOnThrottle}. */
+export interface ThrottleRetryOptions {
+    /** Total attempts including the first. Default 3. Minimum 1. */
+    readonly maxAttempts?: number;
+    /**
+     * Ceiling on the TOTAL time spent waiting across one call, in
+     * milliseconds. Default 10000.
+     *
+     * This is the safety rail on `Retry-After`: a server (or a misconfigured
+     * proxy) that asks for a 24-hour wait does not get one — when the next wait
+     * would push past this ceiling we stop retrying and let the throttle
+     * surface, so the worst case is a slower failure and never a hung agent.
+     */
+    readonly maxWaitMs?: number;
+    /**
+     * Called before each wait. The per-attempt visibility hook, matching the
+     * contract `withRetry` and `withCredentialRetry` already use — a decorator
+     * at a transport boundary reports to its consumer, and emits no events of
+     * its own.
+     *
+     * A retried call is not invisible without this: the wait lands inside the
+     * tool's `stream.tool_end` `durationMs`, and an exhausted retry still
+     * reaches the model with `error: true`. This hook is what turns "that call
+     * was slow" into "that call was throttled twice".
+     */
+    readonly onRetry?: (info: ThrottleRetryInfo) => void;
+}
+/**
+ * How a throttled request is handled. `true` (the default) means bounded
+ * retry with default settings; `false` disables it entirely.
+ */
+export type RetryOnThrottle = boolean | ThrottleRetryOptions;
+/**
+ * What one response says about asking again. `undefined` delivers the response
+ * as it is; a verdict waits, then sends the SAME request once more.
+ */
+export interface RetryVerdict {
+    /**
+     * How long the server asked for, in milliseconds, when it said. Absent, the
+     * loop waits its own jittered backoff.
+     */
+    readonly retryAfterMs?: number;
+}
+/**
+ * The one question the loop asks of each response.
+ *
+ * ── The license every decision must hold ─────────────────────────────────────
+ * A decision may answer "again" ONLY for a refusal the server made BEFORE it
+ * ran anything — the property that makes a 429 safe to repeat (see the module
+ * note). A response that could be the record of half-done work is never one.
+ * The library holds exactly two such decisions: {@link throttled} below, and
+ * AgentCore Runtime's documented "session operation in progress" refusal,
+ * which lives with that vendor's adapter (`adapters/mcp/agentcoreRuntime/`).
+ * Each stays ONE small function, so a retry has exactly one place it is
+ * decided — and one place to route it when retries are written down as
+ * attempts.
+ */
+export type RetryDecision = (response: Response) => RetryVerdict | undefined | Promise<RetryVerdict | undefined>;
+/** HTTP 429, with the server's own `Retry-After` when it sent one. */
+export declare function throttled(response: Response): RetryVerdict | undefined;
+/**
+ * Wrap a `fetch` so HTTP 429 responses are retried, honouring `Retry-After`.
+ *
+ * Returns `inner` untouched when retry is disabled — including `undefined`,
+ * so a transport that passed no custom fetch keeps passing none and its
+ * behaviour is byte-identical to before this existed.
+ *
+ * ── Why this is public ───────────────────────────────────────────────────────
+ * `mcpClient({ transport })` applies it for you, ON by default. `mcpClient({
+ * connection })` cannot: the library builds no transport on that arm, so there
+ * is no `fetch` of its own to wrap — and a browser consumer, who is the main
+ * reason that arm exists, would silently lose the 429 handling Node gets for
+ * free. That asymmetry is invisible from the outside, which is why the answer
+ * is to hand over the same implementation rather than to document the gap:
+ *
+ * ```ts
+ * import { retryingFetch } from 'agentfootprint/providers';
+ * import { StreamableHTTPClientTransport }
+ *   from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+ *
+ * const transport = new StreamableHTTPClientTransport(new URL('/mcp', location.href), {
+ *   fetch: retryingFetch(undefined, { maxAttempts: 5 }),
+ * });
+ * ```
+ *
+ * @param inner the fetch to wrap. `undefined` means the global `fetch`,
+ *   resolved at CALL time so a later polyfill still wins.
+ * @param config `true` / `undefined` for the defaults, `false` to get `inner`
+ *   back unchanged, or an object to tune the ceilings.
+ */
+export declare function retryingFetch(inner: ThrottleFetch | undefined, config: RetryOnThrottle | undefined): ThrottleFetch | undefined;
+/**
+ * The bounded loop itself, asking `decide` of every response.
+ *
+ * {@link retryingFetch} is this loop asking {@link throttled}. A vendor adapter
+ * whose service documents a refusal of its own — one made before anything ran —
+ * passes its decision here instead of writing a second loop, so the ceilings,
+ * the `Retry-After` rail, the replay check, the abort and the `onRetry` report
+ * stay one implementation.
+ *
+ * `decide` is asked only when a retry could actually follow — attempts left, a
+ * body that can be sent again, no abort — so a decision that has to read the
+ * response pays for that only when its answer can matter.
+ *
+ * @internal Public to adapters, not to the door: the decision is the vendor's
+ *   fact, and each one is reviewed against the license on {@link RetryDecision}.
+ */
+export declare function retryingFetchWhen(inner: ThrottleFetch | undefined, config: RetryOnThrottle | undefined, decide: RetryDecision): ThrottleFetch | undefined;
+/**
+ * `Retry-After` in either legal form: delta-seconds (`"2"`) or an HTTP-date
+ * (`"Wed, 21 Oct 2026 07:28:00 GMT"`). Anything else is treated as absent so a
+ * malformed header degrades to our own backoff rather than to a wrong wait.
+ */
+export declare function parseRetryAfter(value: string | null | undefined): number | undefined;
+//# sourceMappingURL=throttleRetry.d.ts.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;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;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,aAAa,GAAG,CAC1B,QAAQ,EAAE,QAAQ,KACf,YAAY,GAAG,SAAS,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAAC;AAElE,sEAAsE;AACtE,wBAAgB,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,YAAY,GAAG,SAAS,CAItE;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,aAAa,GAAG,SAAS,EAChC,MAAM,EAAE,eAAe,GAAG,SAAS,GAClC,aAAa,GAAG,SAAS,CAE3B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,aAAa,GAAG,SAAS,EAChC,MAAM,EAAE,eAAe,GAAG,SAAS,EACnC,MAAM,EAAE,aAAa,GACpB,aAAa,GAAG,SAAS,CA2C3B;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"}