@lamplitisles/dsh-nanocodex 0.1.0-beta.0

package/vendor/nanocodex/managed/ManagedError.d.mts

@@ -0,0 +1,9 @@
+export declare class ManagedError extends Error {
+  readonly code: string;
+  readonly status: number | undefined;
+  constructor(
+    code: string,
+    message: string,
+    options?: { status?: number | undefined; cause?: unknown },
+  );
+}

package/vendor/nanocodex/managed/ManagedError.mjs

@@ -0,0 +1,8 @@
+export class ManagedError extends Error {
+  constructor(code, message, options = {}) {
+    super(message, options.cause === undefined ? undefined : { cause: options.cause });
+    this.name = "ManagedError";
+    this.code = code;
+    this.status = options.status;
+  }
+}

package/vendor/nanocodex/managed/README.md

@@ -0,0 +1,241 @@
+# Managed Nanocodex agents
+
+`nanocodex/managed` is the administration and extended control-plane client for
+account-owned Nanocodex agents. Application turns normally use
+`Agent.create({ transport: Transport.managed(...), tools })` from
+`nanocodex/node`, `nanocodex/browser`, or `nanocodex/host`, which returns the
+same lifecycle shape as local OpenAI and host-managed transports.
+
+In a browser, authentication uses the current origin's HttpOnly account cookie:
+
+```js
+import { Agent } from "nanocodex/managed";
+
+const agent = await Agent.create();
+const turn = agent.turn.prompt({
+  input: "Inspect the repository and summarize it.",
+  idempotencyKey: crypto.randomUUID(),
+});
+const result = await turn.result();
+console.log(result.finalMessage);
+```
+
+New managed agents may be created with an atomic settings object. Existing
+agents retain their model and reasoning mode after their first accepted turn.
+
+```js
+const astra = await Agent.create({
+  settings: {
+    model: "gpt-6-astra",
+    thinking: "high",
+    reasoningMode: "standard",
+    fastMode: false,
+  },
+});
+```
+
+GPT-6 Astra accepts `low`, `medium`, `high`, `xhigh`, or `max` thinking; it
+rejects `none`. Fast mode is deliberately opt-in and is unavailable for Astra
+when the OpenAI project uses EU data residency.
+
+On a server, provide the managed origin and an `ncx_live_...` account API key:
+
+```js
+const agent = await Agent.get(process.env.NANOCODEX_AGENT_ID, {
+  baseUrl: "https://nanocodex.example",
+  apiKey: process.env.NANOCODEX_API_KEY,
+});
+```
+
+The transport-facing constructor requires an explicit identity and never
+infers creation from a missing ID:
+
+```js
+import { Agent, Transport } from "nanocodex/node";
+
+const created = await Agent.create({
+  transport: Transport.managed({
+    agent: { create: true },
+    baseUrl: "https://nanocodex.example",
+    apiKey: process.env.NANOCODEX_API_KEY,
+  }),
+});
+const existing = await Agent.create({
+  transport: Transport.managed({
+    agent: { id: process.env.NANOCODEX_AGENT_ID },
+    baseUrl: "https://nanocodex.example",
+    apiKey: process.env.NANOCODEX_API_KEY,
+  }),
+});
+await existing.session.shutdown(); // closes the client; never deletes the Agent
+```
+
+The same account client can search all completed managed conversations without
+opening an agent turn:
+
+```js
+const found = await Agent.findSessions(
+  { query: "what did we decide about memory?", limit: 8 },
+  { baseUrl: process.env.NANOCODEX_MANAGED_URL, apiKey: process.env.NANOCODEX_API_KEY },
+);
+const session = await Agent.readSession(
+  {
+    session_id: found.results[0].session_id,
+    turn_ids: [found.results[0].turn_id],
+  },
+  { baseUrl: process.env.NANOCODEX_MANAGED_URL, apiKey: process.env.NANOCODEX_API_KEY },
+);
+```
+
+Both methods derive the account scope from the cookie or API key; no scope or user
+identifier is accepted from the caller.
+
+Hosted durable memory is account-owned and independent from session history. The
+memory panel can list records and compare-and-swap delete one current key:
+
+```js
+const memories = await Agent.listMemories({
+  baseUrl: process.env.NANOCODEX_MANAGED_URL,
+  apiKey: process.env.NANOCODEX_API_KEY,
+});
+await Agent.deleteMemory(memories[0].key, {
+  baseUrl: process.env.NANOCODEX_MANAGED_URL,
+  apiKey: process.env.NANOCODEX_API_KEY,
+});
+```
+
+Managed agents access this same hosted store through their `memory` tool. It is
+never mirrored into a browser, TUI, or other local persistence layer.
+
+Account memory uses the same derived organization scope and supports scan, read,
+put, and delete operations. Scan before writing so the service can reject
+duplicates, and retain returned `{ id, version }` keys for compare-and-swap
+updates:
+
+```js
+const scanned = await Agent.memory(
+  { operation: "scan", query: "production deploy schedule" },
+  { baseUrl: process.env.NANOCODEX_MANAGED_URL, apiKey: process.env.NANOCODEX_API_KEY },
+);
+const stored = await Agent.memory(
+  { operation: "put", content: "Production deploys happen on Tuesdays." },
+  { baseUrl: process.env.NANOCODEX_MANAGED_URL, apiKey: process.env.NANOCODEX_API_KEY },
+);
+```
+
+Browser account owners can read and rename their organization:
+
+```js
+const organization = await Agent.getOrganization();
+await Agent.updateOrganization({ name: `${organization.name ?? "Personal"} workspace` });
+```
+
+Memory accepts either account-cookie or API-key authentication. Organization
+metadata and mutation remain subject to the server's principal and owner policy;
+the client sends supplied credentials without weakening that policy.
+
+`Agent.list()` returns agent handles, `agent.state()` reads current state, and
+`agent.delete()` removes the agent and its retained state. `agent.events.watch`
+is an async iterator over durable events. Pass its last decimal `cursor` to a
+later watcher to resume strictly after the acknowledged event. Network endings
+reconnect automatically from that cursor. Watchers and independently awaitable
+turn results on one agent handle share one replayable event connection; each
+subscriber keeps its own cursor, so consuming one never steals another's events.
+Rapid `turn.steer()` calls on one turn handle are sent in invocation order.
+`turn.cancel()` bypasses pending steering requests, so Stop can interrupt them.
+Pass `cursor: "latest"` to attach atomically at the durable head without
+replaying retained history; a history page can then hydrate independently.
+
+Returning browser clients may use `Agent.open(id)` to construct a retained
+handle without a preliminary state request. The first operation on that handle
+still verifies account ownership at the managed service boundary. Use
+`Agent.get(id)` when an eager existence check is part of the caller's workflow.
+
+The managed API never accepts model-provider credentials, egress bindings,
+runtime environment objects, credential grants, or arbitrary request headers.
+
+## Cron triggers
+
+Schedules belong to an existing managed agent and run without an open client.
+Use a stable trigger ID to create or replace a schedule idempotently:
+
+```js
+const agent = await Agent.get(agentId, { baseUrl, apiKey });
+const morning = {
+  cron: "0 7 * * MON-FRI",
+  timezone: "Europe/Athens",
+  input: "Review my running agents and summarize anything that needs attention.",
+};
+await agent.triggers.put("morning-review", morning);
+await agent.triggers.list();
+await agent.triggers.get("morning-review");
+await agent.triggers.put("morning-review", { ...morning, enabled: false }); // pause
+await agent.triggers.put("morning-review", morning); // resume
+await agent.triggers.delete("morning-review");
+```
+
+| Method | Route | Result |
+| --- | --- | --- |
+| GET | `/v1/agents/:agent/triggers` | `{ data: [...] }` |
+| GET | `/v1/agents/:agent/triggers/:id` | Trigger or 404 |
+| PUT | `/v1/agents/:agent/triggers/:id` | Create (201) or replace (200) |
+| DELETE | `/v1/agents/:agent/triggers/:id` | Idempotent deletion (204) |
+
+The managed-agent web composer also has a **Schedules** button. It opens the
+same account-authenticated API: create or edit a prompt and cron expression,
+choose an IANA time zone, inspect the next dispatch time, pause/resume, or
+delete a schedule. The last-dispatched time is not a completion receipt; read
+the conversation for the result. The ephemeral homepage agent has no schedules.
+
+PUT takes `{ cron, input, timezone?, enabled?, session_mode? }`. Expressions have five fields
+(minute, hour, day of month, month, day of week), supporting numeric values,
+lists, ranges, steps, and month/day names. The time zone defaults to UTC and
+accepts IANA names. Local times follow daylight saving transitions. Seconds,
+macros, and random `H` fields are rejected. Inputs are text up to 64 KiB;
+there can be at most 32 triggers per agent. IDs use 1–64 letters, digits,
+underscores, or hyphens. PUT is a full replacement; an identical retry preserves
+the next occurrence. A changed configuration starts from the next matching time.
+
+`session_mode: "new"` (the default for new configurations) creates a fresh managed
+session for every occurrence. It copies the source agent's model settings at
+dispatch time, but no conversation history or schedules. Account permissions,
+connectors, and account memory still belong to the same account. Fresh sessions
+run independently even when the source conversation is busy, and appear in the
+normal agent list. Choose **New session each time** in the Schedules dialog.
+
+`session_mode: "continue"` submits a turn to the existing conversation, retaining
+its history. Choose **Continue this conversation** in the dialog. Schedules saved
+before modes were introduced retain this behavior. Omitting the mode when
+updating an existing schedule preserves its mode, including for older clients.
+Set `session_mode` explicitly to switch modes.
+
+Durable Object alarms dispatch occurrences. Continued turns advance the schedule
+atomically with turn admission. Fresh runs use a durable outbox and deterministic
+session/turn IDs: delivery retries reuse the same session without duplicating
+its turn. Only one undelivered occurrence per schedule is retained. Inspect
+`last_turn_id` on `last_agent_id` through the normal turn and event APIs, or use
+**Open run** in the UI. Times are Unix milliseconds; `last_run_at` is the scheduled
+time of the last accepted occurrence, and `next_run_at` is null while paused.
+Last dispatched does not mean the model response has completed.
+
+Missed ticks coalesce; they are not replayed individually. In continue mode,
+unfinished work or a failed event stream causes an occurrence to be skipped and
+recorded in `last_skipped_at`. New-session mode does not skip because the source
+is busy. Pausing or deleting prevents future dispatches; a turn already accepted
+or a fresh session already claimed for delivery still completes. Resume does
+not backfill. Deleting the source removes its schedules and pending deliveries;
+sessions already created remain independent conversations.
+
+Read requests require `agents:read`; writes require `agents:write`, and PUT also
+requires `tools:use`. The usual ownership and browser-origin checks apply.
+Triggers are account-owned standing instructions with the creator's capability
+scope, and persist after the creating API key or browser session ends. Connect
+grants and multiplayer rooms cannot create schedules. Delete the trigger to
+revoke its standing instruction. Provider credentials are resolved by the usual
+managed execution path and are never stored in trigger definitions or returned
+by these endpoints.
+
+Deleting an agent removes its triggers. Portable durability export currently
+returns `409 cron_triggers_present` while any trigger or pending delivery exists: delete
+triggers and let claimed deliveries finish before transfer, then recreate schedules at the destination. This avoids
+silently dropping schedules or running the same schedule on two agents.

