@opencode/codemode 0.0.0-beta-19500 → 0.0.0-dev-19274

package/README.md

@@ -91,12 +91,6 @@ 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.
 
-### `Values`
-
-`Values` exports the runtime's non-JSON value classes: `Values.URL`, `Values.URLSearchParams`, `Values.Date`,
-`Values.RegExp`, `Values.Map`, `Values.Set`, and `Values.Promise`. The interpreter recognizes these by class; a
-program's `new URL(...)` is a `Values.URL` wrapping the host `URL`. `Values.isValue` narrows to the data-like kinds.
-
 ### OpenAPI tools
 
 `OpenAPI.fromSpec` converts an OpenAPI 3.x document into one tool per supported operation. Dotted `operationId` values

package/dist/codemode.d.ts

@@ -25,20 +25,23 @@ export type ResolvedExecutionLimits = {
     readonly maxToolCalls: number | undefined;
     readonly maxOutputBytes: number | undefined;
 };
-/** Configuration shared by `CodeMode.make` and `CodeMode.execute`. */
-export type Options<Provided extends Record<string, unknown> = {}> = ToolRuntime.ToolCallHooks<Services<Provided>> & {
-    /** Explicit tools exposed to the program as `tools`. */
-    tools?: Provided & Tools<Services<Provided>>;
-    /** Resource limits enforced on each execution. */
-    limits?: ExecutionLimits;
-};
 /** Options for one CodeMode execution. */
