@opencode-ai/codemode 0.0.0-beta-17492

package/README.md

@@ -0,0 +1,168 @@
+# @opencode-ai/codemode
+
+This is our take on code mode: a lightweight, pure interpreter for a JavaScript-like language built around calling
+tools. It supports familiar JavaScript syntax with a few key differences and limitations. See the
+[interpreter support checklist](./interpreter-support.md) for more details.
+
+Rather than trying to sandbox arbitrary JavaScript, CodeMode only runs the language features we implement. Programs
+cannot directly access the network, filesystem, processes, or application APIs. They can interact with the outside
+world only through tools provided by the host, which can also limit execution time, tool calls, output size, and data.
+
+The idea of code mode was originally introduced by Cloudflare. See
+[their post](https://blog.cloudflare.com/code-mode/) to learn more about the concept and their isolate-based approach.
+
+## How it differs from JavaScript
+
+- **Only supported APIs are available.** Programs can use the provided tools and supported JavaScript built-ins. APIs
+  such as `fetch`, timers, `process`, filesystem access, imports, and modules are unavailable.
+- **Unfinished work is interrupted.** Tool calls and async functions start when called. When the program finishes,
+  anything still running is interrupted. Unhandled rejections from un-awaited promises are returned as warnings.
+- **REPL-style results.** Without an explicit `return`, the final top-level expression becomes the result. `undefined`
+  becomes `null`.
+
+Unsupported syntax returns an `UnsupportedSyntax` diagnostic with a source location. Current gaps are tracked in the
+[interpreter support checklist](./interpreter-support.md).
+
+## Quick Start
+
+```ts
+import { CodeMode, Tool } from "@opencode-ai/codemode"
+import { Effect, Schema } from "effect"
+
+const lookupOrder = Tool.make({
+  description: "Look up an order by ID",
+  input: Schema.Struct({ id: Schema.String }),
+  output: Schema.Struct({ id: Schema.String, status: Schema.String }),
+  execute: ({ id }) => Effect.succeed({ id, status: "open" }),
+})
+
+const runtime = CodeMode.make({
+  tools: { orders: { lookup: lookupOrder } },
+})
+
+const result = await Effect.runPromise(
+  runtime.execute(`
+    const order = await tools.orders.lookup({ id: "order_42" })
+    return { id: order.id, needsAttention: order.status !== "complete" }
+  `),
+)
+```
+
+`result` is always a [`CodeMode.Result`](#results).
+
+## API
+
+### `Tool.make`
+
+`input` and `output` accept either an Effect Schema or a render-only JSON Schema document. Effect Schema input is
+decoded before `execute`; Effect Schema output is decoded and safely copied before the program sees it. JSON Schemas
+only shape the model-visible signature. Without `output`, the signature uses `Promise<void>`.
+
+Descriptions and schemas are model-visible contracts. Authorization belongs in `execute`.
+
+Dots in tool names create namespaces: `{ "issues.list": tool }` and `{ issues: { list: tool } }` both expose
+`tools.issues.list(...)`. Other characters use bracket notation, such as
+`tools.context7["resolve-library-id"](...)`.
+
+### `CodeMode.execute` and `CodeMode.make`
+
+`CodeMode.execute({ ...options, code })` runs once. `CodeMode.make(options)` creates a reusable runtime:
+
+```ts
+const runtime = CodeMode.make({ tools, limits: { timeoutMs: 30_000 } })
+
+runtime.catalog() // structured tool descriptions
+runtime.execute(source) // Effect<CodeMode.Result, never, ToolServices>
+```
+
+The Effect environment is inferred from the supplied tools. `onToolCallStart` observes admitted calls with decoded
+input; `onToolCallEnd` observes settled outcomes and duration. Both hooks return Effects and must not fail.
+
+### OpenAPI tools
+
+`OpenAPI.fromSpec` converts an OpenAPI 3.x document into one tool per supported operation. Dotted `operationId` values
+create namespaces:
+
+```ts
+const api = OpenAPI.fromSpec({ spec, auth: { resolve } })
+const runtime = CodeMode.make({ tools: { opencode: api.tools } })
+```
+
+The synchronous result is `{ tools, skipped }`. Operations with unsupported parameter encodings, request bodies
+without JSON content, WebSocket or SSE semantics, or binary responses are reported in `skipped`.
+
+Authentication is resolved by the host and never shown to the model. Generated tools require `HttpClient.HttpClient`.
+Request signatures omit `readOnly` properties; response signatures omit `writeOnly` properties. These JSON Schemas
+shape model-visible signatures but do not filter runtime values: nested JSON body properties and decoded server
+responses pass through unchanged. See `src/openapi/types.ts` for option details.
+
+## Results
+
+Every execution returns:
+
+```ts
+type Result =
+  | {
+      readonly ok: true
+      readonly value: CodeMode.DataValue
+      readonly warnings?: ReadonlyArray<CodeMode.Diagnostic>
+      readonly logs?: ReadonlyArray<string>
+      readonly truncated?: boolean
+      readonly toolCalls: ReadonlyArray<CodeMode.ToolCall>
+    }
+  | {
+      readonly ok: false
+      readonly error: CodeMode.Diagnostic
+      readonly logs?: ReadonlyArray<string>
+      readonly truncated?: boolean
+      readonly toolCalls: ReadonlyArray<CodeMode.ToolCall>
+    }
+```
+
+`value` is JSON-safe. `warnings` are non-fatal diagnostics, `logs` contain program console output, and `truncated`
+indicates that retained output was cut by `maxOutputBytes`. `toolCalls` retains admitted calls in order, including after
+failure.
+
+Diagnostic kinds:
+
+| Kind                    | Meaning                                                                                        |
+| ----------------------- | ---------------------------------------------------------------------------------------------- |
+| `ParseError`            | Source is empty or cannot be parsed.                                                           |
+| `UnsupportedSyntax`     | Parsed JavaScript is outside the supported subset.                                             |
+| `UnknownTool`           | The program referenced an unavailable tool.                                                    |
+| `InvalidToolInput`      | Tool input failed schema decoding or safe-data copying.                                        |
+| `InvalidToolOutput`     | Tool output failed schema decoding or safe-data copying.                                       |
+| `InvalidDataValue`      | Program data violated the plain-data contract.                                                 |
+| `ToolCallLimitExceeded` | The program exceeded `maxToolCalls`.                                                           |
+| `TimeoutExceeded`       | Execution timed out; as a warning, background work was interrupted after the program returned. |
+| `ToolFailure`           | A tool refused or failed.                                                                      |
+| `ExecutionFailure`      | The program threw or another execution error occurred.                                         |
+| `Truncated`             | Warning only: additional warnings were omitted by `maxOutputBytes`.                            |
+
+Unknown host failures, defects, and invalid outputs are sanitized. `toolError("safe message")` explicitly exposes a
+safe refusal to the model; its optional cause remains private.
+
+## Discovery
+
+`runtime.catalog()` returns structured descriptors — exact path, description, and generated TypeScript signature — for
+every visible tool. Hosts render their own model-facing instructions from these descriptors; `CodeMode.searchSignature`
+and `CodeMode.toolExpression(path)` supply the exact callable forms.
+
+The synchronous `search(...)` built-in is always available. It supports exact-path lookup, namespace-scoped search,
+empty-query browsing, and pagination, and returns callable paths with full signatures. Search counts toward
+`maxToolCalls`.
+
+## Execution Limits
+
+| Limit            | Default   | Controls                        |
+| ---------------- | --------- | ------------------------------- |
+| `timeoutMs`      | unlimited | Total execution time.           |
+| `maxToolCalls`   | unlimited | Admitted tool calls.            |
+| `maxOutputBytes` | unlimited | Retained result value and logs. |
+
+Execution limits have no default values.
+
+Invalid limit configuration throws `RangeError`. Warnings receive a separate budget equal to `maxOutputBytes`.
+Truncation does not fail execution; an oversized value becomes a string with an in-band marker. Timeouts interrupt
+tool calls and busy loops, while a result returned before cleanup times out remains successful with a
+`TimeoutExceeded` warning. Tool-call concurrency is unrestricted. Boundary data is limited to 32 nested levels.

package/dist/codemode.d.ts

@@ -0,0 +1,148 @@
+import { Effect, Schema } from "effect";
+import { type Services, type ToolDescription, ToolRuntime } from "./tool-runtime.js";
+import type { Tools } from "./tools.js";
+/** A tool call admitted during an execution. */
+export type { ToolCall, ToolCallEnded, ToolCallHooks, ToolCallStarted, ToolDescription } from "./tool-runtime.js";
+/** Signature-construction helpers for host-owned catalog instructions. */
+export { searchSignature, toolExpression } from "./tool-runtime.js";
+/** Resource budgets enforced independently during each CodeMode program execution. */
+export type ExecutionLimits = {
+    /**
+     * Wall-clock milliseconds before interruption. Result delivery waits for tool cleanup.
+     * No default: absent means no timeout.
+     */
+    readonly timeoutMs?: number;
+    /** Maximum number of tool calls admitted by the runtime. No default: absent means unlimited. */
+    readonly maxToolCalls?: number;
+    /**
+     * Maximum UTF-8 bytes retained from the result and logs. Warnings have a separate equal budget;
+     * truncation notices and host formatting are additional.
+     */
+    readonly maxOutputBytes?: number;
+};
+export type ResolvedExecutionLimits = {
+    readonly timeoutMs: number | undefined;
+    readonly maxToolCalls: number | undefined;
+    readonly maxOutputBytes: number | undefined;
+};
+/** Options for one CodeMode execution. */
+export type ExecuteOptions<Provided extends Record<string, unknown> = {}> = {
+    /** Source for one program in the supported JavaScript subset. */
+    code: string;
+    /** Explicit tools exposed to the program as `tools`. */
+    tools?: Provided & Tools<Services<Provided>>;
+    /** Per-execution overrides for the default resource limits. */
+    limits?: ExecutionLimits;
+    /** Observes decoded tool input immediately before tool execution. */
+    onToolCallStart?: (call: ToolRuntime.ToolCallStarted) => Effect.Effect<void, never, Services<Provided>>;
+    /** Observes each admitted tool call as it succeeds, fails, or is interrupted. */
+    onToolCallEnd?: (call: ToolRuntime.ToolCallEnded) => Effect.Effect<void, never, Services<Provided>>;
+};
+/** A JSON value that can cross the confined interpreter boundary. */
+export type DataValue = Schema.Json;
+/** Configuration shared by `CodeMode.make` and `CodeMode.execute`. */
+export type Options<Provided extends Record<string, unknown> = {}> = Omit<ExecuteOptions<Provided>, "code">;
+/** Schema for a host tool input containing CodeMode source. */
+export declare const Input: Schema.Struct<{
+    readonly code: Schema.String;
+}>;
+export type Input = typeof Input.Type;
+export declare const DiagnosticKind: Schema.Literals<readonly ["ParseError", "UnsupportedSyntax", "UnknownTool", "InvalidToolInput", "InvalidToolOutput", "InvalidDataValue", "ToolCallLimitExceeded", "TimeoutExceeded", "ToolFailure", "ExecutionFailure", "Truncated"]>;
+/** Stable categories produced by program, schema, tool, limit, and truncation diagnostics. */
+export type DiagnosticKind = typeof DiagnosticKind.Type;
+export declare const Diagnostic: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["ParseError", "UnsupportedSyntax", "UnknownTool", "InvalidToolInput", "InvalidToolOutput", "InvalidDataValue", "ToolCallLimitExceeded", "TimeoutExceeded", "ToolFailure", "ExecutionFailure", "Truncated"]>;
+    readonly message: Schema.String;
+    readonly location: Schema.optionalKey<Schema.Struct<{
+        readonly line: Schema.Number;
+        readonly column: Schema.Number;
+    }>>;
+    readonly suggestions: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>;
+/** A normalized program diagnostic safe to return across an agent tool boundary. */
+export type Diagnostic = typeof Diagnostic.Type;
+export declare const Success: Schema.Struct<{
+    readonly ok: Schema.Literal<true>;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly warnings: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["ParseError", "UnsupportedSyntax", "UnknownTool", "InvalidToolInput", "InvalidToolOutput", "InvalidDataValue", "ToolCallLimitExceeded", "TimeoutExceeded", "ToolFailure", "ExecutionFailure", "Truncated"]>;
+        readonly message: Schema.String;
+        readonly location: Schema.optionalKey<Schema.Struct<{
+            readonly line: Schema.Number;
+            readonly column: Schema.Number;
+        }>>;
+        readonly suggestions: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>>>;
+    readonly logs: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly truncated: Schema.optionalKey<Schema.Boolean>;
+    readonly toolCalls: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+    }>>;
+}>;
+/** Successful execution after the result has crossed the plain-data boundary. */
+export type Success = typeof Success.Type;
+export declare const Failure: Schema.Struct<{
+    readonly ok: Schema.Literal<false>;
+    readonly error: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["ParseError", "UnsupportedSyntax", "UnknownTool", "InvalidToolInput", "InvalidToolOutput", "InvalidDataValue", "ToolCallLimitExceeded", "TimeoutExceeded", "ToolFailure", "ExecutionFailure", "Truncated"]>;
+        readonly message: Schema.String;
+        readonly location: Schema.optionalKey<Schema.Struct<{
+            readonly line: Schema.Number;
+            readonly column: Schema.Number;
+        }>>;
+        readonly suggestions: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>;
+    readonly logs: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly truncated: Schema.optionalKey<Schema.Boolean>;
+    readonly toolCalls: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+    }>>;
+}>;
+/** Failed execution with calls admitted before the diagnostic was produced. */
+export type Failure = typeof Failure.Type;
+/** Schema for the structured success or diagnostic returned by CodeMode execution. */
+export declare const Result: Schema.Union<readonly [Schema.Struct<{
+    readonly ok: Schema.Literal<true>;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly warnings: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["ParseError", "UnsupportedSyntax", "UnknownTool", "InvalidToolInput", "InvalidToolOutput", "InvalidDataValue", "ToolCallLimitExceeded", "TimeoutExceeded", "ToolFailure", "ExecutionFailure", "Truncated"]>;
+        readonly message: Schema.String;
+        readonly location: Schema.optionalKey<Schema.Struct<{
+            readonly line: Schema.Number;
+            readonly column: Schema.Number;
+        }>>;
+        readonly suggestions: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>>>;
+    readonly logs: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly truncated: Schema.optionalKey<Schema.Boolean>;
+    readonly toolCalls: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+    }>>;
+}>, Schema.Struct<{
+    readonly ok: Schema.Literal<false>;
+    readonly error: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["ParseError", "UnsupportedSyntax", "UnknownTool", "InvalidToolInput", "InvalidToolOutput", "InvalidDataValue", "ToolCallLimitExceeded", "TimeoutExceeded", "ToolFailure", "ExecutionFailure", "Truncated"]>;
+        readonly message: Schema.String;
+        readonly location: Schema.optionalKey<Schema.Struct<{
+            readonly line: Schema.Number;
+            readonly column: Schema.Number;
+        }>>;
+        readonly suggestions: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>;
+    readonly logs: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly truncated: Schema.optionalKey<Schema.Boolean>;
+    readonly toolCalls: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+    }>>;
+}>]>;
+/** Result of executing a CodeMode program. Program failures are data, not Effect failures. */
+export type Result = typeof Result.Type;
+/** Reusable confined runtime over explicit tools. */
+export type Runtime<R = never> = {
+    readonly catalog: () => ReadonlyArray<ToolDescription>;
+    readonly execute: (code: string) => Effect.Effect<Result, never, R>;
+};
+/** Executes one Effect-native CodeMode program without constructing a reusable runtime. */
+export declare const execute: <const Provided extends Record<string, unknown>>(options: ExecuteOptions<Provided>) => Effect.Effect<Result, never, Services<Provided>>;
+/** Creates an Effect-native runtime over explicit, schema-described tools. */
+export declare const make: <const Provided extends Record<string, unknown> = {}>(options?: Options<Provided>) => Runtime<Services<Provided>>;

