nanocodex 0.2.0 → 0.4.0

package/runtime/code-runtime.mjs

@@ -2,23 +2,45 @@ 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);
+  const toolByName = new Map(configuredTools.map((tool) => [tool.name, tool]));
+
+  async function executeTool(name, encodedInput, sessionId = "default", callId = "tool") {
+    const tool = toolByName.get(name);
+    if (!tool) return encodeToolOutput(`unknown application tool: ${name}`, false, null);
+    let input;
+    try {
+      input = JSON.parse(encodedInput);
+    } catch (error) {
+      return encodeToolOutput(`invalid tool input: ${errorMessage(error)}`, false, null);
+    }
+    try {
+      const result = await tool.handler(input, { sessionId, parentCallId: "", callId });
+      return encodeToolOutput(outputBody(result), true, clone(result) ?? null);
+    } catch (error) {
+      return encodeToolOutput(errorMessage(error), false, null);
+    }
+  }
 
   async function executeCode(source, sessionId = "default", parentCallId = "exec") {
     const startedAt = performance.now();
@@ -27,7 +49,7 @@ 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();
@@ -35,14 +57,13 @@ export function createCodeRuntime(toolConfiguration = {}, extras = {}) {
           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,
@@ -53,7 +74,7 @@ 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,
@@ -148,16 +169,27 @@ export function createCodeRuntime(toolConfiguration = {}, extras = {}) {
 
   return Object.freeze({
     executeCode,
-    toolDefinitions: () => JSON.stringify(definitions),
+    executeTool,
+    toolDefinitions: () => encodedDefinitions,
     reset() {
       stores.clear();
     },
   });
 }
 
+function encodeToolOutput(output, success, codeModeValue) {
+  return JSON.stringify({
+    output,
+    success,
+    code_mode_value: codeModeValue,
+    metadata: null,
+    process_trace: null,
+  });
+}
+
 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);
 }
@@ -177,6 +209,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);

package/types.d.mts

@@ -1,5 +1,6 @@
 export type Thinking = "none" | "low" | "medium" | "high" | "xhigh" | "max";
 export type ReasoningMode = "standard" | "pro";
+export type Model = "gpt-5.6-sol" | "gpt-5.6-terra" | "gpt-5.6-luna";
 
 export type PromptItem =
   | { type: "text"; text: string }
@@ -18,13 +19,29 @@ export type AgentEvent = {
 
 export type AgentOptions = {
   instructions?: string | undefined;
+  model?: Model | undefined;
   reasoningMode?: ReasoningMode | undefined;
   fastMode?: boolean | undefined;
   sessionId?: string | undefined;
   thinking?: Thinking | undefined;
+  workspace?: string | undefined;
   resume?: SessionSnapshot | undefined;
 };
 
+export type EstimatedUsdCost = Readonly<{
+  usd: string;
+  input_usd: string;
+  cached_input_usd: string;
+  cache_write_input_usd: string;
+  output_usd: string;
+  service_tier: "standard" | "priority";
+}>;
+
+export type CostStatus =
+  | "estimated_from_usage"
+  | "usage_not_reported"
+  | "other";
+
 export type SessionSnapshot = Readonly<{
   version: number;
   model: string;
@@ -36,7 +53,18 @@ export type SessionSnapshot = Readonly<{
   history: readonly Record<string, unknown>[];
 }>;
 
-export type ForkOptions = { at?: Turn | undefined };
+export type TurnUsage = Readonly<{
+  input_tokens: number;
+  cached_input_tokens: number;
+  cache_write_input_tokens: number;
+  output_tokens: number;
+  reasoning_output_tokens: number;
+  total_tokens: number;
+  estimated_cost: EstimatedUsdCost | null;
+  cost_status: CostStatus;
+}>;
+
+export type ForkOptions = { at?: TurnResult | undefined };
 export type WatchEventsOptions = { includeAllSessions?: boolean | undefined };
 
 export type EventWatcher = Readonly<{
@@ -50,9 +78,11 @@ export type AgentActions = {
     watch(options?: WatchEventsOptions): EventWatcher;
   };
   session: {
+    compact(): Promise<void>;
     fork(options?: ForkOptions): Promise<DefaultAgent>;
     setFastMode(enabled: boolean): Promise<void>;
     setThinking(thinking: Thinking): Promise<void>;
+    shutdown(): Promise<void>;
     spawn(): Promise<DefaultAgent>;
   };
   turn: {
@@ -69,6 +99,7 @@ export type Agent<extended extends object = {}> = {
   extend<const extension extends object>(
     decorator: (agent: Agent<extended>) => extension,
   ): Agent<extended & extension>;
+  /** Releases this JavaScript/WASM handle without joining unfinished turns. */
   dispose(): void;
 } & extended;
 
@@ -76,13 +107,19 @@ export type DefaultAgent = Agent<AgentActions>;
 
 export type Turn<agent extends Agent<object> = Agent<object>> = Readonly<{
   readonly agent: agent;
-  result(): Promise<string>;
-  snapshot(): SessionSnapshot;
+  result(): Promise<TurnResult>;
   steer(options: { input: PromptInput }): Promise<void>;
   cancel(): Promise<void>;
+  /** Releases this handle without cancelling its accepted turn. */
   dispose(): void;
 }>;
 
+export type TurnResult = Readonly<{
+  finalMessage: string;
+  snapshot: SessionSnapshot;
+  usage: TurnUsage;
+}>;
+
 export type ToolContext = {
   callId: string;
   parentCallId: string;

package/wasm.d.mts

@@ -0,0 +1,4 @@
+/** Precompiled web WASM module for runtimes that import binary modules. */
+declare const module: WebAssembly.Module;
+
+export default module;

package/scripts/check-package.mjs

@@ -1,38 +0,0 @@
-import assert from "node:assert/strict";
-import { readFile, stat } from "node:fs/promises";
-
-const root = new URL("../", import.meta.url);
-const packageJson = JSON.parse(await readFile(new URL("package.json", root), "utf8"));
-
-assert.equal(packageJson.name, "nanocodex");
-assert.equal(packageJson.type, "module");
-assert.equal(packageJson.publishConfig?.access, "public");
-assert.equal(packageJson.exports?.["./browser"]?.import, "./browser/index.mjs");
-assert.equal(packageJson.exports?.["./node"]?.import, "./node/index.mjs");
-
-const requiredFiles = [
-  "browser/index.mjs",
-  "browser/index.d.mts",
-  "node/index.mjs",
-  "node/index.d.mts",
-  "pkg-web/nanocodex.js",
-  "pkg-web/nanocodex.d.ts",
-  "pkg-web/nanocodex_bg.wasm",
-  "pkg-node/nanocodex.js",
-  "pkg-node/nanocodex.d.ts",
-  "pkg-node/nanocodex_bg.wasm",
-];
-
-for (const file of requiredFiles) {
-  const metadata = await stat(new URL(file, root));
-  assert(metadata.isFile(), `${file} must be a file`);
-  assert(metadata.size > 0, `${file} must not be empty`);
-}
-
-for (const target of ["web", "node"]) {
-  const wasm = await readFile(new URL(`pkg-${target}/nanocodex_bg.wasm`, root));
-  assert(wasm.byteLength > 100_000, `pkg-${target} WASM is unexpectedly small`);
-  assert.deepEqual([...wasm.subarray(0, 4)], [0x00, 0x61, 0x73, 0x6d]);
-}
-
-console.log(`nanocodex@${packageJson.version} package artifacts are complete`);