@lamplitisles/dsh-nanocodex 0.1.0-beta.0

package/vendor/nanocodex/runtime/quickjs-evaluator.mjs

@@ -0,0 +1,236 @@
+const DEFAULT_MEMORY_LIMIT_BYTES = 64 * 1024 * 1024;
+const DEFAULT_STACK_LIMIT_BYTES = 512 * 1024;
+const DEFAULT_INTERRUPT_CYCLES = 1_000_000;
+
+/**
+ * Builds a Code Mode evaluator for runtimes that reject eval/new Function.
+ * Pass an asyncified QuickJS WASM module from quickjs-emscripten-core.
+ */
+export function createQuickJsEvaluator(quickJs, options = {}) {
+  if (!quickJs || typeof quickJs.newContext !== "function") {
+    throw new TypeError("quickJs must be an asyncified QuickJS WASM module");
+  }
+  let queue = Promise.resolve();
+
+  return (source, environment) => {
+    const evaluation = queue.then(() => evaluate(quickJs, source, environment, options));
+    queue = evaluation.catch(() => {});
+    return evaluation;
+  };
+}
+
+async function evaluate(quickJs, source, environment, options) {
+  environment.signal?.throwIfAborted();
+  const vm = quickJs.newContext();
+  const runtime = vm.runtime;
+  runtime.setMemoryLimit(options.memoryLimitBytes ?? DEFAULT_MEMORY_LIMIT_BYTES);
+  runtime.setMaxStackSize(options.stackLimitBytes ?? DEFAULT_STACK_LIMIT_BYTES);
+  let interruptCycles = 0;
+  const maxInterruptCycles = options.maxInterruptCycles ?? DEFAULT_INTERRUPT_CYCLES;
+  let aborted = environment.signal?.aborted === true;
+  const onAbort = () => { aborted = true; };
+  environment.signal?.addEventListener("abort", onAbort, { once: true });
+  runtime.setInterruptHandler(() => aborted || ++interruptCycles > maxInterruptCycles);
+  let closed = false;
+
+  try {
+    expose(vm, "__nanocodex_call_tool", (nameHandle, inputHandle) => {
+      const name = vm.getString(nameHandle);
+      const input = vm.getString(inputHandle);
+      const deferred = vm.newPromise();
+      invokeTool(environment, name, input).then((encoded) => {
+        if (closed) return;
+        vm.newString(encoded).consume(deferred.resolve);
+        runtime.executePendingJobs().unwrap();
+      });
+      return deferred.handle;
+    });
+    expose(vm, "__nanocodex_emit", (kindHandle, payloadHandle) => {
+      const kind = vm.getString(kindHandle);
+      const payload = JSON.parse(vm.getString(payloadHandle));
+      if (kind === "text") environment.text(payload);
+      else if (kind === "image") environment.image(payload.value, payload.detail);
+      else if (kind === "audio") environment.audio(payload);
+      else if (kind === "notify") environment.notify(payload);
+      else if (kind === "yield_control") environment.yield_control();
+      else if (kind === "generatedImage") environment.generatedImage(payload);
+      else throw new Error(`unknown Code Mode output kind: ${kind}`);
+    });
+    expose(vm, "__nanocodex_sleep", (delayHandle) => {
+      const deferred = vm.newPromise();
+      environment.setTimeout(() => {
+        if (closed) return;
+        deferred.resolve();
+        runtime.executePendingJobs().unwrap();
+      }, vm.getNumber(delayHandle));
+      return deferred.handle;
+    });
+    expose(vm, "__nanocodex_store", (keyHandle, valueHandle) => {
+      const key = vm.getString(keyHandle);
+      const envelope = JSON.parse(vm.getString(valueHandle));
+      environment.store(key, envelope.value);
+    });
+    expose(vm, "__nanocodex_load", (keyHandle) => {
+      const value = environment.load(vm.getString(keyHandle));
+      return vm.newString(JSON.stringify({ value }));
+    });
+    expose(vm, "__nanocodex_log", (levelHandle, valuesHandle) => {
+      const level = vm.getString(levelHandle);
+      const values = JSON.parse(vm.getString(valuesHandle));
+      const logger = typeof environment.console?.[level] === "function"
+        ? environment.console[level]
+        : environment.console?.log;
+      logger?.(...values);
+    });
+
+    const setup = guestSource(
+      source,
+      Object.keys(environment.tools),
+      environment.toolDefinitions,
+    );
+    const started = await vm.evalCodeAsync(setup, "nanocodex-code-mode.js");
+    const promise = unwrap(vm, started);
+    try {
+      const settling = vm.resolvePromise(promise);
+      runtime.executePendingJobs().unwrap();
+      const settled = await abortable(settling, environment.signal);
+      unwrap(vm, settled).dispose();
+    } finally {
+      promise.dispose();
+    }
+  } finally {
+    closed = true;
+    environment.signal?.removeEventListener("abort", onAbort);
+    vm.dispose();
+  }
+}
+
+function abortable(promise, signal) {
+  if (!signal) return promise;
+  if (signal.aborted) return Promise.reject(signal.reason);
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(signal.reason ?? new Error("Code Mode execution was cancelled"));
+    const settle = (callback, value) => {
+      signal.removeEventListener("abort", onAbort);
+      callback(value);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    Promise.resolve(promise).then(
+      (value) => settle(resolve, value),
+      (error) => settle(reject, error),
+    );
+  });
+}
+
+function expose(vm, name, handler) {
+  vm.newFunction(name, handler).consume((handle) => vm.setProp(vm.global, name, handle));
+}
+
+function exposeAsync(vm, name, handler) {
+  if (typeof vm.newAsyncifiedFunction !== "function") {
+    throw new TypeError("QuickJS module must use an asyncify variant");
+  }
+  vm.newAsyncifiedFunction(name, handler).consume((handle) => vm.setProp(vm.global, name, handle));
+}
+
+function unwrap(vm, result) {
+  if (result.error) {
+    const dumped = vm.dump(result.error);
+    result.error.dispose();
+    throw new Error(formatQuickJsError(dumped));
+  }
+  return result.value;
+}
+
+function formatQuickJsError(error) {
+  if (typeof error === "string") return error;
+  if (error && typeof error === "object") {
+    if (typeof error.stack === "string") {
+      return typeof error.message === "string" && !error.stack.includes(error.message)
+        ? `${error.message}\n${error.stack}`
+        : error.stack;
+    }
+    if (typeof error.message === "string") return error.message;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(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); }
+};
+const __nanocodex_decode = (encoded) => {
+  const result = JSON.parse(encoded);
+  if (!result.ok) throw new Error(result.error);
+  return result.value;
+};
+const tools = Object.freeze(Object.fromEntries(
+  ${JSON.stringify(toolNames)}.map((name) => [name, (input) =>
+    __nanocodex_call_tool(name, JSON.stringify(input ?? null)).then(__nanocodex_decode)])
+));
+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 notify = (value) => __nanocodex_emit("notify", JSON.stringify(__nanocodex_stringify(value)));
+const yield_control = () => __nanocodex_emit("yield_control", "null");
+const __nanocodex_timers = new Map();
+let __nanocodex_next_timer = 1;
+const setTimeout = (callback, delay = 0) => {
+  const id = __nanocodex_next_timer++;
+  __nanocodex_timers.set(id, callback);
+  __nanocodex_sleep(Number(delay) || 0).then(() => {
+    const callback = __nanocodex_timers.get(id);
+    __nanocodex_timers.delete(id);
+    callback?.();
+  });
+  return id;
+};
+const clearTimeout = (id) => __nanocodex_timers.delete(id);
+const generatedImage = (value) =>
+  __nanocodex_emit("generatedImage", JSON.stringify(value));
+const store = (key, value) => {
+  if (typeof key !== "string") throw new TypeError("store key must be a string");
+  __nanocodex_store(key, JSON.stringify({ value }));
+};
+const load = (key) => JSON.parse(__nanocodex_load(key)).value;
+const exit = () => { throw __nanocodex_exit; };
+const require = undefined;
+const console = Object.freeze(Object.fromEntries(
+  ["debug", "info", "log", "warn", "error"].map((level) => [level, (...values) =>
+    __nanocodex_log(level, JSON.stringify(values.map(__nanocodex_stringify)))])
+));
+(async () => {
+  try {
+${source}
+  } catch (error) {
+    if (error !== __nanocodex_exit) throw error;
+  }
+})()
+`;
+}
+
+function errorMessage(error) {
+  if (error && (error.stack || error.message)) return error.stack || error.message;
+  return String(error);
+}
+
+async function invokeTool(environment, name, encodedInput) {
+  try {
+    const tool = environment.tools[name];
+    if (typeof tool !== "function") throw new Error(`unknown application tool: ${name}`);
+    const value = await tool(JSON.parse(encodedInput));
+    return JSON.stringify({ ok: true, value });
+  } catch (error) {
+    return JSON.stringify({ ok: false, error: errorMessage(error) });
+  }
+}

package/vendor/nanocodex/runtime/responses-transport.mjs

@@ -0,0 +1,22 @@
+const responsesTransports = new WeakMap();
+
+export function createResponsesTransport(setup) {
+  const transport = Object.freeze({});
+  responsesTransports.set(transport, Object.freeze({ ...setup }));
+  return transport;
+}
+
+export function resolveResponsesTransport(transport) {
+  const setup = responsesTransports.get(transport);
+  if (setup === undefined) {
+    throw new TypeError("Agent.create requires a Responses transport");
+  }
+  return setup;
+}
+
+export function nonEmpty(value, label) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new TypeError(`${label} must be a non-empty string`);
+  }
+  return value;
+}

package/vendor/nanocodex/runtime/subagents.d.mts

@@ -0,0 +1,107 @@
+import type { DefaultAgent, Thinking } from "../types.mjs";
+
+// Adapter-specific extend() signatures do not change subagent ownership.
+type SubagentOwner = Omit<DefaultAgent, "extend">;
+
+declare const subagentToolBrand: unique symbol;
+
+/** Opaque selector for the Rust-owned subagent tool set. */
+export type Tool = Readonly<{
+  [subagentToolBrand]: true;
+}>;
+
+export type Subagents = readonly [Tool];
+
+export interface Options {
+  /** Optional finite concurrency limit. Omit for unlimited active turns. */
+  maxConcurrency?: number | undefined;
+}
+
+export type AgentId = number;
+export type AgentStatus =
+  | Readonly<{ state: "pending" | "running" | "interrupted" | "closing" | "closed" }>
+  | Readonly<{ state: "completed"; output: unknown }>
+  | Readonly<{ state: "failed"; error: string }>;
+export type AgentSummary = Readonly<{
+  agent_id: AgentId;
+  role: string;
+  task: string;
+  parent_agent_id: AgentId | null;
+  status: AgentStatus;
+  last_output?: unknown;
+}>;
+export type JsonSchema = boolean | Readonly<Record<string, unknown>>;
+export type SpawnOptions = Readonly<{
+  role: string;
+  task: string;
+  model?: "sol" | "terra" | "luna" | "astra" | undefined;
+  thinking?: Thinking | undefined;
+  outputSchema: JsonSchema;
+}>;
+export type BatchSpawnOptions = Readonly<{
+  role: string;
+  task: string;
+  outputSchema: JsonSchema;
+}>;
+export type SpawnReport = Readonly<{
+  agent_id: AgentId;
+  role: string;
+  status: Readonly<{ state: "running" }>;
+}>;
+export type WaitOptions = Readonly<{
+  agentIds: readonly AgentId[];
+  timeoutMs?: number | undefined;
+}>;
+export type WaitReport = Readonly<{
+  agents: readonly AgentSummary[];
+  timed_out: boolean;
+}>;
+export type LifecycleReport = Readonly<{ agents: readonly AgentSummary[] }>;
+export type DirectoryEntry = AgentSummary & Readonly<{
+  can_message: boolean;
+  can_manage: boolean;
+}>;
+export type DirectoryOptions = Readonly<{
+  includeCompleted?: boolean | undefined;
+  includeSelf?: boolean | undefined;
+}>;
+export type DirectoryReport = Readonly<{ agents: readonly DirectoryEntry[] }>;
+export type MessagePriority = "deferred" | "urgent";
+export type MessagePurpose = "delegate" | "coordinate" | "finding" | "question" | "reply";
+export type MessageSender =
+  | Readonly<{ kind: "root" }>
+  | Readonly<{ kind: "agent"; agent_id: AgentId }>;
+export type SendOptions = Readonly<{
+  agentId: AgentId;
+  message: string;
+  priority?: MessagePriority | undefined;
+  purpose?: MessagePurpose | undefined;
+  inReplyTo?: number | undefined;
+}>;
+export type MessageReceipt = Readonly<{
+  message_id: number;
+  thread_id: number;
+  from: MessageSender;
+  to_agent_id: AgentId;
+  disposition: "started" | "queued" | "steered";
+}>;
+
+/** Returns a spreadable Rust-backed tool extension for an Agent's tools array. */
+export function create(options?: Options): Subagents;
+/** Directly invokes the canonical Rust spawn_agent handler. */
+export function spawn(agent: SubagentOwner, options: SpawnOptions): Promise<SpawnReport>;
+/** Atomically reserves and starts an ordered batch of canonical Rust subagents. */
+export function spawnMany(
+  agent: SubagentOwner,
+  options: readonly BatchSpawnOptions[],
+): Promise<readonly SpawnReport[]>;
+/** Directly invokes the canonical Rust wait_agent handler. */
+export function wait(agent: SubagentOwner, options: WaitOptions): Promise<WaitReport>;
+/** Directly invokes the canonical Rust list_agents handler. */
+export function list(agent: SubagentOwner, options?: DirectoryOptions): Promise<DirectoryReport>;
+/** Directly invokes the canonical Rust send_agent_message handler. */
+export function send(agent: SubagentOwner, options: SendOptions): Promise<MessageReceipt>;
+/** Directly invokes the canonical Rust interrupt_agent handler. */
+export function interrupt(agent: SubagentOwner, agentId: AgentId): Promise<LifecycleReport>;
+/** Directly invokes the canonical Rust close_agent handler. */
+export function close(agent: SubagentOwner, agentId: AgentId): Promise<LifecycleReport>;

package/vendor/nanocodex/runtime/subagents.mjs

@@ -0,0 +1,54 @@
+import {
+  closeSubagent,
+  interruptSubagent,
+  listSubagents,
+  sendSubagentMessage,
+  spawnSubagent,
+  spawnSubagents,
+  waitSubagents,
+} from "../internal.mjs";
+import {
+  defaultSubagentMaxConcurrency,
+  subagentsBrand,
+} from "./tool-configuration.mjs";
+
+export function create(options = {}) {
+  if (!options || typeof options !== "object" || Array.isArray(options)) {
+    throw new TypeError("Subagents.create options must be an object");
+  }
+  const maxConcurrency = options.maxConcurrency ?? defaultSubagentMaxConcurrency;
+  if (maxConcurrency !== undefined && (!Number.isSafeInteger(maxConcurrency) || maxConcurrency < 1)) {
+    throw new TypeError("subagents maxConcurrency must be a positive safe integer");
+  }
+  return Object.freeze([Object.freeze({
+    [subagentsBrand]: Object.freeze({ maxConcurrency }),
+  })]);
+}
+
+export function spawn(agent, options) {
+  return spawnSubagent(agent, options);
+}
+
+export function spawnMany(agent, options) {
+  return spawnSubagents(agent, options);
+}
+
+export function wait(agent, options) {
+  return waitSubagents(agent, options);
+}
+
+export function list(agent, options) {
+  return listSubagents(agent, options);
+}
+
+export function send(agent, options) {
+  return sendSubagentMessage(agent, options);
+}
+
+export function interrupt(agent, agentId) {
+  return interruptSubagent(agent, agentId);
+}
+
+export function close(agent, agentId) {
+  return closeSubagent(agent, agentId);
+}

package/vendor/nanocodex/runtime/subscription-store.d.mts

@@ -0,0 +1,8 @@
+export declare function subscriptionRevision(
+  value: string | bigint,
+): import("../types.mjs").SubscriptionRevision;
+
+export declare function createMemoryChatGptSubscriptionStore(
+  id: string,
+  initial?: import("../types.mjs").SubscriptionStoredValue,
+): import("../types.mjs").MemoryChatGptSubscriptionStore;

package/vendor/nanocodex/runtime/subscription-store.mjs

@@ -0,0 +1,42 @@
+const MAX_REVISION = 18_446_744_073_709_551_615n;
+
+export function subscriptionRevision(value) {
+  const revision = String(value);
+  if (!/^(0|[1-9][0-9]*)$/.test(revision) || BigInt(revision) > MAX_REVISION) {
+    throw new TypeError("subscription revision must be an unsigned 64-bit decimal string");
+  }
+  return revision;
+}
+
+export function createMemoryChatGptSubscriptionStore(id, initial) {
+  if (typeof id !== "string" || !id.trim()) {
+    throw new TypeError("subscription ID must be a non-empty string");
+  }
+  let stored = Object.freeze({
+    revision: subscriptionRevision(initial?.revision ?? 0n),
+    ...(initial?.payload === undefined ? {} : { payload: initial.payload }),
+  });
+  const select = (selected) => {
+    if (selected !== id) throw new Error(`unknown ChatGPT subscription: ${selected}`);
+  };
+  return Object.freeze({
+    id,
+    load(selected) {
+      select(selected);
+      return stored;
+    },
+    compareAndSwap(selected, request) {
+      select(selected);
+      const expectedRevision = subscriptionRevision(request.expectedRevision);
+      if (expectedRevision !== stored.revision) {
+        return { status: "conflict", actualRevision: stored.revision };
+      }
+      const revision = subscriptionRevision(BigInt(stored.revision) + 1n);
+      stored = Object.freeze({ revision, payload: request.payload });
+      return { status: "committed", revision };
+    },
+    snapshot() {
+      return stored;
+    },
+  });
+}

package/vendor/nanocodex/runtime/tempo-provider.d.mts

@@ -0,0 +1,125 @@
+import type { McpPayment, McpServers, MppSession } from "../types.mjs";
+
+export declare const DEFAULT_MERCATOR_MCP_URL = "https://mercator.tempo.xyz/mcp";
+
+export type TempoProvider<Session extends MppSession = MppSession> = MppSession & Readonly<{
+  kind: "tempo";
+  /** The underlying session, available for channel and payment telemetry. */
+  session: Session;
+  /** MPP-aware HTTP fetch using the same methods as paid MCP calls. */
+  fetch?: TempoPaymentFetch | undefined;
+}>;
+
+export function createTempoProvider<Session extends MppSession>(
+  options: { session: Session; payment: McpPayment; fetch?: TempoPaymentFetch | undefined },
+): TempoProvider<Session>;
+
+export type TempoPaymentFetch = (
+  input: RequestInfo | URL,
+  init?: RequestInit | undefined,
+  policy?: Readonly<{
+    maxAmount?: bigint | undefined;
+    intent?: "charge" | "session" | undefined;
+  }> | undefined,
+) => Promise<Response>;
+
+type WalletParameters = {
+  getClient: (...args: any[]) => any;
+  resolveAccount: (...args: any[]) => any;
+};
+
+/** The adapter-neutral surface implemented by every Accounts SDK provider. */
+export type AccountsWallet = {
+  getMppxParameters(options?: { accessKey?: `0x${string}` | undefined }): WalletParameters;
+  getAccount?(options?: unknown): { address: `0x${string}` };
+  store?: {
+    getState?(): { activeAccount?: number; accounts?: readonly { address: `0x${string}` }[]; chainId?: number };
+    accessKeys?: {
+      get(options: {
+        account: `0x${string}`;
+        accessKey: `0x${string}`;
+        chainId: number;
+      }): Promise<unknown>;
+    };
+  };
+};
+
+export type AccountsTempoPolicy = {
+  /**
+   * These values stay structurally typed so a wallet may use any compatible
+   * Accounts/MPPx/Viem dependency instance without nominal package coupling.
+   */
+  autoSwap?: unknown;
+  channelStore?: unknown;
+  decimals?: number | undefined;
+  escrow?: `0x${string}` | undefined;
+  maxDeposit?: string | undefined;
+  topUpAmount?: string | undefined;
+  [option: string]: unknown;
+};
+
+export type AccountsTempoSessionOptions = AccountsTempoPolicy & {
+  bootstrap?: boolean | undefined;
+  fetch?: typeof globalThis.fetch | undefined;
+  webSocket?: unknown;
+};
+
+export type AccountsTempoMercatorOptions = AccountsTempoPolicy & {
+  onChannelUpdate?: ((entry: {
+    channelId: `0x${string}`;
+    cumulativeAmount: bigint;
+    [field: string]: unknown;
+  }) => void | Promise<void>) | undefined;
+};
+
+export type AccountsTempoPaymentOptions = {
+  /** Raw fetch wrapped by MPPx. */
+  fetch?: typeof globalThis.fetch | undefined;
+  /** Maximum atomic amount accepted from one HTTP or MCP challenge. */
+  maxAmount?: bigint | undefined;
+  /** Optional application approval composed after the amount check. */
+  onPaymentRequired?: ((challenge: unknown) => boolean | Promise<boolean>) | undefined;
+};
+
+export type AccountsTempoSession = MppSession & {
+  readonly channelId: `0x${string}` | undefined;
+  readonly cumulative: bigint;
+  readonly opened: boolean;
+  readonly state: unknown;
+  close(): Promise<unknown>;
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+  topUp(amount: string | bigint): Promise<unknown>;
+};
+
+export type AccountsTempoProviderOptions = {
+  /** Any provider returned by Accounts SDK `Provider.create(...)`. */
+  wallet: AccountsWallet;
+  /** Connected root account owning the delegated key. Inferred from Accounts when omitted. */
+  account?: `0x${string}` | undefined;
+  /** Optional Accounts SDK access key to pin for both model and MCP payments. */
+  accessKey?: `0x${string}` | undefined;
+  /** Chain on which the delegated key is authorized. Inferred from Accounts when omitted. */
+  chainId?: number | undefined;
+  /** Shared Tempo payment policy applied to the model session and Mercator. */
+  policy?: AccountsTempoPolicy | undefined;
+  /** Model-session-only overrides, such as `bootstrap` or `webSocket`. */
+  session?: AccountsTempoSessionOptions | undefined;
+  /** Mercator-only Tempo method overrides, such as `onChannelUpdate`. */
+  mercator?: AccountsTempoMercatorOptions | undefined;
+  /** Shared HTTP and MCP challenge policy. */
+  payment?: AccountsTempoPaymentOptions | undefined;
+};
+
+/**
+ * Constructs a Tempo provider from any Accounts SDK wallet adapter without
+ * taking a runtime dependency on `accounts`.
+ */
+export function createTempoProviderFromAccounts(
+  options: AccountsTempoProviderOptions,
+): Promise<TempoProvider<AccountsTempoSession>>;
+
+/** @internal */
+export function resolveMcpServers(
+  provider: MppSession | undefined,
+  configured: McpServers | false | undefined,
+): McpServers | undefined;