@opencode/codemode 0.0.0-reserved → 2.0.0

package/dist/stdlib/regexp.js

@@ -0,0 +1,120 @@
+import { sync, syncCall } from "../interpreter/host.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { ProgramArray, record, set } from "../interpreter/objects.js";
+import { Values } from "../values.js";
+import { coerceToNumber, coerceToString } from "./value.js";
+export const regexpMethods = new Set(["test", "exec", "toString"]);
+export const regexpProperties = new Set([
+    "source",
+    "flags",
+    "lastIndex",
+    "hasIndices",
+    "global",
+    "ignoreCase",
+    "multiline",
+    "sticky",
+    "unicode",
+    "unicodeSets",
+    "dotAll",
+]);
+const regexFailureReason = (error) => (error instanceof Error ? error.message : String(error)).replace(/^Invalid regular expression:\s*/i, "");
+const escapeRegexHint = 'To match special characters like ( ) [ ] { } + * ? . literally, escape them with a backslash (e.g. "\\\\(") or test for them with String.includes instead.';
+export const toHostRegex = (arg, method, node, extraFlags = "") => {
+    // Native parity: an undefined pattern behaves as an empty pattern.
+    if (arg === undefined)
+        return new RegExp("", extraFlags);
+    if (arg instanceof Values.RegExp)
+        return arg.regex;
+    if (typeof arg === "string") {
+        try {
+            return new RegExp(arg, extraFlags);
+        }
+        catch (error) {
+            throw new InterpreterRuntimeError(`String.${method} received the string ${JSON.stringify(arg)}, which is not a valid regular expression pattern (${regexFailureReason(error)}). ${escapeRegexHint}`, node).as("SyntaxError");
+        }
+    }
+    throw new InterpreterRuntimeError(`String.${method} expects a regular expression (a /pattern/flags literal or new RegExp(...)) or a string pattern, not ${arg === null ? "null" : typeof arg}.`, node);
+};
+export const matchToValue = (match) => {
+    const result = new ProgramArray(Array.from(match, (group) => group));
+    if (match.index !== undefined)
+        set(result, "index", match.index);
+    if (match.input !== undefined)
+        set(result, "input", match.input);
+    if (match.groups)
+        set(result, "groups", record(match.groups));
+    if (match.indices)
+        set(result, "indices", indicesToValue(match.indices));
+    return result;
+};
+export const constructRegExp = (args, node) => {
+    const first = args[0];
+    const pattern = first instanceof Values.RegExp ? first.regex.source : first === undefined ? "" : coerceToString(first);
+    const flagsArg = args[1];
+    if (flagsArg !== undefined && typeof flagsArg !== "string") {
+        throw new InterpreterRuntimeError(`RegExp flags must be a string of flag characters (e.g. "g", "gi"), not ${flagsArg === null ? "null" : typeof flagsArg}.`, node).as("SyntaxError");
+    }
+    const flags = flagsArg ?? (first instanceof Values.RegExp ? first.regex.flags : "");
+    try {
+        return new Values.RegExp(pattern, flags);
+    }
+    catch (error) {
+        const reason = regexFailureReason(error);
+        throw new InterpreterRuntimeError(/flag/i.test(reason)
+            ? `new RegExp(...) received invalid flags ${JSON.stringify(flags)} (${reason}). Valid flags are d, g, i, m, s, u, v, and y.`
+            : `new RegExp(...) received ${JSON.stringify(pattern)}, which is not a valid regular expression pattern (${reason}). ${escapeRegexHint}`, node).as("SyntaxError");
+    }
+};
+// RegExp constructs identically with or without new, like JS.
+export const regexpGlobal = sync("RegExp", constructRegExp, {
+    construct: syncCall(constructRegExp),
+    instanceOf: (value) => value instanceof Values.RegExp,
+    members: {
+        escape: sync("RegExp.escape", (args, node) => {
+            if (typeof args[0] !== "string") {
+                throw new InterpreterRuntimeError("RegExp.escape expects a string.", node).as("TypeError");
+            }
+            return RegExp.escape(args[0]);
+        }),
+    },
+});
+export const invokeRegExpMethod = (value, name, args, node) => {
+    switch (name) {
+        case "test":
+        case "exec": {
+            const input = coerceToString(args[0]);
+            const lastIndex = value.lastIndex;
+            const stateful = value.regex.global || value.regex.sticky;
+            value.regex.lastIndex = toLength(lastIndex);
+            if (name === "test") {
+                const matched = value.regex.test(input);
+                if (!stateful)
+                    value.lastIndex = lastIndex;
+                return matched;
+            }
+            const matched = value.regex.exec(input);
+            if (!stateful)
+                value.lastIndex = lastIndex;
+            return matched === null ? null : matchToValue(matched);
+        }
+        case "toString":
+            return coerceToString(value);
+        default:
+            throw new InterpreterRuntimeError(`RegExp method '${name}' is not available.`, node);
+    }
+};
+const toLength = (value) => {
+    const number = coerceToNumber(value);
+    if (Number.isNaN(number) || number <= 0)
+        return 0;
+    return Math.min(Math.floor(number), Number.MAX_SAFE_INTEGER);
+};
+const indicesToValue = (indices) => {
+    const range = (pair) => (pair === undefined ? undefined : new ProgramArray([...pair]));
+    const result = new ProgramArray(Array.from(indices, range));
+    const groups = indices.groups;
+    set(result, "groups", groups === undefined
+        ? undefined
+        : record(Object.fromEntries(Object.entries(groups).map(([key, pair]) => [key, range(pair)]))));
+    return result;
+};