package/vendor/nanocodex/managed/Voice.mjs

@@ -0,0 +1,202 @@
+import { ManagedBrowserVoice } from "../pkg-web/nanocodex.js";
+import { initializeBrowserEngine } from "../browser/engine.mjs";
+import {
+  cancelManagedTurn,
+  prefetchManagedRealtime,
+  routeManagedRealtime,
+  startManagedRealtime,
+  stopManagedRealtime,
+} from "./internal.mjs";
+
+/** @internal Adapts the Rust-owned protocol core to one remote managed Agent. */
+export async function createManagedBrowserVoice(agent, voice, options = {}) {
+  await initializeBrowserEngine(options);
+  const raw = new ManagedBrowserVoice(voice);
+  const voiceSessionId = uuidV7();
+  const startOperationId = crypto.randomUUID();
+  const stopOperationId = crypto.randomUUID();
+  const tailOperationId = crypto.randomUUID();
+  const delegationOperations = new Map();
+  let startedTurnId;
+  let activeTurnId;
+  let routePending = false;
+  let pendingEvents = [];
+  let prefetchTimer;
+  const prefetchAbort = new AbortController();
+
+  function observe(value) {
+    if (activeTurnId === undefined || value?.turnId !== activeTurnId) return undefined;
+    const effects = raw.agentEvent(JSON.stringify(value.event));
+    if (isTerminalAgentEvent(value.event)) {
+      if (startedTurnId === activeTurnId) startedTurnId = undefined;
+      activeTurnId = undefined;
+    }
+    return effects;
+  }
+
+  function adoptRoute(routed) {
+    if (typeof routed.turn_id !== "string") return [];
+    activeTurnId = routed.turn_id;
+    if (routed.route === "started") startedTurnId = routed.turn_id;
+    const buffered = pendingEvents;
+    pendingEvents = [];
+    return buffered.map(observe).filter((effects) => effects !== undefined);
+  }
+
+  return {
+    configure: (settings) => raw.configure(settings),
+    appendSpeech: (text) => raw.appendSpeech(text),
+    appendText: (role, text) => raw.appendText(role, text),
+    appendContext: (text) => raw.appendContext(text),
+    parallelStartup: true,
+    async start() {
+      const started = await startManagedRealtime(agent, voiceSessionId, startOperationId);
+      raw.start(JSON.stringify(started.context));
+    },
+    callBody(sdp) {
+      const envelope = JSON.parse(raw.callBody(sdp, voiceSessionId));
+      envelope.managed_agent_id = agent.id;
+      return JSON.stringify(envelope);
+    },
+    completeCall: (body, location) => raw.completeCall(body, location),
+    sidebandUrl(callId) {
+      const path = raw.sidebandUrl(callId, voiceSessionId);
+      const url = new URL(path, globalThis.location?.href ?? "http://localhost");
+      url.searchParams.set("managed_agent_id", agent.id);
+      return `${url.pathname}${url.search}`;
+    },
+    sidebandOpened: () => raw.sidebandOpened(),
+    sidebandClosed: (connectedMs) => raw.sidebandClosed(connectedMs),
+    framesSent: (count) => raw.framesSent(count),
+    requiresAgentAdmission: (payload) => raw.requiresAgentAdmission(payload),
+    async realtimeMessage(payload) {
+      const update = JSON.parse(raw.realtimeMessage(payload));
+      if (update.prefetch) {
+        clearTimeout(prefetchTimer);
+        prefetchTimer = setTimeout(() => {
+          void prefetchManagedRealtime(agent, voiceSessionId, update.prefetch.query,
+            AbortSignal.any([prefetchAbort.signal, AbortSignal.timeout(10_000)])).catch(() => {});
+        }, update.prefetch.debounce_ms);
+      }
+      if (typeof update.delegation === "string" && update.delegation.trim()) {
+        clearTimeout(prefetchTimer);
+        const delegationId = managedDelegationId(payload);
+        let operationId = delegationId && delegationOperations.get(delegationId);
+        if (!operationId) {
+          operationId = crypto.randomUUID();
+          if (delegationId) delegationOperations.set(delegationId, operationId);
+        }
+        routePending = true;
+        try {
+          const bufferedEffects = adoptRoute(await routeManagedRealtime(
+            agent,
+            voiceSessionId,
+            operationId,
+            update.delegation,
+          ));
+          update.effects = mergeVoiceEffects(update.effects, bufferedEffects);
+        } finally {
+          routePending = false;
+          if (activeTurnId === undefined) pendingEvents = [];
+        }
+      }
+      return JSON.stringify(update.effects);
+    },
+    agentEvent(envelope) {
+      const value = typeof envelope === "string" ? JSON.parse(envelope) : envelope;
+      if (value?.event?.type === "managed.voice.context") {
+        return raw.managedEvent(JSON.stringify(value));
+      }
+      if (routePending && value?.turnId !== activeTurnId) {
+        pendingEvents.push(value);
+        return undefined;
+      }
+      return observe(value);
+    },
+    flush: (finalChunk) => raw.flush(finalChunk),
+    async stop() {
+      clearTimeout(prefetchTimer);
+      prefetchAbort.abort();
+      const update = JSON.parse(raw.stop());
+      let routeFailure;
+      if (typeof update.delegation === "string" && update.delegation.trim()) {
+        try {
+          await routeManagedRealtime(
+            agent,
+            voiceSessionId,
+            tailOperationId,
+            update.delegation,
+          );
+        } catch (error) {
+          routeFailure = error;
+        }
+      }
+      let stopFailure;
+      try {
+        await stopManagedRealtime(agent, voiceSessionId, stopOperationId);
+      } catch (error) {
+        stopFailure = error;
+      }
+      startedTurnId = undefined;
+      activeTurnId = undefined;
+      pendingEvents = [];
+      if (routeFailure !== undefined) throw routeFailure;
+      if (stopFailure !== undefined) throw stopFailure;
+      return JSON.stringify(update.effects);
+    },
+    async cancel() {
+      if (!startedTurnId) return false;
+      const turnId = startedTurnId;
+      await cancelManagedTurn(agent, turnId);
+      if (startedTurnId === turnId) startedTurnId = undefined;
+      return true;
+    },
+    preferredPhysicalInput: (current, labels) => raw.preferredPhysicalInput(current, labels),
+    free: () => { clearTimeout(prefetchTimer); prefetchAbort.abort(); raw.free(); },
+  };
+}
+
+function uuidV7() {
+  if (typeof globalThis.crypto?.getRandomValues !== "function") {
+    throw new Error("managed browser voice requires crypto.getRandomValues()");
+  }
+  const bytes = globalThis.crypto.getRandomValues(new Uint8Array(16));
+  let timestamp = Date.now();
+  for (let index = 5; index >= 0; index -= 1) {
+    bytes[index] = timestamp % 256;
+    timestamp = Math.floor(timestamp / 256);
+  }
+  bytes[6] = (bytes[6] & 0x0f) | 0x70;
+  bytes[8] = (bytes[8] & 0x3f) | 0x80;
+  const encoded = [...bytes].map((byte) => byte.toString(16).padStart(2, "0"));
+  return `${encoded.slice(0, 4).join("")}-${encoded.slice(4, 6).join("")}-${encoded.slice(6, 8).join("")}-${encoded.slice(8, 10).join("")}-${encoded.slice(10).join("")}`;
+}
+
+function managedDelegationId(payload) {
+  try {
+    const event = typeof payload === "string" ? JSON.parse(payload) : payload;
+    return typeof event?.item?.id === "string" ? event.item.id : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function isTerminalAgentEvent(event) {
+  return event?.type === "run.completed" || event?.type === "run.failed"
+    || event?.type === "run.cancelled" || event?.type === "turn_failed";
+}
+
+function mergeVoiceEffects(base, encoded) {
+  const effects = [base, ...encoded.map((value) => (
+    typeof value === "string" ? JSON.parse(value) : value
+  ))].filter((value) => value && typeof value === "object");
+  if (effects.length === 0) return base;
+  return {
+    ...effects[0],
+    playback_enabled: effects.findLast((value) => value.playback_enabled !== undefined)?.playback_enabled,
+    acknowledge_frames: effects.some((value) => value.acknowledge_frames),
+    frames: effects.flatMap((value) => value.frames ?? []),
+    transcripts: effects.flatMap((value) => value.transcripts ?? []),
+    schedule_flush: effects.some((value) => value.schedule_flush),
+  };
+}

package/vendor/nanocodex/managed/index.d.mts

@@ -0,0 +1,20 @@
+export * as Agent from "./Agent.mjs";
+export { ManagedError } from "./ManagedError.mjs";
+export type {
+  Agent as ManagedAgent,
+  CronTrigger as ManagedCronTrigger,
+  CronTriggerConfig as ManagedCronTriggerConfig,
+  CreateOptions as ManagedCreateOptions,
+  CreateSettings as ManagedCreateSettings,
+  Event as ManagedEvent,
+  EventData as ManagedEventData,
+  HistoryCitation as ManagedHistoryCitation,
+  FindSessionsResponse as ManagedFindSessionsResponse,
+  ReadSessionResponse as ManagedReadSessionResponse,
+  MemoryKey as ManagedMemoryKey,
+  MemoryRecord as ManagedMemoryRecord,
+  MemoryResult as ManagedMemoryResult,
+  Organization as ManagedOrganization,
+  Turn as ManagedTurn,
+  TurnResult as ManagedTurnResult,
+} from "./Agent.mjs";

package/vendor/nanocodex/managed/index.mjs

@@ -0,0 +1,2 @@
+export * as Agent from "./Agent.mjs";
+export { ManagedError } from "./ManagedError.mjs";

package/vendor/nanocodex/managed/internal.mjs

@@ -0,0 +1,119 @@
+const managedAgents = new WeakMap();
+
+/** @internal Retains the authenticated client without exposing it on the public Agent handle. */
+export function registerManagedAgent(agent, client, id, options = {}) {
+  managedAgents.set(agent, {
+    client,
+    eventAgent: agent,
+    id,
+    ...(options.voiceTransport === undefined ? {} : { voiceTransport: options.voiceTransport }),
+  });
+}
+
+/** @internal Retains managed lifecycle ownership for a capability-bound Agent projection. */
+export function registerManagedAgentAlias(agent, source, options = {}) {
+  const state = managedAgent(source);
+  managedAgents.set(agent, {
+    ...state,
+    ...(options.voiceTransport === undefined ? {} : { voiceTransport: options.voiceTransport }),
+  });
+}
+
+/** @internal Resolves an optional browser media transport owned by an Agent projection. */
+export function managedBrowserVoiceTransport(agent) {
+  return managedAgent(agent).voiceTransport;
+}
+
+/** @internal Starts the canonical Realtime lifecycle on the selected durable Agent. */
+export function startManagedRealtime(agent, voiceSessionId, operationId) {
+  const { client, id } = managedAgent(agent);
+  return client.json(`${agentPath(id)}/realtime/start`, {
+    method: "POST",
+    body: JSON.stringify({
+      voice_session_id: voiceSessionId,
+      operation_id: operationId,
+    }),
+  });
+}
+
+/** @internal Warms exact-query retrieval without admitting an Agent turn. */
+export function prefetchManagedRealtime(agent, voiceSessionId, query, signal) {
+  const { client, id } = managedAgent(agent);
+  return client.json(`${agentPath(id)}/realtime/prefetch`, {
+    method: "POST", signal,
+    body: JSON.stringify({ voice_session_id: voiceSessionId, query }),
+  });
+}
+
+/** @internal Atomically routes one Rust-formatted voice delegation on the durable Agent. */
+export function routeManagedRealtime(agent, voiceSessionId, operationId, input) {
+  const { client, id } = managedAgent(agent);
+  return client.json(`${agentPath(id)}/realtime/delegate`, {
+    method: "POST",
+    body: JSON.stringify({
+      voice_session_id: voiceSessionId,
+      operation_id: operationId,
+      input,
+    }),
+  });
+}
+
+/** @internal Ends the canonical Realtime lifecycle on the selected durable Agent. */
+export function stopManagedRealtime(agent, voiceSessionId, operationId) {
+  const { client, id } = managedAgent(agent);
+  return client.json(`${agentPath(id)}/realtime/stop`, {
+    method: "POST",
+    body: JSON.stringify({
+      voice_session_id: voiceSessionId,
+      operation_id: operationId,
+    }),
+  });
+}
+
+/** @internal Cancels only a managed turn that this voice session started. */
+export function cancelManagedTurn(agent, turnId) {
+  const { client, id } = managedAgent(agent);
+  return client.json(`${agentPath(id)}/turns/${encodeURIComponent(turnId)}/cancel`, {
+    method: "POST",
+  });
+}
+
+/** @internal Streams only canonical typed Agent events from the durable envelope log. */
+export function observeManagedAgentEvents(agent, listener) {
+  if (typeof listener !== "function") throw new TypeError("managed voice event listener must be a function");
+  const controller = new AbortController();
+  void (async () => {
+    try {
+      const { eventAgent } = managedAgent(agent);
+      for await (const envelope of eventAgent.events.watch({
+        cursor: "latest",
+        signal: controller.signal,
+      })) {
+        if (controller.signal.aborted) return;
+        if (envelope.data.type === "event") {
+          listener(Object.freeze({ event: envelope.data.event, turnId: envelope.turnId, cursor: envelope.cursor }));
+        } else if (envelope.data.type === "turn_failed") {
+          listener(Object.freeze({ event: envelope.data, turnId: envelope.turnId, cursor: envelope.cursor }));
+        }
+      }
+    } catch (error) {
+      if (!controller.signal.aborted) reportError(error);
+    }
+  })();
+  return () => controller.abort();
+}
+
+function managedAgent(agent) {
+  const state = managedAgents.get(agent);
+  if (!state) throw new TypeError("voice requires a managed Nanocodex Agent");
+  return state;
+}
+
+function agentPath(id) {
+  return `/v1/agents/${encodeURIComponent(id)}`;
+}
+
+function reportError(error) {
+  if (typeof globalThis.reportError === "function") globalThis.reportError(error);
+  else console.error(error);
+}

package/vendor/nanocodex/node/Agent.d.mts

@@ -0,0 +1,50 @@
+import type {
+  AgentLifecycle,
+  AgentOptions,
+  CodeEvaluator,
+  DefaultAgent,
+  DurabilityStore,
+  McpServers,
+  ToolConfiguration,
+} from "../types.mjs";
+import type { ManagedTransport, ResponsesTransport } from "./Transport.mjs";
+import type { Tool as SubagentTool } from "../runtime/subagents.mjs";
+import type { Workspace } from "./workspace.mjs";
+import type { Tools } from "../tools/Tools.mjs";
+
+export type Agent = DefaultAgent;
+type ToolExposureOptions =
+  | { mcp?: false | undefined; toolMode?: "code" | "direct" | undefined }
+  | { mcp: McpServers; toolMode?: "code" | undefined };
+
+/** Creates a Node-hosted Rust/WASM Agent. */
+export function create(options: create.ManagedOptions): Promise<AgentLifecycle>;
+export function create(options: create.Options): Promise<create.ReturnType>;
+export declare namespace create {
+  type ManagedOptions = Readonly<{
+    transport: ManagedTransport;
+    tools?: Tools | undefined;
+  }>;
+  type Options = AgentOptions & ToolExposureOptions & {
+    /** Enable built-in subagents (default true). False conflicts with Subagents.create(). */
+    subagents?: boolean | undefined;
+    codeEvaluator?: CodeEvaluator | undefined;
+    /** Caller-owned rooted filesystem mounted through standard workspace tools. */
+    filesystem?: Workspace | undefined;
+    module?: unknown;
+    transport: ResponsesTransport;
+  } & (
+    | {
+      durability?: undefined;
+      durabilityId?: undefined;
+      tools?: ToolConfiguration<SubagentTool> | undefined;
+    }
+    | {
+      durability: DurabilityStore;
+      durabilityId: string;
+      /** The root remains durable; clean subagent children are in-memory. */
+      tools?: ToolConfiguration<SubagentTool> | undefined;
+    }
+  );
+  type ReturnType = Agent;
+}