nanocodex 0.1.1 → 0.3.0

package/pkg-web/nanocodex.js

@@ -1,7 +1,7 @@
 /* @ts-self-types="./nanocodex.d.ts" */
 
 /**
- * Persistent WASM agent handle hosted by Node.js or a browser Worker.
+ * JavaScript binding over the shared Rust agent lifecycle.
  */
 export class Nanocodex {
     static __wrap(ptr) {
@@ -21,7 +21,19 @@ export class Nanocodex {
         wasm.__wbg_nanocodex_free(ptr, 0);
     }
     /**
-     * Fork the latest safe committed model boundary.
+     * Compacts retained history immediately without fabricating a user prompt.
+     *
+     * # Errors
+     *
+     * Throws when compaction or the agent driver fails.
+     * @returns {Promise<void>}
+     */
+    compact() {
+        const ret = wasm.nanocodex_compact(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Forks the latest safe committed model boundary.
      *
      * # Errors
      *
@@ -33,26 +45,25 @@ export class Nanocodex {
         return ret;
     }
     /**
-     * Fork from the exact checkpoint retained by a completed historical turn.
+     * Forks from an exact completed historical turn.
      *
      * # Errors
      *
-     * Rejects if the turn is incomplete, belongs to another lineage, or the
-     * driver stops.
-     * @param {Turn} turn
+     * Rejects if the result belongs to another agent or the driver stopped.
+     * @param {TurnResult} result
      * @returns {Promise<Nanocodex>}
      */
-    forkFrom(turn) {
-        _assertClass(turn, Turn);
-        const ret = wasm.nanocodex_forkFrom(this.__wbg_ptr, turn.__wbg_ptr);
+    forkFrom(result) {
+        _assertClass(result, TurnResult);
+        const ret = wasm.nanocodex_forkFrom(this.__wbg_ptr, result.__wbg_ptr);
         return ret;
     }
     /**
-     * Build a persistent agent from a JSON configuration object.
+     * Builds an agent from its JavaScript JSON configuration.
      *
      * # Errors
      *
-     * Throws when the JSON or required configuration is invalid.
+     * Throws when the JSON or agent policy is invalid.
      * @param {string} config_json
      */
     constructor(config_json) {
@@ -67,11 +78,11 @@ export class Nanocodex {
         return this;
     }
     /**
-     * Accept a prompt immediately and return its independently awaitable turn.
+     * Accepts a text prompt and returns its independently awaitable turn.
      *
      * # Errors
      *
-     * Throws when the prompt is empty or the agent driver has stopped.
+     * Throws when the prompt is empty.
      * @param {string} instruction
      * @returns {Turn}
      */
@@ -85,12 +96,11 @@ export class Nanocodex {
         return Turn.__wrap(ret[0]);
     }
     /**
-     * Accept ordered browser-safe text, image, or audio input encoded as JSON.
+     * Accepts browser-safe multimodal input encoded as JSON.
      *
      * # Errors
      *
-     * Throws for malformed or empty content, local filesystem inputs, or a
-     * stopped driver.
+     * Throws for malformed, empty, or local-filesystem input.
      * @param {string} content_json
      * @returns {Turn}
      */
@@ -104,7 +114,7 @@ export class Nanocodex {
         return Turn.__wrap(ret[0]);
     }
     /**
-     * Stable session identifier used to route this agent's event stream.
+     * Returns the stable `UUIDv7` session identity.
      * @returns {string}
      */
     get sessionId() {
@@ -120,7 +130,47 @@ export class Nanocodex {
         }
     }
     /**
-     * Start a clean sibling with the same configuration and tools.
+     * Enables or disables priority processing for subsequently accepted turns.
+     *
+     * # Errors
+     *
+     * Rejects after the driver stops.
+     * @param {boolean} enabled
+     * @returns {Promise<void>}
+     */
+    setFastMode(enabled) {
+        const ret = wasm.nanocodex_setFastMode(this.__wbg_ptr, enabled);
+        return ret;
+    }
+    /**
+     * Changes the reasoning effort for subsequently accepted turns.
+     *
+     * # Errors
+     *
+     * Rejects an invalid effort or a stopped driver.
+     * @param {string} thinking
+     * @returns {Promise<void>}
+     */
+    setThinking(thinking) {
+        const ptr0 = passStringToWasm0(thinking, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.nanocodex_setThinking(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * Gracefully stops the driver and joins every resource owned by this agent.
+     *
+     * # Errors
+     *
+     * Rejects when the driver had already stopped or cleanup fails.
+     * @returns {Promise<void>}
+     */
+    shutdown() {
+        const ret = wasm.nanocodex_shutdown(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Starts a clean sibling with the same private agent policy.
      *
      * # Errors
      *
@@ -135,7 +185,7 @@ export class Nanocodex {
 if (Symbol.dispose) Nanocodex.prototype[Symbol.dispose] = Nanocodex.prototype.free;
 
 /**
- * Completion and control handle for one accepted WASM turn.
+ * JavaScript binding over one shared Rust turn.
  */
 export class Turn {
     static __wrap(ptr) {
@@ -155,11 +205,11 @@ export class Turn {
         wasm.__wbg_turn_free(ptr, 0);
     }
     /**
-     * Cancel this exact active or queued turn.
+     * Cancels this exact active or queued turn.
      *
      * # Errors
      *
-     * Rejects if the turn is already terminal or the driver stops.
+     * Rejects if the turn is already terminal or its driver stopped.
      * @returns {Promise<void>}
      */
     cancel() {
@@ -167,25 +217,23 @@ export class Turn {
         return ret;
     }
     /**
-     * Wait for the turn and return its final assistant message.
+     * Waits for the final assistant message.
      *
      * # Errors
      *
-     * Rejects when the model run fails, the driver stops, or two consumers
-     * await the same pending turn concurrently.
-     * @returns {Promise<string>}
+     * Rejects when the model run or driver fails.
+     * @returns {Promise<TurnResult>}
      */
     result() {
         const ret = wasm.turn_result(this.__wbg_ptr);
         return ret;
     }
     /**
-     * Inject input at this active turn's next safe model boundary.
+     * Injects text input at the active turn's next safe model boundary.
      *
      * # Errors
      *
-     * Rejects for empty input, a queued or terminal turn, a full steer queue,
-     * or a stopped driver.
+     * Rejects if the turn is not active or its driver stopped.
      * @param {string} instruction
      * @returns {Promise<void>}
      */
@@ -196,13 +244,11 @@ export class Turn {
         return ret;
     }
     /**
-     * Inject ordered browser-safe text, image, or audio input at this active
-     * turn's next safe model boundary.
+     * Injects browser-safe multimodal input at the active turn's next boundary.
      *
      * # Errors
      *
-     * Rejects for malformed or empty content, local filesystem inputs, a
-     * queued or terminal turn, a full steer queue, or a stopped driver.
+     * Rejects malformed input or a turn that is no longer active.
      * @param {string} content_json
      * @returns {Promise<void>}
      */
@@ -214,6 +260,97 @@ export class Turn {
     }
 }
 if (Symbol.dispose) Turn.prototype[Symbol.dispose] = Turn.prototype.free;
+
+/**
+ * JavaScript binding over one completed Rust turn result.
+ */
+export class TurnResult {
+    static __wrap(ptr) {
+        const obj = Object.create(TurnResult.prototype);
+        obj.__wbg_ptr = ptr;
+        TurnResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TurnResultFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_turnresult_free(ptr, 0);
+    }
+    /**
+     * Returns the final assistant message.
+     * @returns {string}
+     */
+    get finalMessage() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.turnresult_finalMessage(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Serializes this completed boundary's resumable session snapshot.
+     *
+     * # Errors
+     *
+     * Throws when serialization fails.
+     * @returns {string}
+     */
+    snapshot() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.turnresult_snapshot(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Serializes exact aggregate usage for this completed logical turn.
+     *
+     * # Errors
+     *
+     * Throws when serialization fails.
+     * @returns {string}
+     */
+    usage() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.turnresult_usage(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) TurnResult.prototype[Symbol.dispose] = TurnResult.prototype.free;
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -250,30 +387,29 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1, arg2);
             return ret;
         }, arguments); },
-        __wbg_close_b36455f162d504cf: function(arg0) {
+        __wbg_close_84b985b15720666a: function(arg0) {
             globalThis.nanocodexHost.close(arg0 >>> 0);
         },
-        __wbg_connect_82a82e999c6dad2f: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
-            const ret = globalThis.nanocodexHost.connect(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5));
+        __wbg_connect_fdf81494b56b3a0a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) {
+            const ret = globalThis.nanocodexHost.connect(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), arg4 === 0 ? undefined : getStringFromWasm0(arg4, arg5), arg6 !== 0, getStringFromWasm0(arg7, arg8), arg9 === 0 ? undefined : getStringFromWasm0(arg9, arg10));
             return ret;
         }, arguments); },
-        __wbg_emitEvent_fe69df479c60b4dc: function(arg0, arg1) {
+        __wbg_emitEvent_52491cc5b9c996ad: function(arg0, arg1) {
             globalThis.nanocodexHost.emitEvent(getStringFromWasm0(arg0, arg1));
         },
-        __wbg_executeCode_1b0871b5adb65342: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_executeCode_616baf56d3c8480c: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
             const ret = globalThis.nanocodexHost.executeCode(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5));
             return ret;
         }, arguments); },
-        __wbg_getDate_a1a40c1c5f40fe3b: function(arg0) {
-            const ret = arg0.getDate();
-            return ret;
-        },
-        __wbg_getFullYear_6af8b229792ae254: function(arg0) {
-            const ret = arg0.getFullYear();
+        __wbg_getRandomValues_ceb34d8ffce7e87f: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
+        __wbg_getTime_d6f070c088c9b5ed: function(arg0) {
+            const ret = arg0.getTime();
             return ret;
         },
-        __wbg_getMonth_fffe29d654d5eb69: function(arg0) {
-            const ret = arg0.getMonth();
+        __wbg_getTimezoneOffset_dc9862c79e5a81a3: function(arg0) {
+            const ret = arg0.getTimezoneOffset();
             return ret;
         },
         __wbg_get_78f252d074a84d0b: function() { return handleError(function (arg0, arg1) {
@@ -300,6 +436,10 @@ function __wbg_get_imports() {
             const ret = new Intl.DateTimeFormat(arg0, arg1);
             return ret;
         },
+        __wbg_new_cc984128914cfc6f: function(arg0) {
+            const ret = new Date(arg0);
+            return ret;
+        },
         __wbg_new_da52cf8fe3429cb2: function() {
             const ret = new Object();
             return ret;
@@ -311,7 +451,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen__convert__closures_____invoke__h179cb8eb2e8755ae(a, state0.b, arg0, arg1);
+                        return wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___js_sys_d57619d9eac2c6da___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined___js_sys_d57619d9eac2c6da___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined_______true_(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -322,18 +462,18 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         },
-        __wbg_next_9da746b48109347a: function() { return handleError(function (arg0, arg1) {
+        __wbg_next_4acad3c8f1e88dfb: function() { return handleError(function (arg0, arg1) {
             const ret = globalThis.nanocodexHost.next(arg0 >>> 0, arg1 >>> 0);
             return ret;
         }, arguments); },
-        __wbg_now_86c0d4ba3fa605b8: function() {
-            const ret = Date.now();
-            return ret;
-        },
         __wbg_now_e7c6795a7f81e10f: function(arg0) {
             const ret = arg0.now();
             return ret;
         },
+        __wbg_now_f663ab0a5177b799: function() { return handleError(function () {
+            const ret = Date.now();
+            return ret;
+        }, arguments); },
         __wbg_performance_3fcf6e32a7e1ed0a: function(arg0) {
             const ret = arg0.performance;
             return ret;
@@ -353,14 +493,14 @@ function __wbg_get_imports() {
             const ret = arg0.resolvedOptions();
             return ret;
         },
-        __wbg_send_211e498fb0677de2: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_send_bdd41ab8e18f6042: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = globalThis.nanocodexHost.send(arg0 >>> 0, getStringFromWasm0(arg1, arg2));
             return ret;
         }, arguments); },
-        __wbg_sleep_03cdb40ace612b9f: function(arg0) {
-            const ret = globalThis.nanocodexHost.sleep(arg0 >>> 0);
+        __wbg_sleep_c32f4fdaac627991: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = globalThis.nanocodexHost.sleep(getStringFromWasm0(arg0, arg1), arg2 >>> 0);
             return ret;
-        },
+        }, arguments); },
         __wbg_static_accessor_GLOBAL_4ef717fb391d88b7: function() {
             const ret = typeof global === 'undefined' ? null : global;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -385,19 +525,28 @@ function __wbg_get_imports() {
             const ret = arg0.then(arg1);
             return ret;
         },
-        __wbg_toolDefinitions_976a998d8a17c04c: function(arg0, arg1, arg2) {
+        __wbg_toolDefinitions_4f496f9fbb096753: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = globalThis.nanocodexHost.toolDefinitions(getStringFromWasm0(arg1, arg2));
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        }, arguments); },
+        __wbg_turnresult_new: function(arg0) {
+            const ret = TurnResult.__wrap(arg0);
+            return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 57, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h02eb5eea4c10a535);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 446, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___wasm_bindgen_6c97e59ea7837008___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_6c97e59ea7837008___JsError___true_);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000002: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
             return ret;
         },
-        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
@@ -418,15 +567,15 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__h02eb5eea4c10a535(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h02eb5eea4c10a535(arg0, arg1, arg2);
+function wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___wasm_bindgen_6c97e59ea7837008___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_6c97e59ea7837008___JsError___true_(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___wasm_bindgen_6c97e59ea7837008___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_6c97e59ea7837008___JsError___true_(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h179cb8eb2e8755ae(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h179cb8eb2e8755ae(arg0, arg1, arg2, arg3);
+function wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___js_sys_d57619d9eac2c6da___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined___js_sys_d57619d9eac2c6da___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined_______true_(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___js_sys_d57619d9eac2c6da___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined___js_sys_d57619d9eac2c6da___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined_______true_(arg0, arg1, arg2, arg3);
 }
 
 const NanocodexFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -435,6 +584,9 @@ const NanocodexFinalization = (typeof FinalizationRegistry === 'undefined')
 const TurnFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_turn_free(ptr, 1));
+const TurnResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_turnresult_free(ptr, 1));
 
 function addToExternrefTable0(obj) {
     const idx = wasm.__externref_table_alloc();
@@ -517,6 +669,11 @@ function debugString(val) {
     return className;
 }
 
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {

package/pkg-web/nanocodex_bg.wasm.d.ts

@@ -3,19 +3,27 @@
 export const memory: WebAssembly.Memory;
 export const __wbg_nanocodex_free: (a: number, b: number) => void;
 export const __wbg_turn_free: (a: number, b: number) => void;
+export const __wbg_turnresult_free: (a: number, b: number) => void;
+export const nanocodex_compact: (a: number) => any;
 export const nanocodex_fork: (a: number) => any;
 export const nanocodex_forkFrom: (a: number, b: number) => any;
 export const nanocodex_new: (a: number, b: number) => [number, number, number];
 export const nanocodex_prompt: (a: number, b: number, c: number) => [number, number, number];
 export const nanocodex_promptContent: (a: number, b: number, c: number) => [number, number, number];
 export const nanocodex_sessionId: (a: number) => [number, number];
+export const nanocodex_setFastMode: (a: number, b: number) => any;
+export const nanocodex_setThinking: (a: number, b: number, c: number) => any;
+export const nanocodex_shutdown: (a: number) => any;
 export const nanocodex_spawn: (a: number) => any;
 export const turn_cancel: (a: number) => any;
 export const turn_result: (a: number) => any;
 export const turn_steer: (a: number, b: number, c: number) => any;
 export const turn_steerContent: (a: number, b: number, c: number) => any;
-export const wasm_bindgen__convert__closures_____invoke__h02eb5eea4c10a535: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h179cb8eb2e8755ae: (a: number, b: number, c: any, d: any) => void;
+export const turnresult_finalMessage: (a: number) => [number, number];
+export const turnresult_snapshot: (a: number) => [number, number, number, number];
+export const turnresult_usage: (a: number) => [number, number, number, number];
+export const wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___wasm_bindgen_6c97e59ea7837008___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_6c97e59ea7837008___JsError___true_: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen_6c97e59ea7837008___convert__closures_____invoke___js_sys_d57619d9eac2c6da___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined___js_sys_d57619d9eac2c6da___Function_fn_wasm_bindgen_6c97e59ea7837008___JsValue_____wasm_bindgen_6c97e59ea7837008___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_exn_store: (a: number) => void;

package/runtime/code-runtime.mjs

@@ -2,23 +2,27 @@ export function createCodeRuntime(toolConfiguration = {}, extras = {}) {
   const stores = new Map();
   let nextCallId = 1;
   const definitions = [];
+  const configuredTools = [];
 
   for (const [name, tool] of Object.entries(toolConfiguration)) {
     if (!tool || typeof tool.handler !== "function") {
       throw new TypeError(`tool ${name} requires a handler function`);
     }
-    definitions.push({
+    configuredTools.push(Object.freeze({ handler: tool.handler, name }));
+    definitions.push(deepFreeze({
       type: "function",
       name,
       description: tool.description || "Application-defined tool.",
       strict: false,
-      parameters: tool.parameters || {
+      parameters: jsonSnapshot(tool.parameters || {
         type: "object",
         additionalProperties: true,
-      },
-    });
+      }, `tool ${name} parameters`),
+    }));
   }
+  Object.freeze(configuredTools);
   Object.freeze(definitions);
+  const encodedDefinitions = JSON.stringify(definitions);
 
   async function executeCode(source, sessionId = "default", parentCallId = "exec") {
     const startedAt = performance.now();
@@ -27,20 +31,24 @@ export function createCodeRuntime(toolConfiguration = {}, extras = {}) {
     stores.set(sessionId, stored);
     const nestedCalls = [];
     const tools = Object.create(null);
-    for (const [name, tool] of Object.entries(toolConfiguration)) {
+    for (const { handler, name } of configuredTools) {
       tools[name] = async (input) => {
         const callId = `${parentCallId}/code-${nextCallId++}`;
         const toolStartedAt = performance.now();
+        const startedAfterNs = Math.max(
+          0,
+          Math.round((toolStartedAt - startedAt) * 1_000_000),
+        );
+        const recordedInput = clone(input) ?? null;
         try {
-          const result = await tool.handler(input, { sessionId, parentCallId, callId });
+          const result = await handler(input, { sessionId, parentCallId, callId });
           nestedCalls.push({
             call_id: callId,
             name,
-            // JSON.stringify omits object fields whose value is undefined.
-            // Keep zero-argument calls wire-complete for Rust's typed event.
-            input: clone(input) ?? null,
+            input: recordedInput,
             output: outputBody(result),
             success: true,
+            started_after_ns: startedAfterNs,
             duration_ns: elapsedNs(toolStartedAt),
           });
           return result;
@@ -48,9 +56,10 @@ export function createCodeRuntime(toolConfiguration = {}, extras = {}) {
           nestedCalls.push({
             call_id: callId,
             name,
-            input: clone(input) ?? null,
+            input: recordedInput,
             output: errorMessage(error),
             success: false,
+            started_after_ns: startedAfterNs,
             duration_ns: elapsedNs(toolStartedAt),
           });
           throw error;
@@ -142,7 +151,7 @@ export function createCodeRuntime(toolConfiguration = {}, extras = {}) {
 
   return Object.freeze({
     executeCode,
-    toolDefinitions: () => JSON.stringify(definitions),
+    toolDefinitions: () => encodedDefinitions,
     reset() {
       stores.clear();
     },
@@ -151,7 +160,7 @@ export function createCodeRuntime(toolConfiguration = {}, extras = {}) {
 
 function outputBody(value) {
   if (Array.isArray(value) && value.every((item) => item?.type === "input_text" || item?.type === "input_image")) {
-    return value;
+    return clone(value);
   }
   return stringify(value);
 }
@@ -171,6 +180,20 @@ function clone(value) {
   return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
 }
 
+function jsonSnapshot(value, label) {
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch (error) {
+    throw new TypeError(`${label} must be JSON-serializable`, { cause: error });
+  }
+}
+
+function deepFreeze(value) {
+  if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
+  for (const child of Object.values(value)) deepFreeze(child);
+  return Object.freeze(value);
+}
+
 function errorMessage(error) {
   if (error && (error.stack || error.message)) return error.stack || error.message;
   return String(error);