@cloudflare/think 0.0.0 → 0.0.2

package/README.md

@@ -0,0 +1,241 @@
+# @cloudflare/think
+
+An Agent base class for AI assistants on Cloudflare Workers. Handles the full chat lifecycle — session management, agentic loop, streaming, persistence, workspace tools, and extensions — all backed by Durable Object SQLite.
+
+Works as both a **top-level agent** (WebSocket chat protocol for browser clients) and a **sub-agent** (RPC streaming from a parent agent).
+
+> **Experimental** — requires the `"experimental"` compatibility flag.
+
+## Quick start
+
+```ts
+import { Think } from "@cloudflare/think";
+import { createWorkersAI } from "workers-ai-provider";
+import { createWorkspaceTools } from "@cloudflare/think/tools/workspace";
+import { Workspace } from "agents/experimental/workspace";
+
+export class ChatSession extends Think<Env> {
+  workspace = new Workspace(this);
+
+  getModel() {
+    return createWorkersAI({ binding: this.env.AI })(
+      "@cf/meta/llama-3.3-70b-instruct-fp8-fast"
+    );
+  }
+
+  getSystemPrompt() {
+    return "You are a helpful coding assistant.";
+  }
+
+  getTools() {
+    return createWorkspaceTools(this.workspace);
+  }
+}
+```
+
+That's it. `Think` handles the WebSocket chat protocol, session persistence, the agentic loop, message sanitization, and streaming. Connect from the browser with `useAgentChat` or `useChat` + `AgentChatTransport`.
+
+## Exports
+
+| Export                               | Description                                                     |
+| ------------------------------------ | --------------------------------------------------------------- |
+| `@cloudflare/think`                  | `Think` — the main class, plus types                            |
+| `@cloudflare/think/session`          | `SessionManager` — conversation persistence with branching      |
+| `@cloudflare/think/tools/workspace`  | `createWorkspaceTools()` — file operation tools                 |
+| `@cloudflare/think/tools/execute`    | `createExecuteTool()` — sandboxed code execution via codemode   |
+| `@cloudflare/think/tools/extensions` | `createExtensionTools()` — LLM-driven extension loading         |
+| `@cloudflare/think/extensions`       | `ExtensionManager`, `HostBridgeLoopback` — extension runtime    |
+| `@cloudflare/think/transport`        | `AgentChatTransport` — bridges `useChat` with Agent WebSocket   |
+| `@cloudflare/think/message-builder`  | `applyChunkToParts()` — reconstruct UIMessage parts from chunks |
+
+## Think
+
+### Override points
+
+| Method                    | Default                          | Description                           |
+| ------------------------- | -------------------------------- | ------------------------------------- |
+| `getModel()`              | throws                           | Return the `LanguageModel` to use     |
+| `getSystemPrompt()`       | `"You are a helpful assistant."` | System prompt                         |
+| `getTools()`              | `{}`                             | AI SDK `ToolSet` for the agentic loop |
+| `getMaxSteps()`           | `10`                             | Max tool-call rounds per turn         |
+| `assembleContext()`       | prune older tool calls           | Customize what's sent to the LLM      |
+| `onChatMessage(options?)` | `streamText(...)`                | Full control over inference           |
+| `onChatError(error)`      | passthrough                      | Customize error handling              |
+| `getWorkspace()`          | `null`                           | Workspace for extension host bridge   |
+
+### Session management
+
+Think manages multiple named sessions per agent instance. Sessions are created automatically on the first chat message, or explicitly:
+
+```ts
+session.createSession("research");
+session.switchSession(sessionId);
+session.getSessions(); // Session[]
+session.deleteSession(id);
+session.renameSession(id, "new name");
+session.getCurrentSessionId();
+```
+
+### Sub-agent streaming via RPC
+
+When used as a sub-agent, the `chat()` method runs a full turn and streams events via a callback:
+
+```ts
+// StreamCallback — implement as an RpcTarget in the parent
+interface StreamCallback {
+  onEvent(json: string): void | Promise<void>;
+  onDone(): void | Promise<void>;
+  onError?(error: string): void | Promise<void>;
+}
+
+const session = await this.subAgent(ChatSession, "agent-abc");
+await session.chat("Summarize the project", relay, {
+  tools: extraTools,
+  signal: abortController.signal
+});
+```
+
+### Dynamic configuration
+
+Think accepts a `Config` type parameter for per-instance configuration persisted in SQLite:
+
+```ts
+type MyConfig = { modelTier: "fast" | "capable"; systemPrompt: string };
+
+export class ChatSession extends Think<Env, MyConfig> {
+  getModel() {
+    const tier = this.getConfig()?.modelTier ?? "fast";
+    return createWorkersAI({ binding: this.env.AI })(MODEL_IDS[tier]);
+  }
+}
+
+// From the parent:
+const session = await this.subAgent(ChatSession, "agent-abc");
+await session.configure({ modelTier: "capable", systemPrompt: "..." });
+```
+
+### Production features
+
+- **WebSocket protocol** — wire-compatible with `useAgentChat` / `useChat`
+- **Multi-session** — create, switch, list, delete, rename conversations
+- **Abort/cancel** — pass an `AbortSignal` or send a cancel message
+- **Partial persistence** — on error, the partial assistant message is saved
+- **Message sanitization** — strips ephemeral provider metadata before storage
+- **Row size enforcement** — compacts tool outputs exceeding 1.8MB
+- **Incremental persistence** — skips SQL writes for unchanged messages
+- **Storage bounds** — set `maxPersistedMessages` to cap stored history
+
+## SessionManager
+
+Persistent conversation storage with tree-structured messages (branching) and compaction. Used internally by Think, but also usable standalone.
+
+```ts
+import { SessionManager } from "@cloudflare/think/session";
+
+const sessions = new SessionManager(agent);
+const session = sessions.create("my-chat");
+sessions.append(session.id, userMessage);
+const history = sessions.getHistory(session.id); // UIMessage[]
+```
+
+Also exports truncation utilities (`truncateHead`, `truncateTail`, `truncateMiddle`, `truncateLines`) for managing large tool outputs.
+
+## Workspace tools
+
+File operation tools backed by the Agents SDK `Workspace`:
+
+```ts
+import { createWorkspaceTools } from "@cloudflare/think/tools/workspace";
+
+const tools = createWorkspaceTools(this.workspace);
+// Tools: read, write, edit, list, find, grep, delete
+```
+
+Each tool is an AI SDK `tool()` with Zod schemas. The underlying operations are abstracted behind interfaces (`ReadOperations`, `WriteOperations`, etc.) so you can create tools backed by custom storage.
+
+## Code execution tool
+
+Let the LLM write and run JavaScript in a sandboxed Worker:
+
+```ts
+import { createExecuteTool } from "@cloudflare/think/tools/execute";
+
+getTools() {
+  const wsTools = createWorkspaceTools(this.workspace);
+  return {
+    ...wsTools,
+    execute: createExecuteTool({ tools: wsTools, loader: this.env.LOADER })
+  };
+}
+```
+
+Requires `@cloudflare/codemode` and a `worker_loaders` binding in `wrangler.jsonc`.
+
+## Extensions
+
+Dynamic tool loading at runtime. The LLM can write extension source code, load it as a sandboxed Worker, and use the new tools on the next turn.
+
+```ts
+import { ExtensionManager } from "@cloudflare/think/extensions";
+import { createExtensionTools } from "@cloudflare/think/tools/extensions";
+
+const extensions = new ExtensionManager({
+  loader: this.env.LOADER,
+  workspace: this.workspace
+});
+
+getTools() {
+  return {
+    ...createWorkspaceTools(this.workspace),
+    ...createExtensionTools({ manager: extensions }),
+    ...extensions.getTools()
+  };
+}
+```
+
+Extensions get permission-gated workspace access via `HostBridgeLoopback`. Re-export it from your worker entry point:
+
+```ts
+export { HostBridgeLoopback } from "@cloudflare/think/extensions";
+```
+
+## Chat transport
+
+Client-side transport that bridges `useChat` with Agent WebSocket streaming:
+
+```tsx
+import { AgentChatTransport } from "@cloudflare/think/transport";
+import { useAgent } from "agents/react";
+import { useChat } from "@ai-sdk/react";
+
+const agent = useAgent({ agent: "ChatSession" });
+const transport = useMemo(() => new AgentChatTransport(agent), [agent]);
+const { messages, sendMessage, status } = useChat({ transport });
+```
+
+Options: `sendMethod` (RPC method name, default `"sendMessage"`), `resumeTimeout` (ms, default `500`). Call `transport.detach()` before switching agents.
+
+## Message builder
+
+Reconstruct `UIMessage` parts from stream chunks:
+
+```ts
+import { applyChunkToParts } from "@cloudflare/think/message-builder";
+
+const msg = { id: "...", role: "assistant", parts: [] };
+for (const chunk of streamChunks) {
+  applyChunkToParts(msg.parts, chunk);
+}
+```
+
+Handles all AI SDK chunk types: `text-delta`, `reasoning-delta`, `tool-call`, `tool-result`, `source`, `file`, and more.
+
+## Peer dependencies
+
+| Package                | Required | Notes                             |
+| ---------------------- | -------- | --------------------------------- |
+| `agents`               | yes      | Cloudflare Agents SDK             |
+| `ai`                   | yes      | Vercel AI SDK v6                  |
+| `zod`                  | yes      | Schema validation (v3.25+ or v4)  |
+| `@cloudflare/codemode` | optional | For `createExecuteTool`           |
+| `@cloudflare/shell`    | optional | For shell execution in extensions |