-export type ExecuteOptions<Provided extends Record<string, unknown> = {}> = Options<Provided> & {
+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;
@@ -136,7 +139,7 @@ export declare const Result: Schema.Union<readonly [Schema.Struct<{
 export type Result = typeof Result.Type;
 /** Reusable confined runtime over explicit tools. */
 export type Runtime<R = never> = {
-    readonly catalog: ReadonlyArray<ToolDescription>;
+    readonly catalog: () => ReadonlyArray<ToolDescription>;
     readonly execute: (code: string) => Effect.Effect<Result, never, R>;
 };
 /** Executes one Effect-native CodeMode program without constructing a reusable runtime. */

package/dist/codemode.js

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect";
-import { executeProgram } from "./interpreter/execute.js";
+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";
@@ -54,13 +54,17 @@ const resolveExecutionLimits = (limits) => ({
     maxOutputBytes: validateLimit("maxOutputBytes", limits?.maxOutputBytes, 0),
 });
 /** Executes one Effect-native CodeMode program without constructing a reusable runtime. */
-export const execute = (options) => make(options).execute(options.code);
+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 prepared = ToolRuntime.prepare((options.tools ?? {}));
+    const tools = (options.tools ?? {});
     const limits = resolveExecutionLimits(options.limits);
+    const prepared = ToolRuntime.prepare(tools);
     return {
-        catalog: prepared.catalog,
-        execute: (code) => executeProgram(code, prepared, limits, options),
+        catalog: () => prepared.catalog,
+        execute: (code) => executeWithLimits({ ...options, code }, limits, prepared.searchIndex),
     };
 };

package/dist/index.d.ts

@@ -2,6 +2,5 @@ export * as CodeMode from "./codemode.js";
 export * as Namespace from "./namespace.js";
 export * as Tool from "./tool.js";
 export * as OpenAPI from "./openapi/index.js";
-export { Values } from "./values.js";
 export { searchSignature, toolExpression } from "./codemode.js";
 export { ToolError, toolError } from "./tool-error.js";

package/dist/index.js

@@ -2,6 +2,5 @@ export * as CodeMode from "./codemode.js";
 export * as Namespace from "./namespace.js";
 export * as Tool from "./tool.js";
 export * as OpenAPI from "./openapi/index.js";
-export { Values } from "./values.js";
 export { searchSignature, toolExpression } from "./codemode.js";
 export { ToolError, toolError } from "./tool-error.js";

package/dist/interpreter/errors.d.ts

@@ -1,7 +1,9 @@
+import { Effect } from "effect";
 import type { Diagnostic } from "../codemode.js";
-import { HostFunction } from "./host.js";
-import { type Runner } from "./runner.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;
-/** An error constructor such as `Error` or `TypeError`; callable with or without `new`, like JS. */
-export declare const errorGlobal: <R>(name: string, runner: Runner<R>) => HostFunction<R>;
+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

@@ -1,12 +1,10 @@
 import { Effect } from "effect";
 import { ToolError } from "../tool-error.js";
-import { toData, ToolRuntimeError } from "../data.js";
+import { copyOut, ToolRuntimeError } from "../tool-runtime.js";
 import { formatLocation, InterpreterRuntimeError, ProgramThrow, sourceLocation } from "./model.js";
 import { containsRuntimeReference } from "./references.js";
-import { HostFunction } from "./host.js";
-import { get, ProgramError, ProgramObject } from "./objects.js";
-import {} from "./runner.js";
-import { coerceToString, createAggregateErrorValue, createErrorValue, errorBrandName, errorConstructors, } from "../stdlib/value.js";
+import {} from "./iterator.js";
+import { coerceToString, createAggregateErrorValue, createErrorValue, errorConstructors } from "../stdlib/value.js";
 export const normalizeError = (error) => {
     if (error instanceof InterpreterRuntimeError) {
         return {
@@ -36,12 +34,14 @@ export const normalizeError = (error) => {
         else if (typeof value === "string") {
             message = value;
         }
-        else if (value instanceof ProgramObject && typeof get(value, "message") === "string") {
-            message = get(value, "message");
+        else if (value !== null &&
+            typeof value === "object" &&
+            typeof value.message === "string") {
+            message = value.message;
         }
         else {
             try {
-                message = JSON.stringify(toData(value, "Thrown value")) ?? String(value);
+                message = JSON.stringify(copyOut(value, "json")) ?? String(value);
             }
             catch {
                 message = String(value);
@@ -74,8 +74,8 @@ export const caughtErrorValue = (thrown) => {
     const name = thrown instanceof Error && errorConstructors.has(thrown.name) ? thrown.name : "Error";
     return createErrorValue(name, normalizeError(thrown).message);
 };
-const constructErrorValue = (name, args) => createErrorValue(name, args[0] === undefined ? "" : coerceToString(args[0]));
-const constructAggregateErrorValue = (runner, args, node) => Effect.gen(function* () {
+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");
@@ -89,18 +89,3 @@ const constructAggregateErrorValue = (runner, args, node) => Effect.gen(function
         errors.push(step.value);
     }
 });
-/** An error constructor such as `Error` or `TypeError`; callable with or without `new`, like JS. */
-export const errorGlobal = (name, runner) => {
-    const construct = (args, node) => name === "AggregateError"
-        ? constructAggregateErrorValue(runner, args, node)
-        : Effect.sync(() => constructErrorValue(name, args));
-    return new HostFunction({
-        name,
-        call: construct,
-        construct,
-        instanceOf: (value) => {
-            const brand = errorBrandName(value);
-            return brand !== undefined && (name === "Error" || brand === name);
-        },
-    });
-};

package/dist/interpreter/execute.d.ts

@@ -1,5 +1,4 @@
 import { Effect } from "effect";
-import type { ResolvedExecutionLimits, Result } from "../codemode.js";
-import { ToolRuntime } from "../tool-runtime.js";
-import type { Host } from "./globals.js";
-export declare const executeProgram: <R>(code: string, prepared: ToolRuntime.Prepared<R>, limits: ResolvedExecutionLimits, hooks: ToolRuntime.ToolCallHooks<R>, extraGlobals?: (host: Host<R>) => ReadonlyArray<readonly [string, unknown]>) => Effect.Effect<Result, never, R>;
+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>>;

package/dist/interpreter/execute.js

@@ -3,14 +3,13 @@ import { Cause, Effect, Scope } from "effect";
 // #transpile: conditional import — full typescript on node/bun, an identity
 // pass-through on workerd (the compiler is ~11 MiB and can't init there).
 import { transpile } from "#transpile";
-import { toData } from "../data.js";
-import { ToolRuntime } from "../tool-runtime.js";
+import { copyIn, copyOut, ToolRuntime } from "../tool-runtime.js";
 import { normalizeError } from "./errors.js";
-import { InterpreterRuntimeError } from "./model.js";
+import { InterpreterRuntimeError, isRecord } from "./model.js";
 import { PromiseRuntime } from "./promises.js";
-import { Runtime } from "./runtime.js";
-export const executeProgram = (code, prepared, limits, hooks, extraGlobals) => {
-    if (code.trim().length === 0) {
+import { Interpreter } from "./runtime.js";
+export const executeWithLimits = (options, limits, searchIndex) => {
+    if (options.code.trim().length === 0) {
         return Effect.succeed({
             ok: false,
             error: { kind: "ParseError", message: "Code cannot be empty." },
@@ -19,16 +18,20 @@ export const executeProgram = (code, prepared, limits, hooks, extraGlobals) => {
     }
     // Allocate execution state inside suspension so reused Effects never share it.
     return Effect.suspend(() => {
-        const tools = ToolRuntime.make(prepared, limits.maxToolCalls, hooks);
+        const tools = ToolRuntime.make((options.tools ?? {}), limits.maxToolCalls, searchIndex, {
+            onToolCallStart: options.onToolCallStart,
+            onToolCallEnd: options.onToolCallEnd,
+        });
         const logs = [];
         const logged = () => (logs.length > 0 ? { logs: [...logs] } : {});
         // Set only after copy-out so timeouts cannot report invalid values as completed.
         let returned;
         const base = Effect.acquireUseRelease(Scope.make("parallel"), (scope) => Effect.gen(function* () {
-            const program = parseProgram(code);
+            const program = parseProgram(options.code);
             const promises = new PromiseRuntime(scope);
-            const value = yield* new Runtime(tools.execute, tools.search, tools.keys, promises, logs, extraGlobals).run(program);
-            const result = toData(value, "Execution result", "result");
+            const interpreter = new Interpreter(tools.execute, tools.search, tools.keys, promises, logs);
+            const value = yield* interpreter.run(program);
+            const result = copyOut(copyIn(value, "Execution result"), "nullify");
             returned = { value: result, promises };
             const warnings = yield* promises.interrupt();
             return {
@@ -87,13 +90,17 @@ const parseProgram = (code) => {
     const bodyStart = transpiled.outputText.indexOf("{") + 1;
     const bodyEnd = transpiled.outputText.lastIndexOf("}");
     const executableCode = transpiled.outputText.slice(bodyStart, bodyEnd);
-    return parse(executableCode, {
+    const parsed = parse(executableCode, {
         ecmaVersion: "latest",
         sourceType: "script",
         allowReturnOutsideFunction: true,
         allowAwaitOutsideFunction: true,
         locations: true,
     });
+    if (!isRecord(parsed) || parsed.type !== "Program" || !Array.isArray(parsed.body)) {
+        throw new InterpreterRuntimeError("Failed to parse script as a Program node.");
+    }
+    return parsed;
 };
 const utf8ByteLength = (value) => new TextEncoder().encode(value).byteLength;
 // Drop a replacement character produced by truncating inside a UTF-8 sequence.

package/dist/interpreter/iterator.d.ts

@@ -0,0 +1,13 @@
+import { Effect } from "effect";
+import type { AstNode } from "./model.js";
+export type IteratorCursor<R> = {
+    readonly next: Effect.Effect<{
+        readonly done: boolean;
+        readonly value: unknown;
+    }, unknown, R>;
+    readonly close: Effect.Effect<void, unknown, R>;
+};
+export type SyncIteratorRunner<R> = {
+    readonly syncIterator: (value: unknown, node: AstNode) => Effect.Effect<IteratorCursor<R> | undefined, unknown, R>;
+};
+export declare const preserveConsumerError: <A, R>(cursor: IteratorCursor<R>, effect: Effect.Effect<A, unknown, R>) => Effect.Effect<A, unknown, R>;

package/dist/interpreter/iterator.js

@@ -0,0 +1,4 @@
+import { Effect, Exit } from "effect";
+export const preserveConsumerError = (cursor, effect) => Effect.flatMap(Effect.exit(effect), (exit) => Exit.isSuccess(exit)
+    ? Effect.succeed(exit.value)
+    : Effect.andThen(Effect.exit(cursor.close), Effect.failCause(exit.cause)));

package/dist/interpreter/methods.d.ts

@@ -1,4 +1,17 @@
 import { Effect } from "effect";
-import { type AstNode, IntrinsicReference } from "./model.js";
-import { type Runner } from "./runner.js";
-export declare const invokeIntrinsic: <R>(runner: Runner<R>, ref: IntrinsicReference, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+import { type AstNode, CodeModeFunction, CoercionFunction, ErrorConstructorReference, GlobalMethodReference, GlobalNamespace, IntrinsicReference, JsonMethodReference, PromiseCapabilityFunction, PromiseNamespace, UriFunction } from "./model.js";
+import { CodeModePromise } from "../values.js";
+import { type SyncIteratorRunner } from "./iterator.js";
+export type CallbackRunner<R> = {
+    readonly invokeFunction: (fn: CodeModeFunction, args: Array<unknown>) => Effect.Effect<unknown, unknown, R>;
+    readonly invokeCallable: (callable: unknown, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+    readonly settlePromise: (promise: CodeModePromise) => Effect.Effect<unknown, unknown, never>;
+};
+export type SupportedCallback = CodeModeFunction | CoercionFunction | UriFunction | PromiseCapabilityFunction | GlobalMethodReference | JsonMethodReference | IntrinsicReference | ErrorConstructorReference | GlobalNamespace | PromiseNamespace;
+export declare const isSupportedCallback: (value: unknown) => value is SupportedCallback;
+export declare const invokeIntrinsic: <R>(runner: CallbackRunner<R>, ref: IntrinsicReference, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+export declare const invokeGlobalMethod: (ref: GlobalMethodReference, args: Array<unknown>, node: AstNode) => unknown;
+export declare const arrayStatics: Set<string>;
+export declare const invokeArrayFrom: <R>(runner: CallbackRunner<R> & SyncIteratorRunner<R>, args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+export declare const invokeGroupBy: <R>(runner: CallbackRunner<R> & SyncIteratorRunner<R>, namespace: "Map" | "Object", args: Array<unknown>, node: AstNode) => Effect.Effect<unknown, unknown, R>;
+export declare const applyCollectionCallback: <R>(runner: CallbackRunner<R>, callback: unknown, name: string, node: AstNode) => ((args: Array<unknown>) => Effect.Effect<unknown, unknown, R>);