agents 0.21.0 → 0.23.0

package/dist/ingress-BfetZbMO.js

@@ -0,0 +1,83 @@
+import { t as TextSegmentJoiner } from "./text-segment-joiner-BtAFQSA_.js";
+//#region src/channels/stream.ts
+/**
+* Read a stream to completion, then finalize exactly once.
+*
+* `onFinish` runs whether the stream closed normally, errored because the
+* generation failed, or stopped because `onChunk` threw. A Channel that
+* finalizes here cannot lose a terminal provider call to an early ending.
+*/
+async function consumeChunks(chunks, consumer) {
+	const reader = chunks.getReader();
+	let outcome = { interrupted: false };
+	let cancellation;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			await consumer.onChunk(value);
+		}
+	} catch (error) {
+		outcome = {
+			interrupted: true,
+			error
+		};
+		cancellation = reader.cancel().catch(() => {});
+	} finally {
+		reader.releaseLock();
+	}
+	try {
+		return await consumer.onFinish(outcome);
+	} finally {
+		await cancellation;
+	}
+}
+/**
+* Collect every `text` chunk into one Markdown answer.
+*
+* The result reports interruption instead of throwing, because a Channel that
+* has partial text still has to decide what to deliver.
+*/
+function collectText(chunks) {
+	let text = "";
+	const joiner = new TextSegmentJoiner();
+	return consumeChunks(chunks, {
+		onChunk(chunk) {
+			for (const event of joiner.pushChunk(chunk.type === "text" ? {
+				type: "text-delta",
+				text: chunk.text
+			} : { type: chunk.type })) if (event.type === "text") text += event.text;
+		},
+		onFinish: (outcome) => ({
+			text,
+			interrupted: outcome.interrupted
+		})
+	});
+}
+/**
+* Pace repeated provider calls without dropping anything.
+*
+* A Channel accumulates into its own buffer and asks whether enough time has
+* passed to flush. Keeping the buffer in the Channel means an interrupted
+* stream leaves its tail in hand, ready for the terminal provider call, rather
+* than stranded inside a transform.
+*/
+function createPacer(intervalMs) {
+	let lastFlushAt = Number.NEGATIVE_INFINITY;
+	return () => {
+		const now = Date.now();
+		if (now - lastFlushAt < intervalMs) return false;
+		lastFlushAt = now;
+		return true;
+	};
+}
+//#endregion
+//#region src/channels/ingress.ts
+/** Match an HTTP request to one exact URL pathname. */
+function matchesPath(request, path) {
+	return new URL(request.url).pathname === path;
+}
+//#endregion
+export { createPacer as i, collectText as n, consumeChunks as r, matchesPath as t };
+
+//# sourceMappingURL=ingress-BfetZbMO.js.map

