@cloudflare/think 0.0.0 → 0.0.2

package/dist/index-C4OTSwUW.d.ts

@@ -0,0 +1,193 @@
+import { UIMessage } from "ai";
+
+//#region src/session/storage.d.ts
+interface Session {
+  id: string;
+  name: string;
+  created_at: string;
+  updated_at: string;
+}
+interface Compaction {
+  id: string;
+  session_id: string;
+  summary: string;
+  from_message_id: string;
+  to_message_id: string;
+  created_at: string;
+}
+//#endregion
+//#region src/session/index.d.ts
+/**
+ * Truncate from the head (keep the end of the content).
+ */
+declare function truncateHead(text: string, maxChars?: number): string;
+/**
+ * Truncate from the tail (keep the start of the content).
+ */
+declare function truncateTail(text: string, maxChars?: number): string;
+/**
+ * Truncate by line count (keep the first N lines).
+ */
+declare function truncateLines(text: string, maxLines?: number): string;
+/**
+ * Truncate from both ends, keeping the start and end.
+ */
+declare function truncateMiddle(text: string, maxChars?: number): string;
+/**
+ * Smart truncation for tool output.
+ */
+declare function truncateToolOutput(
+  output: string,
+  options?: {
+    maxChars?: number;
+    maxLines?: number;
+    strategy?: "head" | "tail" | "middle";
+  }
+): string;
+interface AgentLike {
+  sql: (
+    strings: TemplateStringsArray,
+    ...values: (string | number | boolean | null)[]
+  ) => Array<Record<string, unknown>>;
+}
+interface SessionManagerOptions {
+  /**
+   * Maximum number of messages on the current branch before
+   * needsCompaction() returns true. Default: 100.
+   */
+  maxContextMessages?: number;
+  /**
+   * Raw SQL exec function for batch operations (e.g. DELETE ... WHERE id IN (...)).
+   * When provided, batch deletes use a single query instead of N individual ones.
+   *
+   * Typically: `(query, ...values) => { agent.ctx.storage.sql.exec(query, ...values); }`
+   */
+  exec?: (
+    query: string,
+    ...values: (string | number | boolean | null)[]
+  ) => void;
+}
+declare class SessionManager {
+  private _storage;
+  private _options;
+  constructor(agent: AgentLike, options?: SessionManagerOptions);
+  /**
+   * Create a new session with a name.
+   */
+  create(name: string): Session;
+  /**
+   * Get a session by ID.
+   */
+  get(sessionId: string): Session | null;
+  /**
+   * List all sessions, most recently updated first.
+   */
+  list(): Session[];
+  /**
+   * Delete a session and all its messages and compactions.
+   */
+  delete(sessionId: string): void;
+  /**
+   * Clear all messages and compactions for a session without
+   * deleting the session itself.
+   */
+  clearMessages(sessionId: string): void;
+  /**
+   * Rename a session.
+   */
+  rename(sessionId: string, name: string): void;
+  /**
+   * Append a message to a session. If parentId is not provided,
+   * the message is appended after the latest leaf.
+   *
+   * Idempotent — appending the same message.id twice is a no-op.
+   *
+   * Returns the stored message ID.
+   */
+  append(sessionId: string, message: UIMessage, parentId?: string): string;
+  /**
+   * Insert or update a message. First call inserts, subsequent calls
+   * update the content. Enables incremental persistence.
+   *
+   * Idempotent on insert, content-updating on subsequent calls.
+   */
+  upsert(sessionId: string, message: UIMessage, parentId?: string): string;
+  /**
+   * Delete a single message by ID.
+   * Children of the deleted message naturally become path roots
+   * (their parent_id points to a missing row, truncating the CTE walk).
+   */
+  deleteMessage(messageId: string): void;
+  /**
+   * Delete multiple messages by ID.
+   */
+  deleteMessages(messageIds: string[]): void;
+  /**
+   * Append multiple messages in sequence (each parented to the previous).
+   * Returns the ID of the last appended message.
+   */
+  appendAll(
+    sessionId: string,
+    messages: UIMessage[],
+    parentId?: string
+  ): string | null;
+  /**
+   * Get the conversation history for a session as UIMessage[].
+   *
+   * If leafId is provided, returns the path from root to that leaf
+   * (a specific branch). Otherwise returns the path to the most
+   * recent leaf (the "current" branch).
+   *
+   * If compactions exist, older messages covered by a compaction
+   * are replaced with a system message containing the summary.
+   */
+  getHistory(sessionId: string, leafId?: string): UIMessage[];
+  /**
+   * Get the total message count for a session (across all branches).
+   */
+  getMessageCount(sessionId: string): number;
+  /**
+   * Check if the session's current branch needs compaction.
+   * Uses a count-only query — does not load message content.
+   */
+  needsCompaction(sessionId: string): boolean;
+  /**
+   * Get the children of a message (branches from that point).
+   */
+  getBranches(messageId: string): UIMessage[];
+  /**
+   * Fork a session at a specific message, creating a new session
+   * with the history up to that point copied over.
+   */
+  fork(atMessageId: string, newName: string): Session;
+  /**
+   * Add a compaction record. The summary replaces messages from
+   * fromMessageId to toMessageId in context assembly.
+   *
+   * Typically called after using an LLM to summarize older messages.
+   */
+  addCompaction(
+    sessionId: string,
+    summary: string,
+    fromMessageId: string,
+    toMessageId: string
+  ): Compaction;
+  /**
+   * Get all compaction records for a session.
+   */
+  getCompactions(sessionId: string): Compaction[];
+  private _applyCompactions;
+}
+//#endregion
+export {
+  truncateMiddle as a,
+  Compaction as c,
+  truncateLines as i,
+  Session as l,
+  SessionManagerOptions as n,
+  truncateTail as o,
+  truncateHead as r,
+  truncateToolOutput as s,
+  SessionManager as t
+};
+//# sourceMappingURL=index-C4OTSwUW.d.ts.map