package/dist/stdlib/string.d.ts

@@ -0,0 +1,2 @@
+export declare const stringMethods: Set<string>;
+export declare const stringGlobal: import("../interpreter/host.js").HostFunction<never>;

package/dist/stdlib/string.js

@@ -0,0 +1,51 @@
+import { sync } from "../interpreter/host.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { coercion } from "./value.js";
+export const stringMethods = new Set([
+    "toLowerCase",
+    "toUpperCase",
+    "trim",
+    "trimStart",
+    "trimEnd",
+    "trimLeft",
+    "trimRight",
+    "split",
+    "slice",
+    "substring",
+    "substr",
+    "includes",
+    "startsWith",
+    "endsWith",
+    "indexOf",
+    "lastIndexOf",
+    "replace",
+    "replaceAll",
+    "repeat",
+    "padStart",
+    "padEnd",
+    "charAt",
+    "charCodeAt",
+    "codePointAt",
+    "at",
+    "concat",
+    "toString",
+    "match",
+    "matchAll",
+    "search",
+    "localeCompare",
+    "normalize",
+    "isWellFormed",
+    "toWellFormed",
+]);
+const codeUnits = (name, op) => sync(`String.${name}`, (args, node) => op(...args.map((arg) => {
+    if (typeof arg !== "number")
+        throw new InterpreterRuntimeError(`String.${name} expects number arguments.`, node);
+    return arg;
+})));
+export const stringGlobal = coercion("String", {
+    instanceOf: () => false,
+    members: {
+        fromCharCode: codeUnits("fromCharCode", String.fromCharCode),
+        fromCodePoint: codeUnits("fromCodePoint", String.fromCodePoint),
+    },
+});

package/dist/stdlib/url.d.ts

@@ -0,0 +1,16 @@
+import { HostFunction } from "../interpreter/host.js";
+import { type AstNode } from "../interpreter/model.js";
+import { type Runner } from "../interpreter/runner.js";
+import { Values } from "../values.js";
+export declare const urlProperties: Set<string>;
+export declare const urlWritableProperties: Set<string>;
+export declare const urlMethods: Set<string>;
+export declare const urlSearchParamsMethods: Set<string>;
+export declare const uriArgument: (value: unknown, label: string) => string;
+type UriFunction = "encodeURI" | "encodeURIComponent" | "decodeURI" | "decodeURIComponent";
+export declare const uriGlobal: (name: UriFunction) => HostFunction<never>;
+export declare const urlArgument: (value: unknown, label: string) => string;
+export declare const urlGlobal: HostFunction<never>;
+export declare const urlSearchParamsGlobal: <R>(runner: Runner<R>) => HostFunction<R>;
+export declare const invokeURLMethod: (value: Values.URL, name: string, node: AstNode) => string;
+export {};

package/dist/stdlib/url.js

