agents 0.22.0 → 0.23.0

package/dist/channel-Bnm4S7T2.d.ts

@@ -0,0 +1,491 @@
+//#region src/channels/identity.d.ts
+type ChannelIdentity = Readonly<{
+  /** Configured Channel that observed this identity. */ channelKey: string /** Stable Channel namespace in which `subject` is unique. @default "default" */;
+  scope?: string /** Stable Channel subject within `scope`. */;
+  subject: string;
+}>;
+/** A Channel-produced identity before its Host stamps the configured key. */
+type ChannelIdentityInput = Readonly<{
+  scope?: string;
+  subject: string;
+}>;
+/** Build a stable key for comparing or indexing a Channel identity. */
+declare function identityKey(identity: ChannelIdentity): string;
+type UserIdentity = Readonly<{
+  /** Opaque identity owned by this store. */ id: string /** Channel identities explicitly linked to this user. */;
+  channelIdentities: readonly ChannelIdentity[];
+}>;
+type UserIdentityConflict = Readonly<{
+  channelIdentity: ChannelIdentity;
+  userId: string;
+}>;
+/** Raised when an operation would join identities already assigned to users. */
+declare class UserIdentityConflictError extends Error {
+  readonly conflicts: readonly UserIdentityConflict[];
+  readonly attemptedUserId?: string | undefined;
+  readonly code = "USER_IDENTITY_CONFLICT";
+  constructor(
+    conflicts: readonly UserIdentityConflict[],
+    attemptedUserId?: string | undefined
+  );
+}
+/**
+ * Application-owned user identity links.
+ *
+ * Implementations never infer links from usernames, email-like values, display
+ * names, or message surfaces. Every link is an explicit application decision.
+ */
+interface UserIdentityStore {
+  /** Link one Channel identity to a user. Repeating the same link is safe. */
+  link(userId: string, identity: ChannelIdentity): Promise<UserIdentity>;
+  /** Find the user linked to one Channel identity. */
+  findUser(identity: ChannelIdentity): Promise<UserIdentity | null>;
+  /** Get a user and all of its linked Channel identities. */
+  getUser(userId: string): Promise<UserIdentity | null>;
+  /** List every user and its linked Channel identities, ordered by user ID. */
+  listUsers(): Promise<UserIdentity[]>;
+  /**
+   * Atomically join two previously unjoined Channel identities.
+   *
+   * If one is linked, the other joins that user. If neither is linked, a new
+   * user is created. If both are linked, this raises
+   * `UserIdentityConflictError`, including when both point to the same user.
+   */
+  linkChannelIdentities(
+    first: ChannelIdentity,
+    second: ChannelIdentity
+  ): Promise<UserIdentity>;
+}
+type UserIdentitySqlValue = ArrayBuffer | string | number | null;
+/** Structural storage seam satisfied by Durable Object SQLite storage. */
+interface UserIdentityStorage {
+  readonly sql: {
+    exec<Row extends Record<string, UserIdentitySqlValue>>(
+      query: string,
+      ...bindings: UserIdentitySqlValue[]
+    ): {
+      toArray(): Row[];
+    };
+  };
+  transactionSync<Result>(closure: () => Result): Result;
+}
+type UserIdentityStoreOptions = {
+  /** Generate a new opaque user ID. @default crypto.randomUUID */ createUserId?: () => string;
+};
+/** Build the off-the-shelf user identity store over application-owned SQLite. */
+declare function createUserIdentityStore(
+  storage: UserIdentityStorage,
+  options?: UserIdentityStoreOptions
+): UserIdentityStore;
+/** Join two Channel identities through a `UserIdentityStore`. */
+declare function linkChannelIdentities(
+  store: UserIdentityStore,
+  first: ChannelIdentity,
+  second: ChannelIdentity
+): Promise<UserIdentity>;
+//#endregion
+//#region src/channels/surface.d.ts
+/**
+ * A JSON value safe to persist across Worker and Durable Object boundaries.
+ *
+ * The recursive arms are interfaces rather than inline type literals so that
+ * TypeScript defers resolving them. Workers RPC checks a return type with
+ * `R extends Rpc.Serializable<R>`, which eagerly expands a self-referential
+ * type alias and fails with "Type instantiation is excessively deep". Deferred
+ * arms let a surface be returned from a Durable Object method.
+ */
+type ChannelSurfaceValue =
+  | null
+  | boolean
+  | number
+  | string
+  | ChannelSurfaceArray
+  | ChannelSurfaceObject;
+interface ChannelSurfaceArray extends ReadonlyArray<ChannelSurfaceValue> {}
+interface ChannelSurfaceObject {
+  readonly [key: string]: ChannelSurfaceValue;
+}
+/** A durable configured destination for one outbound message attempt. */
+type ChannelMessageSurface<
+  TChannelKey extends string = string,
+  TAddress extends ChannelSurfaceValue = ChannelSurfaceValue
+> = Readonly<{
+  channelKey: TChannelKey;
+  version: 1;
+  address: TAddress /** Human-readable destination text captured when the surface is created. */;
+  label: string;
+}>;
+/** A Channel-produced destination before its Host stamps the configured key. */
+type ChannelMessageSurfaceInput<
+  TAddress extends ChannelSurfaceValue = ChannelSurfaceValue
+> = Readonly<{
+  version: 1;
+  address: TAddress;
+  label: string;
+}>;
+/** Validate the common envelope before provider-specific address parsing. */
+declare function isChannelMessageSurface(
+  value: unknown
+): value is ChannelMessageSurface;
+//#endregion
+//#region src/channels/ingress.d.ts
+/** Serializable provider attachment facts available after ingress returns. */
+type ChannelAttachment = {
+  id?: string;
+  mediaType?: string;
+  name?: string;
+  size?: number;
+  text?: string;
+  url?: string;
+};
+type ChannelActor = {
+  readonly id: string /** Stable Channel identity suitable for explicit application linking. */;
+  readonly identity?: ChannelIdentity;
+  readonly username?: string;
+  readonly fullName?: string;
+  readonly isBot?: boolean | "unknown";
+  readonly isSelf?: boolean;
+};
+/** An actor before the Host stamps its configured Channel key. */
+type ChannelActorInput = Omit<ChannelActor, "identity"> & {
+  readonly identity?: ChannelIdentityInput;
+};
+type ChannelEventContext = {
+  /** Immutable Channel-scoped identity, independent of application routing. */ readonly eventId: string;
+  readonly thread: {
+    readonly id: string;
+    readonly isDirectMessage: boolean | "unknown";
+  } /** Exact provider destination for responding to this inbound event. */;
+  readonly replySurface?: ChannelMessageSurface;
+  readonly actor?: ChannelActor;
+};
+/** A normalized inbound message from a Channel adapter. */
+type ChannelInboundMessage = ChannelEventContext & {
+  readonly type: "message";
+  readonly message: {
+    readonly id: string;
+    readonly text: string;
+    readonly title?: string;
+    readonly markdown?: string;
+    readonly attachments?: readonly ChannelAttachment[];
+    readonly isMention?: boolean;
+    readonly reply?: {
+      readonly id: string;
+      readonly text?: string;
+    };
+    readonly metadata?: {
+      /** ISO 8601 timestamp supplied by the provider. */ readonly sentAt?: string;
+      readonly edited?: boolean /** ISO 8601 timestamp supplied by the provider. */;
+      readonly editedAt?: string;
+      readonly autoReply?: boolean;
+    };
+  };
+};
+/** A provider-normalized response to an external approval request. */
+type ChannelApprovalResponse = ChannelEventContext & {
+  readonly type: "approval-response";
+  readonly interactionId: string;
+  readonly decision:
+    | "approve"
+    | "reject" /** Provider reference for this inbound response. */;
+  readonly reference: string;
+};
+type ChannelIngressEvent = ChannelInboundMessage | ChannelApprovalResponse;
+/** A normalized message before the Host stamps its configured Channel key. */
+type ChannelEventContextInput = Omit<
+  ChannelEventContext,
+  "replySurface" | "actor"
+> & {
+  readonly replySurface?: ChannelMessageSurfaceInput;
+  readonly actor?: ChannelActorInput;
+};
+type ChannelInboundMessageInput = Omit<
+  ChannelInboundMessage,
+  "replySurface" | "actor"
+> & {
+  readonly replySurface?: ChannelMessageSurfaceInput;
+  readonly actor?: ChannelActorInput;
+};
+/** A normalized approval before the Host stamps its configured Channel key. */
+type ChannelApprovalResponseInput = Omit<
+  ChannelApprovalResponse,
+  "replySurface" | "actor"
+> & {
+  readonly replySurface?: ChannelMessageSurfaceInput;
+  readonly actor?: ChannelActorInput;
+};
+/** Authenticated event produced by a Channel before Host dispatch. */
+type ChannelIngressEventInput =
+  | ChannelInboundMessageInput
+  | ChannelApprovalResponseInput;
+/** Authenticated adapter output retained only until Host routing completes. */
+type ChannelIngressEnvelope<TRaw = unknown> = {
+  event: ChannelIngressEventInput;
+  raw: TRaw;
+};
+/** The normalized envelopes and provider acknowledgement produced by ingress. */
+type ChannelIngressResult<TRaw = unknown> = {
+  events: readonly ChannelIngressEnvelope<TRaw>[];
+  response: Response;
+};
+/** Match an HTTP request to one exact URL pathname. */
+declare function matchesPath(request: Request, path: string): boolean;
+/** Webhook-shaped inbound support owned by a Channel. */
+interface ChannelIngress<TRaw = unknown> {
+  /** Return null when this Channel does not own the request. */
+  receive(request: Request): Promise<ChannelIngressResult<TRaw> | null>;
+}
+/** Structural input supported by Workers Email and Agent email handlers. */
+type ChannelEmailInput = {
+  from: string;
+  to: string;
+  headers: Headers;
+  raw?: ReadableStream<Uint8Array>;
+  getRaw?: () => Promise<Uint8Array>;
+};
+type ChannelEmailIngressResult<TRaw = unknown> = {
+  events: readonly ChannelIngressEnvelope<TRaw>[];
+};
+/** Non-HTTP ingress for a Workers Email event. */
+interface ChannelEmailIngress<TRaw = unknown> {
+  /** Return null when this Channel does not own the email. */
+  receive(
+    email: ChannelEmailInput
+  ): Promise<ChannelEmailIngressResult<TRaw> | null>;
+}
+//#endregion
+//#region src/channels/channel.d.ts
+type Awaitable<T> = T | Promise<T>;
+/** A transport-neutral outbound message whose canonical content is Markdown. */
+type ChannelMessage = {
+  /** Optional topic. Each transport decides how to represent it. */ title?: string /** Canonical Markdown content. */;
+  markdown: string;
+};
+/** A transport failure safe to expose to an AI model. */
+type DeliveryFailure = {
+  code: string;
+  message: string;
+};
+/**
+ * The result of a direct delivery attempt, defined by what reached the reader.
+ *
+ * `delivered` means the whole message reached the reader, not that a person
+ * read it. `failed` means none of it did; its `retryable` field says whether
+ * the same route can be attempted again. `uncertain` means an unknown amount
+ * of the message reached the reader, so another attempt or route could
+ * duplicate content. A stream that ends before its answer is complete is
+ * `uncertain`, and carries a `reference` when the Channel created something
+ * the caller can point at.
+ */
+type DeliveryResult =
+  | {
+      status: "delivered";
+      reference?: string;
+    }
+  | {
+      status: "failed";
+      retryable: boolean;
+      error: DeliveryFailure;
+    }
+  | {
+      status: "uncertain";
+      reference?: string;
+      error: DeliveryFailure;
+    };
+/**
+ * One element of a progressively generated answer.
+ *
+ * The variants describe what an Agent produces, not what a provider renders.
+ * Any Channel may ignore any variant, so `text` alone must always be a
+ * complete answer; a variant carrying meaning `text` does not is a bug in the
+ * variant.
+ */
+type ChannelChunk =
+  | {
+      type: "text";
+      text: string;
+    }
+  | {
+      type: "reasoning";
+      text: string;
+    }
+  | {
+      type: "tool" /** Stable identity for one invocation when the producer provides it. */;
+      id?: string;
+      name: string;
+      status: "started" | "completed" | "failed";
+      title?: string;
+      detail?: string;
+    }
+  | {
+      type: "source";
+      url: string;
+      title?: string;
+    };
+/** The normalized stream shape accepted by `ChannelHost.stream`. */
+type ChannelChunkSource = ReadableStream<ChannelChunk>;
+/** Caller options for one finished delivery. */
+type ChannelDeliveryOptions = {
+  /** Caller-owned correlation an Adapter may use where the provider supports it. */ delivery?: ChannelDeliveryContext;
+};
+/** Caller options for one streamed answer. */
+type ChannelStreamOptions = {
+  /**
+   * Optional topic. It is an option rather than a chunk because it is known
+   * before the first token, and a Channel usually needs it in its opening
+   * provider call.
+   */
+  title?: string /** Caller-owned correlation an Adapter may use where the provider supports it. */;
+  delivery?: ChannelDeliveryContext;
+};
+/**
+ * Caller-owned correlation supplied to one provider delivery attempt.
+ *
+ * This is not an idempotency guarantee. An Adapter may map it to a provider
+ * idempotency primitive when one exists, or otherwise use it for observability.
+ */
+type ChannelDeliveryContext = {
+  deliveryId: string;
+};
+/** Caller-supplied approval links a Channel may include in its rendering. */
+type ChannelApprovalLinks = {
+  approve: string;
+  reject: string;
+};
+/** The content a Channel needs to render an external approval request. */
+type ChannelApprovalRequest = {
+  title?: string;
+  summary: string;
+  input: unknown;
+};
+type ChannelApprovalRequestOptions = {
+  interactionId: string;
+  request: ChannelApprovalRequest /** Caller-owned correlation an Adapter may use where the provider supports it. */;
+  delivery?: ChannelDeliveryContext /** Lazily obtains approval links supplied and settled by the caller. */;
+  getApprovalLinks?: () => Promise<ChannelApprovalLinks>;
+};
+type ChannelRouteContext = {
+  /** Lazily resolve the application user explicitly linked to the event actor. */ findUser(): Promise<UserIdentity | null>;
+};
+type ChannelRoute<TRaw = unknown> = (
+  event: ChannelIngressEvent,
+  raw: TRaw,
+  context: ChannelRouteContext
+) => Awaitable<string | null>;
+/** Recursive outbound capability injected into a composite Channel. */
+type OutboundResolver = {
+  deliver(
+    surface: ChannelMessageSurface,
+    message: ChannelMessage,
+    options?: ChannelDeliveryOptions
+  ): Promise<DeliveryResult>;
+  stream(
+    surface: ChannelMessageSurface,
+    chunks: ChannelChunkSource,
+    options?: ChannelStreamOptions
+  ): Promise<DeliveryResult>;
+  requestApproval(
+    surface: ChannelMessageSurface,
+    options: ChannelApprovalRequestOptions
+  ): Promise<DeliveryResult>;
+  isAvailable(surface: ChannelMessageSurface): Promise<boolean>;
+};
+/** A configured delivery route with optional approval and ingress support. */
+interface Channel<TRaw = unknown> {
+  /** Select an opaque application route, or return null to ignore the event. */
+  route?(
+    event: ChannelIngressEvent,
+    raw: TRaw,
+    context: ChannelRouteContext
+  ): Awaitable<string | null>;
+  /** Derive a direct destination from this configured Channel's identity. */
+  contactSurface?(identity: ChannelIdentity): ChannelMessageSurfaceInput | null;
+  /**
+   * Whether this route can currently be selected without attempting delivery.
+   * Absence means the channel should be attempted.
+   */
+  isAvailable?(surface: ChannelMessageSurface): Awaitable<boolean>;
+  /**
+   * Perform one outbound delivery. Absent for inbound-only Channels.
+   */
+  deliver?(
+    surface: ChannelMessageSurface,
+    message: ChannelMessage,
+    options?: ChannelDeliveryOptions
+  ): Promise<DeliveryResult>;
+  /**
+   * Deliver one progressively generated answer. Absent for Channels that
+   * cannot stream, which the Host serves by collecting and calling `deliver`.
+   *
+   * The Channel owns the consumption loop. It must finalize whether the
+   * stream closed or errored, because a model can fail mid-generation, and it
+   * must not abandon a terminal provider call on error.
+   */
+  stream?(
+    surface: ChannelMessageSurface,
+    chunks: ReadableStream<ChannelChunk>,
+    options: ChannelStreamOptions
+  ): Promise<DeliveryResult>;
+  requestApproval?(
+    surface: ChannelMessageSurface,
+    options: ChannelApprovalRequestOptions
+  ): Promise<DeliveryResult>;
+  readonly ingress?: ChannelIngress<TRaw>;
+  readonly emailIngress?: ChannelEmailIngress<TRaw>;
+}
+//#endregion
+export {
+  ChannelIngressEnvelope as A,
+  isChannelMessageSurface as B,
+  ChannelEmailIngressResult as C,
+  ChannelInboundMessage as D,
+  ChannelEventContextInput as E,
+  ChannelMessageSurface as F,
+  UserIdentityConflictError as G,
+  ChannelIdentityInput as H,
+  ChannelMessageSurfaceInput as I,
+  UserIdentityStore as J,
+  UserIdentitySqlValue as K,
+  ChannelSurfaceArray as L,
+  ChannelIngressEventInput as M,
+  ChannelIngressResult as N,
+  ChannelInboundMessageInput as O,
+  matchesPath as P,
+  linkChannelIdentities as Q,
+  ChannelSurfaceObject as R,
+  ChannelEmailIngress as S,
+  ChannelEventContext as T,
+  UserIdentity as U,
+  ChannelIdentity as V,
+  UserIdentityConflict as W,
+  createUserIdentityStore as X,
+  UserIdentityStoreOptions as Y,
+  identityKey as Z,
+  ChannelActor as _,
+  ChannelApprovalRequestOptions as a,
+  ChannelApprovalResponseInput as b,
+  ChannelDeliveryContext as c,
+  ChannelRoute as d,
+  ChannelRouteContext as f,
+  OutboundResolver as g,
+  DeliveryResult as h,
+  ChannelApprovalRequest as i,
+  ChannelIngressEvent as j,
+  ChannelIngress as k,
+  ChannelDeliveryOptions as l,
+  DeliveryFailure as m,
+  Channel as n,
+  ChannelChunk as o,
+  ChannelStreamOptions as p,
+  UserIdentityStorage as q,
+  ChannelApprovalLinks as r,
+  ChannelChunkSource as s,
+  Awaitable as t,
+  ChannelMessage as u,
+  ChannelActorInput as v,
+  ChannelEmailInput as w,
+  ChannelAttachment as x,
+  ChannelApprovalResponse as y,
+  ChannelSurfaceValue as z
+};
+//# sourceMappingURL=channel-Bnm4S7T2.d.ts.map