package/dist/manager-DIV0gQf3.js

@@ -0,0 +1,214 @@
+import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldGet2, r as _assertClassBrand, t as _classPrivateFieldSet2 } from "./classPrivateFieldSet2-COLddhya.js";
+import { t as _classPrivateMethodInitSpec } from "./classPrivateMethodInitSpec-CdQXQy1O.js";
+import { jsonSchema, tool } from "ai";
+//#region src/extensions/manager.ts
+/**
+* ExtensionManager — loads, manages, and exposes tools from extension Workers.
+*
+* Extensions are sandboxed Workers created via WorkerLoader. Each extension
+* declares tools (with JSON Schema inputs) and permissions. The manager:
+*
+* 1. Wraps extension source in a Worker module with describe/execute RPC
+* 2. Loads it via WorkerLoader with permission-gated bindings
+* 3. Discovers tools via describe() RPC call
+* 4. Exposes them as AI SDK tools via getTools()
+*
+* Extension source format — a JS object expression defining tools:
+*
+* ```js
+* ({
+*   greet: {
+*     description: "Greet someone",
+*     parameters: { name: { type: "string" } },
+*     required: ["name"],
+*     execute: async (args, host) => `Hello, ${args.name}!`
+*   }
+* })
+* ```
+*
+* The `host` parameter in execute is provided via `env.host` — a loopback
+* binding that resolves the parent agent and delegates workspace operations
+* (gated by permissions). See HostBridgeLoopback.
+*/
+/**
+* Sanitize a name for use as a tool name prefix.
+* Replaces any non-alphanumeric characters with underscores and
+* collapses consecutive underscores.
+*/
+function sanitizeName(name) {
+	if (!name || name.trim().length === 0) throw new Error("Extension name must not be empty");
+	return name.replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+}
+const STORAGE_PREFIX = "ext:";
+var _loader = /* @__PURE__ */ new WeakMap();
+var _storage = /* @__PURE__ */ new WeakMap();
+var _createHostBinding = /* @__PURE__ */ new WeakMap();
+var _extensions = /* @__PURE__ */ new WeakMap();
+var _restored = /* @__PURE__ */ new WeakMap();
+var _ExtensionManager_brand = /* @__PURE__ */ new WeakSet();
+var ExtensionManager = class {
+	constructor(options) {
+		_classPrivateMethodInitSpec(this, _ExtensionManager_brand);
+		_classPrivateFieldInitSpec(this, _loader, void 0);
+		_classPrivateFieldInitSpec(this, _storage, void 0);
+		_classPrivateFieldInitSpec(this, _createHostBinding, void 0);
+		_classPrivateFieldInitSpec(this, _extensions, /* @__PURE__ */ new Map());
+		_classPrivateFieldInitSpec(this, _restored, false);
+		_classPrivateFieldSet2(_loader, this, options.loader);
+		_classPrivateFieldSet2(_storage, this, options.storage ?? null);
+		_classPrivateFieldSet2(_createHostBinding, this, options.createHostBinding ?? null);
+	}
+	/**
+	* Load an extension from source code.
+	*
+	* The source is a JS object expression defining tools. Each tool has
+	* `description`, `parameters` (JSON Schema properties), optional
+	* `required` array, and an `execute` async function.
+	*
+	* @returns Summary of the loaded extension including discovered tools.
+	*/
+	/**
+	* Restore extensions from DO storage after hibernation.
+	*
+	* Idempotent — skips extensions already in memory. Call this at the
+	* start of each chat turn (e.g. in onChatMessage before getTools).
+	*/
+	async restore() {
+		if (_classPrivateFieldGet2(_restored, this) || !_classPrivateFieldGet2(_storage, this)) return;
+		_classPrivateFieldSet2(_restored, this, true);
+		const entries = await _classPrivateFieldGet2(_storage, this).list({ prefix: STORAGE_PREFIX });
+		for (const persisted of entries.values()) {
+			if (_classPrivateFieldGet2(_extensions, this).has(persisted.manifest.name)) continue;
+			await _assertClassBrand(_ExtensionManager_brand, this, _loadInternal).call(this, persisted.manifest, persisted.source);
+		}
+	}
+	async load(manifest, source) {
+		if (_classPrivateFieldGet2(_extensions, this).has(manifest.name)) throw new Error(`Extension "${manifest.name}" is already loaded. Unload it first.`);
+		const info = await _assertClassBrand(_ExtensionManager_brand, this, _loadInternal).call(this, manifest, source);
+		if (_classPrivateFieldGet2(_storage, this)) await _classPrivateFieldGet2(_storage, this).put(`${STORAGE_PREFIX}${manifest.name}`, {
+			manifest,
+			source
+		});
+		return info;
+	}
+	/**
+	* Unload an extension, removing its tools from the agent.
+	*/
+	async unload(name) {
+		const removed = _classPrivateFieldGet2(_extensions, this).delete(name);
+		if (removed && _classPrivateFieldGet2(_storage, this)) await _classPrivateFieldGet2(_storage, this).delete(`${STORAGE_PREFIX}${name}`);
+		return removed;
+	}
+	/**
+	* List all loaded extensions.
+	*/
+	list() {
+		return [..._classPrivateFieldGet2(_extensions, this).values()].map((ext) => toExtensionInfo(ext.manifest, ext.tools));
+	}
+	/**
+	* Get AI SDK tools from all loaded extensions.
+	*
+	* Tool names are prefixed with the sanitized extension name to avoid
+	* collisions: e.g. extension "github" with tool "create_pr" → "github_create_pr".
+	*/
+	getTools() {
+		const tools = {};
+		for (const ext of _classPrivateFieldGet2(_extensions, this).values()) {
+			const prefix = sanitizeName(ext.manifest.name);
+			for (const descriptor of ext.tools) {
+				const toolName = `${prefix}_${descriptor.name}`;
+				tools[toolName] = tool({
+					description: `[${ext.manifest.name}] ${descriptor.description}`,
+					inputSchema: jsonSchema(descriptor.inputSchema),
+					execute: async (args) => {
+						if (!_classPrivateFieldGet2(_extensions, this).has(ext.manifest.name)) throw new Error(`Extension "${ext.manifest.name}" has been unloaded. Tool "${toolName}" is no longer available.`);
+						const resultJson = await ext.entrypoint.execute(descriptor.name, JSON.stringify(args));
+						const parsed = JSON.parse(resultJson);
+						if (parsed.error) throw new Error(parsed.error);
+						return parsed.result;
+					}
+				});
+			}
+		}
+		return tools;
+	}
+};
+async function _loadInternal(manifest, source) {
+	const workerModule = wrapExtensionSource(source);
+	const permissions = manifest.permissions ?? {};
+	const workerEnv = {};
+	const wsLevel = permissions.workspace ?? "none";
+	if (_classPrivateFieldGet2(_createHostBinding, this) && wsLevel !== "none") workerEnv.host = _classPrivateFieldGet2(_createHostBinding, this).call(this, permissions);
+	const entrypoint = _classPrivateFieldGet2(_loader, this).get(`ext-${manifest.name}-${manifest.version}-${Date.now()}`, () => ({
+		compatibilityDate: "2025-06-01",
+		compatibilityFlags: ["nodejs_compat"],
+		mainModule: "extension.js",
+		modules: { "extension.js": workerModule },
+		globalOutbound: permissions.network?.length ? void 0 : null,
+		...Object.keys(workerEnv).length > 0 ? { env: workerEnv } : {}
+	})).getEntrypoint();
+	const descriptorsJson = await entrypoint.describe();
+	const tools = JSON.parse(descriptorsJson);
+	_classPrivateFieldGet2(_extensions, this).set(manifest.name, {
+		manifest,
+		tools,
+		entrypoint
+	});
+	return toExtensionInfo(manifest, tools);
+}
+function toExtensionInfo(manifest, tools) {
+	const prefix = sanitizeName(manifest.name);
+	return {
+		name: manifest.name,
+		version: manifest.version,
+		description: manifest.description,
+		tools: tools.map((t) => `${prefix}_${t.name}`),
+		permissions: manifest.permissions ?? {}
+	};
+}
+/**
+* Wrap an extension source (JS object expression) in a Worker module
+* that exposes describe() and execute() RPC methods.
+*/
+function wrapExtensionSource(source) {
+	return `import { WorkerEntrypoint } from "cloudflare:workers";
+
+const __tools = (${source});
+
+export default class Extension extends WorkerEntrypoint {
+  describe() {
+    const descriptors = [];
+    for (const [name, def] of Object.entries(__tools)) {
+      descriptors.push({
+        name,
+        description: def.description || name,
+        inputSchema: {
+          type: "object",
+          properties: def.parameters || {},
+          required: def.required || []
+        }
+      });
+    }
+    return JSON.stringify(descriptors);
+  }
+
+  async execute(toolName, argsJson) {
+    const def = __tools[toolName];
+    if (!def || !def.execute) {
+      return JSON.stringify({ error: "Unknown tool: " + toolName });
+    }
+    try {
+      const args = JSON.parse(argsJson);
+      const result = await def.execute(args, this.env.host ?? null);
+      return JSON.stringify({ result });
+    } catch (err) {
+      return JSON.stringify({ error: err.message || String(err) });
+    }
+  }
+}
+`;
+}
+//#endregion
+export { sanitizeName as n, ExtensionManager as t };
+
+//# sourceMappingURL=manager-DIV0gQf3.js.map