package/dist/classPrivateFieldSet2-COLddhya.js

@@ -0,0 +1,27 @@
+//#region \0@oxc-project+runtime@0.115.0/helpers/checkPrivateRedeclaration.js
+function _checkPrivateRedeclaration(e, t) {
+	if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/classPrivateFieldInitSpec.js
+function _classPrivateFieldInitSpec(e, t, a) {
+	_checkPrivateRedeclaration(e, t), t.set(e, a);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/assertClassBrand.js
+function _assertClassBrand(e, t, n) {
+	if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+	throw new TypeError("Private element is not present on this object");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/classPrivateFieldGet2.js
+function _classPrivateFieldGet2(s, a) {
+	return s.get(_assertClassBrand(s, a));
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.115.0/helpers/classPrivateFieldSet2.js
+function _classPrivateFieldSet2(s, a, r) {
+	return s.set(_assertClassBrand(s, a), r), r;
+}
+//#endregion
+export { _checkPrivateRedeclaration as a, _classPrivateFieldInitSpec as i, _classPrivateFieldGet2 as n, _assertClassBrand as r, _classPrivateFieldSet2 as t };

package/dist/classPrivateMethodInitSpec-CdQXQy1O.js

@@ -0,0 +1,7 @@
+import { a as _checkPrivateRedeclaration } from "./classPrivateFieldSet2-COLddhya.js";
+//#region \0@oxc-project+runtime@0.115.0/helpers/classPrivateMethodInitSpec.js
+function _classPrivateMethodInitSpec(e, a) {
+	_checkPrivateRedeclaration(e, a), a.add(e);
+}
+//#endregion
+export { _classPrivateMethodInitSpec as t };

package/dist/extensions/index.d.ts

@@ -0,0 +1,20 @@
+import {
+  a as ExtensionInfo,
+  c as ExtensionToolDescriptor,
+  i as ExtensionManagerOptions,
+  n as HostBridgeLoopbackProps,
+  o as ExtensionManifest,
+  r as ExtensionManager,
+  s as ExtensionPermissions,
+  t as HostBridgeLoopback
+} from "../index-BlcvIdWK.js";
+export {
+  ExtensionInfo,
+  ExtensionManager,
+  ExtensionManagerOptions,
+  ExtensionManifest,
+  ExtensionPermissions,
+  ExtensionToolDescriptor,
+  HostBridgeLoopback,
+  HostBridgeLoopbackProps
+};

package/dist/extensions/index.js

@@ -0,0 +1,62 @@
+import { r as _assertClassBrand } from "../classPrivateFieldSet2-COLddhya.js";
+import { t as _classPrivateMethodInitSpec } from "../classPrivateMethodInitSpec-CdQXQy1O.js";
+import { t as ExtensionManager } from "../manager-DIV0gQf3.js";
+import { WorkerEntrypoint } from "cloudflare:workers";
+//#region src/extensions/host-bridge.ts
+/**
+* HostBridgeLoopback — a WorkerEntrypoint that provides controlled workspace
+* access to extension Workers loaded via WorkerLoader.
+*
+* This is a loopback: the extension worker's `env.host` binding points here,
+* and each method call resolves the parent agent via `ctx.exports`, then
+* delegates to the agent's workspace proxy methods (`_hostReadFile`, etc.).
+*
+* Props carry serializable identifiers (agent class name, agent ID, and
+* permissions) so the binding survives across requests and hibernation.
+*
+* Users must re-export this class from their worker entry point:
+*
+* ```typescript
+* export { HostBridgeLoopback } from "@cloudflare/think/extensions";
+* ```
+*
+* @experimental Requires the `"experimental"` compatibility flag.
+*/
+var _HostBridgeLoopback_brand = /* @__PURE__ */ new WeakSet();
+var HostBridgeLoopback = class extends WorkerEntrypoint {
+	constructor(..._args) {
+		super(..._args);
+		_classPrivateMethodInitSpec(this, _HostBridgeLoopback_brand);
+		this._permissions = this.ctx.props.permissions;
+	}
+	_getAgent() {
+		const { agentClassName, agentId } = this.ctx.props;
+		const ns = this.ctx.exports[agentClassName];
+		return ns.get(ns.idFromString(agentId));
+	}
+	async readFile(path) {
+		_assertClassBrand(_HostBridgeLoopback_brand, this, _requirePermission).call(this, "read");
+		return this._getAgent()._hostReadFile(path);
+	}
+	async writeFile(path, content) {
+		_assertClassBrand(_HostBridgeLoopback_brand, this, _requirePermission).call(this, "read-write");
+		return this._getAgent()._hostWriteFile(path, content);
+	}
+	async deleteFile(path) {
+		_assertClassBrand(_HostBridgeLoopback_brand, this, _requirePermission).call(this, "read-write");
+		return this._getAgent()._hostDeleteFile(path);
+	}
+	async listFiles(dir) {
+		_assertClassBrand(_HostBridgeLoopback_brand, this, _requirePermission).call(this, "read");
+		return this._getAgent()._hostListFiles(dir);
+	}
+};
+function _requirePermission(level) {
+	const ws = this._permissions.workspace ?? "none";
+	if (ws === "none") throw new Error("Extension error: no workspace permission declared");
+	if (level === "read-write" && ws !== "read-write") throw new Error("Extension error: workspace write permission required, but only read granted");
+}
+//#endregion
+export { ExtensionManager, HostBridgeLoopback };
+
+//# sourceMappingURL=index.js.map

package/dist/extensions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/extensions/host-bridge.ts"],"sourcesContent":["/**\n * HostBridgeLoopback — a WorkerEntrypoint that provides controlled workspace\n * access to extension Workers loaded via WorkerLoader.\n *\n * This is a loopback: the extension worker's `env.host` binding points here,\n * and each method call resolves the parent agent via `ctx.exports`, then\n * delegates to the agent's workspace proxy methods (`_hostReadFile`, etc.).\n *\n * Props carry serializable identifiers (agent class name, agent ID, and\n * permissions) so the binding survives across requests and hibernation.\n *\n * Users must re-export this class from their worker entry point:\n *\n * ```typescript\n * export { HostBridgeLoopback } from \"@cloudflare/think/extensions\";\n * ```\n *\n * @experimental Requires the `\"experimental\"` compatibility flag.\n */\n\nimport { WorkerEntrypoint } from \"cloudflare:workers\";\nimport type { ExtensionPermissions } from \"./types\";\n\nexport type HostBridgeLoopbackProps = {\n  agentClassName: string;\n  agentId: string;\n  permissions: ExtensionPermissions;\n};\n\nexport class HostBridgeLoopback extends WorkerEntrypoint<\n  Record<string, unknown>,\n  HostBridgeLoopbackProps\n> {\n  private _permissions = this.ctx.props.permissions;\n\n  private _getAgent() {\n    const { agentClassName, agentId } = this.ctx.props;\n    // @ts-expect-error — experimental: ctx.exports on WorkerEntrypoint\n    const ns = this.ctx.exports[agentClassName] as DurableObjectNamespace;\n    return ns.get(ns.idFromString(agentId));\n  }\n\n  #requirePermission(level: \"read\" | \"read-write\"): void {\n    const ws = this._permissions.workspace ?? \"none\";\n    if (ws === \"none\") {\n      throw new Error(\"Extension error: no workspace permission declared\");\n    }\n    if (level === \"read-write\" && ws !== \"read-write\") {\n      throw new Error(\n        \"Extension error: workspace write permission required, but only read granted\"\n      );\n    }\n  }\n\n  async readFile(path: string): Promise<string | null> {\n    this.#requirePermission(\"read\");\n    return (\n      this._getAgent() as unknown as {\n        _hostReadFile(path: string): Promise<string | null>;\n      }\n    )._hostReadFile(path);\n  }\n\n  async writeFile(path: string, content: string): Promise<void> {\n    this.#requirePermission(\"read-write\");\n    return (\n      this._getAgent() as unknown as {\n        _hostWriteFile(path: string, content: string): Promise<void>;\n      }\n    )._hostWriteFile(path, content);\n  }\n\n  async deleteFile(path: string): Promise<boolean> {\n    this.#requirePermission(\"read-write\");\n    return (\n      this._getAgent() as unknown as {\n        _hostDeleteFile(path: string): Promise<boolean>;\n      }\n    )._hostDeleteFile(path);\n  }\n\n  async listFiles(\n    dir: string\n  ): Promise<\n    Array<{ name: string; type: string; size: number; path: string }>\n  > {\n    this.#requirePermission(\"read\");\n    return (\n      this._getAgent() as unknown as {\n        _hostListFiles(\n          dir: string\n        ): Promise<\n          Array<{ name: string; type: string; size: number; path: string }>\n        >;\n      }\n    )._hostListFiles(dir);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAa,qBAAb,cAAwC,iBAGtC;;;;AACA,OAAQ,eAAe,KAAK,IAAI,MAAM;;CAEtC,YAAoB;EAClB,MAAM,EAAE,gBAAgB,YAAY,KAAK,IAAI;EAE7C,MAAM,KAAK,KAAK,IAAI,QAAQ;AAC5B,SAAO,GAAG,IAAI,GAAG,aAAa,QAAQ,CAAC;;CAezC,MAAM,SAAS,MAAsC;AACnD,oBAAA,2BAAA,MAAA,mBAAuB,CAAA,KAAA,MAAC,OAAO;AAC/B,SACE,KAAK,WAAW,CAGhB,cAAc,KAAK;;CAGvB,MAAM,UAAU,MAAc,SAAgC;AAC5D,oBAAA,2BAAA,MAAA,mBAAuB,CAAA,KAAA,MAAC,aAAa;AACrC,SACE,KAAK,WAAW,CAGhB,eAAe,MAAM,QAAQ;;CAGjC,MAAM,WAAW,MAAgC;AAC/C,oBAAA,2BAAA,MAAA,mBAAuB,CAAA,KAAA,MAAC,aAAa;AACrC,SACE,KAAK,WAAW,CAGhB,gBAAgB,KAAK;;CAGzB,MAAM,UACJ,KAGA;AACA,oBAAA,2BAAA,MAAA,mBAAuB,CAAA,KAAA,MAAC,OAAO;AAC/B,SACE,KAAK,WAAW,CAOhB,eAAe,IAAI;;;AArDvB,SAAA,mBAAmB,OAAoC;CACrD,MAAM,KAAK,KAAK,aAAa,aAAa;AAC1C,KAAI,OAAO,OACT,OAAM,IAAI,MAAM,oDAAoD;AAEtE,KAAI,UAAU,gBAAgB,OAAO,aACnC,OAAM,IAAI,MACR,8EACD"}

package/dist/index-BlcvIdWK.d.ts

@@ -0,0 +1,171 @@
+import { ToolSet } from "ai";
+import { WorkerEntrypoint } from "cloudflare:workers";
+
+//#region src/extensions/types.d.ts
+/**
+ * Extension system types.
+ *
+ * Extensions are sandboxed Workers loaded on demand via WorkerLoader.
+ * Each extension provides tools that the agent can use, with controlled
+ * access to the host (workspace, network) via permissions.
+ */
+/**
+ * Manifest declaring an extension's identity and permissions.
+ * Passed to ExtensionManager.load() alongside the extension source.
+ */
+interface ExtensionManifest {
+  /** Unique name for this extension (used as namespace prefix for tools). */
+  name: string;
+  /** Semver version string. */
+  version: string;
+  /** Human-readable description. */
+  description?: string;
+  /** Permission declarations — controls what the extension can access. */
+  permissions?: ExtensionPermissions;
+}
+interface ExtensionPermissions {
+  /**
+   * Allowed network hosts. If empty or undefined, the extension has
+   * no outbound network access (globalOutbound: null).
+   * If set, the extension inherits the parent Worker's network.
+   *
+   * Note: per-host filtering is not yet enforced at the runtime level.
+   * This field serves as a declaration of intent; actual enforcement
+   * is all-or-nothing via globalOutbound.
+   */
+  network?: string[];
+  /**
+   * Workspace access level.
+   * - "none" (default): no workspace access
+   * - "read": can read files and list directories
+   * - "read-write": can read, write, and delete files
+   */
+  workspace?: "read" | "read-write" | "none";
+}
+/**
+ * Tool descriptor returned by the extension's describe() method.
+ * Uses JSON Schema for input validation.
+ */
+interface ExtensionToolDescriptor {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: "object";
+    properties: Record<string, unknown>;
+    required?: string[];
+  };
+}
+/**
+ * Summary of a loaded extension, returned by ExtensionManager.list().
+ */
+interface ExtensionInfo {
+  name: string;
+  version: string;
+  description?: string;
+  /** Names of tools provided by this extension. */
+  tools: string[];
+  permissions: ExtensionPermissions;
+}
+//#endregion
+//#region src/extensions/manager.d.ts
+interface ExtensionManagerOptions {
+  /** WorkerLoader binding for creating sandboxed extension Workers. */
+  loader: WorkerLoader;
+  /**
+   * Durable Object storage for persisting extensions across hibernation.
+   * If provided, loaded extensions survive DO restarts. Call `restore()`
+   * on each turn to rebuild in-memory state from storage.
+   */
+  storage?: DurableObjectStorage;
+  /**
+   * Factory that creates a loopback Fetcher for workspace access, given
+   * an extension's declared permissions. The returned binding is injected
+   * into the extension worker's `env.host`.
+   *
+   * If not provided, extensions receive no host binding (workspace tools
+   * will get `null` for the host parameter).
+   *
+   * Typically wired up using HostBridgeLoopback via `ctx.exports`:
+   * ```typescript
+   * createHostBinding: (permissions) =>
+   *   ctx.exports.HostBridgeLoopback({
+   *     props: { agentClassName: "ChatSession", agentId: ctx.id.toString(), permissions }
+   *   })
+   * ```
+   */
+  createHostBinding?: (permissions: ExtensionPermissions) => Fetcher;
+}
+declare class ExtensionManager {
+  #private;
+  constructor(options: ExtensionManagerOptions);
+  /**
+   * 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).
+   */
+  restore(): Promise<void>;
+  load(manifest: ExtensionManifest, source: string): Promise<ExtensionInfo>;
+  /**
+   * Unload an extension, removing its tools from the agent.
+   */
+  unload(name: string): Promise<boolean>;
+  /**
+   * List all loaded extensions.
+   */
+  list(): ExtensionInfo[];
+  /**
+   * 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(): ToolSet;
+}
+//#endregion
+//#region src/extensions/host-bridge.d.ts
+type HostBridgeLoopbackProps = {
+  agentClassName: string;
+  agentId: string;
+  permissions: ExtensionPermissions;
+};
+declare class HostBridgeLoopback extends WorkerEntrypoint<
+  Record<string, unknown>,
+  HostBridgeLoopbackProps
+> {
+  #private;
+  private _permissions;
+  private _getAgent;
+  readFile(path: string): Promise<string | null>;
+  writeFile(path: string, content: string): Promise<void>;
+  deleteFile(path: string): Promise<boolean>;
+  listFiles(dir: string): Promise<
+    Array<{
+      name: string;
+      type: string;
+      size: number;
+      path: string;
+    }>
+  >;
+}
+//#endregion
+export {
+  ExtensionInfo as a,
+  ExtensionToolDescriptor as c,
+  ExtensionManagerOptions as i,
+  HostBridgeLoopbackProps as n,
+  ExtensionManifest as o,
+  ExtensionManager as r,
+  ExtensionPermissions as s,
+  HostBridgeLoopback as t
+};
+//# sourceMappingURL=index-BlcvIdWK.d.ts.map