package/dist/channels/ai-sdk.d.ts

@@ -0,0 +1,46 @@
+import {
+  F as ChannelMessageSurface,
+  h as DeliveryResult,
+  o as ChannelChunk,
+  u as ChannelMessage
+} from "../channel-Bnm4S7T2.js";
+import { n as ChannelHost } from "../index-BB0kqhIz.js";
+import { TextStreamPart, Tool, ToolSet } from "ai";
+
+//#region src/channels/ai-sdk.d.ts
+type SendMessageTool = Tool<ChannelMessage, DeliveryResult>;
+/** Model-facing options controlled by the caller creating the tool. */
+type CreateSendMessageToolOptions = Pick<
+  SendMessageTool,
+  | "description"
+  | "inputExamples"
+  | "metadata"
+  | "needsApproval"
+  | "providerOptions"
+  | "strict"
+>;
+/**
+ * Adapt one Host-resolved surface to an AI SDK tool.
+ *
+ * The caller chooses the key used in its ToolSet and owns model-facing policy
+ * such as the description, examples, metadata, and approval requirement.
+ */
+declare function createSendMessageTool(
+  host: ChannelHost,
+  surface: ChannelMessageSurface,
+  options?: CreateSendMessageToolOptions
+): Tool<ChannelMessage, DeliveryResult>;
+/**
+ * Project an AI SDK `fullStream` onto neutral Channel chunks.
+ *
+ * Parts a Channel cannot express are dropped, which keeps provider part
+ * shapes out of `ChannelChunk`. An `error` or `abort` part errors the returned
+ * stream, so a generation that fails part-way reaches a Channel as the
+ * abnormal ending it is rather than as a complete answer.
+ */
+declare function toChannelChunks(
+  fullStream: AsyncIterable<TextStreamPart<ToolSet>>
+): ReadableStream<ChannelChunk>;
+//#endregion
+export { CreateSendMessageToolOptions, createSendMessageTool, toChannelChunks };
+//# sourceMappingURL=ai-sdk.d.ts.map