@@ -0,0 +1,161 @@
+import { Effect } from "effect";
+import { toProgram } from "../data.js";
+import { HostFunction, requiresNew, sync, syncCall } from "../interpreter/host.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { ownEntries, ProgramObject } from "../interpreter/objects.js";
+import { isRuntimeReference } from "../interpreter/references.js";
+import { preserveConsumerError } from "../interpreter/runner.js";
+import { Values } from "../values.js";
+import { coerceToString } from "./value.js";
+export const urlProperties = new Set([
+    "href",
+    "origin",
+    "protocol",
+    "username",
+    "password",
+    "host",
+    "hostname",
+    "port",
+    "pathname",
+    "search",
+    "hash",
+]);
+export const urlWritableProperties = new Set([
+    "href",
+    "protocol",
+    "username",
+    "password",
+    "host",
+    "hostname",
+    "port",
+    "pathname",
+    "search",
+    "hash",
+]);
+export const urlMethods = new Set(["toString", "toJSON"]);
+export const urlSearchParamsMethods = new Set([
+    "append",
+    "delete",
+    "get",
+    "getAll",
+    "has",
+    "set",
+    "sort",
+    "forEach",
+    "keys",
+    "values",
+    "entries",
+    "toString",
+]);
+export const uriArgument = (value, label) => coerceToString(toProgram(value, label));
+const uriFunctions = {
+    encodeURI,
+    encodeURIComponent,
+    decodeURI,
+    decodeURIComponent,
+};
+export const uriGlobal = (name) => sync(name, (args, node) => {
+    const value = uriArgument(args[0], `${name} input`);
+    try {
+        return uriFunctions[name](value);
+    }
+    catch (error) {
+        throw new InterpreterRuntimeError(`${name} received malformed URI data: ${error instanceof Error ? error.message : String(error)}`, node).as("URIError");
+    }
+});
+export const urlArgument = (value, label) => value instanceof Values.URL ? value.url.href : uriArgument(value, label);
+const urlStatic = (name) => sync(`URL.${name}`, (args, node) => {
+    if (args.length === 0) {
+        throw new InterpreterRuntimeError(`URL.${name} requires a URL argument.`, node).as("TypeError");
+    }
+    const input = urlArgument(args[0], `URL.${name} input`);
+    const base = args[1] === undefined ? undefined : urlArgument(args[1], `URL.${name} base`);
+    try {
+        const url = new URL(input, base);
+        return name === "canParse" ? true : new Values.URL(url);
+    }
+    catch {
+        return name === "canParse" ? false : null;
+    }
+});
+const constructURL = (args, node) => {
+    if (args.length === 0) {
+        throw new InterpreterRuntimeError("new URL(...) requires a URL string and an optional base URL.", node).as("TypeError");
+    }
+    const input = urlArgument(args[0], "new URL input");
+    const base = args[1] === undefined ? undefined : urlArgument(args[1], "new URL base");
+    try {
+        return new Values.URL(new URL(input, base));
+    }
+    catch {
+        throw new InterpreterRuntimeError(`new URL(...) received an invalid URL${base === undefined ? "" : " or base URL"}.`, node).as("TypeError");
+    }
+};
+export const urlGlobal = new HostFunction({
+    name: "URL",
+    call: requiresNew("URL"),
+    construct: syncCall(constructURL),
+    instanceOf: (value) => value instanceof Values.URL,
+    members: { canParse: urlStatic("canParse"), parse: urlStatic("parse") },
+});
+const readURLSearchParamsPair = (runner, value, node) => Effect.gen(function* () {
+    const cursor = yield* runner.syncIterator(value, node);
+    if (cursor === undefined) {
+        throw new InterpreterRuntimeError("new URLSearchParams(...) expects iterable [name, value] pairs.", node).as("TypeError");
+    }
+    const items = [];
+    while (true) {
+        const step = yield* cursor.next;
+        if (step.done)
+            return items;
+        items.push(yield* preserveConsumerError(cursor, Effect.sync(() => uriArgument(step.value, "URLSearchParams pair value"))));
+    }
+});
+const constructURLSearchParams = (runner, init, node) => {
+    if (init === undefined)
+        return Effect.succeed(new Values.URLSearchParams(new URLSearchParams()));
+    if (init instanceof Values.URLSearchParams) {
+        return Effect.succeed(new Values.URLSearchParams(new URLSearchParams(init.params)));
+    }
+    if (typeof init === "string")
+        return Effect.succeed(new Values.URLSearchParams(new URLSearchParams(init)));
+    if (init === null || typeof init === "number" || typeof init === "boolean") {
+        return Effect.succeed(new Values.URLSearchParams(new URLSearchParams(coerceToString(init))));
+    }
+    return Effect.gen(function* () {
+        const cursor = yield* runner.syncIterator(init, node);
+        if (cursor !== undefined) {
+            const entries = [];
+            while (true) {
+                const step = yield* cursor.next;
+                if (step.done) {
+                    if (entries.some((entry) => entry.length !== 2)) {
+                        throw new InterpreterRuntimeError("new URLSearchParams(...) expects iterable [name, value] pairs.", node).as("TypeError");
+                    }
+                    return new Values.URLSearchParams(new URLSearchParams(entries.map((entry) => [entry[0] ?? "", entry[1] ?? ""])));
+                }
+                entries.push(yield* preserveConsumerError(cursor, readURLSearchParamsPair(runner, step.value, node)));
+            }
+        }
+        if (isRuntimeReference(init)) {
+            throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, or synchronous iterable pairs.", node).as("TypeError");
+        }
+        if (Values.isValue(init))
+            return new Values.URLSearchParams(new URLSearchParams());
+        if (!(init instanceof ProgramObject)) {
+            throw new InterpreterRuntimeError("new URLSearchParams(...) expects a query string, data object, iterable pairs, or URLSearchParams.", node).as("TypeError");
+        }
+        return new Values.URLSearchParams(new URLSearchParams(Object.fromEntries(ownEntries(init).map(([key, value]) => [key, coerceToString(value)]))));
+    });
+};
+export const urlSearchParamsGlobal = (runner) => new HostFunction({
+    name: "URLSearchParams",
+    call: requiresNew("URLSearchParams"),
+    construct: (args, node) => constructURLSearchParams(runner, args[0], node),
+    instanceOf: (value) => value instanceof Values.URLSearchParams,
+});
+export const invokeURLMethod = (value, name, node) => {
+    if (name === "toString" || name === "toJSON")
+        return value.url.href;
+    throw new InterpreterRuntimeError(`URL method '${name}' is not available.`, node);
+};