package/dist/manager-DIV0gQf3.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager-DIV0gQf3.js","names":[],"sources":["../src/extensions/manager.ts"],"sourcesContent":["/**\n * ExtensionManager — loads, manages, and exposes tools from extension Workers.\n *\n * Extensions are sandboxed Workers created via WorkerLoader. Each extension\n * declares tools (with JSON Schema inputs) and permissions. The manager:\n *\n * 1. Wraps extension source in a Worker module with describe/execute RPC\n * 2. Loads it via WorkerLoader with permission-gated bindings\n * 3. Discovers tools via describe() RPC call\n * 4. Exposes them as AI SDK tools via getTools()\n *\n * Extension source format — a JS object expression defining tools:\n *\n * ```js\n * ({\n *   greet: {\n *     description: \"Greet someone\",\n *     parameters: { name: { type: \"string\" } },\n *     required: [\"name\"],\n *     execute: async (args, host) => `Hello, ${args.name}!`\n *   }\n * })\n * ```\n *\n * The `host` parameter in execute is provided via `env.host` — a loopback\n * binding that resolves the parent agent and delegates workspace operations\n * (gated by permissions). See HostBridgeLoopback.\n */\n\nimport { tool, jsonSchema } from \"ai\";\nimport type { ToolSet } from \"ai\";\nimport type {\n  ExtensionManifest,\n  ExtensionPermissions,\n  ExtensionInfo,\n  ExtensionToolDescriptor\n} from \"./types\";\n\n/**\n * Sanitize a name for use as a tool name prefix.\n * Replaces any non-alphanumeric characters with underscores and\n * collapses consecutive underscores.\n */\nexport function sanitizeName(name: string): string {\n  if (!name || name.trim().length === 0) {\n    throw new Error(\"Extension name must not be empty\");\n  }\n  return name\n    .replace(/[^a-zA-Z0-9]/g, \"_\")\n    .replace(/_+/g, \"_\")\n    .replace(/^_|_$/g, \"\");\n}\n\ninterface ExtensionEntrypoint {\n  describe(): Promise<string>;\n  execute(toolName: string, argsJson: string): Promise<string>;\n}\n\ninterface LoadedExtension {\n  manifest: ExtensionManifest;\n  tools: ExtensionToolDescriptor[];\n  entrypoint: ExtensionEntrypoint;\n}\n\n/** Shape persisted to DO storage for each extension. */\ninterface PersistedExtension {\n  manifest: ExtensionManifest;\n  source: string;\n}\n\nconst STORAGE_PREFIX = \"ext:\";\n\nexport interface ExtensionManagerOptions {\n  /** WorkerLoader binding for creating sandboxed extension Workers. */\n  loader: WorkerLoader;\n  /**\n   * Durable Object storage for persisting extensions across hibernation.\n   * If provided, loaded extensions survive DO restarts. Call `restore()`\n   * on each turn to rebuild in-memory state from storage.\n   */\n  storage?: DurableObjectStorage;\n  /**\n   * Factory that creates a loopback Fetcher for workspace access, given\n   * an extension's declared permissions. The returned binding is injected\n   * into the extension worker's `env.host`.\n   *\n   * If not provided, extensions receive no host binding (workspace tools\n   * will get `null` for the host parameter).\n   *\n   * Typically wired up using HostBridgeLoopback via `ctx.exports`:\n   * ```typescript\n   * createHostBinding: (permissions) =>\n   *   ctx.exports.HostBridgeLoopback({\n   *     props: { agentClassName: \"ChatSession\", agentId: ctx.id.toString(), permissions }\n   *   })\n   * ```\n   */\n  createHostBinding?: (permissions: ExtensionPermissions) => Fetcher;\n}\n\nexport class ExtensionManager {\n  #loader: WorkerLoader;\n  #storage: DurableObjectStorage | null;\n  #createHostBinding: ((permissions: ExtensionPermissions) => Fetcher) | null;\n  #extensions = new Map<string, LoadedExtension>();\n  #restored = false;\n\n  constructor(options: ExtensionManagerOptions) {\n    this.#loader = options.loader;\n    this.#storage = options.storage ?? null;\n    this.#createHostBinding = options.createHostBinding ?? null;\n  }\n\n  /**\n   * Load an extension from source code.\n   *\n   * The source is a JS object expression defining tools. Each tool has\n   * `description`, `parameters` (JSON Schema properties), optional\n   * `required` array, and an `execute` async function.\n   *\n   * @returns Summary of the loaded extension including discovered tools.\n   */\n  /**\n   * Restore extensions from DO storage after hibernation.\n   *\n   * Idempotent — skips extensions already in memory. Call this at the\n   * start of each chat turn (e.g. in onChatMessage before getTools).\n   */\n  async restore(): Promise<void> {\n    if (this.#restored || !this.#storage) return;\n    this.#restored = true;\n\n    const entries = await this.#storage.list<PersistedExtension>({\n      prefix: STORAGE_PREFIX\n    });\n\n    for (const persisted of entries.values()) {\n      if (this.#extensions.has(persisted.manifest.name)) continue;\n      await this.#loadInternal(persisted.manifest, persisted.source);\n    }\n  }\n\n  async load(\n    manifest: ExtensionManifest,\n    source: string\n  ): Promise<ExtensionInfo> {\n    if (this.#extensions.has(manifest.name)) {\n      throw new Error(\n        `Extension \"${manifest.name}\" is already loaded. Unload it first.`\n      );\n    }\n\n    const info = await this.#loadInternal(manifest, source);\n\n    // Persist to storage so it survives hibernation\n    if (this.#storage) {\n      await this.#storage.put<PersistedExtension>(\n        `${STORAGE_PREFIX}${manifest.name}`,\n        { manifest, source }\n      );\n    }\n\n    return info;\n  }\n\n  async #loadInternal(\n    manifest: ExtensionManifest,\n    source: string\n  ): Promise<ExtensionInfo> {\n    const workerModule = wrapExtensionSource(source);\n    const permissions = manifest.permissions ?? {};\n\n    // Build env bindings for the dynamic worker. If a host binding\n    // factory is configured and the extension declares workspace\n    // access, inject a loopback Fetcher as env.host.\n    const workerEnv: Record<string, Fetcher> = {};\n    const wsLevel = permissions.workspace ?? \"none\";\n    if (this.#createHostBinding && wsLevel !== \"none\") {\n      workerEnv.host = this.#createHostBinding(permissions);\n    }\n\n    const worker = this.#loader.get(\n      `ext-${manifest.name}-${manifest.version}-${Date.now()}`,\n      () => ({\n        compatibilityDate: \"2025-06-01\",\n        compatibilityFlags: [\"nodejs_compat\"],\n        mainModule: \"extension.js\",\n        modules: { \"extension.js\": workerModule },\n        globalOutbound: permissions.network?.length ? undefined : null,\n        ...(Object.keys(workerEnv).length > 0 ? { env: workerEnv } : {})\n      })\n    );\n\n    const entrypoint = worker.getEntrypoint() as unknown as ExtensionEntrypoint;\n\n    // Discover tools via RPC\n    const descriptorsJson = await entrypoint.describe();\n    const tools = JSON.parse(descriptorsJson) as ExtensionToolDescriptor[];\n\n    this.#extensions.set(manifest.name, { manifest, tools, entrypoint });\n\n    return toExtensionInfo(manifest, tools);\n  }\n\n  /**\n   * Unload an extension, removing its tools from the agent.\n   */\n  async unload(name: string): Promise<boolean> {\n    const removed = this.#extensions.delete(name);\n    if (removed && this.#storage) {\n      await this.#storage.delete(`${STORAGE_PREFIX}${name}`);\n    }\n    return removed;\n  }\n\n  /**\n   * List all loaded extensions.\n   */\n  list(): ExtensionInfo[] {\n    return [...this.#extensions.values()].map((ext) =>\n      toExtensionInfo(ext.manifest, ext.tools)\n    );\n  }\n\n  /**\n   * Get AI SDK tools from all loaded extensions.\n   *\n   * Tool names are prefixed with the sanitized extension name to avoid\n   * collisions: e.g. extension \"github\" with tool \"create_pr\" → \"github_create_pr\".\n   */\n  getTools(): ToolSet {\n    const tools: ToolSet = {};\n\n    for (const ext of this.#extensions.values()) {\n      const prefix = sanitizeName(ext.manifest.name);\n\n      for (const descriptor of ext.tools) {\n        const toolName = `${prefix}_${descriptor.name}`;\n\n        tools[toolName] = tool({\n          description: `[${ext.manifest.name}] ${descriptor.description}`,\n          inputSchema: jsonSchema(\n            descriptor.inputSchema as Record<string, unknown>\n          ),\n          execute: async (args: Record<string, unknown>) => {\n            if (!this.#extensions.has(ext.manifest.name)) {\n              throw new Error(\n                `Extension \"${ext.manifest.name}\" has been unloaded. Tool \"${toolName}\" is no longer available.`\n              );\n            }\n            const resultJson = await ext.entrypoint.execute(\n              descriptor.name,\n              JSON.stringify(args)\n            );\n            const parsed = JSON.parse(resultJson) as {\n              result?: unknown;\n              error?: string;\n            };\n            if (parsed.error) throw new Error(parsed.error);\n            return parsed.result;\n          }\n        });\n      }\n    }\n\n    return tools;\n  }\n}\n\nfunction toExtensionInfo(\n  manifest: ExtensionManifest,\n  tools: ExtensionToolDescriptor[]\n): ExtensionInfo {\n  const prefix = sanitizeName(manifest.name);\n  return {\n    name: manifest.name,\n    version: manifest.version,\n    description: manifest.description,\n    tools: tools.map((t) => `${prefix}_${t.name}`),\n    permissions: manifest.permissions ?? {}\n  };\n}\n\n/**\n * Wrap an extension source (JS object expression) in a Worker module\n * that exposes describe() and execute() RPC methods.\n */\nfunction wrapExtensionSource(source: string): string {\n  return `import { WorkerEntrypoint } from \"cloudflare:workers\";\n\nconst __tools = (${source});\n\nexport default class Extension extends WorkerEntrypoint {\n  describe() {\n    const descriptors = [];\n    for (const [name, def] of Object.entries(__tools)) {\n      descriptors.push({\n        name,\n        description: def.description || name,\n        inputSchema: {\n          type: \"object\",\n          properties: def.parameters || {},\n          required: def.required || []\n        }\n      });\n    }\n    return JSON.stringify(descriptors);\n  }\n\n  async execute(toolName, argsJson) {\n    const def = __tools[toolName];\n    if (!def || !def.execute) {\n      return JSON.stringify({ error: \"Unknown tool: \" + toolName });\n    }\n    try {\n      const args = JSON.parse(argsJson);\n      const result = await def.execute(args, this.env.host ?? null);\n      return JSON.stringify({ result });\n    } catch (err) {\n      return JSON.stringify({ error: err.message || String(err) });\n    }\n  }\n}\n`;\n}\n"],"mappings":"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"}

