@opencode/codemode 2.0.3 → 2.0.5

package/dist/tool-runtime.js

@@ -1,10 +1,22 @@
 import { Cause, Effect, Exit, Formatter, Schema } from "effect";
-import { fromData, toData, ToolRuntimeError } from "./data.js";
 import { toolError } from "./tool-error.js";
 import { decodeInput as decodeToolInput, decodeOutput as decodeToolOutput, identifierSegment, inputProperties, inputTypeScript, isEmptyInput, outputTypeScript, } from "./tool-schema.js";
 import { isNamespace } from "./namespace.js";
 import { isTool } from "./tool.js";
 export const compareText = (left, right) => (left < right ? -1 : left > right ? 1 : 0);
+/** Runs `before`, then `run`, then `after` with how it ended, including when interrupted. */
+export const hooked = (call, before, after, run) => {
+    const observed = after === undefined
+        ? run
+        : Effect.onExit(run, (exit) => {
+            if (Exit.isSuccess(exit))
+                return after(call, { status: "success", value: exit.value });
+            if (Cause.hasInterruptsOnly(exit.cause))
+                return after(call, { status: "interrupted" });
+            return after(call, { status: "failure", error: Cause.squash(exit.cause) });
+        });
+    return before === undefined ? observed : Effect.andThen(before(call), observed);
+};
 const defaultSearchLimit = 10;
 const PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));
 const NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
@@ -68,13 +80,22 @@ const flattenTools = (node, path = [], namespaces = []) => {
         ...Array.from(node.children).flatMap(([name, child]) => flattenTools(child, [...path, name], next)),
     ];
 };
-const describeTool = (visible) => ({
-    path: visible.path,
-    description: visible.tool.description,
-    signature: isEmptyInput(visible.tool)
-        ? `${toolExpression(visible.path)}(): Promise<${outputTypeScript(visible.tool, true)}>`
-        : `${toolExpression(visible.path)}(input: ${inputTypeScript(visible.tool, true)}): Promise<${outputTypeScript(visible.tool, true)}>`,
-});
+const describeTool = (visible) => {
+    let signature;
+    return {
+        path: visible.path,
+        description: visible.tool.description,
+        get signature() {
+            // Search ranks paths and descriptions first; only returned matches need their schemas rendered.
+            // Joining the final fragments avoids retaining the rendering's intermediate string ropes in JSC.
+            return (signature ??= [
+                toolExpression(visible.path),
+                isEmptyInput(visible.tool) ? "()" : `(input: ${inputTypeScript(visible.tool, true)})`,
+                `: Promise<${outputTypeScript(visible.tool, true)}>`,
+            ].join(""));
+        },
+    };
+};
 const tokenize = (query) => query
     .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
     .toLowerCase()
@@ -153,12 +174,20 @@ const toSearchEntry = (visible) => ({
 });
 export const prepare = (tools) => {
     const root = toolTrie(tools);
-    // Discovery bytes are durable instructions, so order only after canonical-path collisions settle.
-    const visible = flattenTools(root).sort((left, right) => compareText(left.path, right.path));
+    let searchIndex;
+    let catalog;
     return {
         root,
-        catalog: visible.map(describeTool),
-        searchIndex: visible.map(toSearchEntry),
+        get catalog() {
+            return (catalog ??= this.searchIndex.map((entry) => entry.description));
+        },
+        get searchIndex() {
+            // Executing known tools only needs the trie. Render discovery when it is actually read,
+            // ordering after canonical-path collisions settle so instruction bytes stay deterministic.
+            return (searchIndex ??= flattenTools(root)
+                .sort((left, right) => compareText(left.path, right.path))
+                .map(toSearchEntry));
+        },
     };
 };
 const lookup = (root, segments) => segments.reduce((node, segment) => node?.children.get(segment), root);
@@ -183,49 +212,36 @@ const resolve = (root, path) => {
     }
     return node.tool;
 };
+export class ToolRuntimeError extends Error {
+    kind;
+    suggestions;
+    constructor(kind, message, suggestions = []) {
+        super(message);
+        this.kind = kind;
+        this.suggestions = suggestions;
+        this.name = "ToolRuntimeError";
+    }
+}
 /** Per-execution call state over tools prepared once for the runtime. */