package/dist/stdlib/value.d.ts

@@ -0,0 +1,13 @@
+import { type HostFunction, type SyncOptions } from "../interpreter/host.js";
+import { ProgramError } from "../interpreter/objects.js";
+export declare const errorConstructors: Set<string>;
+export declare const compoundOperators: Set<string>;
+export declare const createErrorValue: (name: string, message: string) => ProgramError;
+export declare const createAggregateErrorValue: (errors: Array<unknown>, message: string) => ProgramError;
+export declare const errorBrandName: (value: unknown) => string | undefined;
+export declare const coerceToString: (value: unknown) => string;
+export declare const coerceToNumber: (value: unknown) => number;
+type Coercion = "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN";
+/** A global coercion function such as `Number` or `parseInt`. */
+export declare const coercion: (name: Coercion, options?: SyncOptions) => HostFunction;
+export {};

package/dist/stdlib/value.js

@@ -0,0 +1,120 @@
+import { sync } from "../interpreter/host.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { toProgram } from "../data.js";
+import { get, ProgramArray, ProgramError, set } from "../interpreter/objects.js";
+import { Values } from "../values.js";
+export const errorConstructors = new Set([
+    "Error",
+    "TypeError",
+    "RangeError",
+    "SyntaxError",
+    "ReferenceError",
+    "EvalError",
+    "URIError",
+    "AggregateError",
+]);
+export const compoundOperators = new Set(["+=", "-=", "*=", "/=", "%=", "**=", "&=", "|=", "^=", "<<=", ">>=", ">>>="]);
+export const createErrorValue = (name, message) => {
+    const value = new ProgramError(name);
+    set(value, "name", name);
+    set(value, "message", message);
+    return value;
+};
+export const createAggregateErrorValue = (errors, message) => {
+    const value = createErrorValue("AggregateError", message);
+    set(value, "errors", new ProgramArray(errors));
+    return value;
+};
+export const errorBrandName = (value) => value instanceof ProgramError ? value.errorName : undefined;
+export const coerceToString = (value) => {
+    if (value === null)
+        return "null";
+    if (value === undefined)
+        return "undefined";
+    if (value instanceof Values.Date)
+        return Number.isFinite(value.time) ? new Date(value.time).toISOString() : "Invalid Date";
+    if (value instanceof Values.RegExp)
+        return `/${value.regex.source}/${value.regex.flags}`;
+    if (value instanceof Values.Map)
+        return "[object Map]";
+    if (value instanceof Values.Set)
+        return "[object Set]";
+    if (value instanceof Values.URL)
+        return value.url.href;
+    if (value instanceof Values.URLSearchParams)
+        return value.params.toString();
+    if (value instanceof ProgramError) {
+        // Match Error.prototype.toString: "name: message", or just one when the other is empty.
+        const name = get(value, "name");
+        const message = get(value, "message");
+        const shownName = typeof name === "string" ? name : "Error";
+        const shownMessage = typeof message === "string" ? message : "";
+        if (shownMessage === "")
+            return shownName;
+        if (shownName === "")
+            return shownMessage;
+        return `${shownName}: ${shownMessage}`;
+    }
+    if (value instanceof ProgramArray) {
+        return value.items.map((item) => (item === null || item === undefined ? "" : coerceToString(item))).join(",");
+    }
+    if (typeof value === "object")
+        return "[object Object]";
+    return String(value);
+};
+export const coerceToNumber = (value) => {
+    if (value instanceof Values.Date)
+        return value.time;
+    if (Values.isValue(value))
+        return Number.NaN;
+    if (value instanceof ProgramArray)
+        return Number(coerceToString(value));
+    return value !== null && typeof value === "object" ? Number.NaN : Number(value);
+};
+const coerce = (name, args, node) => {
+    // Native: Number() is 0 and String() is "", unlike their undefined-argument forms; the
+    // other coercers match native through the undefined-argument path below.
+    if (args.length === 0) {
+        if (name === "Number")
+            return 0;
+        if (name === "String")
+            return "";
+    }
+    const raw = args[0];
+    if (Values.isValue(raw)) {
+        if (name === "Boolean")
+            return true;
+        if (name === "Number")
+            return coerceToNumber(raw);
+        if (name === "String")
+            return coerceToString(raw);
+        if (name === "isFinite")
+            return Number.isFinite(coerceToNumber(raw));
+        if (name === "isNaN")
+            return Number.isNaN(coerceToNumber(raw));
+        if (name === "parseInt")
+            return parseInt(coerceToString(raw));
+        return parseFloat(coerceToString(raw));
+    }
+    const value = toProgram(raw, `${name} input`);
+    if (name === "Number")
+        return coerceToNumber(value);
+    if (name === "Boolean")
+        return Boolean(value);
+    if (name === "isFinite")
+        return Number.isFinite(coerceToNumber(value));
+    if (name === "isNaN")
+        return Number.isNaN(coerceToNumber(value));
+    if (name === "parseInt") {
+        const radix = args[1];
+        if (radix !== undefined && typeof radix !== "number") {
+            throw new InterpreterRuntimeError("parseInt expects a numeric radix.", node);
+        }
+        return parseInt(coerceToString(value), radix);
+    }
+    if (name === "parseFloat")
+        return parseFloat(coerceToString(value));
+    return coerceToString(value);
+};
+/** A global coercion function such as `Number` or `parseInt`. */
+export const coercion = (name, options = {}) => sync(name, (args, node) => toProgram(coerce(name, args, node), `${name} result`), options);