package/dist/ingress-BfetZbMO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingress-BfetZbMO.js","names":[],"sources":["../src/channels/stream.ts","../src/channels/ingress.ts"],"sourcesContent":["import { TextSegmentJoiner } from \"../chat/text-segment-joiner\";\nimport type { Awaitable, ChannelChunk } from \"./channel\";\n\n/** Why a consumption loop stopped reading. */\nexport type StreamOutcome =\n  | { interrupted: false }\n  | { interrupted: true; error: unknown };\n\nexport type ChunkConsumer<TChunk, TResult> = {\n  onChunk(chunk: TChunk): Awaitable<void>;\n  /** Runs exactly once, whether the stream closed or ended abnormally. */\n  onFinish(outcome: StreamOutcome): Awaitable<TResult>;\n};\n\n/** The complete text of a stream, and whether it ended before its answer did. */\nexport type CollectedText = {\n  text: string;\n  interrupted: boolean;\n};\n\n/**\n * Read a stream to completion, then finalize exactly once.\n *\n * `onFinish` runs whether the stream closed normally, errored because the\n * generation failed, or stopped because `onChunk` threw. A Channel that\n * finalizes here cannot lose a terminal provider call to an early ending.\n */\nexport async function consumeChunks<TChunk, TResult>(\n  chunks: ReadableStream<TChunk>,\n  consumer: ChunkConsumer<TChunk, TResult>\n): Promise<TResult> {\n  const reader = chunks.getReader();\n  let outcome: StreamOutcome = { interrupted: false };\n  let cancellation: Promise<void> | undefined;\n  try {\n    while (true) {\n      const { done, value } = await reader.read();\n      if (done) break;\n      await consumer.onChunk(value);\n    }\n  } catch (error) {\n    outcome = { interrupted: true, error };\n    // Start cancellation before finalizing, but do not block the terminal\n    // provider call on sibling tee branches. Await cleanup only afterward.\n    cancellation = reader.cancel().catch(() => {});\n  } finally {\n    reader.releaseLock();\n  }\n  try {\n    return await consumer.onFinish(outcome);\n  } finally {\n    await cancellation;\n  }\n}\n\n/**\n * Collect every `text` chunk into one Markdown answer.\n *\n * The result reports interruption instead of throwing, because a Channel that\n * has partial text still has to decide what to deliver.\n */\nexport function collectText(\n  chunks: ReadableStream<ChannelChunk>\n): Promise<CollectedText> {\n  let text = \"\";\n  const joiner = new TextSegmentJoiner();\n  return consumeChunks(chunks, {\n    onChunk(chunk) {\n      for (const event of joiner.pushChunk(\n        chunk.type === \"text\"\n          ? { type: \"text-delta\", text: chunk.text }\n          : { type: chunk.type }\n      )) {\n        if (event.type === \"text\") text += event.text;\n      }\n    },\n    onFinish: (outcome) => ({ text, interrupted: outcome.interrupted })\n  });\n}\n\n/**\n * Pace repeated provider calls without dropping anything.\n *\n * A Channel accumulates into its own buffer and asks whether enough time has\n * passed to flush. Keeping the buffer in the Channel means an interrupted\n * stream leaves its tail in hand, ready for the terminal provider call, rather\n * than stranded inside a transform.\n */\nexport function createPacer(intervalMs: number): () => boolean {\n  let lastFlushAt = Number.NEGATIVE_INFINITY;\n  return () => {\n    const now = Date.now();\n    if (now - lastFlushAt < intervalMs) return false;\n    lastFlushAt = now;\n    return true;\n  };\n}\n","import type { ChannelIdentity, ChannelIdentityInput } from \"./identity\";\nimport type {\n  ChannelMessageSurface,\n  ChannelMessageSurfaceInput\n} from \"./surface\";\n\n/** Serializable provider attachment facts available after ingress returns. */\nexport type ChannelAttachment = {\n  id?: string;\n  mediaType?: string;\n  name?: string;\n  size?: number;\n  text?: string;\n  url?: string;\n};\n\nexport type ChannelActor = {\n  readonly id: string;\n  /** Stable Channel identity suitable for explicit application linking. */\n  readonly identity?: ChannelIdentity;\n  readonly username?: string;\n  readonly fullName?: string;\n  readonly isBot?: boolean | \"unknown\";\n  readonly isSelf?: boolean;\n};\n\n/** An actor before the Host stamps its configured Channel key. */\nexport type ChannelActorInput = Omit<ChannelActor, \"identity\"> & {\n  readonly identity?: ChannelIdentityInput;\n};\n\nexport type ChannelEventContext = {\n  /** Immutable Channel-scoped identity, independent of application routing. */\n  readonly eventId: string;\n  readonly thread: {\n    readonly id: string;\n    readonly isDirectMessage: boolean | \"unknown\";\n  };\n  /** Exact provider destination for responding to this inbound event. */\n  readonly replySurface?: ChannelMessageSurface;\n  readonly actor?: ChannelActor;\n};\n\n/** A normalized inbound message from a Channel adapter. */\nexport type ChannelInboundMessage = ChannelEventContext & {\n  readonly type: \"message\";\n  readonly message: {\n    readonly id: string;\n    readonly text: string;\n    readonly title?: string;\n    readonly markdown?: string;\n    readonly attachments?: readonly ChannelAttachment[];\n    readonly isMention?: boolean;\n    readonly reply?: {\n      readonly id: string;\n      readonly text?: string;\n    };\n    readonly metadata?: {\n      /** ISO 8601 timestamp supplied by the provider. */\n      readonly sentAt?: string;\n      readonly edited?: boolean;\n      /** ISO 8601 timestamp supplied by the provider. */\n      readonly editedAt?: string;\n      readonly autoReply?: boolean;\n    };\n  };\n};\n\n/** A provider-normalized response to an external approval request. */\nexport type ChannelApprovalResponse = ChannelEventContext & {\n  readonly type: \"approval-response\";\n  readonly interactionId: string;\n  readonly decision: \"approve\" | \"reject\";\n  /** Provider reference for this inbound response. */\n  readonly reference: string;\n};\n\nexport type ChannelIngressEvent =\n  | ChannelInboundMessage\n  | ChannelApprovalResponse;\n\n/** A normalized message before the Host stamps its configured Channel key. */\nexport type ChannelEventContextInput = Omit<\n  ChannelEventContext,\n  \"replySurface\" | \"actor\"\n> & {\n  readonly replySurface?: ChannelMessageSurfaceInput;\n  readonly actor?: ChannelActorInput;\n};\n\nexport type ChannelInboundMessageInput = Omit<\n  ChannelInboundMessage,\n  \"replySurface\" | \"actor\"\n> & {\n  readonly replySurface?: ChannelMessageSurfaceInput;\n  readonly actor?: ChannelActorInput;\n};\n\n/** A normalized approval before the Host stamps its configured Channel key. */\nexport type ChannelApprovalResponseInput = Omit<\n  ChannelApprovalResponse,\n  \"replySurface\" | \"actor\"\n> & {\n  readonly replySurface?: ChannelMessageSurfaceInput;\n  readonly actor?: ChannelActorInput;\n};\n\n/** Authenticated event produced by a Channel before Host dispatch. */\nexport type ChannelIngressEventInput =\n  | ChannelInboundMessageInput\n  | ChannelApprovalResponseInput;\n\n/** Authenticated adapter output retained only until Host routing completes. */\nexport type ChannelIngressEnvelope<TRaw = unknown> = {\n  event: ChannelIngressEventInput;\n  raw: TRaw;\n};\n\n/** The normalized envelopes and provider acknowledgement produced by ingress. */\nexport type ChannelIngressResult<TRaw = unknown> = {\n  events: readonly ChannelIngressEnvelope<TRaw>[];\n  response: Response;\n};\n\n/** Match an HTTP request to one exact URL pathname. */\nexport function matchesPath(request: Request, path: string): boolean {\n  return new URL(request.url).pathname === path;\n}\n\n/** Webhook-shaped inbound support owned by a Channel. */\nexport interface ChannelIngress<TRaw = unknown> {\n  /** Return null when this Channel does not own the request. */\n  receive(request: Request): Promise<ChannelIngressResult<TRaw> | null>;\n}\n\n/** Structural input supported by Workers Email and Agent email handlers. */\nexport type ChannelEmailInput = {\n  from: string;\n  to: string;\n  headers: Headers;\n  raw?: ReadableStream<Uint8Array>;\n  getRaw?: () => Promise<Uint8Array>;\n};\n\nexport type ChannelEmailIngressResult<TRaw = unknown> = {\n  events: readonly ChannelIngressEnvelope<TRaw>[];\n};\n\n/** Non-HTTP ingress for a Workers Email event. */\nexport interface ChannelEmailIngress<TRaw = unknown> {\n  /** Return null when this Channel does not own the email. */\n  receive(\n    email: ChannelEmailInput\n  ): Promise<ChannelEmailIngressResult<TRaw> | null>;\n}\n"],"mappings":";;;;;;;;;AA2BA,eAAsB,cACpB,QACA,UACkB;CAClB,MAAM,SAAS,OAAO,UAAU;CAChC,IAAI,UAAyB,EAAE,aAAa,MAAM;CAClD,IAAI;CACJ,IAAI;EACF,OAAO,MAAM;GACX,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,KAAK;GAC1C,IAAI,MAAM;GACV,MAAM,SAAS,QAAQ,KAAK;EAC9B;CACF,SAAS,OAAO;EACd,UAAU;GAAE,aAAa;GAAM;EAAM;EAGrC,eAAe,OAAO,OAAO,CAAC,CAAC,YAAY,CAAC,CAAC;CAC/C,UAAU;EACR,OAAO,YAAY;CACrB;CACA,IAAI;EACF,OAAO,MAAM,SAAS,SAAS,OAAO;CACxC,UAAU;EACR,MAAM;CACR;AACF;;;;;;;AAQA,SAAgB,YACd,QACwB;CACxB,IAAI,OAAO;CACX,MAAM,SAAS,IAAI,kBAAkB;CACrC,OAAO,cAAc,QAAQ;EAC3B,QAAQ,OAAO;GACb,KAAK,MAAM,SAAS,OAAO,UACzB,MAAM,SAAS,SACX;IAAE,MAAM;IAAc,MAAM,MAAM;GAAK,IACvC,EAAE,MAAM,MAAM,KAAK,CACzB,GACE,IAAI,MAAM,SAAS,QAAQ,QAAQ,MAAM;EAE7C;EACA,WAAW,aAAa;GAAE;GAAM,aAAa,QAAQ;EAAY;CACnE,CAAC;AACH;;;;;;;;;AAUA,SAAgB,YAAY,YAAmC;CAC7D,IAAI,cAAc,OAAO;CACzB,aAAa;EACX,MAAM,MAAM,KAAK,IAAI;EACrB,IAAI,MAAM,cAAc,YAAY,OAAO;EAC3C,cAAc;EACd,OAAO;CACT;AACF;;;;AC6BA,SAAgB,YAAY,SAAkB,MAAuB;CACnE,OAAO,IAAI,IAAI,QAAQ,GAAG,CAAC,CAAC,aAAa;AAC3C"}

