nanocodex 0.6.6 → 0.6.7

package/host/index.mjs

@@ -1,10 +1,7 @@
 export * as Actions from "../actions/index.mjs";
 export { createQuickJsEvaluator } from "../runtime/quickjs-evaluator.mjs";
-export {
-  createTempoProvider,
-  createTempoProviderFromAccounts,
-  DEFAULT_MERCATOR_MCP_URL,
-} from "../runtime/tempo-provider.mjs";
 export * as Agent from "./Agent.mjs";
 export * as Subagents from "../runtime/subagents.mjs";
 export * as Transport from "../browser/Transport.mjs";
+
+export * as Claude from "./Claude.mjs";

package/index.d.mts

@@ -8,16 +8,6 @@ export { createTools } from "./tools/Tools.mjs";
 export type { Tools, AttachmentClient, AttachmentTarget, AttachmentTransport } from "./tools/Tools.mjs";
 export type { HostedMachine } from "./tools/hostedCatalog.mjs";
 export type { AsyncQuickJsModule, QuickJsEvaluatorOptions } from "./runtime/quickjs-evaluator.mjs";
-export {
-  createTempoProvider,
-  createTempoProviderFromAccounts,
-  DEFAULT_MERCATOR_MCP_URL,
-} from "./runtime/tempo-provider.mjs";
-export type {
-  AccountsTempoProviderOptions,
-  AccountsWallet,
-  TempoProvider,
-} from "./runtime/tempo-provider.mjs";
 export type {
   Agent,
   AgentActions,
@@ -35,6 +25,9 @@ export type {
   ChatGptSubscriptionStore,
   CostStatus,
   CodeEvaluator,
+  CodeEffectContext,
+  CodeEffectReceipt,
+  CodeEffectJournal,
   CodeEvaluatorEnvironment,
   DefaultAgent,
   EventWatcher,
@@ -43,6 +36,8 @@ export type {
   ForkOptions,
   McpClient,
   McpPayment,
+  PaidMcpPayment,
+  McpPrivateResultPolicy,
   McpServer,
   McpServers,
   McpTool,
@@ -70,3 +65,9 @@ export type {
   TurnUsage,
   WatchEventsOptions,
 } from "./types.mjs";
+
+export type {
+  Options as ClaudeSubscriptionOptions,
+  Subscription as ClaudeSubscriptionHandle,
+  Status as ClaudeSubscriptionStatus,
+} from "./worker/ClaudeSubscription.mjs";

package/index.mjs

@@ -5,8 +5,3 @@ export {
 } from "./runtime/subscription-store.mjs";
 export { createQuickJsEvaluator } from "./runtime/quickjs-evaluator.mjs";
 export { createTools } from "./tools/Tools.mjs";
-export {
-  createTempoProvider,
-  createTempoProviderFromAccounts,
-  DEFAULT_MERCATOR_MCP_URL,
-} from "./runtime/tempo-provider.mjs";

package/internal.mjs

@@ -110,6 +110,14 @@ export async function routePrompt(agent, options) {
   return raw === undefined ? undefined : createTurn(raw, agent);
 }
 
+/** Internal host lifecycle identity; accepted() retains its public durable-only contract. */
+export function getTurnHostId(turn) {
+  const state = turnState(turn);
+  return typeof state.raw.hostTurnId === "function"
+    ? Promise.resolve(state.raw.hostTurnId())
+    : awaitTurnAcceptance(turn);
+}
+
 export function getTurnResult(turn) {
   const state = turnState(turn);
   if (!state.result) {
@@ -321,6 +329,7 @@ export function toWasmConfig(options = {}) {
   copy(config, "thinking", options.thinking);
   copy(config, "reasoning_mode", options.reasoningMode);
   copy(config, "fast_mode", options.fastMode);
+  copy(config, "instant_tool_steering", options.instantToolSteering);
   copy(config, "stateless_http", options.stateless);
   copy(config, "subagent_routing", options.subagentRouting);
   copy(config, "websocket_warmup", options.websocketWarmup);
@@ -330,6 +339,7 @@ export function toWasmConfig(options = {}) {
   copy(config, "instructions", options.instructions);
   copy(config, "additional_instructions", options.additionalInstructions);
   copy(config, "session_id", options.sessionId);
+  copy(config, "prompt_cache_key", options.promptCacheKey);
   copy(config, "workspace", options.workspace);
   if (options.executionEnvironment !== undefined) {
     const environment = options.executionEnvironment;
@@ -351,6 +361,7 @@ export function toWasmConfig(options = {}) {
   copy(config, "durability_host_id", options.durabilityHostId);
   copy(config, "terminal_receipt_retention", options.terminalReceiptRetention);
   copy(config, "subagents", options.subagents);
+  copy(config, "claude_harness", options.claudeHarness);
   copy(config, "host_definition_id", options.hostDefinitionId);
   copy(config, "before_compaction", options.beforeCompaction);
   return config;
@@ -463,6 +474,12 @@ export function releaseDefinitionHost(id) {
 }
 
 const hostBridge = Object.freeze({
+  claudeAuth(hostDefinitionId) {
+    return requiredDefinitionHost(hostDefinitionId).claudeAuthHeaders();
+  },
+  executeClaudeTool(hostDefinitionId, name, input, sessionId, callId, model, turnId, localDefinitions, executeLocalTool) {
+    return requiredDefinitionHost(hostDefinitionId).executeClaudeTool(name, input, sessionId, callId, model, turnId, localDefinitions, executeLocalTool);
+  },
   httpOpen(endpoint, apiKey, accountId, fedramp, sessionId, threadId, turnState, body) {
     const host = requiredSessionHost(threadId);
     if (typeof host.httpOpen !== "function") {
@@ -592,8 +609,8 @@ const hostBridge = Object.freeze({
     host.releaseSession(sessionId);
     releaseHostSession(host, sessionId);
   },
-  executeCode(source, sessionId, callId, model, turnId) {
-    return requiredSessionHost(sessionId).executeCode(source, sessionId, callId, model, turnId);
+  executeCode(source, sessionId, callId, model, turnId, localDefinitions, executeLocalTool) {
+    return requiredSessionHost(sessionId).executeCode(source, sessionId, callId, model, turnId, localDefinitions, executeLocalTool);
   },
   waitCode(input, sessionId, callId) {
     return requiredSessionHost(sessionId).waitCode(input, sessionId, callId);
@@ -604,6 +621,12 @@ const hostBridge = Object.freeze({
   executeTool(name, input, sessionId, callId, model, turnId) {
     return requiredSessionHost(sessionId).executeTool(name, input, sessionId, callId, model, turnId);
   },
+  preemptCode(sessionId, callId) {
+    return hostSessions.get(sessionId)?.preemptCode?.(sessionId, callId) ?? false;
+  },
+  preemptCodeTurn(sessionId) {
+    return hostSessions.get(sessionId)?.preemptCodeTurn?.(sessionId) ?? 0;
+  },
   beginCodeTurn(sessionId) {
     hostSessions.get(sessionId)?.beginCodeTurn?.(sessionId);
   },
@@ -1021,7 +1044,9 @@ function connectFailure(error) {
       kind: "handshake_rejected",
       status,
       body: typeof error?.body === "string" ? error.body : errorDetail(error),
-      ...(Number.isFinite(retryAfter) && retryAfter >= 0 ? { retry_after: retryAfter } : {}),
+      ...(error?.retryAfter !== undefined && Number.isFinite(retryAfter) && retryAfter >= 0 ? { retry_after: retryAfter } : {}),
+      ...(Number.isSafeInteger(error?.retry_after_deadline_ms) && error.retry_after_deadline_ms >= 0
+        ? { retry_after_deadline_ms: error.retry_after_deadline_ms } : {}),
     };
   }
   return {

package/managed/Agent.d.mts

@@ -73,7 +73,7 @@ export type Options = Readonly<{
 }>;
 
 export type CreateSettings = Readonly<{
-  model: Model;
+  model: Model | "claude-sonnet-4-6" | "claude-opus-4-6" | "claude-sonnet-5-5" | "claude-opus-5-5";
   thinking: Thinking;
   reasoningMode: ReasoningMode;
   fastMode: boolean;
@@ -89,6 +89,8 @@ export type Environment = Readonly<{
   network?: NetworkPolicy;
 }>;
 export type Configuration = Readonly<{
+  /** Yield active exec/wait observers on accepted steering; default false. */
+  instant_tool_steering?: boolean;
   /** Pin this session to one connected ChatGPT account; disables automatic account failover. */
   chatgpt_account_id?: string;
   settings?: Readonly<{ model: CreateSettings["model"]; thinking: CreateSettings["thinking"]; reasoning_mode: "standard" | "pro"; fast_mode: boolean }>;
@@ -163,7 +165,7 @@ export type State = Readonly<{
   latest_event_cursor: string;
   stream_error: string | null;
   settings: Readonly<{
-    model: Model;
+    model: Model | "claude-sonnet-4-6" | "claude-opus-4-6" | "claude-sonnet-5-5" | "claude-opus-5-5";
     thinking: Thinking;
     reasoning_mode: ReasoningMode;
     fast_mode: boolean;
@@ -357,6 +359,8 @@ export type CronTrigger = Readonly<{
 export type Agent = Readonly<{
   /** Start bounded background runtime/socket preparation for an active conversation.
    * Resolves on acceptance, not provider readiness. Never required before prompt(). */
+  /** Idle manual compaction; uncertain failures are never automatically retried. */
+  compact(options?: Readonly<{ signal?: AbortSignal }>): Promise<void>;
   prepare(options?: Readonly<{ signal?: AbortSignal }>): Promise<void>;
   requiredActions: Readonly<{
     list(): Promise<{ data: readonly Readonly<{ call_id: string; session_id: string; source_call_id: string; name: string; input: unknown; deadline_at: number }>[] }>;

package/managed/Agent.mjs

@@ -1,3 +1,4 @@
+import { attachRetryAfterAdvice, retryAfterAdvice, retryAfterRemaining } from "../runtime/retry-after.mjs";
 import { steerInputKey } from "../runtime/steer-receipt.mjs";
 import { requestOriginContext } from "../tools/environment.mjs";
 import { ManagedError } from "./ManagedError.mjs";
@@ -17,6 +18,14 @@ const TERMINAL_TYPES = new Set([
   "turn_cancelled",
   "turn_failed",
 ]);
+// Typed terminal failures override an otherwise retryable HTTP status.
+const TERMINAL_RETRY_CODES = new Set([
+  "context_length_exceeded", "insufficient_quota", "usage_not_included",
+  "cyber_policy", "misalignment_policy_violation", "invalid_prompt", "bio_policy",
+]);
+// Private event-reconnect veto; does not alter public code precedence or the
+// independent creation/mutation retry policy.
+const terminalResponseErrors = new WeakSet();
 const TERMINAL_CACHE_CAPACITY = 256;
 const TERMINAL_CACHE_BYTES = 8 * 1024 * 1024;
 const SUBSCRIBER_QUEUE_CAPACITY = 4_096;
@@ -29,7 +38,7 @@ const TURN_STATE_READ_TIMEOUT_MS = 2_000;
 const ALLOWED_OPTIONS = new Set(["apiKey", "baseUrl", "fetch", "toolsTransport", "requestOrigin"]);
 const CREATE_SETTINGS = new Set(["model", "thinking", "reasoningMode", "fastMode"]);
 const SETTINGS_PATCH = CREATE_SETTINGS;
-const MODELS = new Set(["gpt-6.1-sol", "gpt-6-luna", "gpt-6-astra", "@cf/zai-org/glm-5.3", "kimi-k3", "mimo-v2.6-pro"]);
+const MODELS = new Set(["gpt-6.1-sol", "gpt-6-luna", "gpt-6-astra", "@cf/zai-org/glm-5.3", "kimi-k3", "mimo-v2.6-pro", "claude-sonnet-4-6", "claude-opus-4-6", "claude-sonnet-5-5", "claude-opus-5-5"]);
 const THINKING = new Set(["none", "low", "medium", "high", "xhigh", "max"]);
 const REASONING_MODES = new Set(["standard", "pro"]);
 const eventEncoder = new TextEncoder();
@@ -159,6 +168,7 @@ function managedCreateOptions(options) {
   if (settings.model === "gpt-6-astra" && settings.reasoningMode === "pro") {
     throw new TypeError("GPT-6 Astra does not support pro reasoning mode");
   }
+  if (settings.model.startsWith("claude-") && (!["low", "medium", "high"].includes(settings.thinking) || settings.reasoningMode !== "standard" || settings.fastMode)) throw new TypeError("unsupported Claude settings");
   return {
     clientOptions,
     creationKey,
@@ -302,6 +312,9 @@ function agentHandle(client, id, summary, retainedEventStream) {
       return agentHandle(client, childId);
     },
     // Activation is explicit: passive event/history readers never warm a model.
+    compact: (options = {}) => client.json(`${agentPath(id)}/compact`, {
+      method: "POST", signal: options.signal,
+    }).then(() => undefined),
     prepare: (options = {}) => client.json(`${agentPath(id)}/prepare`, {
       method: "POST", ...(options.signal === undefined ? {} : { signal: options.signal }),
     }).then(() => undefined),
@@ -452,6 +465,7 @@ function managedSettings(value) {
     || !REASONING_MODES.has(value.reasoning_mode) || typeof value.fast_mode !== "boolean"
     || (["@cf/zai-org/glm-5.3", "kimi-k3", "mimo-v2.6-pro"].includes(value.model) && (!(value.model === "kimi-k3" ? ["low", "high"] : ["low", "medium", "high"]).includes(value.thinking) || value.reasoning_mode === "pro"))
     || (["gpt-6-astra", "gpt-6.1-sol"].includes(value.model) && value.thinking === "none")
+    || (value.model.startsWith("claude-") && (!["low", "medium", "high"].includes(value.thinking) || value.reasoning_mode !== "standard" || value.fast_mode))
     || (value.model === "gpt-6-astra" && value.reasoning_mode === "pro")
   ) {
     throw new ManagedError("invalid_response", "managed agent settings are malformed");
@@ -1323,8 +1337,8 @@ async function* readEvents(client, agentId, initialCursor, signal, onControlCurs
     }
     if (!response.ok) {
       const error = await responseError(response);
-      if (response.status !== 429 && response.status < 500) throw error;
-      await delay(reconnectDelay, signal);
+      if ((terminalResponseErrors.has(error) || TERMINAL_RETRY_CODES.has(error.code)) || (response.status !== 429 && response.status < 500)) throw error;
+      await waitForRetryAdvice(error, reconnectDelay, signal);
       continue;
     }
     if (!response.body) throw new ManagedError("invalid_response", "managed event stream has no body");
@@ -1376,6 +1390,16 @@ async function* readEvents(client, agentId, initialCursor, signal, onControlCurs
   }
 }
 
+async function waitForRetryAdvice(advice, fallback, signal) {
+  let remaining = retryAfterRemaining(advice);
+  if (remaining === undefined) return delay(fallback, signal);
+  while (remaining > 0) {
+    // Timers coerce larger delays to ~1ms; chunking preserves the original deadline.
+    await delay(Math.min(remaining, 2_147_483_647), signal);
+    remaining = retryAfterRemaining(advice);
+  }
+}
+
 function encodedBytes(value) {
   const encoded = typeof value === "string" ? value : JSON.stringify(value);
   return eventEncoder.encode(encoded).byteLength;
@@ -1569,11 +1593,21 @@ function managedClient(options) {
 }
 
 async function responseError(response) {
+  const advice = retryAfterAdvice(response.headers.get("retry-after"));
   let body;
   try { body = await response.json(); } catch { body = undefined; }
-  const code = typeof body?.error === "string" ? body.error : `http_${response.status}`;
+  const code = typeof body?.error === "string" ? body.error
+    : typeof body?.error?.code === "string" ? body.error.code
+      : typeof body?.code === "string" ? body.code
+        : typeof body?.error?.type === "string" ? body.error.type : `http_${response.status}`;
   const message = typeof body?.message === "string" ? body.message : `managed request failed (${response.status})`;
-  return new ManagedError(code, message, { status: response.status });
+  const error = attachRetryAfterAdvice(new ManagedError(code, message, { status: response.status }), advice);
+  const discriminators = [body?.error, body?.code, body?.type,
+    body?.error?.code, body?.error?.type, body?.response?.error?.code, body?.response?.error?.type];
+  if (discriminators.some((value) => typeof value === "string" && TERMINAL_RETRY_CODES.has(value))) {
+    terminalResponseErrors.add(error);
+  }
+  return error;
 }
 
 function validateOptions(options) {

package/managed/ManagedError.d.mts

@@ -1,6 +1,9 @@
 export declare class ManagedError extends Error {
   readonly code: string;
   readonly status: number | undefined;
+  /** Server advice captured before consuming a rejected response body. */
+  readonly retry_after?: number;
+  readonly retry_after_deadline_ms?: number;
   constructor(
     code: string,
     message: string,

package/node/Agent.d.mts

@@ -2,6 +2,7 @@ import type {
   AgentLifecycle,
   AgentOptions,
   CodeEvaluator,
+  CodeEffectJournal,
   DefaultAgent,
   DurabilityStore,
   McpServers,
@@ -14,10 +15,11 @@ 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 };
+  | { mcp?: false | undefined; toolMode?: "code" | "code-only" | "direct" | undefined }
+  | { mcp: McpServers; toolMode?: "code" | "code-only" | undefined };
 
 /** Creates a Node-hosted Rust/WASM Agent. */
+export function create(options: import('../runtime/claude.mjs').Options & { harness: 'claude' }): Promise<import('../runtime/claude.mjs').Agent>;
 export function create(options: create.ManagedOptions): Promise<AgentLifecycle>;
 export function create(options: create.Options): Promise<create.ReturnType>;
 export declare namespace create {
@@ -27,6 +29,8 @@ export declare namespace create {
   }>;
   type Options = AgentOptions & ToolExposureOptions & {
     codeEvaluator?: CodeEvaluator | undefined;
+    /** Opt-in durable direct-tool and nested Code Mode receipts for safe cold recovery. */
+    codeEffectJournal?: CodeEffectJournal | undefined;
     /** Caller-owned rooted filesystem mounted through standard workspace tools. */
     filesystem?: Workspace | undefined;
     module?: unknown;

package/node/Agent.mjs

@@ -1,3 +1,5 @@
+import { prepareHarnesses } from '../runtime/harnesses.mjs';
+import { create as createClaude } from './Claude.mjs';
 import { createRequire } from "node:module";
 import initWeb, { Nanocodex as WebNanocodex } from "../pkg-web/nanocodex.js";
 
@@ -29,12 +31,15 @@ let initializedWeb;
 let NodeNanocodex;
 
 export function create(options = {}) {
+  if (options.harness === 'claude') return createClaude(options);
+  if (options.harness !== undefined && options.harness !== 'codex') throw new TypeError('unsupported harness family');
   if (managedTransportOptions(options?.transport)) return createManagedAgent(options);
   const {
     model,
     thinking,
     reasoningMode,
     fastMode,
+    instantToolSteering,
     rawApiEvents,
     instructions,
     additionalInstructions,
@@ -51,6 +56,7 @@ export function create(options = {}) {
     toolMode,
     mcp,
     codeEvaluator,
+    codeEffectJournal,
   } = options;
   const stableSessionId = sessionId ?? createSessionId();
   const {
@@ -63,6 +69,8 @@ export function create(options = {}) {
   } = resolveResponsesTransport(transport);
   const { tools: hostTools, subagents: subagentConfig } = resolveTools(tools);
   const events = createEventChannel();
+  // Host lifecycle observers need terminal events even without a public watcher.
+  events.subscribe(() => {});
   if (filesystem && workspace !== undefined && workspace !== filesystem.root) {
     throw new TypeError("workspace must match filesystem.root when both are provided");
   }
@@ -80,8 +88,10 @@ export function create(options = {}) {
     toolMode,
     workspace: workspace ?? filesystem?.root ?? resume?.workspace,
     codeEvaluator,
-    onDispose: () => releaseDefinitionHost(hostDefinitionId),
+    codeEffectJournal,
+    onDispose: () => { releaseDefinitionHost(hostDefinitionId); void harnesses?.close(); },
   });
+  let harnesses;
   let durabilityOwner;
   let creationStarted = false;
   hostDefinitionId = registerDefinitionHost(host);
@@ -100,6 +110,7 @@ export function create(options = {}) {
             durabilityId,
           );
         }
+        harnesses = await prepareHarnesses(options.harnesses, events.emit);
         activateHost(host);
         await host.ready();
         const Nanocodex = module === undefined
@@ -116,6 +127,7 @@ export function create(options = {}) {
           apiBaseUrl,
           websocketWarmup,
           subagents: subagentConfig,
+          claudeHarness: harnesses?.claude,
           hostDefinitionId,
           beforeCompaction: beforeCompaction !== undefined,
           ...config,
@@ -162,6 +174,7 @@ export function create(options = {}) {
     thinking,
     reasoningMode,
     fastMode,
+    instantToolSteering,
     rawApiEvents,
     instructions,
     additionalInstructions,

package/node/Claude.d.mts

@@ -0,0 +1,4 @@
+import type { Agent, Options } from '../runtime/claude.mjs';
+export type { Agent, Auth, Options, NativeToolResult, Result, Tool, ToolContent, ToolResult, Turn } from '../runtime/claude.mjs';
+/** Creates the actual Claude Rust/WASM backend with explicit host-owned authentication and tools. */
+export function create(options: Options): Promise<Agent>;

package/node/Claude.mjs

@@ -0,0 +1,24 @@
+import { createRequire } from 'node:module';
+import { createClaude } from '../runtime/claude.mjs';
+import { createNodeHost } from './host.mjs';
+import { createBrowserHost } from '../browser/host.mjs';
+
+function createCodexHost(options) {
+  // Function-backed Web API transports retain their own callbacks and evaluator.
+  if (options.hostAuth || options.createResponse || options.createWebSocket || options.WebSocketImpl) {
+    if ((options.toolMode === 'code' || options.toolMode === 'code-only') && typeof globalThis.Worker !== 'function' && options.codeEvaluator === undefined) throw new TypeError('host-managed Codex Code Mode requires an explicit codeEvaluator');
+    return createBrowserHost(options);
+  }
+  return createNodeHost(options);
+}
+
+/** Explicit Claude Messages runtime; no authentication or tools are inferred. */
+export function create(options) {
+  return createClaude(options, async (module) => {
+    if (module === undefined) return createRequire(import.meta.url)('../pkg-node/nanocodex.js').Nanoclaude;
+    const wasm = await import('../pkg-web/nanocodex.js');
+    const { initializeBrowserEngine } = await import('../browser/engine.mjs');
+    await initializeBrowserEngine({ module });
+    return wasm.Nanoclaude;
+  }, 'node', { createCodexHost });
+}

package/node/host.mjs

@@ -1,3 +1,6 @@
+import { retryAfterAdvice } from "../runtime/retry-after.mjs";
+
+import { createCodeEffectIdentity } from "../runtime/code-effect-identity.mjs";
 import { createBeforeCompaction } from "../runtime/before-compaction.mjs";
 import { createResponsesHttp, responsesHttpHeaders } from "../runtime/responses-http.mjs";
 import { Console } from "node:console";
@@ -26,8 +29,8 @@ const MPP_CLIENT_PROTOCOL_ERROR_CLOSE_CODE = 3008;
 export function createNodeHost(options = {}) {
   const preservation = createBeforeCompaction(options.beforeCompaction);
   const toolMode = options.toolMode ?? "code";
-  if (toolMode !== "code" && toolMode !== "direct") {
-    throw new TypeError("toolMode must be code or direct");
+  if (toolMode !== "code" && toolMode !== "code-only" && toolMode !== "direct") {
+    throw new TypeError("toolMode must be code, code-only or direct");
   }
   const toolsRouter = options.tools?.[toolRouterBrand]
     ? options.tools[toolRouterRuntime]
@@ -39,7 +42,7 @@ export function createNodeHost(options = {}) {
   if (toolsMcp && options.mcpServers) {
     throw new TypeError("MCP is already configured in Tools");
   }
-  if ((toolsMcp || options.mcpServers) && toolMode !== "code") {
+  if ((toolsMcp || options.mcpServers) && toolMode === "direct") {
     throw new TypeError("remote MCP requires Code Mode");
   }
   const toolsLifecycle = options.tools?.[toolRuntimeLifecycle];
@@ -51,10 +54,13 @@ export function createNodeHost(options = {}) {
       body, signal, redirect: "error" });
   });
   const connections = new Map();
+  const effectIdentity = createCodeEffectIdentity(options.codeEffectJournal);
   const code = createCodeRuntime(options.tools, {
     require: createRequire(resolve(options.workspace ?? process.cwd(), ".nanocodex-code-mode.cjs")),
     console: new Console({ stdout: process.stderr, stderr: process.stderr }),
     evaluate: options.codeEvaluator,
+    effectJournal: options.codeEffectJournal,
+    effectIdentity: options.codeEffectJournal ? effectIdentity.resolve : undefined,
   });
   const filesystem = options.filesystem
     ? import("../runtime/workspace.mjs")
@@ -118,6 +124,7 @@ export function createNodeHost(options = {}) {
       socket.on("unexpected-response", (_request, response) => {
         if (settled) return;
         settled = true;
+        const advice = retryAfterAdvice(header(response.headers, "retry-after"));
         response.setEncoding("utf8");
         const chunks = [];
         response.on("data", (chunk) => chunks.push(chunk));
@@ -125,8 +132,8 @@ export function createNodeHost(options = {}) {
           const error = new Error(`WebSocket handshake was rejected with HTTP ${response.statusCode}`);
           error.status = response.statusCode;
           error.body = chunks.length ? chunks.join("") : "empty response body";
-          const retryAfter = Number(header(response.headers, "retry-after"));
-          if (Number.isFinite(retryAfter) && retryAfter >= 0) error.retryAfter = retryAfter;
+          Object.assign(error, advice);
+          if (advice.retry_after !== undefined) error.retryAfter = advice.retry_after;
           reject(error);
         });
       });
@@ -301,7 +308,7 @@ export function createNodeHost(options = {}) {
     http.dispose();
     disposal = Promise.resolve().then(() => settleCleanup([
       ...[...connections.keys()].map((handle) => () => close(handle)),
-      () => code.reset(),
+      () => { effectIdentity.reset(); return code.reset(); },
       () => mcpInstalled,
       () => toolsLifecycle?.close(),
       () => options.onDispose?.(),
@@ -335,15 +342,17 @@ export function createNodeHost(options = {}) {
     waitCode: code.waitCodeObserved,
     beginCodeTurn: code.beginTurn,
     cancelCodeTurn: code.cancelTurn,
+    preemptCode: code.preempt,
+    preemptCodeTurn: code.preemptTurn,
     nextCodeUpdate: code.nextCodeUpdate,
     executeTool: code.executeTool,
     bindSubagentSession: code.bindSubagentSession,
     cancelCode: code.cancel,
     toolMode: () => toolMode,
     toolDefinitions: code.toolDefinitions,
-    releaseSession: code.releaseSession,
-    emitEvent: onEvent,
-    reset: code.reset,
+    releaseSession: (sessionId) => { effectIdentity.release(sessionId); return code.releaseSession(sessionId); },
+    emitEvent: (event, ...args) => { code.observeEvent(event); effectIdentity.observe(event); return onEvent(event, ...args); },
+    reset: () => { effectIdentity.reset(); return code.reset(); },
     dispose,
   });
 }

package/node/index.d.mts

@@ -4,16 +4,6 @@ export {
   subscriptionRevision,
 } from "../runtime/subscription-store.mjs";
 export { createQuickJsEvaluator } from "../runtime/quickjs-evaluator.mjs";
-export {
-  createTempoProvider,
-  createTempoProviderFromAccounts,
-  DEFAULT_MERCATOR_MCP_URL,
-} from "../runtime/tempo-provider.mjs";
-export type {
-  AccountsTempoProviderOptions,
-  AccountsWallet,
-  TempoProvider,
-} from "../runtime/tempo-provider.mjs";
 export type {
   AgentEvent,
   AgentLifecycle,
@@ -27,6 +17,9 @@ export type {
   CostStatus,
   CodeEvaluator,
   CodeEvaluatorEnvironment,
+  CodeEffectContext,
+  CodeEffectReceipt,
+  CodeEffectJournal,
   EstimatedUsdCost,
   PromptInput,
   PromptItem,
@@ -45,6 +38,7 @@ export type {
   TurnResult,
   TurnUsage,
   McpPayment,
+  PaidMcpPayment,
   McpServer,
   McpServers,
   MemoryChatGptSubscriptionStore,
@@ -60,3 +54,5 @@ export * as Subagents from "../runtime/subagents.mjs";
 export * as Transport from "./Transport.mjs";
 export * as Workspace from "./workspace.mjs";
 export * as Tools from "../tools/index.mjs";
+
+export * as Claude from "./Claude.mjs";

package/node/index.mjs

@@ -4,14 +4,11 @@ export {
   subscriptionRevision,
 } from "../runtime/subscription-store.mjs";
 export { createQuickJsEvaluator } from "../runtime/quickjs-evaluator.mjs";
-export {
-  createTempoProvider,
-  createTempoProviderFromAccounts,
-  DEFAULT_MERCATOR_MCP_URL,
-} from "../runtime/tempo-provider.mjs";
 export * as Agent from "./Agent.mjs";
 export * as ChatGptSubscription from "./ChatGptSubscription.mjs";
 export * as Subagents from "../runtime/subagents.mjs";
 export * as Transport from "./Transport.mjs";
 export * as Workspace from "./workspace.mjs";
 export * as Tools from "../tools/index.mjs";
+
+export * as Claude from "./Claude.mjs";