package/dist/channels/ai-sdk.js

@@ -0,0 +1,120 @@
+import { n as parseChannelMessage, t as channelMessageJsonSchema } from "../tool-schema-CBjGPrsQ.js";
+import { jsonSchema, tool } from "ai";
+//#region src/channels/ai-sdk.ts
+const channelMessageSchema = jsonSchema(channelMessageJsonSchema, { validate(value) {
+	try {
+		return {
+			success: true,
+			value: parseChannelMessage(value)
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: error instanceof Error ? error : new Error(String(error))
+		};
+	}
+} });
+/**
+* Adapt one Host-resolved surface to an AI SDK tool.
+*
+* The caller chooses the key used in its ToolSet and owns model-facing policy
+* such as the description, examples, metadata, and approval requirement.
+*/
+function createSendMessageTool(host, surface, options = {}) {
+	return tool({
+		...options,
+		inputSchema: channelMessageSchema,
+		execute: (message) => host.deliver(surface, message)
+	});
+}
+function toChannelChunk(part) {
+	switch (part.type) {
+		case "text-delta": return {
+			type: "text",
+			text: part.text
+		};
+		case "reasoning-delta": return {
+			type: "reasoning",
+			text: part.text
+		};
+		case "source": return part.sourceType === "url" ? {
+			type: "source",
+			url: part.url,
+			...part.title !== void 0 && { title: part.title }
+		} : void 0;
+		case "tool-call": return {
+			type: "tool",
+			id: part.toolCallId,
+			name: part.toolName,
+			status: "started"
+		};
+		case "tool-result": return {
+			type: "tool",
+			id: part.toolCallId,
+			name: part.toolName,
+			status: "completed"
+		};
+		case "tool-error": return {
+			type: "tool",
+			id: part.toolCallId,
+			name: part.toolName,
+			status: "failed"
+		};
+		default: return;
+	}
+}
+/**
+* Project an AI SDK `fullStream` onto neutral Channel chunks.
+*
+* Parts a Channel cannot express are dropped, which keeps provider part
+* shapes out of `ChannelChunk`. An `error` or `abort` part errors the returned
+* stream, so a generation that fails part-way reaches a Channel as the
+* abnormal ending it is rather than as a complete answer.
+*/
+function toChannelChunks(fullStream) {
+	const parts = fullStream[Symbol.asyncIterator]();
+	let sourceClosed = false;
+	async function closeSource(reason) {
+		if (sourceClosed) return;
+		sourceClosed = true;
+		await parts.return?.(reason);
+	}
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				while (true) {
+					const { done, value } = await parts.next();
+					if (done) {
+						sourceClosed = true;
+						controller.close();
+						return;
+					}
+					if (value.type === "error") {
+						const error = value.error instanceof Error ? value.error : new Error(String(value.error));
+						await closeSource().catch(() => {});
+						controller.error(error);
+						return;
+					}
+					if (value.type === "abort") {
+						const error = new Error(value.reason ?? "The generation was aborted");
+						await closeSource().catch(() => {});
+						controller.error(error);
+						return;
+					}
+					const chunk = toChannelChunk(value);
+					if (!chunk) continue;
+					controller.enqueue(chunk);
+					return;
+				}
+			} catch (error) {
+				await closeSource().catch(() => {});
+				controller.error(error);
+			}
+		},
+		cancel: closeSource
+	});
+}
+//#endregion
+export { createSendMessageTool, toChannelChunks };
+
+//# sourceMappingURL=ai-sdk.js.map