package/dist/internal-CYlgHl1l.js

@@ -0,0 +1,59 @@
+import { t as isChannelMessageSurface } from "./surface-bZZJqBka.js";
+//#region src/channels/internal.ts
+const textEncoder = new TextEncoder();
+function encodeUtf8(value) {
+	return textEncoder.encode(value);
+}
+function utf8ByteLength(value) {
+	return encodeUtf8(value).byteLength;
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function defaultText(message) {
+	return message.title ? `${message.title}\n\n${message.markdown}` : message.markdown;
+}
+function renderInput(input) {
+	if (typeof input === "string") return input;
+	try {
+		return JSON.stringify(input, null, 2) ?? String(input);
+	} catch {
+		return String(input);
+	}
+}
+function uncertain(code, message, reference) {
+	return {
+		status: "uncertain",
+		...reference !== void 0 && { reference },
+		error: {
+			code,
+			message
+		}
+	};
+}
+function emptyIngressResponse(status = 200) {
+	return {
+		events: [],
+		response: new Response(null, { status })
+	};
+}
+function compositeDestinations(surface) {
+	if (surface.address === null || typeof surface.address !== "object" || Array.isArray(surface.address)) return;
+	const destinations = surface.address.surfaces;
+	if (!Array.isArray(destinations) || destinations.length === 0 || !destinations.every(isChannelMessageSurface)) return;
+	return destinations;
+}
+function unsupported(code, message) {
+	return {
+		status: "failed",
+		retryable: false,
+		error: {
+			code,
+			message
+		}
+	};
+}
+//#endregion
+export { isRecord as a, unsupported as c, encodeUtf8 as i, utf8ByteLength as l, defaultText as n, renderInput as o, emptyIngressResponse as r, uncertain as s, compositeDestinations as t };
+
+//# sourceMappingURL=internal-CYlgHl1l.js.map

package/dist/internal-CYlgHl1l.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-CYlgHl1l.js","names":[],"sources":["../src/channels/internal.ts"],"sourcesContent":["import type { ChannelMessage, DeliveryResult } from \"./channel\";\nimport type { ChannelIngressResult } from \"./ingress\";\nimport { isChannelMessageSurface, type ChannelMessageSurface } from \"./surface\";\n\nconst textEncoder = new TextEncoder();\n\nexport function encodeUtf8(value: string): Uint8Array<ArrayBuffer> {\n  return textEncoder.encode(value);\n}\n\nexport function utf8ByteLength(value: string): number {\n  return encodeUtf8(value).byteLength;\n}\n\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === \"object\" && !Array.isArray(value);\n}\n\nexport function defaultText(message: ChannelMessage): string {\n  return message.title\n    ? `${message.title}\\n\\n${message.markdown}`\n    : message.markdown;\n}\n\nexport function renderInput(input: unknown): string {\n  if (typeof input === \"string\") return input;\n  try {\n    return JSON.stringify(input, null, 2) ?? String(input);\n  } catch {\n    return String(input);\n  }\n}\n\nexport function uncertain(\n  code: string,\n  message: string,\n  reference?: string\n): Extract<DeliveryResult, { status: \"uncertain\" }> {\n  return {\n    status: \"uncertain\",\n    ...(reference !== undefined && { reference }),\n    error: { code, message }\n  };\n}\n\nexport function emptyIngressResponse<TRaw>(\n  status = 200\n): ChannelIngressResult<TRaw> {\n  return { events: [], response: new Response(null, { status }) };\n}\n\nexport function compositeDestinations(\n  surface: ChannelMessageSurface\n): readonly ChannelMessageSurface[] | undefined {\n  if (\n    surface.address === null ||\n    typeof surface.address !== \"object\" ||\n    Array.isArray(surface.address)\n  ) {\n    return undefined;\n  }\n  const destinations = (surface.address as Record<string, unknown>).surfaces;\n  if (\n    !Array.isArray(destinations) ||\n    destinations.length === 0 ||\n    !destinations.every(isChannelMessageSurface)\n  ) {\n    return undefined;\n  }\n  return destinations;\n}\n\nexport function unsupported(\n  code: string,\n  message: string\n): Extract<DeliveryResult, { status: \"failed\" }> {\n  return {\n    status: \"failed\",\n    retryable: false,\n    error: { code, message }\n  };\n}\n"],"mappings":";;AAIA,MAAM,cAAc,IAAI,YAAY;AAEpC,SAAgB,WAAW,OAAwC;CACjE,OAAO,YAAY,OAAO,KAAK;AACjC;AAEA,SAAgB,eAAe,OAAuB;CACpD,OAAO,WAAW,KAAK,CAAC,CAAC;AAC3B;AAEA,SAAgB,SAAS,OAAkD;CACzE,OAAO,UAAU,QAAQ,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,KAAK;AAC5E;AAEA,SAAgB,YAAY,SAAiC;CAC3D,OAAO,QAAQ,QACX,GAAG,QAAQ,MAAM,MAAM,QAAQ,aAC/B,QAAQ;AACd;AAEA,SAAgB,YAAY,OAAwB;CAClD,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI;EACF,OAAO,KAAK,UAAU,OAAO,MAAM,CAAC,KAAK,OAAO,KAAK;CACvD,QAAQ;EACN,OAAO,OAAO,KAAK;CACrB;AACF;AAEA,SAAgB,UACd,MACA,SACA,WACkD;CAClD,OAAO;EACL,QAAQ;EACR,GAAI,cAAc,KAAA,KAAa,EAAE,UAAU;EAC3C,OAAO;GAAE;GAAM;EAAQ;CACzB;AACF;AAEA,SAAgB,qBACd,SAAS,KACmB;CAC5B,OAAO;EAAE,QAAQ,CAAC;EAAG,UAAU,IAAI,SAAS,MAAM,EAAE,OAAO,CAAC;CAAE;AAChE;AAEA,SAAgB,sBACd,SAC8C;CAC9C,IACE,QAAQ,YAAY,QACpB,OAAO,QAAQ,YAAY,YAC3B,MAAM,QAAQ,QAAQ,OAAO,GAE7B;CAEF,MAAM,eAAgB,QAAQ,QAAoC;CAClE,IACE,CAAC,MAAM,QAAQ,YAAY,KAC3B,aAAa,WAAW,KACxB,CAAC,aAAa,MAAM,uBAAuB,GAE3C;CAEF,OAAO;AACT;AAEA,SAAgB,YACd,MACA,SAC+C;CAC/C,OAAO;EACL,QAAQ;EACR,WAAW;EACX,OAAO;GAAE;GAAM;EAAQ;CACzB;AACF"}

