nanocodex 0.6.0 → 0.6.4

package/pkg-web/nanocodex_bg.js

@@ -2064,10 +2064,10 @@ export function __wbg___wbindgen_throw_344f42d3211c4765(arg0, arg1) {
 export function __wbg__wbg_cb_unref_fffb441def202758(arg0) {
     getObject(arg0)._wbg_cb_unref();
 }
-export function __wbg_beginCodeTurn_562e43a4d024e969(arg0, arg1) {
+export function __wbg_beginCodeTurn_0a7124b7eee451a5(arg0, arg1) {
     globalThis.nanocodexHost.beginCodeTurn(getStringFromWasm0(arg0, arg1));
 }
-export function __wbg_bindSubagentSession_0739d749b1a66d55() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
+export function __wbg_bindSubagentSession_94bff1e8dd70d1d1() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
     globalThis.nanocodexHost.bindSubagentSession(arg0 >>> 0, getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), getStringFromWasm0(arg5, arg6), arg7 === 0 ? undefined : getStringFromWasm0(arg7, arg8));
 }, arguments); }
 export function __wbg_call_8a2dd23819f8a60a() { return handleError(function (arg0, arg1) {
@@ -2078,50 +2078,50 @@ export function __wbg_call_a6e5c5dce5018821() { return handleError(function (arg
     const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
     return addHeapObject(ret);
 }, arguments); }
-export function __wbg_cancelCodeTurn_0289eab94b547fa9(arg0, arg1) {
+export function __wbg_cancelCodeTurn_cd5a2ff077ecc94f(arg0, arg1) {
     globalThis.nanocodexHost.cancelCodeTurn(getStringFromWasm0(arg0, arg1));
 }
-export function __wbg_cancelCode_34a11a338ededbe2(arg0, arg1) {
+export function __wbg_cancelCode_c598a558677e0400(arg0, arg1) {
     globalThis.nanocodexHost.cancelCode(getStringFromWasm0(arg0, arg1));
 }
 export function __wbg_chatgptsubscription_new(arg0) {
     const ret = ChatGptSubscription.__wrap(arg0);
     return addHeapObject(ret);
 }
-export function __wbg_close_e47f7852ba6527a3(arg0) {
+export function __wbg_close_fdf88ca6545d2dfa(arg0) {
     globalThis.nanocodexHost.close(arg0 >>> 0);
 }
-export function __wbg_connect_f17b2b140b3402d3() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12) {
+export function __wbg_connect_a4aca5683039d7a7() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12) {
     const ret = globalThis.nanocodexHost.connect(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), arg4 === 0 ? undefined : getStringFromWasm0(arg4, arg5), arg6 !== 0, getStringFromWasm0(arg7, arg8), getStringFromWasm0(arg9, arg10), arg11 === 0 ? undefined : getStringFromWasm0(arg11, arg12));
     return addHeapObject(ret);
 }, arguments); }
-export function __wbg_durabilityAcquire_f93999e2fde26eb1() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+export function __wbg_durabilityAcquire_2ef4917a34fa75f2() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
     const ret = globalThis.nanocodexHost.durabilityAcquire(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5));
     return addHeapObject(ret);
 }, arguments); }
-export function __wbg_durabilityReadRecord_a95f9c0591d8bdd7() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+export function __wbg_durabilityReadRecord_539304eeef4f34de() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
     const ret = globalThis.nanocodexHost.durabilityReadRecord(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5));
     return addHeapObject(ret);
 }, arguments); }
-export function __wbg_durabilityReadRecords_55154229140c587c() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+export function __wbg_durabilityReadRecords_d858dd4d53e07fad() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
     const ret = globalThis.nanocodexHost.durabilityReadRecords(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5));
     return addHeapObject(ret);
 }, arguments); }