package/dist/stdlib/web.d.ts

@@ -0,0 +1,4 @@
+import { HostNamespace } from "../interpreter/host.js";
+export declare const atobGlobal: import("../interpreter/host.js").HostFunction<never>;
+export declare const btoaGlobal: import("../interpreter/host.js").HostFunction<never>;
+export declare const cryptoGlobal: HostNamespace;

package/dist/stdlib/web.js

@@ -0,0 +1,20 @@
+import { HostNamespace, sync } from "../interpreter/host.js";
+import { InterpreterRuntimeError } from "../interpreter/model.js";
+import { coerceToString } from "./value.js";
+// WebIDL DOMString conversion: a missing argument is a TypeError, anything else stringifies.
+const base64 = (name) => sync(name, (args, node) => {
+    if (args.length === 0)
+        throw new InterpreterRuntimeError(`${name} requires 1 argument (a string)`, node).as("TypeError");
+    const input = coerceToString(args[0]);
+    try {
+        return name === "atob" ? atob(input) : btoa(input);
+    }
+    catch {
+        throw new InterpreterRuntimeError("The string contains invalid characters.", node).as("InvalidCharacterError");
+    }
+});
+export const atobGlobal = base64("atob");
+export const btoaGlobal = base64("btoa");
+export const cryptoGlobal = new HostNamespace("crypto", {
+    randomUUID: sync("crypto.randomUUID", () => crypto.randomUUID()),
+});