package/dist/internal_context-BlxFEWfn.d.ts

@@ -0,0 +1,19 @@
+//#region src/internal_context.d.ts
+type AgentEmail = {
+  from: string;
+  to: string;
+  getRaw: () => Promise<Uint8Array>;
+  headers: Headers;
+  rawSize: number;
+  setReject: (reason: string) => void;
+  forward: (rcptTo: string, headers?: Headers) => Promise<EmailSendResult>;
+  reply: (options: {
+    from: string;
+    to: string;
+    raw: string;
+  }) => Promise<EmailSendResult> /** @internal Indicates email was routed via createSecureReplyEmailResolver */;
+  _secureRouted?: boolean;
+};
+//#endregion
+export { AgentEmail as t };
+//# sourceMappingURL=internal_context-BlxFEWfn.d.ts.map

package/dist/internal_context.d.ts

@@ -1,6 +1,12 @@
 import {
-  n as AgentEmail,
-  r as __DO_NOT_USE_WILL_BREAK__agentContext,
+  i as __DO_NOT_USE_WILL_BREAK__agentContext,
+  n as CurrentAgentContext,
   t as AgentContextStore
-} from "./internal_context-Dg4Cgjcu.js";
-export { AgentContextStore, AgentEmail, __DO_NOT_USE_WILL_BREAK__agentContext };
+} from "./current-agent-Da_C9a3b.js";
+import { t as AgentEmail } from "./internal_context-BlxFEWfn.js";
+export {
+  type AgentContextStore,
+  AgentEmail,
+  type CurrentAgentContext,
+  __DO_NOT_USE_WILL_BREAK__agentContext
+};

