nanocodex 0.4.0 → 0.6.0

package/runtime/code-runtime.mjs

@@ -1,243 +1 @@
-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`);
-    }
-    configuredTools.push(Object.freeze({ handler: tool.handler, name }));
-    definitions.push(deepFreeze({
-      type: "function",
-      name,
-      description: tool.description || "Application-defined tool.",
-      strict: false,
-      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();
-    const content = [];
-    const stored = stores.get(sessionId) || new Map();
-    stores.set(sessionId, stored);
-    const nestedCalls = [];
-    const tools = Object.create(null);
-    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 handler(input, { sessionId, parentCallId, callId });
-          nestedCalls.push({
-            call_id: callId,
-            name,
-            input: recordedInput,
-            output: outputBody(result),
-            success: true,
-            started_after_ns: startedAfterNs,
-            duration_ns: elapsedNs(toolStartedAt),
-          });
-          return result;
-        } catch (error) {
-          nestedCalls.push({
-            call_id: callId,
-            name,
-            input: recordedInput,
-            output: errorMessage(error),
-            success: false,
-            started_after_ns: startedAfterNs,
-            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,
-    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 clone(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 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);
-}
-
-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];
-}
+export * from "nanocodex-tools/runtime/code-runtime";

package/runtime/durability-store.d.mts

@@ -0,0 +1,85 @@
+export type {
+  DurabilityAcquiredState,
+  DurabilityAcquireRequest,
+  DurabilityReplaceRequest,
+  DurabilityReplaceResult,
+  DurabilityFence,
+  DurabilityExportCursor,
+  DurabilityExportPageRequest,
+  DurabilityPortableStatePage,
+  DurabilityPortableStateArchive,
+  DurabilityPortableStore,
+  DurabilityRevision,
+  DurabilitySqliteQuery,
+  DurabilitySqliteRow,
+  DurabilitySqliteTransaction,
+  DurabilitySqliteValue,
+  DurabilityStore,
+  DurabilityStoredState,
+  MemoryDurabilityStore,
+  SqliteDurabilityStoreOptions,
+} from "../types.mjs";
+
+export declare const sqliteDurabilitySchema: readonly string[];
+
+export declare class DurabilityImportConflictError extends Error {
+  override readonly name: "DurabilityImportConflictError";
+  readonly expectedRevision: import("../types.mjs").DurabilityRevision | undefined;
+  readonly actualRevision: import("../types.mjs").DurabilityRevision | undefined;
+  constructor(
+    stateId: string,
+    expectedRevision?: import("../types.mjs").DurabilityRevision,
+    actualRevision?: import("../types.mjs").DurabilityRevision,
+  );
+}
+
+export declare function durabilityRevision(
+  /** Numbers must be nonnegative safe integers; use exact decimal text for larger values. */
+  value: string | bigint | number,
+): import("../types.mjs").DurabilityRevision;
+
+/** Returns SHA-256 over the UTF-8 JSON tuple `[revision, payload]`. */
+export declare function durabilityStateDigest(
+  state: import("../types.mjs").DurabilityStoredState,
+): Promise<string>;
+
+/**
+ * Atomically fences the source owner and exports one coherent JSON-safe state.
+ * Do not resume the source provider after beginning a cutover.
+ */
+export declare function exportDurabilityState(
+  store: import("../types.mjs").DurabilityStore,
+  stateId: string,
+): Promise<import("../types.mjs").DurabilityPortableStateArchive>;
+
+/** Restores an exact archive and its stable state identity into an empty destination. */
+export declare function importDurabilityState(
+  store: import("../types.mjs").DurabilityPortableStore,
+  archive: import("../types.mjs").DurabilityPortableStateArchive,
+): Promise<import("../types.mjs").DurabilityStoredState>;
+
+/**
+ * Fences the source once and returns a deterministic page of its exact `to` revision.
+ * `from` is exclusive, `to` is inclusive, and `cursor` resumes the same payload export.
+ * Nonzero ranges must supply `fromDigest` so every page carries the exact lineage proof.
+ */
+export declare function exportDurabilityStatePage(
+  store: import("../types.mjs").DurabilityStore,
+  stateId: string,
+  request: import("../types.mjs").DurabilityExportPageRequest,
+): Promise<import("../types.mjs").DurabilityPortableStatePage>;
+
+/** Imports a complete contiguous page set iff the destination still has the exact state at `from`. */
+export declare function importDurabilityStatePages(
+  store: import("../types.mjs").DurabilityPortableStore,
+  pages: Iterable<import("../types.mjs").DurabilityPortableStatePage> | AsyncIterable<import("../types.mjs").DurabilityPortableStatePage>,
+): Promise<import("../types.mjs").DurabilityStoredState>;
+
+export declare function createMemoryDurabilityStore(
+  stateId: string,
+  initial?: import("../types.mjs").DurabilityStoredState,
+): import("../types.mjs").MemoryDurabilityStore;
+
+export declare function createSqliteDurabilityStore(
+  options: import("../types.mjs").SqliteDurabilityStoreOptions,
+): import("../types.mjs").DurabilityPortableStore;