nanocodex 0.1.1

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

@@ -0,0 +1,27 @@
+/* tslint:disable */
+/* eslint-disable */
+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 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_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 __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;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_destroy_closure: (a: number, b: number) => void;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_start: () => void;

package/pkg-web/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/runtime/code-runtime.mjs

@@ -0,0 +1,191 @@
+export function createCodeRuntime(toolConfiguration = {}, extras = {}) {
+  const stores = new Map();
+  let nextCallId = 1;
+  const definitions = [];
+
+  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({
+      type: "function",
+      name,
+      description: tool.description || "Application-defined tool.",
+      strict: false,
+      parameters: tool.parameters || {
+        type: "object",
+        additionalProperties: true,
+      },
+    });
+  }
+  Object.freeze(definitions);
+
+  async function executeCode(source, sessionId = "default", parentCallId = "exec") {
+    const startedAt = performance.now();
+    const content = [];
+    const stored = stores.get(sessionId) || new Map();
+    stores.set(sessionId, stored);
+    const nestedCalls = [];
+    const tools = Object.create(null);
+    for (const [name, tool] of Object.entries(toolConfiguration)) {
+      tools[name] = async (input) => {
+        const callId = `${parentCallId}/code-${nextCallId++}`;
+        const toolStartedAt = performance.now();
+        try {
+          const result = await tool.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,
+            output: outputBody(result),
+            success: true,
+            duration_ns: elapsedNs(toolStartedAt),
+          });
+          return result;
+        } catch (error) {
+          nestedCalls.push({
+            call_id: callId,
+            name,
+            input: clone(input) ?? null,
+            output: errorMessage(error),
+            success: false,
+            duration_ns: elapsedNs(toolStartedAt),
+          });
+          throw error;
+        }
+      };
+    }
+    Object.freeze(tools);
+    const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+    const EXIT = Symbol("exit");
+
+    function text(value) {
+      content.push({ type: "input_text", text: stringify(value) });
+    }
+    function image(value, detail = "auto") {
+      if (typeof value === "string") {
+        content.push({ type: "input_image", image_url: value, detail });
+        return;
+      }
+      if (!value || typeof value !== "object" || typeof value.image_url !== "string") {
+        throw new TypeError("image() requires an image URL or image item");
+      }
+      content.push({
+        type: "input_image",
+        image_url: value.image_url,
+        detail: value.detail == null ? detail : value.detail,
+      });
+    }
+    function generatedImage(result) {
+      if (!result || typeof result !== "object" || typeof result.image_url !== "string") {
+        throw new TypeError("generatedImage() requires an image generation result");
+      }
+      image(result.image_url, "high");
+      if (typeof result.output_hint === "string" && result.output_hint) text(result.output_hint);
+    }
+    function store(key, value) {
+      if (typeof key !== "string") throw new TypeError("store key must be a string");
+      stored.set(key, clone(value));
+    }
+    function load(key) {
+      return stored.has(key) ? clone(stored.get(key)) : undefined;
+    }
+    function exit() {
+      throw EXIT;
+    }
+
+    try {
+      const script = new AsyncFunction(
+        "tools",
+        "ALL_TOOLS",
+        "text",
+        "image",
+        "generatedImage",
+        "store",
+        "load",
+        "exit",
+        "require",
+        "console",
+        source,
+      );
+      try {
+        await script(
+          tools,
+          definitions,
+          text,
+          image,
+          generatedImage,
+          store,
+          load,
+          exit,
+          extras.require,
+          extras.console || console,
+        );
+      } catch (error) {
+        if (error !== EXIT) throw error;
+      }
+      return JSON.stringify({
+        output: withStatus("Script completed", startedAt, content),
+        success: true,
+        nested_calls: nestedCalls,
+      });
+    } catch (error) {
+      return JSON.stringify({
+        output: `Script failed\nWall time ${wallTime(startedAt)} seconds\nOutput:\n${errorMessage(error)}`,
+        success: false,
+        nested_calls: nestedCalls,
+      });
+    }
+  }
+
+  return Object.freeze({
+    executeCode,
+    toolDefinitions: () => JSON.stringify(definitions),
+    reset() {
+      stores.clear();
+    },
+  });
+}
+
+function outputBody(value) {
+  if (Array.isArray(value) && value.every((item) => item?.type === "input_text" || item?.type === "input_image")) {
+    return value;
+  }
+  return stringify(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 clone(value) {
+  if (typeof globalThis.structuredClone === "function") return structuredClone(value);
+  return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+}
+
+function errorMessage(error) {
+  if (error && (error.stack || error.message)) return error.stack || error.message;
+  return String(error);
+}
+
+function elapsedNs(startedAt) {
+  return Math.max(0, Math.round((performance.now() - startedAt) * 1_000_000));
+}
+
+function wallTime(startedAt) {
+  return ((performance.now() - startedAt) / 1_000).toFixed(1);
+}
+
+function withStatus(status, startedAt, content) {
+  const heading = `${status}\nWall time ${wallTime(startedAt)} seconds\nOutput:\n`;
+  if (!content.length) return heading;
+  return [{ type: "input_text", text: heading }, ...content];
+}

package/scripts/check-package.mjs

@@ -0,0 +1,38 @@
+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`);

package/types.d.mts

@@ -0,0 +1,82 @@
+export type Thinking = "none" | "low" | "medium" | "high" | "xhigh" | "max";
+export type ReasoningMode = "standard" | "pro";
+
+export type PromptItem =
+  | { type: "text"; text: string }
+  | { type: "image"; image_url: string; detail?: "auto" | "low" | "high" | "original" | undefined }
+  | { type: "audio"; audio_url: string };
+
+export type PromptInput = string | readonly PromptItem[];
+
+export type AgentEvent = {
+  protocol_version: number;
+  request_id: string;
+  seq: number;
+  type: string;
+  payload: Record<string, unknown>;
+};
+
+export type AgentOptions = {
+  instructions?: string | undefined;
+  reasoningMode?: ReasoningMode | undefined;
+  sessionId?: string | undefined;
+  thinking?: Thinking | undefined;
+};
+
+export type ForkOptions = { at?: Turn | undefined };
+export type WatchEventsOptions = { includeAllSessions?: boolean | undefined };
+
+export type EventWatcher = Readonly<{
+  onEvent(listener: (event: AgentEvent) => void): () => void;
+  off(): void;
+  [Symbol.asyncIterator](): AsyncIterableIterator<AgentEvent>;
+}>;
+
+export type AgentActions = {
+  events: {
+    watch(options?: WatchEventsOptions): EventWatcher;
+  };
+  session: {
+    fork(options?: ForkOptions): Promise<DefaultAgent>;
+    spawn(): Promise<DefaultAgent>;
+  };
+  turn: {
+    prompt(options: { input: PromptInput }): Turn;
+  };
+};
+
+export type Agent<extended extends object = {}> = {
+  readonly key: string;
+  readonly name: string;
+  readonly sessionId: string;
+  readonly type: string;
+  readonly uid: string;
+  extend<const extension extends object>(
+    decorator: (agent: Agent<extended>) => extension,
+  ): Agent<extended & extension>;
+  dispose(): void;
+} & extended;
+
+export type DefaultAgent = Agent<AgentActions>;
+
+export type Turn<agent extends Agent<object> = Agent<object>> = Readonly<{
+  readonly agent: agent;
+  result(): Promise<string>;
+  steer(options: { input: PromptInput }): Promise<void>;
+  cancel(): Promise<void>;
+  dispose(): void;
+}>;
+
+export type ToolContext = {
+  callId: string;
+  parentCallId: string;
+  sessionId: string;
+};
+
+export type Tool = {
+  description: string;
+  parameters: Record<string, unknown>;
+  handler(input: unknown, context: ToolContext): unknown | Promise<unknown>;
+};
+
+export type ToolMap = Record<string, Tool>;