@lamplitisles/dsh-nanocodex 0.1.0-beta.0

package/vendor/nanocodex/node/Agent.mjs

@@ -0,0 +1,203 @@
+import { createRequire } from "node:module";
+import initWeb, { Nanocodex as WebNanocodex } from "../pkg-web/nanocodex.js";
+
+import { agentActions } from "../actions/index.mjs";
+import {
+  activateHost,
+  bindHostSession,
+  createAgentClient,
+  createEventChannel,
+  createSessionId,
+  defineRuntime,
+  loadDurabilityRuntime,
+  loadSubscriptionRuntime,
+  reportError,
+  registerDefinitionHost,
+  releaseDefinitionHost,
+  releaseHostSession,
+  toWasmConfig,
+} from "../internal.mjs";
+import { createNodeHost } from "./host.mjs";
+import { resolveResponsesTransport } from "../runtime/responses-transport.mjs";
+import {
+  createManagedAgent,
+  managedTransportOptions,
+} from "../runtime/managed-transport.mjs";
+import { resolveTools } from "../runtime/tool-configuration.mjs";
+
+let initializedWeb;
+let NodeNanocodex;
+
+export function create(options = {}) {
+  if (managedTransportOptions(options?.transport)) return createManagedAgent(options);
+  const {
+    model,
+    thinking,
+    reasoningMode,
+    fastMode,
+    instructions,
+    additionalInstructions,
+    companionCompactionInstruction,
+    resolveCompactionInstruction,
+    historySeed,
+    sessionId,
+    workspace,
+    resume,
+    durability,
+    durabilityId,
+    transport,
+    module,
+    filesystem,
+    tools,
+    subagents = true,
+    toolMode,
+    mcp,
+    codeEvaluator,
+  } = options;
+  const stableSessionId = sessionId ?? createSessionId();
+  const {
+    apiKey,
+    subscription,
+    mpp,
+    websocketUrl,
+    apiBaseUrl,
+    websocketWarmup,
+  } = resolveResponsesTransport(transport);
+  if (typeof subagents !== "boolean") {
+    throw new TypeError("subagents must be a boolean");
+  }
+  const { tools: hostTools, subagents: subagentConfig } = resolveTools(tools, {
+    defaultSubagents: subagents,
+  });
+  if (!subagents && subagentConfig !== undefined) {
+    throw new TypeError("Subagents.create() conflicts with subagents: false");
+  }
+  const events = createEventChannel();
+  if (filesystem && workspace !== undefined && workspace !== filesystem.root) {
+    throw new TypeError("workspace must match filesystem.root when both are provided");
+  }
+  const tempoMcp = mpp?.[Symbol.for("nanocodex.tempo.mcp")];
+  let hostDefinitionId;
+  const host = createNodeHost({
+    mpp,
+    mcpServers: mcp === false
+      ? undefined
+      : tempoMcp ? { ...tempoMcp, ...mcp } : mcp,
+    onEvent: events.emit,
+    filesystem,
+    tools: hostTools,
+    toolMode,
+    workspace: workspace ?? filesystem?.root ?? resume?.workspace,
+    codeEvaluator,
+    resolveCompactionInstruction,
+    onDispose: () => releaseDefinitionHost(hostDefinitionId),
+  });
+  let durabilityOwner;
+  let creationStarted = false;
+  hostDefinitionId = registerDefinitionHost(host);
+  activateHost(host);
+  const runtime = defineRuntime({
+    key: "node-wasm",
+    name: "Nanocodex Node WASM",
+    type: "node",
+    async create(config) {
+      creationStarted = true;
+      try {
+        if (durability !== undefined || durabilityId !== undefined) {
+          durabilityOwner = (await loadDurabilityRuntime()).own(
+            host,
+            durability,
+            durabilityId,
+          );
+        }
+        activateHost(host);
+        await host.ready();
+        const Nanocodex = module === undefined
+          ? loadNodeNanocodex()
+          : await loadWebNanocodex(module);
+        activateHost(host);
+        const configJson = JSON.stringify(toWasmConfig({
+          apiKey: apiKey ?? (subscription === undefined
+            ? mpp === undefined ? undefined : "mpp-managed"
+            : "subscription-managed"),
+          websocketUrl: websocketUrl ?? (mpp === undefined
+            ? undefined
+            : "wss://openai.mpp.tempo.xyz/v1/responses"),
+          apiBaseUrl,
+          websocketWarmup,
+          hostHttp: mpp === undefined,
+          subagents: subagentConfig,
+          hostDefinitionId,
+          ...config,
+          durabilityHostId: durabilityOwner?.id,
+        }));
+        return subscription === undefined
+          ? Nanocodex.create(configJson)
+          : Nanocodex.createWithChatGpt(
+              configJson,
+              (await loadSubscriptionRuntime()).rawSubscription(subscription),
+            );
+      } catch (error) {
+        durabilityOwner?.abandon();
+        await host.dispose();
+        throw error;
+      }
+    },
+    subscribe: events.subscribe,
+    adopt(raw) {
+      host.retain();
+      try {
+        durabilityOwner?.retain();
+        bindHostSession(host, raw.sessionId);
+        events.addSource(raw);
+      } catch (error) {
+        events.removeSource(raw);
+        durabilityOwner?.release();
+        releaseHost(host);
+        throw error;
+      }
+    },
+    release(raw) {
+      events.removeSource(raw);
+      host.releaseSession(raw.sessionId);
+      releaseHostSession(host, raw.sessionId);
+      durabilityOwner?.release();
+      releaseHost(host);
+    },
+    decorate: (agent) => agent.extend(agentActions()),
+  });
+  return createAgentClient(runtime, {
+    model,
+    thinking,
+    reasoningMode,
+    fastMode,
+    instructions,
+    additionalInstructions,
+    companionCompactionInstruction,
+    resolveCompactionInstruction,
+    historySeed,
+    sessionId: stableSessionId,
+    workspace: workspace ?? filesystem?.root,
+    resume,
+    durabilityId,
+  }).catch(async (error) => {
+    if (!creationStarted) await host.dispose();
+    throw error;
+  });
+}
+
+function releaseHost(host) {
+  void host.release().catch(reportError);
+}
+
+function loadNodeNanocodex() {
+  const require = createRequire(import.meta.url);
+  NodeNanocodex ||= require("../pkg-node/nanocodex.js").Nanocodex;
+  return NodeNanocodex;
+}
+
+async function loadWebNanocodex(module) {
+  initializedWeb ||= initWeb({ module_or_path: module });
+  await initializedWeb;
+  return WebNanocodex;
+}

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