package/dist/channels/ai-sdk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-sdk.js","names":[],"sources":["../../src/channels/ai-sdk.ts"],"sourcesContent":["import {\n  jsonSchema,\n  tool,\n  type TextStreamPart,\n  type Tool,\n  type ToolSet\n} from \"ai\";\nimport type { ChannelChunk, ChannelMessage, DeliveryResult } from \"./channel\";\nimport type { ChannelHost } from \"./host\";\nimport type { ChannelMessageSurface } from \"./surface\";\nimport { channelMessageJsonSchema, parseChannelMessage } from \"./tool-schema\";\n\ntype SendMessageTool = Tool<ChannelMessage, DeliveryResult>;\n\n/** Model-facing options controlled by the caller creating the tool. */\nexport type CreateSendMessageToolOptions = Pick<\n  SendMessageTool,\n  | \"description\"\n  | \"inputExamples\"\n  | \"metadata\"\n  | \"needsApproval\"\n  | \"providerOptions\"\n  | \"strict\"\n>;\n\nconst channelMessageSchema = jsonSchema<ChannelMessage>(\n  channelMessageJsonSchema,\n  {\n    validate(value) {\n      try {\n        return { success: true, value: parseChannelMessage(value) };\n      } catch (error) {\n        return {\n          success: false,\n          error: error instanceof Error ? error : new Error(String(error))\n        };\n      }\n    }\n  }\n);\n\n/**\n * Adapt one Host-resolved surface to an AI SDK tool.\n *\n * The caller chooses the key used in its ToolSet and owns model-facing policy\n * such as the description, examples, metadata, and approval requirement.\n */\nexport function createSendMessageTool(\n  host: ChannelHost,\n  surface: ChannelMessageSurface,\n  options: CreateSendMessageToolOptions = {}\n): Tool<ChannelMessage, DeliveryResult> {\n  return tool({\n    ...options,\n    inputSchema: channelMessageSchema,\n    execute: (message) => host.deliver(surface, message)\n  });\n}\n\nfunction toChannelChunk(\n  part: TextStreamPart<ToolSet>\n): ChannelChunk | undefined {\n  switch (part.type) {\n    case \"text-delta\":\n      return { type: \"text\", text: part.text };\n    case \"reasoning-delta\":\n      return { type: \"reasoning\", text: part.text };\n    case \"source\":\n      return part.sourceType === \"url\"\n        ? {\n            type: \"source\",\n            url: part.url,\n            ...(part.title !== undefined && { title: part.title })\n          }\n        : undefined;\n    case \"tool-call\":\n      return {\n        type: \"tool\",\n        id: part.toolCallId,\n        name: part.toolName,\n        status: \"started\"\n      };\n    case \"tool-result\":\n      return {\n        type: \"tool\",\n        id: part.toolCallId,\n        name: part.toolName,\n        status: \"completed\"\n      };\n    case \"tool-error\":\n      return {\n        type: \"tool\",\n        id: part.toolCallId,\n        name: part.toolName,\n        status: \"failed\"\n      };\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Project an AI SDK `fullStream` onto neutral Channel chunks.\n *\n * Parts a Channel cannot express are dropped, which keeps provider part\n * shapes out of `ChannelChunk`. An `error` or `abort` part errors the returned\n * stream, so a generation that fails part-way reaches a Channel as the\n * abnormal ending it is rather than as a complete answer.\n */\nexport function toChannelChunks(\n  fullStream: AsyncIterable<TextStreamPart<ToolSet>>\n): ReadableStream<ChannelChunk> {\n  const parts = fullStream[Symbol.asyncIterator]();\n  let sourceClosed = false;\n\n  async function closeSource(reason?: unknown): Promise<void> {\n    if (sourceClosed) return;\n    sourceClosed = true;\n    await parts.return?.(reason);\n  }\n\n  return new ReadableStream<ChannelChunk>({\n    async pull(controller) {\n      try {\n        while (true) {\n          const { done, value } = await parts.next();\n          if (done) {\n            sourceClosed = true;\n            controller.close();\n            return;\n          }\n          if (value.type === \"error\") {\n            const error =\n              value.error instanceof Error\n                ? value.error\n                : new Error(String(value.error));\n            await closeSource().catch(() => {});\n            controller.error(error);\n            return;\n          }\n          if (value.type === \"abort\") {\n            const error = new Error(\n              value.reason ?? \"The generation was aborted\"\n            );\n            await closeSource().catch(() => {});\n            controller.error(error);\n            return;\n          }\n          const chunk = toChannelChunk(value);\n          if (!chunk) continue;\n          controller.enqueue(chunk);\n          return;\n        }\n      } catch (error) {\n        await closeSource().catch(() => {});\n        controller.error(error);\n      }\n    },\n    cancel: closeSource\n  });\n}\n"],"mappings":";;;AAyBA,MAAM,uBAAuB,WAC3B,0BACA,EACE,SAAS,OAAO;CACd,IAAI;EACF,OAAO;GAAE,SAAS;GAAM,OAAO,oBAAoB,KAAK;EAAE;CAC5D,SAAS,OAAO;EACd,OAAO;GACL,SAAS;GACT,OAAO,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;EACjE;CACF;AACF,EACF,CACF;;;;;;;AAQA,SAAgB,sBACd,MACA,SACA,UAAwC,CAAC,GACH;CACtC,OAAO,KAAK;EACV,GAAG;EACH,aAAa;EACb,UAAU,YAAY,KAAK,QAAQ,SAAS,OAAO;CACrD,CAAC;AACH;AAEA,SAAS,eACP,MAC0B;CAC1B,QAAQ,KAAK,MAAb;EACE,KAAK,cACH,OAAO;GAAE,MAAM;GAAQ,MAAM,KAAK;EAAK;EACzC,KAAK,mBACH,OAAO;GAAE,MAAM;GAAa,MAAM,KAAK;EAAK;EAC9C,KAAK,UACH,OAAO,KAAK,eAAe,QACvB;GACE,MAAM;GACN,KAAK,KAAK;GACV,GAAI,KAAK,UAAU,KAAA,KAAa,EAAE,OAAO,KAAK,MAAM;EACtD,IACA,KAAA;EACN,KAAK,aACH,OAAO;GACL,MAAM;GACN,IAAI,KAAK;GACT,MAAM,KAAK;GACX,QAAQ;EACV;EACF,KAAK,eACH,OAAO;GACL,MAAM;GACN,IAAI,KAAK;GACT,MAAM,KAAK;GACX,QAAQ;EACV;EACF,KAAK,cACH,OAAO;GACL,MAAM;GACN,IAAI,KAAK;GACT,MAAM,KAAK;GACX,QAAQ;EACV;EACF,SACE;CACJ;AACF;;;;;;;;;AAUA,SAAgB,gBACd,YAC8B;CAC9B,MAAM,QAAQ,WAAW,OAAO,cAAc,CAAC;CAC/C,IAAI,eAAe;CAEnB,eAAe,YAAY,QAAiC;EAC1D,IAAI,cAAc;EAClB,eAAe;EACf,MAAM,MAAM,SAAS,MAAM;CAC7B;CAEA,OAAO,IAAI,eAA6B;EACtC,MAAM,KAAK,YAAY;GACrB,IAAI;IACF,OAAO,MAAM;KACX,MAAM,EAAE,MAAM,UAAU,MAAM,MAAM,KAAK;KACzC,IAAI,MAAM;MACR,eAAe;MACf,WAAW,MAAM;MACjB;KACF;KACA,IAAI,MAAM,SAAS,SAAS;MAC1B,MAAM,QACJ,MAAM,iBAAiB,QACnB,MAAM,QACN,IAAI,MAAM,OAAO,MAAM,KAAK,CAAC;MACnC,MAAM,YAAY,CAAC,CAAC,YAAY,CAAC,CAAC;MAClC,WAAW,MAAM,KAAK;MACtB;KACF;KACA,IAAI,MAAM,SAAS,SAAS;MAC1B,MAAM,QAAQ,IAAI,MAChB,MAAM,UAAU,4BAClB;MACA,MAAM,YAAY,CAAC,CAAC,YAAY,CAAC,CAAC;MAClC,WAAW,MAAM,KAAK;MACtB;KACF;KACA,MAAM,QAAQ,eAAe,KAAK;KAClC,IAAI,CAAC,OAAO;KACZ,WAAW,QAAQ,KAAK;KACxB;IACF;GACF,SAAS,OAAO;IACd,MAAM,YAAY,CAAC,CAAC,YAAY,CAAC,CAAC;IAClC,WAAW,MAAM,KAAK;GACxB;EACF;EACA,QAAQ;CACV,CAAC;AACH"}