package/dist/internal_context.js

@@ -1,11 +1,2 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-//#region src/internal_context.ts
-/**
-* @internal — This is an internal implementation detail.
-* Importing or relying on this symbol **will** break your code in a future release.
-*/
-const __DO_NOT_USE_WILL_BREAK__agentContext = new AsyncLocalStorage();
-//#endregion
+import { t as __DO_NOT_USE_WILL_BREAK__agentContext } from "./current-agent-DhoDkSnH.js";
 export { __DO_NOT_USE_WILL_BREAK__agentContext };
-
-//# sourceMappingURL=internal_context.js.map

package/dist/{client-invoker-BNSZxAkv.d.ts → invoker-CG0_p_Wq.d.ts}

@@ -10,11 +10,11 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 import { Client as Client$1 } from "@modelcontextprotocol/sdk/client/index.js";
 
-//#region src/mcp/client-invoker.d.ts
+//#region src/mcp/client/invoker.d.ts
 type LegacyCallToolResultSchema =
   | typeof CallToolResultSchema
   | typeof CompatibilityCallToolResultSchema;
 type CompatibleMcpClient = Client | Client$1;
 //#endregion
 export { LegacyCallToolResultSchema as n, CompatibleMcpClient as t };
-//# sourceMappingURL=client-invoker-BNSZxAkv.d.ts.map
+//# sourceMappingURL=invoker-CG0_p_Wq.d.ts.map