@@ -0,0 +1,9 @@
+import type {
+  ChatGptSubscriptionHandle,
+  ChatGptSubscriptionOptions,
+} from "../types.mjs";
+
+/** Opens the Rust-owned ChatGPT device-login and credential lifecycle. */
+export function open(
+  options: Omit<ChatGptSubscriptionOptions, "module"> & { module?: never },
+): Promise<ChatGptSubscriptionHandle>;

package/vendor/nanocodex/node/ChatGptSubscription.mjs

@@ -0,0 +1,17 @@
+import { createRequire } from "node:module";
+
+import { installHostBridge } from "../internal.mjs";
+import { openSubscription } from "../runtime/chatgpt-subscription.mjs";
+
+const require = createRequire(import.meta.url);
+let WasmChatGptSubscription;
+
+/** Opens a Rust-managed ChatGPT subscription over caller-owned storage and fetch. */
+export async function open(options) {
+  if (options?.module !== undefined) {
+    throw new TypeError("Node ChatGptSubscription does not accept a browser WASM module");
+  }
+  installHostBridge();
+  WasmChatGptSubscription ||= require("../pkg-node/nanocodex.js").ChatGptSubscription;
+  return openSubscription(options, (config) => WasmChatGptSubscription.open(config));
+}

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

@@ -0,0 +1,44 @@
+import type {
+  ChatGptSubscriptionHandle,
+  MppSession,
+} from "../types.mjs";
+import type { Options as ManagedClientOptions } from "../managed/Agent.mjs";
+
+declare const responsesTransport: unique symbol;
+declare const managedTransport: unique symbol;
+
+export type ResponsesTransport = Readonly<{
+  [responsesTransport]: true;
+}>;
+export type ManagedTransport = Readonly<{ [managedTransport]: true }>;
+export type Transport = ResponsesTransport | ManagedTransport;
+
+type EndpointOptions = Readonly<{
+  /** HTTPS `/v1` base used for Node's pre-output SSE fallback. */
+  apiBaseUrl?: string | undefined;
+  /** Preferred Responses WebSocket endpoint. */
+  websocketUrl?: string | undefined;
+  /** Whether the Node host should probe the WebSocket with a non-generating request. */
+  websocketWarmup?: boolean | undefined;
+}>;
+
+export function openAi(options: EndpointOptions & Readonly<{
+  apiKey: string;
+}>): ResponsesTransport;
+
+export function chatGpt(options: EndpointOptions & Readonly<{
+  subscription: ChatGptSubscriptionHandle;
+}>): ResponsesTransport;
+
+export function mpp(options: EndpointOptions & Readonly<{
+  session: MppSession;
+}>): ResponsesTransport;
+
+export type ManagedIdentity =
+  | Readonly<{ create: true; id?: never }>
+  | Readonly<{ id: string; create?: never }>;
+
+/** Account-authenticated durable Agent transport with explicit create/open identity. */
+export function managed(options: ManagedClientOptions & Readonly<{
+  agent: ManagedIdentity;
+}>): ManagedTransport;

package/vendor/nanocodex/node/Transport.mjs

@@ -0,0 +1,46 @@
+import {
+  createResponsesTransport,
+  nonEmpty,
+} from "../runtime/responses-transport.mjs";
+import { createManagedTransport } from "../runtime/managed-transport.mjs";
+
+export function openAi(options) {
+  const apiKey = nonEmpty(options?.apiKey, "OpenAI API key");
+  return createResponsesTransport({
+    apiKey,
+    ...endpoints(options),
+  });
+}
+
+export function chatGpt(options) {
+  if (!options?.subscription || typeof options.subscription !== "object") {
+    throw new TypeError("ChatGPT transport requires a subscription handle");
+  }
+  return createResponsesTransport({
+    subscription: options.subscription,
+    ...endpoints(options),
+  });
+}
+
+export function mpp(options) {
+  if (!options?.session || typeof options.session.ws !== "function") {
+    throw new TypeError("MPP transport requires a session with ws(endpoint)");
+  }
+  return createResponsesTransport({
+    mpp: options.session,
+    ...endpoints(options),
+  });
+}
+
+/** Account-authenticated durable Agent transport with explicit create/open identity. */
+export function managed(options) {
+  return createManagedTransport(options);
+}
+
+function endpoints(options = {}) {
+  return {
+    apiBaseUrl: options.apiBaseUrl,
+    websocketUrl: options.websocketUrl,
+    websocketWarmup: options.websocketWarmup,
+  };
+}