-export function __wbg_durabilityReplace_c4b92bb6e96144af() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13) {
+export function __wbg_durabilityReplace_98e18f8a4e1ffa87() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13) {
     const ret = globalThis.nanocodexHost.durabilityReplace(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5), getStringFromWasm0(arg6, arg7), getStringFromWasm0(arg8, arg9), getStringFromWasm0(arg10, arg11), getStringFromWasm0(arg12, arg13));
     return addHeapObject(ret);
 }, arguments); }
-export function __wbg_emitEvent_117683c6b324c5d7() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+export function __wbg_emitEvent_ea060841206c3e75() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
     globalThis.nanocodexHost.emitEvent(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), arg4 >>> 0, arg5 === 0 ? undefined : getStringFromWasm0(arg5, arg6));
 }, arguments); }
-export function __wbg_error_142f90eed0c7cc75() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_error_90a3fc8068d88664() { return handleError(function (arg0, arg1, arg2) {
     console.error(getStringFromWasm0(arg0, arg1), getObject(arg2));
 }, arguments); }
-export function __wbg_executeCode_c07d50da74c407df() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+export function __wbg_executeCode_1f043e54c74768ed() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
     const ret = globalThis.nanocodexHost.executeCode(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5), getStringFromWasm0(arg6, arg7));
     return addHeapObject(ret);
 }, arguments); }
-export function __wbg_executeTool_86d627717b7b04d6() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+export function __wbg_executeTool_77f3e9a52b85860c() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
     const ret = globalThis.nanocodexHost.executeTool(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5), getStringFromWasm0(arg6, arg7), getStringFromWasm0(arg8, arg9));
     return addHeapObject(ret);
 }, arguments); }
@@ -2147,6 +2147,21 @@ export function __wbg_get_unchecked_6e0ad6d2a41b06f6(arg0, arg1) {
     const ret = getObject(arg0)[arg1 >>> 0];
     return addHeapObject(ret);
 }