package/dist/{client-invoker-VNZ7X0nn.js → invoker-CHMnoxIA.js}

@@ -1,4 +1,4 @@
-//#region src/mcp/client-invoker.ts
+//#region src/mcp/client/invoker.ts
 function isLegacyResultSchema(value) {
 	return typeof value?.parse === "function";
 }
@@ -54,4 +54,4 @@ function bindMcpClient(client) {
 //#endregion
 export { callV2Tool as n, bindMcpClient as t };
 
-//# sourceMappingURL=client-invoker-VNZ7X0nn.js.map
+//# sourceMappingURL=invoker-CHMnoxIA.js.map

package/dist/invoker-CHMnoxIA.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invoker-CHMnoxIA.js","names":[],"sources":["../src/mcp/client/invoker.ts"],"sourcesContent":["import type {\n  CallToolRequest,\n  CallToolRequestOptions,\n  CallToolResult,\n  Client,\n  ListToolsResult\n} from \"@modelcontextprotocol/client\";\nimport type { Client as LegacyClient } from \"@modelcontextprotocol/sdk/client/index.js\";\nimport type {\n  CallToolResult as LegacyCallToolResult,\n  CallToolResultSchema,\n  CompatibilityCallToolResultSchema,\n  ListToolsRequest\n} from \"@modelcontextprotocol/sdk/types.js\";\nimport type { RequestOptions as LegacyRequestOptions } from \"@modelcontextprotocol/sdk/shared/protocol.js\";\n\nexport type LegacyCallToolResultSchema =\n  | typeof CallToolResultSchema\n  | typeof CompatibilityCallToolResultSchema;\n\nexport type CallToolSchemaOrOptions =\n  | LegacyCallToolResultSchema\n  | CallToolRequestOptions;\n\nexport type CompatibleMcpClient = Client | LegacyClient;\n\nexport interface BoundMcpClientInvoker {\n  listTools(\n    params?: ListToolsRequest[\"params\"],\n    options?: CallToolRequestOptions\n  ): Promise<ListToolsResult>;\n  callTool(\n    params: CallToolRequest[\"params\"],\n    schemaOrOptions?: CallToolSchemaOrOptions,\n    options?: CallToolRequestOptions\n  ): Promise<LegacyCallToolResult>;\n}\n\nfunction isLegacyResultSchema(\n  value: CallToolSchemaOrOptions | undefined\n): value is LegacyCallToolResultSchema {\n  return (\n    typeof (value as { parse?: unknown } | undefined)?.parse === \"function\"\n  );\n}\n\nfunction normalizeCallToolArguments(\n  schemaOrOptions?: CallToolSchemaOrOptions,\n  options?: CallToolRequestOptions\n): {\n  schema?: LegacyCallToolResultSchema;\n  options?: CallToolRequestOptions;\n} {\n  return isLegacyResultSchema(schemaOrOptions)\n    ? { schema: schemaOrOptions, options }\n    : { options: schemaOrOptions ?? options };\n}\n\n/**\n * Invoke SDK v2 while preserving the deprecated v1 result-schema overload.\n * The v2 request funnel still owns decoding and automatic MRTR.\n */\nexport function callV2Tool(\n  client: Client,\n  params: CallToolRequest[\"params\"],\n  schemaOrOptions?: CallToolSchemaOrOptions,\n  options?: CallToolRequestOptions\n): Promise<CallToolResult> {\n  const normalized = normalizeCallToolArguments(schemaOrOptions, options);\n  if (normalized.schema) {\n    return client.request(\n      { method: \"tools/call\", params },\n      normalized.schema as never,\n      normalized.options\n    ) as Promise<CallToolResult>;\n  }\n  return client.callTool(params, normalized.options);\n}\n\n/**\n * Bind the original methods before decorators such as x402 replace them. All\n * generation-specific calling conventions stay behind this small interface.\n */\nexport function bindMcpClient(\n  client: CompatibleMcpClient\n): BoundMcpClientInvoker {\n  const isV2 =\n    \"getProtocolEra\" in client &&\n    typeof (client as { getProtocolEra?: unknown }).getProtocolEra ===\n      \"function\";\n\n  if (isV2) {\n    const v2Client = client as Client;\n    const listTools = v2Client.listTools.bind(v2Client);\n    const callTool = v2Client.callTool.bind(v2Client);\n    return {\n      listTools: (params, options) => listTools(params, options),\n      callTool: (params, schemaOrOptions, options) => {\n        const normalized = normalizeCallToolArguments(schemaOrOptions, options);\n        const pending = normalized.schema\n          ? v2Client.request(\n              { method: \"tools/call\", params },\n              normalized.schema as never,\n              normalized.options\n            )\n          : callTool(params, normalized.options);\n        return pending as Promise<LegacyCallToolResult>;\n      }\n    };\n  }\n\n  const legacy = client as LegacyClient;\n  const listTools = legacy.listTools.bind(legacy);\n  const callTool = legacy.callTool.bind(legacy);\n  return {\n    listTools: (params, options) =>\n      listTools(\n        params,\n        options as LegacyRequestOptions\n      ) as Promise<ListToolsResult>,\n    callTool: (params, schemaOrOptions, options) => {\n      const normalized = normalizeCallToolArguments(schemaOrOptions, options);\n      return callTool(\n        params as Parameters<LegacyClient[\"callTool\"]>[0],\n        normalized.schema,\n        normalized.options as LegacyRequestOptions\n      ) as Promise<LegacyCallToolResult>;\n    }\n  };\n}\n"],"mappings":";AAsCA,SAAS,qBACP,OACqC;CACrC,OACE,OAAQ,OAA2C,UAAU;AAEjE;AAEA,SAAS,2BACP,iBACA,SAIA;CACA,OAAO,qBAAqB,eAAe,IACvC;EAAE,QAAQ;EAAiB;CAAQ,IACnC,EAAE,SAAS,mBAAmB,QAAQ;AAC5C;;;;;AAMA,SAAgB,WACd,QACA,QACA,iBACA,SACyB;CACzB,MAAM,aAAa,2BAA2B,iBAAiB,OAAO;CACtE,IAAI,WAAW,QACb,OAAO,OAAO,QACZ;EAAE,QAAQ;EAAc;CAAO,GAC/B,WAAW,QACX,WAAW,OACb;CAEF,OAAO,OAAO,SAAS,QAAQ,WAAW,OAAO;AACnD;;;;;AAMA,SAAgB,cACd,QACuB;CAMvB,IAJE,oBAAoB,UACpB,OAAQ,OAAwC,mBAC9C,YAEM;EACR,MAAM,WAAW;EACjB,MAAM,YAAY,SAAS,UAAU,KAAK,QAAQ;EAClD,MAAM,WAAW,SAAS,SAAS,KAAK,QAAQ;EAChD,OAAO;GACL,YAAY,QAAQ,YAAY,UAAU,QAAQ,OAAO;GACzD,WAAW,QAAQ,iBAAiB,YAAY;IAC9C,MAAM,aAAa,2BAA2B,iBAAiB,OAAO;IAQtE,OAPgB,WAAW,SACvB,SAAS,QACP;KAAE,QAAQ;KAAc;IAAO,GAC/B,WAAW,QACX,WAAW,OACb,IACA,SAAS,QAAQ,WAAW,OAAO;GAEzC;EACF;CACF;CAEA,MAAM,SAAS;CACf,MAAM,YAAY,OAAO,UAAU,KAAK,MAAM;CAC9C,MAAM,WAAW,OAAO,SAAS,KAAK,MAAM;CAC5C,OAAO;EACL,YAAY,QAAQ,YAClB,UACE,QACA,OACF;EACF,WAAW,QAAQ,iBAAiB,YAAY;GAC9C,MAAM,aAAa,2BAA2B,iBAAiB,OAAO;GACtE,OAAO,SACL,QACA,WAAW,QACX,WAAW,OACb;EACF;CACF;AACF"}