package/dist/codemode.js

@@ -0,0 +1,70 @@
+import { Effect, Schema } from "effect";
+import { executeWithLimits } from "./interpreter/execute.js";
+import { ToolRuntime } from "./tool-runtime.js";
+/** Signature-construction helpers for host-owned catalog instructions. */
+export { searchSignature, toolExpression } from "./tool-runtime.js";
+/** Schema for a host tool input containing CodeMode source. */
+export const Input = Schema.Struct({ code: Schema.String });
+export const DiagnosticKind = Schema.Literals([
+    "ParseError",
+    "UnsupportedSyntax",
+    "UnknownTool",
+    "InvalidToolInput",
+    "InvalidToolOutput",
+    "InvalidDataValue",
+    "ToolCallLimitExceeded",
+    "TimeoutExceeded",
+    "ToolFailure",
+    "ExecutionFailure",
+    "Truncated",
+]);
+export const Diagnostic = Schema.Struct({
+    kind: DiagnosticKind,
+    message: Schema.String,
+    location: Schema.optionalKey(Schema.Struct({ line: Schema.Number, column: Schema.Number })),
+    suggestions: Schema.optionalKey(Schema.Array(Schema.String)),
+});
+const ToolCallSchema = Schema.Struct({ name: Schema.String });
+export const Success = Schema.Struct({
+    ok: Schema.Literal(true),
+    value: Schema.Json,
+    warnings: Schema.optionalKey(Schema.Array(Diagnostic)),
+    logs: Schema.optionalKey(Schema.Array(Schema.String)),
+    truncated: Schema.optionalKey(Schema.Boolean),
+    toolCalls: Schema.Array(ToolCallSchema),
+});
+export const Failure = Schema.Struct({
+    ok: Schema.Literal(false),
+    error: Diagnostic,
+    logs: Schema.optionalKey(Schema.Array(Schema.String)),
+    truncated: Schema.optionalKey(Schema.Boolean),
+    toolCalls: Schema.Array(ToolCallSchema),
+});
+/** Schema for the structured success or diagnostic returned by CodeMode execution. */
+export const Result = Schema.Union([Success, Failure]);
+const validateLimit = (name, value, minimum) => {
+    if (value !== undefined && (!Number.isSafeInteger(value) || value < minimum)) {
+        throw new RangeError(`${name} must be a safe integer greater than or equal to ${minimum}.`);
+    }
+    return value;
+};
+const resolveExecutionLimits = (limits) => ({
+    timeoutMs: validateLimit("timeoutMs", limits?.timeoutMs, 1),
+    maxToolCalls: validateLimit("maxToolCalls", limits?.maxToolCalls, 0),
+    maxOutputBytes: validateLimit("maxOutputBytes", limits?.maxOutputBytes, 0),
+});
+/** Executes one Effect-native CodeMode program without constructing a reusable runtime. */
+export const execute = (options) => {
+    const tools = (options.tools ?? {});
+    return executeWithLimits(options, resolveExecutionLimits(options.limits), ToolRuntime.searchIndex(tools));
+};
+/** Creates an Effect-native runtime over explicit, schema-described tools. */
+export const make = (options = {}) => {
+    const tools = (options.tools ?? {});
+    const limits = resolveExecutionLimits(options.limits);
+    const prepared = ToolRuntime.prepare(tools);
+    return {
+        catalog: () => prepared.catalog,
+        execute: (code) => executeWithLimits({ ...options, code }, limits, prepared.searchIndex),
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * as CodeMode from "./codemode.js";
+export * as Tool from "./tool.js";
+export * as OpenAPI from "./openapi/index.js";
+export { searchSignature, toolExpression } from "./codemode.js";
+export { ToolError, toolError } from "./tool-error.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export * as CodeMode from "./codemode.js";
+export * as Tool from "./tool.js";
+export * as OpenAPI from "./openapi/index.js";
+export { searchSignature, toolExpression } from "./codemode.js";
+export { ToolError, toolError } from "./tool-error.js";

package/dist/interpreter/errors.d.ts

@@ -0,0 +1,9 @@
+import { Effect } from "effect";
+import type { Diagnostic } from "../codemode.js";
+import { type SafeObject } from "../tool-runtime.js";
+import { type AstNode } from "./model.js";
+import { type SyncIteratorRunner } from "./iterator.js";
+export declare const normalizeError: (error: unknown) => Diagnostic;
+export declare const caughtErrorValue: (thrown: unknown) => unknown;
+export declare const constructErrorValue: (name: string, args: Array<unknown>) => SafeObject;
+export declare const constructAggregateErrorValue: <R>(runner: SyncIteratorRunner<R>, args: Array<unknown>, node: AstNode) => Effect.Effect<SafeObject, unknown, R>;

package/dist/interpreter/errors.js

@@ -0,0 +1,91 @@
+import { Effect } from "effect";
+import { ToolError } from "../tool-error.js";
+import { copyOut, ToolRuntimeError } from "../tool-runtime.js";
+import { formatLocation, InterpreterRuntimeError, ProgramThrow, sourceLocation } from "./model.js";
+import { containsRuntimeReference } from "./references.js";
+import {} from "./iterator.js";
+import { coerceToString, createAggregateErrorValue, createErrorValue, errorConstructors } from "../stdlib/value.js";
+export const normalizeError = (error) => {
+    if (error instanceof InterpreterRuntimeError) {
+        return {
+            kind: error.kind,
+            message: `${error.message}${formatLocation(error.node)}`,
+            ...(error.node?.loc ? { location: sourceLocation(error.node) } : {}),
+            ...(error.suggestions ? { suggestions: error.suggestions } : {}),
+        };
+    }
+    if (error instanceof ToolRuntimeError) {
+        return {
+            kind: error.kind,
+            message: error.message,
+            ...(error.suggestions.length > 0 ? { suggestions: error.suggestions } : {}),
+        };
+    }
+    if (error instanceof ToolError) {
+        return { kind: "ToolFailure", message: error.message };
+    }
+    if (error instanceof ProgramThrow) {
+        const value = error.value;
+        let message;
+        if (containsRuntimeReference(value)) {
+            // Never expose runtime reference internals through thrown values.
+            message = "a non-data value";
+        }
+        else if (typeof value === "string") {
+            message = value;
+        }
+        else if (value !== null &&
+            typeof value === "object" &&
+            typeof value.message === "string") {
+            message = value.message;
+        }
+        else {
+            try {
+                message = JSON.stringify(copyOut(value, "json")) ?? String(value);
+            }
+            catch {
+                message = String(value);
+            }
+        }
+        return { kind: "ExecutionFailure", message: `Uncaught: ${message}` };
+    }
+    if (error instanceof RangeError && /call stack|recursion/i.test(error.message)) {
+        return {
+            kind: "ExecutionFailure",
+            message: "Execution exceeded the maximum nesting depth.",
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            kind: error.name === "SyntaxError" ? "ParseError" : "ExecutionFailure",
+            message: error.message,
+        };
+    }
+    return {
+        kind: "ExecutionFailure",
+        message: String(error),
+    };
+};
+export const caughtErrorValue = (thrown) => {
+    if (thrown instanceof ProgramThrow)
+        return thrown.value;
+    if (thrown instanceof InterpreterRuntimeError)
+        return createErrorValue(thrown.errorName, thrown.message);
+    const name = thrown instanceof Error && errorConstructors.has(thrown.name) ? thrown.name : "Error";
+    return createErrorValue(name, normalizeError(thrown).message);
+};
+export const constructErrorValue = (name, args) => createErrorValue(name, args[0] === undefined ? "" : coerceToString(args[0]));
+export const constructAggregateErrorValue = (runner, args, node) => Effect.gen(function* () {
+    const cursor = yield* runner.syncIterator(args[0], node);
+    if (cursor === undefined) {
+        throw new InterpreterRuntimeError("new AggregateError(...) expects a synchronous iterable of errors.", node).as("TypeError");
+    }
+    const errors = [];
+    while (true) {
+        const step = yield* cursor.next;
+        if (step.done) {
+            return createAggregateErrorValue(errors, args[1] === undefined ? "" : coerceToString(args[1]));
+        }
+        errors.push(step.value);
+    }
+});

package/dist/interpreter/execute.d.ts

@@ -0,0 +1,4 @@
+import { Effect } from "effect";
+import type { ExecuteOptions, ResolvedExecutionLimits, Result } from "../codemode.js";
+import { ToolRuntime, type Services } from "../tool-runtime.js";
+export declare const executeWithLimits: <const Provided extends Record<string, unknown>>(options: ExecuteOptions<Provided>, limits: ResolvedExecutionLimits, searchIndex: ToolRuntime.DiscoveryPlan["searchIndex"]) => Effect.Effect<Result, never, Services<Provided>>;