-export const make = (prepared, prototypes, maxToolCalls, hooks) => {
+export const make = (prepared, maxToolCalls, hooks = {}) => {
     const calls = [];
     const root = prepared.root;
-    const searchTool = makeSearchTool(prepared.searchIndex);
-    const observeEnd = (effect, call) => {
-        const onEnd = hooks?.onToolCallEnd;
-        if (onEnd === undefined)
-            return effect;
-        const startedAt = Date.now();
-        return effect.pipe(Effect.onExit((exit) => {
-            const durationMs = Date.now() - startedAt;
-            if (Exit.isSuccess(exit))
-                return onEnd({ ...call, durationMs, outcome: "success" });
-            if (Cause.hasInterruptsOnly(exit.cause))
-                return onEnd({ ...call, durationMs, outcome: "interrupted" });
-            const error = Cause.squash(exit.cause);
-            const message = error instanceof Error ? error.message : Cause.pretty(exit.cause);
-            return onEnd({ ...call, durationMs, outcome: "failure", message });
-        }));
-    };
     const recordCall = (call) => {
         if (maxToolCalls !== undefined && calls.length >= maxToolCalls) {
             throw new ToolRuntimeError("ToolCallLimitExceeded", `Execution exceeded its tool-call limit of ${maxToolCalls}.`);
         }
         calls.push(call);
     };
-    const executeTool = (name, tool, externalArgs) => Effect.gen(function* () {
-        const normalized = externalArgs.length === 0 ? [{}] : externalArgs;
+    const executeTool = (name, tool, args) => Effect.gen(function* () {
+        const normalized = args.length === 0 ? [{}] : args;
         if (normalized.length !== 1)
             throw new ToolRuntimeError("InvalidToolInput", `Tool '${name}' expects at most one input object.`);
         const input = yield* Effect.try({
             try: () => decodeToolInput(tool, normalized[0]),
             catch: (cause) => new ToolRuntimeError("InvalidToolInput", `Invalid input for tool '${name}': ${String(cause)}`, name === "search" ? [] : ["The signature may have changed. Use search to get the current signature."]),
         });
-        const index = yield* Effect.sync(() => {
-            recordCall({ name });
-            return calls.length - 1;
-        });
-        const call = { index, name, input };
-        return yield* observeEnd(Effect.gen(function* () {
-            if (hooks?.onToolCallStart !== undefined)
-                yield* hooks.onToolCallStart(call);
+        yield* Effect.sync(() => recordCall({ name }));
+        return yield* hooked({ name, input }, hooks["tool.before"], hooks["tool.after"], Effect.gen(function* () {
             const raw = yield* Effect.suspend(() => tool.execute(input)).pipe(Effect.catchCause((cause) => {
                 if (Cause.hasInterruptsOnly(cause))
                     return Effect.interrupt;
@@ -233,21 +249,27 @@ export const make = (prepared, prototypes, maxToolCalls, hooks) => {
                     .map((error) => (error.cause ? Formatter.format(error) : error.message || error.name))
                     .join("\n")));
             }));
+            // The same round trip a tool result would take through text: exact JSON.stringify semantics.
             return yield* Effect.try({
-                try: () => fromData(prototypes, decodeToolOutput(tool, raw), `Result from tool '${name}'`),
+                try: () => {
+                    const text = JSON.stringify(decodeToolOutput(tool, raw));
+                    return text === undefined ? undefined : JSON.parse(text);
+                },
                 catch: (cause) => new ToolRuntimeError("InvalidToolOutput", `Invalid output from tool '${name}': ${cause}`),
             });
-        }), call);
+        }));
     });
     return {
         calls,
+        hooks,
         keys: (path) => namespaceKeys(root, path),
-        search: (args) => Effect.suspend(() => executeTool("search", searchTool, args.map((arg) => toData(arg, "Arguments for tool 'search'")))),
-        execute: (path, args) => Effect.gen(function* () {
-            const name = canonicalSegments(path).join(".");
-            const externalArgs = args.map((arg) => toData(arg, `Arguments for tool '${name}'`));
-            const tool = resolve(root, path);
-            return yield* executeTool(name, tool, externalArgs);
+        search: (args) => Effect.suspend(() => executeTool("search", makeSearchTool(prepared.searchIndex), args)),
+        execute: (path, args) => Effect.suspend(() => {
+            const segments = canonicalSegments(path);
+            // Models often write `tools.search(...)` for the bare `search(...)`; honor it unless a tool owns that path.
+            if (segments.length === 1 && segments[0] === "search" && lookup(root, segments) === undefined)
+                return executeTool("search", makeSearchTool(prepared.searchIndex), args);
+            return executeTool(segments.join("."), resolve(root, path), args);
         }),
     };
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/codemode",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",

package/dist/interpreter/runner.d.ts

@@ -1,28 +0,0 @@
-import { Effect } from "effect";
-import type { Prototypes } from "./intrinsics.js";
-import { type AstNode } from "./model.js";
-import { Callable, ProgramPromise } from "./objects.js";
-export type IteratorCursor<R> = {
-    readonly next: Effect.Effect<{
-        readonly done: boolean;
-        readonly value: unknown;
-    }, unknown, R>;
-    readonly close: Effect.Effect<void, unknown, R>;
-};
-/** Everything a native function needs from the realm: calling back into the program and its intrinsic objects. */
-export type Runner<R> = {
-    readonly invokeCallable: (callable: unknown, thisValue: unknown, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
-    readonly settlePromise: (promise: ProgramPromise) => Effect.Effect<unknown, unknown, never>;
-    readonly syncIterator: (value: unknown, node: AstNode) => Effect.Effect<IteratorCursor<R> | undefined, unknown, R>;
-    readonly prototypes: Prototypes;
-};
-export declare const preserveConsumerError: <A, R>(cursor: IteratorCursor<R>, effect: Effect.Effect<A, unknown, R>) => Effect.Effect<A, unknown, R>;
-/**
- * ToPrimitive: calls `valueOf`/`toString` in hint order and returns the first primitive result. Dates treat the
- * default hint as "string", like their `Symbol.toPrimitive`.
- */
-export declare const toPrimitive: <R>(runner: Runner<R>, value: unknown, hint: "number" | "string" | "default", node: AstNode) => Effect.Effect<unknown, unknown, R>;
-export declare const toPrimitiveString: <R>(runner: Runner<R>, value: unknown, node: AstNode) => Effect.Effect<string, unknown, R>;
-export declare const toPrimitiveNumber: <R>(runner: Runner<R>, value: unknown, node: AstNode) => Effect.Effect<number, unknown, R>;
-export declare const isSupportedCallback: (value: unknown) => value is Callable;
-export declare const applyCollectionCallback: <R>(runner: Runner<R>, callback: unknown, name: string, node: AstNode) => ((args: Array<unknown>) => Effect.Effect<unknown, unknown, R>);

package/dist/interpreter/runtime.d.ts

@@ -1,19 +0,0 @@
-import type { Program } from "acorn";
-import { Effect } from "effect";
-import type { Prototypes } from "./intrinsics.js";
-import { type Host } from "./globals.js";
-import { type Runner } from "./runner.js";
-import { PromiseRuntime } from "./promises.js";
-/** One program execution: the tool bridge, promise scheduler, captured logs, and the global scope built once. */
-export declare class Runtime<R> {
-    readonly executeTool: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
-    readonly search: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
-    readonly toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>;
-    readonly promises: PromiseRuntime<R>;
-    readonly prototypes: Prototypes;
-    readonly logs: Array<string>;
-    readonly runner: Runner<R>;
-    private readonly root;
-    constructor(executeTool: (path: ReadonlyArray<string>, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, search: (args: Array<unknown>) => Effect.Effect<unknown, unknown, R>, toolKeys: (path: ReadonlyArray<string>) => ReadonlyArray<string>, promises: PromiseRuntime<R>, prototypes: Prototypes, logs?: Array<string>, extraGlobals?: (host: Host<R>) => ReadonlyArray<readonly [string, unknown]>);
-    run(program: Program): Effect.Effect<unknown, unknown, R>;
-}