package/dist/lifecycle/index.d.ts

@@ -0,0 +1,66 @@
+import {
+  C as ConnectionState,
+  S as ConnectionSetStateFn,
+  _ as LifecycleJobOutcome,
+  a as LifecycleEvent,
+  b as Connection,
+  c as LifecycleEvents,
+  d as LifecycleRouteContext,
+  f as LifecycleRoutes,
+  g as LifecycleJobContext,
+  h as LifecycleJob,
+  i as DurableObjectCapability,
+  l as LifecycleHostContextScope,
+  m as LifecycleSockets,
+  n as CapabilityStartContext,
+  o as MemoryLimitContext,
+  p as LifecycleServices,
+  r as CapabilityWebSocketUpgradeContext,
+  s as LifecycleCapability,
+  t as CapabilityRequestContext,
+  u as LifecycleRouteAddress,
+  v as LifecycleJobPushOptions,
+  w as WSMessage,
+  x as ConnectionContext,
+  y as LifecycleJobs
+} from "../capability-runner-Be_-PLR1.js";
+import {
+  a as getCurrentAgent,
+  l as LifecycleUseOptions,
+  n as CurrentAgentContext,
+  o as Lifecycle,
+  r as LifecycleObject,
+  s as LifecycleOptions
+} from "../current-agent-Da_C9a3b.js";
+export {
+  type CapabilityRequestContext,
+  type CapabilityStartContext,
+  type CapabilityWebSocketUpgradeContext,
+  type Connection,
+  type ConnectionContext,
+  type ConnectionSetStateFn,
+  type ConnectionState,
+  type CurrentAgentContext,
+  type DurableObjectCapability,
+  Lifecycle,
+  LifecycleCapability,
+  type LifecycleEvent,
+  type LifecycleEvents,
+  type LifecycleHostContextScope,
+  type LifecycleJob,
+  type LifecycleJobContext,
+  type LifecycleJobOutcome,
+  type LifecycleJobPushOptions,
+  type LifecycleJobs,
+  type LifecycleObject,
+  type LifecycleOptions,
+  type LifecycleRouteAddress,
+  type LifecycleRouteContext,
+  type LifecycleRoutes,
+  type LifecycleServices,
+  type LifecycleSockets,
+  type LifecycleUseOptions,
+  type MemoryLimitContext,
+  type WSMessage,
+  getCurrentAgent
+};

package/dist/lifecycle/index.js

@@ -0,0 +1,4 @@
+import { n as getCurrentAgent } from "../current-agent-DhoDkSnH.js";
+import { t as LifecycleCapability } from "../capability-BjSKYpzg.js";
+import { t as Lifecycle } from "../lifecycle-CMRGjZdw.js";
+export { Lifecycle, LifecycleCapability, getCurrentAgent };