+export function __wbg_httpClose_bb7d713b151b9a56(arg0) {
+    globalThis.nanocodexHost.httpClose(arg0 >>> 0);
+}
+export function __wbg_httpNext_4cb6bce08da7fadb() { return handleError(function (arg0) {
+    const ret = globalThis.nanocodexHost.httpNext(arg0 >>> 0);
+    return addHeapObject(ret);
+}, arguments); }
+export function __wbg_httpOpen_7b0f76ffd6c246d1() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14) {
+    const ret = globalThis.nanocodexHost.httpOpen(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), arg4 === 0 ? undefined : getStringFromWasm0(arg4, arg5), arg6 !== 0, getStringFromWasm0(arg7, arg8), getStringFromWasm0(arg9, arg10), arg11 === 0 ? undefined : getStringFromWasm0(arg11, arg12), getStringFromWasm0(arg13, arg14));
+    return ret;
+}, arguments); }
+export function __wbg_httpReady_472d23f7f1654a26() { return handleError(function (arg0) {
+    const ret = globalThis.nanocodexHost.httpReady(arg0 >>> 0);
+    return addHeapObject(ret);
+}, arguments); }
 export function __wbg_instanceof_Uint8Array_309b927aaf7a3fc7(arg0) {
     let result;
     try {
@@ -2212,7 +2227,7 @@ export function __wbg_new_typed_1824d93f294193e5(arg0, arg1) {
             const a = state0.a;
             state0.a = 0;
             try {
-                return __wasm_bindgen_func_elem_19793(a, state0.b, arg0, arg1);
+                return __wasm_bindgen_func_elem_24935(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
@@ -2223,11 +2238,11 @@ export function __wbg_new_typed_1824d93f294193e5(arg0, arg1) {
         state0.a = 0;
     }
 }
-export function __wbg_nextCodeUpdate_81e642d6973d8080() { return handleError(function (arg0, arg1, arg2, arg3) {
+export function __wbg_nextCodeUpdate_8f3d030aa1cf40cf() { return handleError(function (arg0, arg1, arg2, arg3) {
     const ret = globalThis.nanocodexHost.nextCodeUpdate(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
     return addHeapObject(ret);
 }, arguments); }
-export function __wbg_next_a97247e133bb6188() { return handleError(function (arg0) {
+export function __wbg_next_73a833f68917f36e() { return handleError(function (arg0) {
     const ret = globalThis.nanocodexHost.next(arg0 >>> 0);
     return addHeapObject(ret);
 }, arguments); }
@@ -2257,14 +2272,14 @@ export function __wbg_queueMicrotask_0ab5b2d2393e99b9(arg0) {
 export function __wbg_queueMicrotask_6a09b7bc46549209(arg0) {
     queueMicrotask(getObject(arg0));
 }
-export function __wbg_readWorkspaceFile_ce1dfa978e09347b() { return handleError(function (arg0, arg1, arg2, arg3) {
+export function __wbg_readWorkspaceFile_aa4a72507d05aff1() { return handleError(function (arg0, arg1, arg2, arg3) {
     const ret = globalThis.nanocodexHost.readWorkspaceFile(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
     return addHeapObject(ret);
 }, arguments); }
-export function __wbg_releaseSubagentSession_3b41b91262fb7b84() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+export function __wbg_releaseSubagentSession_1a80c6837d2f614c() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     globalThis.nanocodexHost.releaseSubagentSession(arg0 >>> 0, getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
 }, arguments); }
-export function __wbg_removeWorkspaceFile_913543277dc3d8a6() { return handleError(function (arg0, arg1, arg2, arg3) {
+export function __wbg_removeWorkspaceFile_142bc3149a6ebc97() { return handleError(function (arg0, arg1, arg2, arg3) {
     const ret = globalThis.nanocodexHost.removeWorkspaceFile(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
     return addHeapObject(ret);
 }, arguments); }
@@ -2276,11 +2291,11 @@ export function __wbg_resolvedOptions_ce0ede387898d6bd(arg0) {
     const ret = getObject(arg0).resolvedOptions();
     return addHeapObject(ret);
 }
-export function __wbg_send_7e40303b2078ba70() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_send_4a0833d63a63b91f() { return handleError(function (arg0, arg1, arg2) {
     const ret = globalThis.nanocodexHost.send(arg0 >>> 0, getStringFromWasm0(arg1, arg2));
     return addHeapObject(ret);
 }, arguments); }
-export function __wbg_setTimeout_5a8020b9bc901945(arg0, arg1) {
+export function __wbg_setTimeout_c6205ad5adcd1a59(arg0, arg1) {
     const ret = globalThis.setTimeout(getObject(arg0), arg1);
     return addHeapObject(ret);
 }
@@ -2288,7 +2303,7 @@ export function __wbg_set_8535240470bf2500() { return handleError(function (arg0
     const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
     return ret;
 }, arguments); }
-export function __wbg_sleep_f8472ee57dd033c4() { return handleError(function (arg0, arg1, arg2) {
+export function __wbg_sleep_3921e17fb319947c() { return handleError(function (arg0, arg1, arg2) {
     const ret = globalThis.nanocodexHost.sleep(getStringFromWasm0(arg0, arg1), arg2 >>> 0);
     return addHeapObject(ret);
 }, arguments); }
@@ -2308,15 +2323,15 @@ export function __wbg_static_accessor_WINDOW_f2829a2234d7819e() {
     const ret = typeof window === 'undefined' ? null : window;
     return isLikeNone(ret) ? 0 : addHeapObject(ret);
 }
-export function __wbg_subscriptionCompareAndSwap_314b83b503c547e4() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+export function __wbg_subscriptionCompareAndSwap_a9d25cd277d5d0ef() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
     const ret = globalThis.nanocodexHost.subscriptionCompareAndSwap(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5));
     return addHeapObject(ret);
 }, arguments); }
-export function __wbg_subscriptionLoad_ba70514eb107cef9() { return handleError(function (arg0, arg1) {
+export function __wbg_subscriptionLoad_26d28b5db170c54b() { return handleError(function (arg0, arg1) {
     const ret = globalThis.nanocodexHost.subscriptionLoad(getStringFromWasm0(arg0, arg1));
     return addHeapObject(ret);
 }, arguments); }
-export function __wbg_subscriptionRequest_a13061bc25f3b48c() { return handleError(function (arg0, arg1, arg2, arg3) {
+export function __wbg_subscriptionRequest_cedb47bd8ab61075() { return handleError(function (arg0, arg1, arg2, arg3) {
     const ret = globalThis.nanocodexHost.subscriptionRequest(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
     return addHeapObject(ret);
 }, arguments); }
@@ -2328,14 +2343,14 @@ export function __wbg_then_6ec10ae38b3e92f7(arg0, arg1) {
     const ret = getObject(arg0).then(getObject(arg1));
     return addHeapObject(ret);
 }
-export function __wbg_toolDefinitions_1b7c861eb298b0f7() { return handleError(function (arg0, arg1, arg2, arg3) {
+export function __wbg_toolDefinitions_1a0d8e90ad1fa7f9() { return handleError(function (arg0, arg1, arg2, arg3) {
     const ret = globalThis.nanocodexHost.toolDefinitions(arg1 >>> 0, getStringFromWasm0(arg2, arg3));
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
     const len1 = WASM_VECTOR_LEN;
     getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
     getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
 }, arguments); }
-export function __wbg_toolMode_e724941f28c8358d(arg0, arg1, arg2, arg3) {
+export function __wbg_toolMode_a1078d9aa4c7dda3(arg0, arg1, arg2, arg3) {
     const ret = globalThis.nanocodexHost.toolMode(arg1 >>> 0, getStringFromWasm0(arg2, arg3));
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
     const len1 = WASM_VECTOR_LEN;
@@ -2350,22 +2365,22 @@ export function __wbg_turnresult_new(arg0) {
     const ret = TurnResult.__wrap(arg0);
     return addHeapObject(ret);
 }
-export function __wbg_waitCode_643e87f0ee663a3f() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+export function __wbg_waitCode_a3ad47cf509664d9() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
     const ret = globalThis.nanocodexHost.waitCode(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3), getStringFromWasm0(arg4, arg5));
     return addHeapObject(ret);
 }, arguments); }
-export function __wbg_writeWorkspaceFile_28ef4bf3f8930a6f() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+export function __wbg_writeWorkspaceFile_6285745ca0de9e76() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
     const ret = globalThis.nanocodexHost.writeWorkspaceFile(getStringFromWasm0(arg0, arg1), getObject(arg2), getStringFromWasm0(arg3, arg4));
     return addHeapObject(ret);
 }, arguments); }
 export function __wbindgen_cast_0000000000000001(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 2813, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_19791);
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 3664, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_24933);
     return addHeapObject(ret);
 }
 export function __wbindgen_cast_0000000000000002(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 508, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_4593);
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 529, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_4744);
     return addHeapObject(ret);
 }
 export function __wbindgen_cast_0000000000000003(arg0) {
@@ -2385,14 +2400,14 @@ export function __wbindgen_object_clone_ref(arg0) {
 export function __wbindgen_object_drop_ref(arg0) {
     takeObject(arg0);
 }
-function __wasm_bindgen_func_elem_4593(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_4593(arg0, arg1);
+function __wasm_bindgen_func_elem_4744(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_4744(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_19791(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_24933(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_19791(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_24933(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {
@@ -2403,8 +2418,8 @@ function __wasm_bindgen_func_elem_19791(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_19793(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_19793(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_24935(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_24935(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const BrowserVoiceFinalization = (typeof FinalizationRegistry === 'undefined')

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

@@ -95,9 +95,9 @@ export const turn_withdrawSteer: (a: number, b: number, c: number) => number;
 export const turnresult_finalMessage: (a: number, b: number) => void;
 export const turnresult_snapshot: (a: number, b: number) => void;
 export const turnresult_usage: (a: number, b: number) => void;
-export const __wasm_bindgen_func_elem_19791: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_19793: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_4593: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_24933: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_24935: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_4744: (a: number, b: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;

package/runtime/code-evaluator.worker.mjs

@@ -1,3 +1,4 @@
+import { stringify, storeSnapshot, normalizeImage, normalizeAudio, generatedImageItems } from "nanocodex-tools/runtime/code-values";
 import { installBrowserEgressFetch } from "../tools/browser/browserEgress.mjs";
 
 const WORKER_PROTOCOL = "nanocodex.code-evaluator.v1";
@@ -40,23 +41,36 @@ async function evaluate({ source, storedEntries = [], toolDefinitions = [], tool
   });
   Object.freeze(tools);
 
-  const text = (value) => post("output", { kind: "text", value });
-  const image = (value, detail) => post("output", {
-    kind: "image",
-    value,
-    detail,
-  });
-  const audio = (value) => post("output", { kind: "audio", value });
-  const notify = (value) => post("output", { kind: "notify", value });
+  const text = (value) => post("output", { kind: "text", value: stringify(value) });
+  const image = (value, detail) => {
+    const item = normalizeImage(value, detail);
+    post("output", { kind: "image", value: item, detail: item.detail });
+  };
+  const audio = (value) => {
+    const item = normalizeAudio(value);
+    if (item.type === "input_text") text(item.text);
+    else post("output", { kind: "audio", value: item });
+  };
+  const notify = (value) => {
+    const text = stringify(value);
+    if (!text.trim()) throw new TypeError("notify expects non-empty text");
+    post("output", { kind: "notify", value: text });
+  };
   const yield_control = () => post("output", { kind: "yield_control" });
-  const generatedImage = (value) => post("output", { kind: "generatedImage", value });
+  const generatedImage = (value) => {
+    for (const item of generatedImageItems(value)) {
+      if (item.type === "input_text") text(item.text);
+      else image(item);
+    }
+  };
   const store = (key, value) => {
-    if (typeof key !== "string") throw new TypeError("store key must be a string");
-    const snapshot = structuredClone(value);
+    const entry = storeSnapshot(key, value);
+    key = entry[0];
+    const snapshot = entry[1];
     stored.set(key, snapshot);
     storedWrites.set(key, snapshot);
   };
-  const load = (key) => stored.has(key) ? structuredClone(stored.get(key)) : undefined;
+  const load = (key) => { key = `${key}`; return stored.has(key) ? JSON.parse(JSON.stringify(stored.get(key))) : undefined; };
   const EXIT = Symbol("exit");
   const exit = () => { throw EXIT; };
   const guestConsole = Object.freeze(Object.fromEntries(
@@ -100,10 +114,8 @@ async function evaluate({ source, storedEntries = [], toolDefinitions = [], tool
         guestConsole,
       );
     } finally {
-      // Discarding a tool Promise or calling exit() must not orphan parent-held
-      // work. The evaluator remains alive until each invocation receives its
-      // terminal response, or its supervisor terminates this cell on cancel.
-      await Promise.allSettled(toolInvocations);
+      // The supervisor disposes the worker and cancels pending nested calls
+      // when the root script completes.
     }
     return [...storedWrites];
   } catch (error) {
@@ -126,12 +138,6 @@ function post(type, value = {}) {
   globalThis.postMessage({ protocol: WORKER_PROTOCOL, evaluationId, type, ...value });
 }
 
-function stringify(value) {
-  if (typeof value === "string") return value;
-  if (value === undefined) return "undefined";
-  try { return JSON.stringify(value); } catch { return String(value); }
-}
-
 function errorMessage(error) {
   return error && (error.stack || error.message) ? error.stack || error.message : String(error);
 }

package/runtime/managed-transport.mjs

@@ -50,6 +50,7 @@ export async function createManagedAgent(options) {
   const managed = setup.identity.kind === "create"
     ? await ManagedAgent.create(setup.client)
     : ManagedAgent.open(setup.identity.id, setup.client);
+  void managed.prepare().catch(() => {});
   const managedState = await managed.state();
   if (managedState.agent_id !== managed.id
       || typeof managedState.session_id !== "string"

package/runtime/quickjs-evaluator.mjs

@@ -1,3 +1,4 @@
+import { guestValueHelpers } from "nanocodex-tools/runtime/code-values";
 const DEFAULT_MEMORY_LIMIT_BYTES = 64 * 1024 * 1024;
 const DEFAULT_STACK_LIMIT_BYTES = 512 * 1024;
 const DEFAULT_INTERRUPT_CYCLES = 1_000_000;
@@ -32,12 +33,14 @@ async function evaluate(quickJs, source, environment, options) {
   environment.signal?.addEventListener("abort", onAbort, { once: true });
   runtime.setInterruptHandler(() => aborted || ++interruptCycles > maxInterruptCycles);
   let closed = false;
+  const pending = new Set();
 
   try {
     expose(vm, "__nanocodex_call_tool", (nameHandle, inputHandle) => {
       const name = vm.getString(nameHandle);
       const input = vm.getString(inputHandle);
       const deferred = vm.newPromise();
+      pending.add(deferred);
       invokeTool(environment, name, input).then((encoded) => {
         if (closed) return;
         vm.newString(encoded).consume(deferred.resolve);
@@ -58,6 +61,7 @@ async function evaluate(quickJs, source, environment, options) {
     });
     expose(vm, "__nanocodex_sleep", (delayHandle) => {
       const deferred = vm.newPromise();
+      pending.add(deferred);
       environment.setTimeout(() => {
         if (closed) return;
         deferred.resolve();
@@ -101,6 +105,7 @@ async function evaluate(quickJs, source, environment, options) {
   } finally {
     closed = true;
     environment.signal?.removeEventListener("abort", onAbort);
+    for (const deferred of pending) deferred.dispose();
     vm.dispose();
   }
 }
@@ -162,14 +167,23 @@ function formatQuickJsError(error) {
 function guestSource(source, toolNames, toolDefinitions) {
   return `
 const __nanocodex_exit = Symbol("exit");
-const __nanocodex_stringify = (value) => {
-  if (typeof value === "string") return value;
-  if (value === undefined) return "undefined";
-  try { return JSON.stringify(value); } catch { return String(value); }
-};
+${guestValueHelpers()}
+const __nanocodex_stringify = stringify;
 const __nanocodex_decode = (encoded) => {
   const result = JSON.parse(encoded);
-  if (!result.ok) throw new Error(result.error);
+  if (!result.ok) {
+    const failure = result.error;
+    const structured = failure !== null && typeof failure === "object";
+    const error = new Error(structured && typeof failure.message === "string"
+      ? failure.message
+      : __nanocodex_stringify(failure));
+    if (structured) {
+      if (typeof failure.stack === "string") error.stack = failure.stack;
+      if (Object.hasOwn(failure, "code")) error.code = failure.code;
+      if (Object.hasOwn(failure, "details")) error.details = failure.details;
+    }
+    throw error;
+  }
   return result.value;
 };
 const tools = Object.freeze(Object.fromEntries(
@@ -178,9 +192,15 @@ const tools = Object.freeze(Object.fromEntries(
 ));
 const ALL_TOOLS = Object.freeze(${JSON.stringify(toolDefinitions)});
 const text = (value) => __nanocodex_emit("text", JSON.stringify(__nanocodex_stringify(value)));
-const image = (value, detail) =>
-  __nanocodex_emit("image", JSON.stringify({ value, detail }));
-const audio = (value) => __nanocodex_emit("audio", JSON.stringify(value));
+const image = (value, detail) => {
+  const item = normalizeImage(value, detail);
+  __nanocodex_emit("image", JSON.stringify({ value: item, detail: item.detail }));
+};
+const audio = (value) => {
+  const item = normalizeAudio(value);
+  if (item.type === "input_text") text(item.text);
+  else __nanocodex_emit("audio", JSON.stringify(item));
+};
 const notify = (value) => __nanocodex_emit("notify", JSON.stringify(__nanocodex_stringify(value)));
 const yield_control = () => __nanocodex_emit("yield_control", "null");
 const __nanocodex_timers = new Map();
@@ -196,13 +216,20 @@ const setTimeout = (callback, delay = 0) => {
   return id;
 };
 const clearTimeout = (id) => __nanocodex_timers.delete(id);
-const generatedImage = (value) =>
-  __nanocodex_emit("generatedImage", JSON.stringify(value));
+const generatedImage = (value) => {
+  for (const item of generatedImageItems(value)) {
+    if (item.type === "input_text") text(item.text);
+    else image(item);
+  }
+};
 const store = (key, value) => {
-  if (typeof key !== "string") throw new TypeError("store key must be a string");
-  __nanocodex_store(key, JSON.stringify({ value }));
+  const entry = storeSnapshot(key, value);
+  __nanocodex_store(entry[0], JSON.stringify({ value: entry[1] }));
+};
+const load = (key) => {
+  if (typeof key === "symbol") throw new TypeError("load key must be a string");
+  return JSON.parse(__nanocodex_load(String(key))).value;
 };
-const load = (key) => JSON.parse(__nanocodex_load(key)).value;
 const exit = () => { throw __nanocodex_exit; };
 const require = undefined;
 const console = Object.freeze(Object.fromEntries(
@@ -219,8 +246,15 @@ ${source}
 `;
 }
 
-function errorMessage(error) {
-  if (error && (error.stack || error.message)) return error.stack || error.message;
+function serializeToolError(error) {
+  if (error && typeof error === "object") {
+    return {
+      message: typeof error.message === "string" ? error.message : formatQuickJsError(error),
+      ...(typeof error.stack === "string" ? { stack: error.stack } : {}),
+      ...(Object.hasOwn(error, "code") ? { code: error.code } : {}),
+      ...(Object.hasOwn(error, "details") ? { details: error.details } : {}),
+    };
+  }
   return String(error);
 }
 
@@ -231,6 +265,14 @@ async function invokeTool(environment, name, encodedInput) {
     const value = await tool(JSON.parse(encodedInput));
     return JSON.stringify({ ok: true, value });
   } catch (error) {
-    return JSON.stringify({ ok: false, error: errorMessage(error) });
+    const ancestors = [];
+    return JSON.stringify({ ok: false, error: serializeToolError(error) }, function (_key, value) {
+      if (typeof value === "bigint") return String(value);
+      if (value === null || typeof value !== "object") return value;
+      while (ancestors.length && ancestors.at(-1) !== this) ancestors.pop();
+      if (ancestors.includes(value)) return "[Circular]";
+      ancestors.push(value);
+      return value;
+    });
   }
 }

package/runtime/response-controls.mjs

@@ -1,35 +1,13 @@
 /** Apply stable managed response policy at the provider wire boundary, including replay. */
 export function responseControlsSocket(socket, controls = {}) {
-  if (controls.promptCacheKey !== undefined && (typeof controls.promptCacheKey !== "string" || controls.promptCacheKey.length === 0 || controls.promptCacheKey.length > 64)) {
-    throw new TypeError("invalid prompt cache key");
-  }
-  if (controls.promptCache !== undefined && !["implicit", "explicit"].includes(controls.promptCache)) {
-    throw new TypeError("invalid prompt cache mode");
-  }
-  if (controls.outputSchema !== undefined && (!controls.outputSchema || typeof controls.outputSchema !== "object" || Array.isArray(controls.outputSchema))) {
-    throw new TypeError("output schema must be an object");
-  }
+  validateResponseControls(controls);
   return new Proxy({}, {
     get(_target, property) {
       const target = socket;
       if (property === "send") return (data, ...args) => {
         const body = typeof data === "string" ? JSON.parse(data) : undefined;
         if (body?.type === "response.create") {
-          if (controls.promptCacheKey !== undefined) body.prompt_cache_key = controls.promptCacheKey;
-          if (controls.outputSchema !== undefined) body.text = {
-            ...body.text, format: { type: "json_schema", name: "managed_output", strict: true, schema: controls.outputSchema },
-          };
-          if (controls.promptCache !== undefined) {
-            body.prompt_cache_options = { mode: controls.promptCache, ttl: "30m" };
-            if (controls.promptCache === "explicit") {
-              // Cache the developer context without marking changing user input.
-              // Continuations with no prefix intentionally do not write new cache entries.
-              const developers = (Array.isArray(body.input) ? body.input : []).filter(item => item.role === "developer");
-              const text = developers.flatMap(item => Array.isArray(item.content) ? item.content : [])
-                .filter(part => part.type === "input_text").at(-1);
-              if (text) text.prompt_cache_breakpoint = { mode: "explicit" };
-            }
-          }
+          applyResponseControls(body, controls);
           return target.send(JSON.stringify(body), ...args);
         }
         return target.send(data, ...args);
@@ -40,3 +18,42 @@ export function responseControlsSocket(socket, controls = {}) {
     set(_target, property, value) { return Reflect.set(socket, property, value, socket); },
   });
 }
+
+/** Apply the same policy to an HTTPS Responses body before provider dispatch. */
+export function responseControlsBody(encoded, controls = {}) {
+  validateResponseControls(controls);
+  const body = JSON.parse(encoded);
+  if (!body || typeof body !== "object" || Array.isArray(body)) throw new TypeError("response body must be an object");
+  applyResponseControls(body, controls);
+  return JSON.stringify(body);
+}
+
+function validateResponseControls(controls) {
+  if (controls.promptCacheKey !== undefined && (typeof controls.promptCacheKey !== "string" || controls.promptCacheKey.length === 0 || controls.promptCacheKey.length > 64)) {
+    throw new TypeError("invalid prompt cache key");
+  }
+  if (controls.promptCache !== undefined && !["implicit", "explicit"].includes(controls.promptCache)) {
+    throw new TypeError("invalid prompt cache mode");
+  }
+  if (controls.outputSchema !== undefined && (!controls.outputSchema || typeof controls.outputSchema !== "object" || Array.isArray(controls.outputSchema))) {
+    throw new TypeError("output schema must be an object");
+  }
+}
+
+function applyResponseControls(body, controls) {
+  if (controls.promptCacheKey !== undefined) body.prompt_cache_key = controls.promptCacheKey;
+  if (controls.outputSchema !== undefined) body.text = {
+    ...body.text, format: { type: "json_schema", name: "managed_output", strict: true, schema: controls.outputSchema },
+  };
+  if (controls.promptCache !== undefined) {
+    body.prompt_cache_options = { mode: controls.promptCache, ttl: "30m" };
+    if (controls.promptCache === "explicit") {
+      // Cache the developer context without marking changing user input.
+      // Continuations with no prefix intentionally do not write new cache entries.
+      const developers = (Array.isArray(body.input) ? body.input : []).filter(item => item.role === "developer");
+      const text = developers.flatMap(item => Array.isArray(item.content) ? item.content : [])
+        .filter(part => part.type === "input_text").at(-1);
+      if (text) text.prompt_cache_breakpoint = { mode: "explicit" };
+    }
+  }
+}