package/dist/tool-error.d.ts

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+declare const ToolError_base: Schema.Class<ToolError, Schema.TaggedStruct<"ToolError", {
+    readonly message: Schema.String;
+    readonly cause: Schema.optionalKey<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** Tool failure reported as `ToolFailure`. */
+export declare class ToolError extends ToolError_base {
+}
+/** Creates a tool failure with an optional underlying cause. */
+export declare const toolError: (message: string, cause?: unknown) => ToolError;
+export {};

package/dist/tool-error.js

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+/** Tool failure reported as `ToolFailure`. */
+export class ToolError extends Schema.TaggedError()("ToolError", {
+    message: Schema.String,
+    cause: Schema.optionalKey(Schema.Defect()),
+}) {
+}
+/** Creates a tool failure with an optional underlying cause. */
+export const toolError = (message, cause) => new ToolError({ message, ...(cause === undefined ? {} : { cause }) });

package/dist/tool-runtime.d.ts

@@ -0,0 +1,69 @@
+import { Effect } from "effect";
+import { type Namespace } from "./namespace.js";
+import { type Tool } from "./tool.js";
+import type { Tools } from "./tools.js";
+export declare const compareText: (left: string, right: string) => 1 | -1 | 0;
+export type Services<T> = ServicesOf<T, []>;
+type ServicesOf<T, Depth extends ReadonlyArray<unknown>> = Depth["length"] extends 8 ? never : T extends {
+    readonly _tag: "CodeModeTool";
+    readonly execute: (input: unknown) => Effect.Effect<unknown, unknown, infer R>;
+} ? R : T extends object ? string extends keyof T ? ServicesOf<T[string], [...Depth, unknown]> : ServicesOf<T[keyof T], [...Depth, unknown]> : never;
+export type ToolCall = {
+    readonly name: string;
+};
+export type ToolCallStarted = {
+    readonly index: number;
+    readonly name: string;
+    readonly input: unknown;
+};
+export type ToolCallEnded = {
+    readonly index: number;
+    readonly name: string;
+    readonly input: unknown;
+    readonly durationMs: number;
+    readonly outcome: "success" | "failure" | "interrupted";
+    readonly message?: string;
+};
+export type ToolCallHooks<R = never> = {
+    /** Observes decoded tool input immediately before tool execution. */
+    readonly onToolCallStart?: ((call: ToolCallStarted) => Effect.Effect<void, never, R>) | undefined;
+    /** Observes each admitted tool call as it succeeds, fails, or is interrupted. */
+    readonly onToolCallEnd?: ((call: ToolCallEnded) => Effect.Effect<void, never, R>) | undefined;
+};
+export type ToolDescription = {
+    readonly path: string;
+    readonly description: string;
+    readonly signature: string;
+};
+export declare const toolExpression: (path: string) => string;
+export declare class ToolReference {
+    readonly path: ReadonlyArray<string>;
+    constructor(path: ReadonlyArray<string>);
+}
+type ToolNode<R> = {
+    tool?: Tool<R>;
+    namespace?: Namespace<R>;
+    readonly children: Map<string, ToolNode<R>>;
+};
+/** Tools indexed once per runtime: the lookup trie plus the model-facing catalog and search index. */
+export type Prepared<R = never> = {
+    readonly root: ToolNode<R>;
+    readonly catalog: ReadonlyArray<ToolDescription>;
+    readonly searchIndex: ReadonlyArray<SearchEntry>;
+};
+export type SearchEntry = {
+    readonly description: ToolDescription;
+    readonly searchText: string;
+};
+/** Exact callable signature of the built-in `search` function, for host-owned instructions. */
+export declare const searchSignature: string;
+export declare const prepare: <R>(tools: Tools<R>) => Prepared<R>;
+export type ToolRuntime<R = never> = {
+    readonly calls: Array<ToolCall>;
+    readonly execute: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
+    readonly search: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
+    readonly keys: (path: ReadonlyArray<string>) => ReadonlyArray<string>;
+};
+/** Per-execution call state over tools prepared once for the runtime. */
+export declare const make: <R>(prepared: Prepared<R>, maxToolCalls: number | undefined, hooks?: ToolCallHooks<R>) => ToolRuntime<R>;
+export * as ToolRuntime from "./tool-runtime.js";