effect-codemode 0.0.1 → 0.1.0-beta.0

package/README.md

@@ -1,5 +1,641 @@
 # effect-codemode
 
-Effect-native codemode for MCP — give LLMs a typed Effect SDK instead of individual tool calls.
+Give LLMs a typed Effect SDK instead of individual tool calls.
 
-Coming soon. See https://github.com/aulneau/effect-codemode
+effect-codemode implements the [codemode pattern](https://blog.cloudflare.com/code-mode-mcp/) for [MCP](https://modelcontextprotocol.io) — collapsing N tools into 2 (`search_tools` + `execute_code`) so the LLM writes typed Effect code against your services instead of making one tool call at a time.
+
+## The problem
+
+Traditional MCP exposes each operation as a separate tool. A workspace with Linear, GitHub, Sheets, and Slack integrations might have 36+ tools — each loaded into the LLM's context at ~500 tokens each. That's 18,000 tokens before the LLM has done anything.
+
+Worse, composition requires round trips. "Find my Linear issues and check for linked PRs" means:
+
+1. LLM calls `linear_issue_list` -> waits for result
+2. LLM calls `gh_list_prs` -> waits for result
+3. LLM reasons about both -> responds
+
+Each round trip burns tokens and adds latency. A 5-step workflow means 5 round trips.
+
+## The codemode pattern
+
+With effect-codemode, the LLM writes one code block:
+
+```typescript
+Effect.gen(function* () {
+  const issues = yield* codemode.linear_issue_list({ assigneeId: me.id, first: 10 })
+  const prs = yield* codemode.gh_list_prs({ owner: "Org", repo: "app", state: "open" })
+  return issues.filter(i => prs.some(p => p.title.includes(i.identifier)))
+})
+```
+
+One round trip. Multiple API calls. Data filtering happens in the sandbox, not in the LLM's context. And because this is Effect, the LLM gets typed errors, structured concurrency, and composable resilience — not just `async/await`.
+
+## Quick start
+
+### Install
+
+```bash
+bun add effect-codemode effect @effect/ai @effect/platform
+```
+
+### 1. Define your schemas and errors
+
+```typescript
+import { Context, Effect, Layer, Schema } from "effect"
+
+const Todo = Schema.Struct({
+  id: Schema.String.annotations({ description: "Todo UUID" }),
+  title: Schema.String.annotations({ description: "Short summary" }),
+  completed: Schema.Boolean,
+}).annotations({ identifier: "Todo" })
+
+type Todo = typeof Todo.Type
+
+class NotFoundError extends Schema.TaggedError<NotFoundError>()("NotFoundError", {
+  message: Schema.String,
+}) {}
+
+class ValidationError extends Schema.TaggedError<ValidationError>()("ValidationError", {
+  message: Schema.String,
+  field: Schema.String,
+}) {}
+```
+
+### 2. Define tool shapes
+
+Tool shapes are pure data descriptors — name, description, input/output schemas, error types, and flags. No implementation.
+
+```typescript
+import { Codemode } from "effect-codemode"
+
+const TodoGet = Codemode.tool("todo_get", {
+  description: "Get a todo by ID",
+  input: Schema.Struct({ id: Schema.String.annotations({ description: "Todo UUID" }) }),
+  output: Todo,
+  errors: [NotFoundError],
+  example: 'yield* codemode.todo_get({ id: "todo-1" })',
+})
+
+const TodoList = Codemode.tool("todo_list", {
+  description: "List todos with optional filter",
+  input: Schema.Struct({
+    completed: Schema.optional(Schema.Boolean.annotations({ description: "Filter by status" }), { exact: true }),
+  }),
+  output: Schema.Array(Todo),
+  example: "yield* codemode.todo_list({ completed: false })",
+})
+
+const TodoCreate = Codemode.tool("todo_create", {
+  description: "Create a new todo",
+  input: Schema.Struct({
+    title: Schema.String.annotations({ description: "Title for the new todo" }),
+  }),
+  output: Todo,
+  errors: [ValidationError],
+  example: 'yield* codemode.todo_create({ title: "New task" })',
+})
+```
+
+### 3. Create a group with `.toLayer()`
+
+Groups bundle related tool shapes and bind them to an implementation via `.toLayer()`. The handlers can depend on Effect services.
+
+```typescript
+class TodoService extends Context.Tag("TodoService")<
+  TodoService,
+  {
+    readonly get: (id: string) => Effect.Effect<Todo, NotFoundError>
+    readonly list: (filter?: { completed?: boolean }) => Effect.Effect<Todo[]>
+    readonly create: (input: { title: string }) => Effect.Effect<Todo, ValidationError>
+  }
+>() {}
+
+class TodoTools extends Codemode.group("todos", TodoGet, TodoList, TodoCreate) {}
+
+const TodoToolsLive = TodoTools.toLayer(
+  Effect.gen(function* () {
+    const svc = yield* TodoService
+    return {
+      todo_get: ({ id }) => svc.get(id),
+      todo_list: (input) => svc.list(input),
+      todo_create: (input) => svc.create(input),
+    }
+  }),
+).pipe(Layer.provide(TodoServiceLive))
+```
+
+Or pass handlers directly without an Effect if there are no service dependencies:
+
+```typescript
+const TodoToolsLive = TodoTools.toLayer({
+  todo_get: ({ id }) => Effect.succeed(todos.find(t => t.id === id)),
+  todo_list: (input) => Effect.succeed(todos),
+  todo_create: (input) => Effect.succeed({ id: "new", title: input.title, completed: false }),
+})
+```
+
+### 4. Serve
+
+The quickest way to get running is `Codemode.live()`, which bundles `Codemode.serve()` with the default VM executor:
+
+```typescript
+import { Codemode, CodemodeRegistry } from "effect-codemode"
+import { McpServer } from "@effect/ai"
+import { Effect, Layer } from "effect"
+
+Codemode.live().pipe(
+  Layer.provide(TodoToolsLive),
+  Layer.provide(CodemodeRegistry.layer),
+  Layer.provide(McpServer.layerStdio({
+    name: "my-mcp-server",
+    version: "1.0.0",
+    stdin,
+    stdout,
+  })),
+  Layer.launch,
+  Effect.runFork,
+)
+```
+
+For more control, use `Codemode.serve()` and provide the executor explicitly:
+
+```typescript
+import { Codemode, CodemodeRegistry, CodeExecutor } from "effect-codemode"
+
+Codemode.serve().pipe(
+  Layer.provide(TodoToolsLive),
+  Layer.provide(CodemodeRegistry.layer),
+  Layer.provide(CodeExecutor.Default),
+  Layer.provide(McpServer.layerStdio({
+    name: "my-mcp-server",
+    version: "1.0.0",
+    stdin,
+    stdout,
+  })),
+  Layer.launch,
+  Effect.runFork,
+)
+```
+
+Or use the `StdioTransport` helper if you have `@effect/platform-bun` or `@effect/platform-node`:
+
+```typescript
+import { BunRuntime } from "@effect/platform-bun"
+import { BunSink, BunStream } from "@effect/platform-bun"
+
+Codemode.live().pipe(
+  Layer.provide(TodoToolsLive),
+  Layer.provide(CodemodeRegistry.layer),
+  Layer.provide(Codemode.StdioTransport(BunStream.stdin, BunSink.stdout, {
+    name: "my-mcp-server",
+    version: "1.0.0",
+  })),
+  Layer.launch,
+  BunRuntime.runMain,
+)
+```
+
+### 5. Connect to Claude Code
+
+Create `.mcp.json` in your project root:
+
+```json
+{
+  "mcpServers": {
+    "my-tools": {
+      "command": "bun",
+      "args": ["run", "src/server.ts"]
+    }
+  }
+}
+```
+
+## What the LLM sees
+
+effect-codemode walks your Effect Schema AST and generates TypeScript declarations. When the LLM calls `execute_code`, this is in the tool description:
+
+```typescript
+type NotFoundError = { readonly _tag: "NotFoundError"; readonly message: string }
+
+type Todo = {
+  id: string
+  title: string
+  completed: boolean
+}
+
+declare const codemode: {
+  /** Get a todo by ID
+   * @param id - Todo UUID
+   * @error NotFoundError
+   */
+  todo_get(input: { id: string }): Effect<Todo, NotFoundError>
+
+  /** List todos with optional filter */
+  todo_list(input: { completed?: boolean }): Effect<Todo[], never>
+}
+```
+
+The LLM writes natural Effect code against this typed SDK. Schema annotations become `@param` descriptions. Error types are deduplicated across tools. Output types shared between tools are emitted once.
+
+When the tool count exceeds 7, the description automatically switches to a compact one-line-per-tool catalog and directs the LLM to use `search_tools` for full type signatures.
+
+## Effect patterns in the sandbox
+
+The sandbox has `Effect`, `pipe`, `Duration`, `Schedule`, `Option`, `Either`, `Match`, `Schema`, `Arr` (Effect's Array module), `Ref`, `Stream`, `Chunk`, `Data`, `Order`, and `Predicate` available as globals. Helper functions `parallel()` and `sleep(ms)` are also available. Each method on `codemode` returns an Effect — use `yield*` inside `Effect.gen` to call them.
+
+### Typed error handling
+
+```typescript
+Effect.gen(function* () {
+  return yield* codemode.todo_get({ id: "nonexistent" })
+}).pipe(
+  Effect.catchTag("NotFoundError", (e) =>
+    Effect.succeed({ error: e.message, fallback: true })
+  )
+)
+```
+
+### Parallel composition
+
+```typescript
+Effect.gen(function* () {
+  const [todos, users] = yield* Effect.all([
+    codemode.todo_list({}),
+    codemode.user_list({}),
+  ], { concurrency: "unbounded" })
+  return { todos: todos.length, users: users.length }
+})
+```
+
+### Retry with backoff
+
+```typescript
+Effect.gen(function* () {
+  return yield* codemode.flaky_api_call({})
+}).pipe(
+  Effect.retry({ times: 3, schedule: Schedule.exponential("1 second") })
+)
+```
+
+### Timeout
+
+```typescript
+Effect.gen(function* () {
+  return yield* codemode.slow_operation({})
+}).pipe(Effect.timeout("10 seconds"))
+```
+
+### Progress streaming
+
+`console.log` in sandbox code streams as MCP logging notifications in real-time:
+
+```typescript
+Effect.gen(function* () {
+  console.log("Fetching todos...")
+  const todos = yield* codemode.todo_list({})
+  console.log(`Got ${todos.length} todos, processing...`)
+  return todos
+})
+```
+
+## Multiple services
+
+Compose groups for cross-service workflows:
+
+```typescript
+Codemode.live().pipe(
+  Layer.provide(Layer.mergeAll(TaskToolsLive, ProjectToolsLive, SlackToolsLive)),
+  Layer.provide(CodemodeRegistry.layer),
+  Layer.provide(McpServer.layerStdio({
+    name: "my-workspace",
+    version: "1.0.0",
+    stdin,
+    stdout,
+  })),
+  Layer.launch,
+  Effect.runFork,
+)
+```
+
+The LLM can now compose across all services in one code block:
+
+```typescript
+Effect.gen(function* () {
+  const user = yield* codemode.user_get({ id: "user-1" })
+  const todos = yield* codemode.todo_list({ assignee: user.id })
+
+  yield* Effect.all(
+    todos.map(todo =>
+      codemode.slack_send({
+        channel: "#tasks",
+        message: `${user.name}: ${todo.title}`,
+      })
+    ),
+    { concurrency: 5 }
+  )
+
+  return { notified: todos.length }
+})
+```
+
+Failed groups are automatically excluded at startup. The server starts with whatever's available, and service status is included in the tool description so the LLM knows what's online.
+
+## Features
+
+### Middleware
+
+Add cross-cutting concerns to all tool executions:
+
+```typescript
+import { Codemode } from "effect-codemode"
+import type { ToolMiddleware } from "effect-codemode"
+
+const loggingMiddleware: ToolMiddleware = (tool, next) =>
+  Effect.gen(function* () {
+    console.log(`Calling ${tool.name}`)
+    const start = Date.now()
+    const result = yield* next
+    console.log(`${tool.name} took ${Date.now() - start}ms`)
+    return result
+  })
+
+// Global middleware wraps ALL tools from every group
+Codemode.serve().pipe(
+  Layer.provide(Codemode.withMiddleware(loggingMiddleware)),
+  Layer.provide(Layer.mergeAll(TodoToolsLive, UserToolsLive)),
+  Layer.provide(CodemodeRegistry.layer),
+  // ...transport + executor
+)
+```
+
+Middleware receives a `ToolInvocation` (with `name` and `input`) and a `next` Effect. You can inspect the invocation, transform results, catch errors, or skip execution entirely.
+
+#### Per-group middleware
+
+Attach middleware to a specific group using `.middleware()`:
+
+```typescript
+class TodoTools extends Codemode.group("todos", TodoGet, TodoList, TodoCreate)
+  .middleware(auditMiddleware, rateLimitMiddleware) {}
+```
+
+Or pass middleware via `.toLayer()` options:
+
+```typescript
+const TodoToolsLive = TodoTools.toLayer(handlers, {
+  middleware: [auditMiddleware],
+})
+```
+
+#### Per-tool middleware
+
+Attach middleware to individual tool shapes:
+
+```typescript
+const TodoDelete = Codemode.tool("todo_delete", {
+  description: "Delete a todo permanently",
+  input: Schema.Struct({ id: Schema.String }),
+  output: Schema.Struct({ deleted: Schema.Boolean }),
+  middleware: [auditMiddleware],
+})
+```
+
+### Confirmation-required tools
+
+Tools with `requiresConfirmation: true` are excluded from the sandbox and registered as separate MCP tools, so the MCP client can show a confirmation dialog:
+
+```typescript
+const TodoDelete = Codemode.tool("todo_delete", {
+  description: "Delete a todo permanently",
+  input: Schema.Struct({ id: Schema.String }),
+  output: Schema.Struct({ deleted: Schema.Boolean }),
+  errors: [NotFoundError],
+  requiresConfirmation: true,
+})
+```
+
+### Tool search
+
+The `search_tools` MCP tool supports keyword search, service browsing, fuzzy matching, and configurable detail levels:
+
+```
+search_tools({ query: "todo" })                    // keyword search
+search_tools({ query: "service:todos" })           // browse by service
+search_tools({ query: "isue" })                    // fuzzy match -> "issue"
+search_tools({ query: "" })                        // list all tools
+search_tools({ query: "todo", detail: "list" })    // names + descriptions only
+search_tools({ query: "todo", detail: "summary" }) // names + descriptions + params
+search_tools({ query: "todo", detail: "full" })    // complete TypeScript declarations (default)
+```
+
+Multi-term queries use AND semantics — all terms must match. Workflow queries like `"sheets read write"` fall back to returning all tools for the matched service.
+
+### Network isolation
+
+Block network access in the sandbox:
+
+```typescript
+const result = await executor.execute(code, fns, { allowNetwork: false })
+```
+
+When disabled, `fetch`, `URL`, `Request`, `Headers`, and `Response` throw clear errors.
+
+### Code executor
+
+`CodeExecutor` is an Effect service tag with multiple implementations:
+
+```typescript
+import { CodeExecutor } from "effect-codemode"
+
+CodeExecutor.Vm      // node:vm — stronger isolation (default)
+CodeExecutor.Direct  // new Function() — faster, less isolated
+CodeExecutor.Default // alias for Vm
+```
+
+Provide the executor when using `Codemode.serve()`:
+
+```typescript
+Codemode.serve().pipe(
+  Layer.provide(CodeExecutor.Default), // or CodeExecutor.Direct
+  // ...
+)
+```
+
+Or use `Codemode.live()` which bundles `CodeExecutor.Default` automatically.
+
+### Execution timeout
+
+The sandbox has a default 30-second timeout. Configure it via `ExecutorOptions`:
+
+```typescript
+executor.execute(code, fns, { timeoutMs: 60_000 }) // 60 seconds
+```
+
+### Auto-retry on rate limits
+
+Tool calls that fail with a `RateLimitError` (or any error with `status: 429`) are automatically retried up to 3 times with exponential backoff.
+
+## Testing
+
+effect-codemode exports testing utilities from `effect-codemode/test`:
+
+```typescript
+import { buildTestTool, buildInspector } from "effect-codemode/test"
+```
+
+### `buildTestTool`
+
+Creates a full CodemodeTool from group layers — run sandbox code without starting an MCP server:
+
+```typescript
+const codemode = buildTestTool(TodoToolsLive, UserToolsLive)
+
+const result = await codemode.execute(`
+  Effect.gen(function* () {
+    const todos = yield* codemode.todo_list({})
+    return todos.length
+  })
+`)
+// result.result === 3
+// result.logs === [...]
+```
+
+### `buildInspector`
+
+Returns just the TypeScript declarations string — useful for snapshot testing your generated API:
+
+```typescript
+const declarations = buildInspector(TodoToolsLive)
+expect(declarations).toContain("todo_get")
+```
+
+## Architecture
+
+```
+MCP Client (Claude Code, Cursor, etc.)
+    | search_tools / execute_code
+@effect/ai McpServer (stdio / HTTP transport)
+    |
+serve.ts -> registry snapshot -> tool registration
+    |
+codemode.ts -> typegen (declarations) + bridge (fn table) + executor
+    |
++----------------------------------------------------------+
+| Sandbox                                                  |
+|                                                          |
+|  Globals: Effect, pipe, Duration, Schedule, Option,      |
+|  Either, Match, Schema, Arr, Ref, Stream, Chunk, Data,   |
+|  Order, Predicate, parallel, sleep, codemode.*            |
+|                                                          |
+|  codemode.tool_name(input)                               |
+|    -> Schema.decodeUnknown (input validation)            |
+|    -> middleware chain                                    |
+|    -> Effect service method (via captured Runtime)        |
+|    -> unwrapEffectTypes (Option -> null, Either -> value) |
+|    -> auto-retry on RateLimitError                        |
+|    -> returns Effect<Output, Error>                       |
+|                                                          |
+|  LLM writes: Effect.gen(function* () { yield* ... })     |
+|  Executor detects Effect return -> Effect.runPromise()    |
++----------------------------------------------------------+
+    |
+Effect Services (your existing Context.Tag + Layer stack)
+```
+
+## API reference
+
+### Core
+
+| Export | Description |
+|--------|-------------|
+| `Codemode.tool(name, config)` | Define a tool shape — pure data descriptor with no implementation |
+| `Codemode.group(name, ...tools)` | Bundle related tools into a group class with `.toLayer()` and `.middleware()` |
+| `Codemode.serve()` | Return a Layer that sets up the full MCP server (requires `CodeExecutor`) |
+| `Codemode.live()` | Convenience — `serve()` with `CodeExecutor.Default` bundled |
+| `Codemode.StdioTransport(stdin, stdout, options?)` | Stdio transport for MCP — provides McpServer |
+| `Codemode.CodemodeRegistry` | Shared registry tag — also available as named export |
+| `CodemodeRegistry.layer` | Shared registry Layer — provide once so groups and serve share state |
+| `Codemode.withMiddleware(mw)` | Register a global middleware Layer |
+
+### Tool config
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `description` | `string` | What the tool does |
+| `input` | `Schema` | Input schema |
+| `output` | `Schema?` | Output schema |
+| `errors` | `TaggedError[]?` | Error types the tool can fail with |
+| `example` | `string?` | Example code shown to the LLM |
+| `requiresConfirmation` | `boolean?` | Register as separate MCP tool for confirmation |
+| `middleware` | `ToolMiddleware[]?` | Per-tool middleware |
+
+### Executor
+
+| Export | Description |
+|--------|-------------|
+| `CodeExecutor` | Effect service tag for code execution |
+| `CodeExecutor.Vm` | V8-isolated executor (`node:vm`) |
+| `CodeExecutor.Direct` | Fast executor (`new Function`) |
+| `CodeExecutor.Default` | Alias for `Vm` |
+| `normalizeCode(code)` | Acorn-based code normalization |
+
+### Bridge
+
+| Export | Description |
+|--------|-------------|
+| `effectToEffectFn(tool, runtime)` | Convert a tool to an Effect-returning function |
+| `buildEffectFnTable(tools, runtime)` | Build a table of Effect-returning functions |
+| `unwrapEffectTypes(value)` | Recursively unwrap Option/Either to plain values |
+
+### Discovery
+
+| Export | Description |
+|--------|-------------|
+| `searchTools(catalog, query, detail?)` | Search tools by keyword with fuzzy matching |
+| `listToolSummary(catalog, detail?)` | List all tools grouped by service |
+| `generateDeclarations(tools)` | Generate TypeScript declarations from Schema AST |
+| `astToTypeScript(ast)` | Convert a single Schema AST node to TypeScript |
+
+### Testing
+
+| Export | Description |
+|--------|-------------|
+| `buildTestTool(...groups)` | Create a CodemodeTool for in-process testing |
+| `buildInspector(...groups)` | Generate declarations string for snapshot testing |
+
+### Utilities
+
+| Export | Description |
+|--------|-------------|
+| `sanitizeToolName(name)` | Sanitize a tool name to a valid JS identifier |
+
+### Types
+
+| Export | Description |
+|--------|-------------|
+| `ToolShape` | Pure tool shape descriptor from `Codemode.tool()` |
+| `ToolDescriptor` | Complete tool definition with schema, errors, execute |
+| `ToolMiddleware` | Middleware function type `(invocation, next) => Effect` |
+| `ToolInvocation` | Invocation context: `{ name, input }` |
+| `ExecuteResult` | Result of sandbox execution: `{ result, error?, logs }` |
+| `Executor` | Interface for code execution engines |
+| `ExecutorOptions` | Options: `{ onLog?, allowNetwork?, timeoutMs? }` |
+
+## Why Effect in the sandbox?
+
+Cloudflare's codemode uses async/await. That works, but leaves capabilities on the table:
+
+| | async/await | Effect |
+|---|---|---|
+| Error handling | `try/catch` guessing | `Effect.catchTag("NotFoundError", ...)` with typed errors |
+| Concurrency | `Promise.all` | `Effect.all([...], { concurrency: 5 })` with structured semantics |
+| Resilience | Manual retry loops | `Effect.retry({ schedule: Schedule.exponential("1s") })` |
+| Timeout | `Promise.race` hacks | `Effect.timeout("10 seconds")` |
+| Type generation | Zod -> JSON Schema -> TypeScript | Schema AST -> TypeScript (zero conversion, richer annotations) |
+| Integration | Conversion layer needed | Your `Context.Tag` + `Layer` + `Schema` _are_ the tool definitions |
+
+If your services already use Effect, there's no conversion layer. Your schemas, services, and error types flow directly into the LLM's typed SDK.
+
+## License
+
+MIT

package/dist/bridge.d.ts

@@ -0,0 +1,46 @@
+import { Effect, Runtime } from "effect";
+import type { ToolDescriptor, ToolMiddleware } from "./types";
+/**
+ * Recursively unwraps Effect tagged types (Option, Either) into plain
+ * JSON-friendly values. Uses a WeakSet to safely handle circular references.
+ *
+ * - Option<A>: Some → unwrapped value, None → null
+ * - Either<L, R>: Right → unwrapped right value, Left → { _tag: "Left", left: ... }
+ * - Arrays: each element recursively unwrapped
+ * - Plain objects: each value recursively unwrapped
+ */
+export declare const unwrapEffectTypes: (value: unknown, seen?: WeakSet<object> | undefined) => unknown;
+export interface EffectToAsyncFnOptions {
+    /** Whether to validate output against the tool's outputSchema (default: true) */
+    readonly validateOutput?: boolean | undefined;
+    /** Middleware to wrap around each tool execution */
+    readonly middleware?: ReadonlyArray<ToolMiddleware> | undefined;
+}
+/**
+ * Converts a single Effect-based tool into a plain async function
+ * using a captured Effect Runtime. Unwraps Effect types (Option, Either)
+ * from the return value and retries on rate limit errors.
+ */
+export declare const effectToAsyncFn: <R>(tool: ToolDescriptor, runtime: Runtime.Runtime<R>, options?: EffectToAsyncFnOptions | undefined) => (rawInput: unknown) => Promise<unknown>;
+/**
+ * Builds a table of plain async functions from an array of tool descriptors
+ * and a captured Effect Runtime.
+ */
+export declare const buildFnTable: <R>(tools: readonly ToolDescriptor[], runtime: Runtime.Runtime<R>, options?: EffectToAsyncFnOptions | undefined) => Record<string, (...args: unknown[]) => Promise<unknown>>;
+/**
+ * Converts a single Effect-based tool into a function that returns an Effect.
+ * The returned Effect decodes input, calls the service, unwraps Effect types,
+ * and keeps errors in the Effect error channel (no throwing).
+ *
+ * Rate limit errors are retried using Effect.retry with exponential backoff.
+ */
+export declare const effectToEffectFn: <R>(tool: ToolDescriptor, runtime: Runtime.Runtime<R>, options?: EffectToAsyncFnOptions | undefined) => (rawInput: unknown) => Effect.Effect<unknown, unknown, never>;
+/**
+ * Builds a table of Effect-returning functions from an array of tool
+ * descriptors and a captured Effect Runtime.
+ *
+ * Each function in the table takes an input and returns an
+ * `Effect<unknown, unknown>` — errors stay in the Effect error channel.
+ */
+export declare const buildEffectFnTable: <R>(tools: readonly ToolDescriptor[], runtime: Runtime.Runtime<R>, options?: EffectToAsyncFnOptions | undefined) => Record<string, (...args: unknown[]) => Effect.Effect<unknown, unknown, never>>;
+//# sourceMappingURL=bridge.d.ts.map

package/dist/bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../src/bridge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAQ,OAAO,EAAoB,MAAM,QAAQ,CAAA;AAGhE,OAAO,KAAK,EAAE,cAAc,EAAkB,cAAc,EAAE,MAAM,SAAS,CAAA;AAM7E;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,iEA8C7B,CAAA;AAkDD,MAAM,WAAW,sBAAsB;IACrC,iFAAiF;IACjF,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7C,oDAAoD;IACpD,QAAQ,CAAC,UAAU,CAAC,EAAE,aAAa,CAAC,cAAc,CAAC,GAAG,SAAS,CAAA;CAChE;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,6IAyFhC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,0KAe7B,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,mKAiDjC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,gMAcnC,CAAA"}