package/dist/message-builder.d.ts

@@ -0,0 +1,51 @@
+import { UIMessage } from "ai";
+
+//#region src/message-builder.d.ts
+/** The parts array type from UIMessage */
+type MessageParts = UIMessage["parts"];
+/** A single part from the UIMessage parts array */
+type MessagePart = MessageParts[number];
+/**
+ * Parsed chunk data from an AI SDK stream event.
+ * This is the JSON-parsed body of a CF_AGENT_USE_CHAT_RESPONSE message,
+ * or the `data:` payload of an SSE line.
+ */
+type StreamChunkData = {
+  type: string;
+  id?: string;
+  delta?: string;
+  text?: string;
+  mediaType?: string;
+  url?: string;
+  sourceId?: string;
+  title?: string;
+  filename?: string;
+  toolCallId?: string;
+  toolName?: string;
+  input?: unknown;
+  inputTextDelta?: string;
+  output?: unknown;
+  state?: string;
+  errorText?: string;
+  preliminary?: boolean;
+  approvalId?: string;
+  providerMetadata?: Record<string, unknown>;
+  providerExecuted?: boolean;
+  data?: unknown;
+  transient?: boolean;
+  messageId?: string;
+  messageMetadata?: Record<string, unknown>;
+  [key: string]: unknown;
+};
+/**
+ * Applies a stream chunk to a mutable parts array, building up the message
+ * incrementally. Returns true if the chunk was handled, false if it was
+ * an unrecognized type (caller may handle it with additional logic).
+ */
+declare function applyChunkToParts(
+  parts: MessagePart[],
+  chunk: StreamChunkData
+): boolean;
+//#endregion
+export { MessagePart, MessageParts, StreamChunkData, applyChunkToParts };
+//# sourceMappingURL=message-builder.d.ts.map