nanocodex 0.6.4 → 0.6.6

package/cloudflare/tracing.mjs

@@ -0,0 +1,47 @@
+import { tracing as runtimeTracing } from "cloudflare:workers";
+
+/** Attributes must be content-free metadata, never prompts, credentials or bodies. */
+export function setSpanAttributes(span, attributes) {
+  if (typeof span.setAttributes === "function") {
+    span.setAttributes(attributes);
+  } else {
+    // The pinned local workerd predates the September 2026 span additions.
+    for (const [key, value] of Object.entries(attributes)) {
+      if (value !== undefined) span.setAttribute(key, value);
+    }
+  }
+}
+
+/** Annotate the current invocation/context without creating another child span. */
+export function annotateActiveSpan(attributes) {
+  const span = runtimeTracing.getActiveSpan?.();
+  if (span) setSpanAttributes(span, attributes);
+}
+
+/** code must be a static operation label, never derived from a caught error. */
+export function recordSpanException(span, code) {
+  span.setAttribute("error.type", code);
+  // Error objects include their raw message and stack. These can contain secrets.
+  span.recordException?.({ code });
+}
+
+/** Native nesting and lifetime, with content-free exception events. */
+export const tracing = {
+  enterSpan(name, callback, ...args) {
+    return runtimeTracing.enterSpan(name, span => {
+      try {
+        const result = callback(span, ...args);
+        if (result != null && typeof result.then === "function") {
+          return Promise.resolve(result).catch(error => {
+            recordSpanException(span, name);
+            throw error;
+          });
+        }
+        return result;
+      } catch (error) {
+        recordSpanException(span, name);
+        throw error;
+      }
+    });
+  },
+};

package/cloudflare/workers-ai-responses.d.mts

@@ -0,0 +1,28 @@
+import type { BrowserHttpRequest } from "../browser/host.mjs";
+
+export type ResponsesCanonicalModel = "@cf/zai-org/glm-5.3" | "gpt-6-astra" | "gpt-6.1-sol" | "gpt-6-luna" | "kimi-k3" | "mimo-v2.6-pro";
+
+/** Structural Workers AI binding; provider credentials stay with Cloudflare. */
+export type WorkersAiBinding<Model extends ResponsesCanonicalModel = "@cf/zai-org/glm-5.3"> = {
+  run(model: Model, input: Record<string, unknown>): Promise<unknown>;
+};
+export type WorkersAiResponsesOptions<Model extends ResponsesCanonicalModel = "@cf/zai-org/glm-5.3"> = Readonly<{
+  /** Canonical response identity; defaults to GLM-5.3. */
+  model?: Model;
+  /** Local transport identity, never fetched. Defaults to https://workers-ai.invalid/v1. */
+  apiBaseUrl?: string;
+}>;
+export type WorkersAiResponsesTransport = Readonly<{
+  apiBaseUrl: string;
+  createResponse(endpoint: string, sessionId: string, request: BrowserHttpRequest): Promise<Response>;
+}>;
+/**
+ * Incremental (stream:true) or buffered, stateless Responses SSE over the GLM-5.3 Workers AI binding.
+ * Requires full text history; opaque compaction and unsupported modalities fail explicitly.
+ * x-nanocodex-inference-buffering reports streaming or buffered (including binding fallback).
+ * Text/reasoning stream incrementally; tool events follow terminal tool validation.
+ * Structured output formats and malformed or truncated tool calls fail explicitly.
+ * Custom grammars are supplied as instructions, not enforced by the provider.
+ * Cancellation stops waiting; the binding does not expose cancellation of inference.
+ */
+export function createWorkersAiResponses<Model extends ResponsesCanonicalModel = "@cf/zai-org/glm-5.3">(ai: WorkersAiBinding<Model>, options?: WorkersAiResponsesOptions<Model>): WorkersAiResponsesTransport;

package/cloudflare/workers-ai-responses.mjs

@@ -0,0 +1,399 @@
+import { toolAliasFailure } from "./tool-alias-diagnostic.mjs";
+import { chatReasoningText } from "./chat-reasoning.mjs";
+import { providerStream, streamResponse } from "./provider-stream.mjs";
+const MODEL = "@cf/zai-org/glm-5.3";
+const MODELS = [MODEL, "gpt-6-astra", "gpt-6.1-sol", "gpt-6-luna", "kimi-k3", "mimo-v2.6-pro"];
+const BASE = "https://workers-ai.invalid/v1";
+const fail = (message) => { throw new Error(`Workers AI Responses: ${message}`); };
+const json = (value) => typeof value === "string" ? value : JSON.stringify(value);
+const key = (namespace, name) => JSON.stringify([namespace ?? null, name]);
+
+/** Stateless Responses transport for the Workers AI binding. */
+export function createWorkersAiResponses(ai, options = {}) {
+  if (typeof ai?.run !== "function") throw new TypeError("Workers AI binding must provide run()");
+  const apiBaseUrl = options.apiBaseUrl ?? BASE;
+  const model = options.model ?? MODEL;
+  if (!MODELS.includes(model)) fail("unsupported canonical model");
+  return Object.freeze({
+    apiBaseUrl,
+    async createResponse(endpoint, _sessionId, request) {
+      if (endpoint !== `${apiBaseUrl}/responses`) fail("unexpected endpoint; compaction is not supported");
+      if (request.authorization !== "host_managed") fail("hostManaged authorization is required");
+      request.signal?.throwIfAborted();
+      const body = JSON.parse(request.body);
+      const { input, registry } = translate(body, model);
+      const pending = Promise.resolve().then(() => ai.run(model, input)).catch(() => {
+        request.signal?.throwIfAborted();
+        // Binding failures may contain credentials or raw request/provider data.
+        fail("provider request failed");
+      }).then(result => {
+        // A binding may ignore cancellation while creating its stream. Release a
+        // late result even after abortable() has stopped waiting for inference.
+        if (request.signal?.aborted) {
+          const stream = result instanceof ReadableStream ? result : result?.providerStream ? result.body : null;
+          if (stream) void stream.cancel().catch(() => {});
+          request.signal.throwIfAborted();
+        }
+        return result;
+      });
+      const result = await abortable(pending, request.signal);
+      request.signal?.throwIfAborted();
+      if (body.stream === true) {
+        const source = result instanceof ReadableStream ? providerStream(result, "workers_ai_chat") : result;
+        if (source?.providerStream) {
+          return streamResponse(source, (value, prologue = false) => normalizeResponse(value, registry, model, prologue ? undefined : body.tool_choice), responseEvents,
+            request.signal);
+        }
+        // Some bindings return a completed object despite stream:true. Validate
+        // normally and label this honestly; HTTP gateways never take this path.
+      }
+      return toResponse(result, registry, model, body.tool_choice);
+    },
+  });
+}
+
+async function abortable(promise, signal) {
+  if (!signal) return promise;
+  signal.throwIfAborted();
+  let listener;
+  const cancelled = new Promise((_, reject) => {
+    listener = () => reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+    signal.addEventListener("abort", listener, { once: true });
+  });
+  try { return await Promise.race([promise, cancelled]); }
+  finally { signal.removeEventListener("abort", listener); }
+}
+
+function translate(body, model) {
+  if (!body || typeof body !== "object" || Array.isArray(body)) fail("expected a Responses request object");
+  if (body.model !== undefined && body.model !== model) fail("unsupported model override; expected pinned model");
+  const effort = (value) => {
+    if (value !== undefined && !(model === "gpt-6-luna" ? ["none", "low", "medium", "high", "xhigh", "max"] : model === "gpt-6.1-sol" ? ["low", "medium", "high", "xhigh", "max"] : model === "kimi-k3" ? ["low", "high"] : ["low", "medium", "high"]).includes(value)) fail("unsupported reasoning effort for pinned model");
+    return value;
+  };
+  if (body.previous_response_id) fail("previous_response_id is unsupported; send the complete Responses history");
+  if (body.context_management?.length) fail("provider compaction is unsupported; supply portable text history");
+  const history = typeof body.input === "string"
+    ? [{ type: "message", role: "user", content: body.input }] : body.input ?? [];
+  if (!Array.isArray(history)) fail("expected complete Responses history");
+  if (body.text?.format && body.text.format.type !== "text") fail("structured output formats are unsupported");
+  const registry = new Map();
+  const byIdentity = new Map();
+  function register(tool, namespace, description = "") {
+    if (tool.type === "namespace") {
+      if (namespace) fail("nested tool namespaces are unsupported");
+      for (const child of tool.tools) register(child, tool.name, tool.description);
+      return;
+    }
+    if (!["function", "custom", "tool_search"].includes(tool.type)) fail(`unsupported tool type ${tool.type}`);
+    if (tool.type === "tool_search" && tool.execution !== "client") fail("tool search must use client execution");
+    const name = tool.type === "tool_search" ? "tool_search" : tool.name;
+    const identity = key(namespace, name);
+    let entry = byIdentity.get(identity);
+    if (!entry) {
+      entry = { alias: `tool_${registry.size}`, name, namespace, type: tool.type };
+      registry.set(entry.alias, entry);
+      byIdentity.set(identity, entry);
+    }
+    entry.definition = { type: "function", function: {
+      name: entry.alias,
+      description: [namespace ? `${namespace}.${name}` : name, description, tool.description,
+        tool.type === "custom" ? "Pass the exact free-form tool input as the JSON string field input. Preserve all code and newlines." : "",
+        tool.format?.definition ? `Input grammar (${tool.format.syntax}): ${tool.format.definition}` : ""].filter(Boolean).join("\n"),
+      ...(tool.type === "function" && tool.strict === true ? { strict: true } : {}),
+      parameters: tool.type === "custom" ? {
+        type: "object", properties: { input: { type: "string" } }, required: ["input"], additionalProperties: false,
+      } : tool.parameters ?? { type: "object", properties: {} },
+    } };
+  }
+  for (const tool of body.tools ?? []) register(tool);
+  for (const item of history) {
+    if (item.type === "additional_tools" || item.type === "tool_search_output") {
+      for (const tool of item.tools ?? []) register(tool);
+    }
+  }
+  const messages = [];
+  if (body.instructions) messages.push({ role: "system", content: body.instructions });
+  const vision = model !== MODEL;
+  const pendingImages = [];
+  const pending = new Set();
+  const seenCallIds = new Set();
+  let reasoningEffort = effort(body.reasoning?.effort);
+  for (const item of history) {
+    switch (item.type ?? "message") {
+      case "additional_tools": break;
+      case "configuration_update":
+        reasoningEffort = effort(item.reasoning?.effort) ?? reasoningEffort;
+        break;
+      case "message": {
+        if (pending.size) fail("tool calls require their outputs before the next message");
+        if (!["user", "assistant", "system", "developer"].includes(item.role)) fail(`unsupported message role ${item.role}`);
+        const content = vision && item.role === "user" ? visionContent(item.content) : textContent(item.content);
+        const previous = messages.at(-1);
+        if (item.role === "assistant" && previous?.role === "assistant" && previous.content === null && !previous.tool_calls) previous.content = content;
+        else messages.push({ role: item.role === "developer" ? "system" : item.role, content });
+        break;
+      }
+      case "agent_message": {
+        if (pending.size) fail("tool calls require their outputs before an agent message");
+        messages.push({ role: "user", content: JSON.stringify({ author: item.author, recipient: item.recipient,
+          message: textContent(item.content) }) });
+        break;
+      }
+      case "reasoning": {
+        // Encrypted provider reasoning is not portable, but is not user history.
+        const text = [...(item.summary ?? []), ...(item.content ?? [])].map(part => part.text ?? "").join("\n");
+        const details = decodeReasoning(item.encrypted_content, model);
+        if (text || details) {
+          const previous = messages.at(-1);
+          const fields = { ...(text ? { reasoning_content: text } : {}), ...(details ? { reasoning_details: details } : {}) };
+          if (previous?.role === "assistant") Object.assign(previous, fields);
+          else messages.push({ role: "assistant", content: null, ...fields });
+        }
+        break;
+      }
+      case "function_call":
+      case "custom_tool_call":
+      case "tool_search_call": {
+        if (item.encrypted_function_args?.length) fail("encrypted function arguments cannot be replayed");
+        const name = item.type === "tool_search_call" ? "tool_search" : item.name;
+        let entry = byIdentity.get(key(item.namespace, name));
+        if (!entry) {
+          // Historical calls may belong to tools no longer available this turn.
+          entry = { alias: `history_${byIdentity.size}` };
+          byIdentity.set(key(item.namespace, name), entry);
+        }
+        if (typeof item.call_id !== "string" || !item.call_id || seenCallIds.has(item.call_id)) fail("missing or duplicate tool call ID");
+        if (pending.size && messages.at(-1)?.role !== "assistant") fail("tool calls require all outputs before another tool call");
+        seenCallIds.add(item.call_id);
+        pending.add(item.call_id);
+        const call = { id: item.call_id, type: "function", function: { name: entry.alias,
+          arguments: item.type === "custom_tool_call" ? JSON.stringify({ input: item.input }) : json(item.arguments) } };
+        const previous = messages.at(-1);
+        if (previous?.role === "assistant") (previous.tool_calls ??= []).push(call);
+        else messages.push({ role: "assistant", content: null, tool_calls: [call] });
+        break;
+      }
+      case "function_call_output":
+      case "custom_tool_call_output":
+      case "tool_search_output": {
+        if (!pending.delete(item.call_id)) fail("tool output has no matching call in full history");
+        const content = item.type === "tool_search_output" ? JSON.stringify({ tools: item.tools })
+          : vision ? visionContent(item.output) : textContent(item.output);
+        // Chat providers accept screenshots as user image parts, not tool text.
+        // Keep every call/result matched before appending the image observations.
+        if (Array.isArray(content)) {
+          messages.push({ role: "tool", tool_call_id: item.call_id,
+            content: content.filter(part => part.type === "text").map(part => part.text).join("\n") });
+          const images = content.filter(part => part.type === "image_url");
+          if (images.length) pendingImages.push({ role: "user", content: [
+            { type: "text", text: `Image observations returned by tool call ${item.call_id}:` }, ...images,
+          ] });
+        } else messages.push({ role: "tool", tool_call_id: item.call_id, content });
+        if (!pending.size) messages.push(...pendingImages.splice(0));
+        break;
+      }
+      case "compaction": case "compaction_summary": case "context_compaction": case "compaction_trigger":
+        fail("compaction is unsupported; restore portable text history before using Workers AI");
+        break;
+      default: fail(`unsupported history item ${item.type}`);
+    }
+  }
+  if (pending.size) fail("full history contains tool calls without outputs");
+  const input = { messages, stream: body.stream === true };
+  if (registry.size) input.tools = [...registry.values()].map(entry => entry.definition);
+  for (const field of ["temperature", "top_p", "parallel_tool_calls"]) {
+    if (body[field] !== undefined) input[field] = body[field];
+  }
+  if (body.max_output_tokens !== undefined) input.max_completion_tokens = body.max_output_tokens;
+  if (reasoningEffort !== undefined) input.reasoning_effort = reasoningEffort;
+  if (body.tool_choice !== undefined) {
+    if (typeof body.tool_choice === "string") {
+      if (!["auto", "none", "required"].includes(body.tool_choice)) fail("unsupported tool_choice");
+      input.tool_choice = body.tool_choice;
+    }
+    else {
+      const choice = byIdentity.get(key(body.tool_choice.namespace, body.tool_choice.name ?? (body.tool_choice.type === "tool_search" ? "tool_search" : undefined)));
+      if (!choice?.definition) fail("tool_choice refers to an unavailable tool");
+      input.tool_choice = { type: "function", function: { name: choice.alias } };
+    }
+  }
+  return { input, registry };
+}
+
+function textContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) fail("expected text content");
+  return content.map(part => {
+    if (!["input_text", "output_text", "text"].includes(part.type) || typeof part.text !== "string") {
+      fail(`unsupported content ${part.type}; GLM history must contain text`);
+    }
+    return part.text;
+  }).join("\n");
+}
+
+// Opaque transport envelope, not encryption. Keep provider reasoning metadata
+// byte-for-byte at the JSON value level across Responses history/tool replay.
+const REASONING_PREFIX = "nanocodex-chat-reasoning-v1:";
+function encodeReasoning(details, model) {
+  const value = JSON.stringify({ model, details });
+  if (value.length > 4 * 1024 * 1024) fail("reasoning details exceed limit");
+  return REASONING_PREFIX + value;
+}
+function decodeReasoning(value, model) {
+  if (typeof value !== "string" || !value.startsWith(REASONING_PREFIX)) return undefined;
+  if (value.length > 4 * 1024 * 1024 + REASONING_PREFIX.length) fail("reasoning details exceed limit");
+  let parsed;
+  try { parsed = JSON.parse(value.slice(REASONING_PREFIX.length)); } catch { fail("invalid reasoning replay"); }
+  if (parsed.model !== model || !Array.isArray(parsed.details)
+    || parsed.details.some(d => !d || typeof d !== "object" || Array.isArray(d))) fail("invalid reasoning replay");
+  return parsed.details;
+}
+function visionContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) fail("expected text or image content");
+  return content.map(part => {
+    if (["input_text", "output_text", "text"].includes(part.type) && typeof part.text === "string") return { type: "text", text: part.text };
+    if (part.type !== "input_image" || typeof part.image_url !== "string"
+      || !(/^(https:\/\/|data:image\/(png|jpeg|jpg|webp|gif);base64,)/.test(part.image_url))
+      || (part.detail !== undefined && !["auto", "low", "high", "original"].includes(part.detail))) fail("unsupported image content");
+    return { type: "image_url", image_url: { url: part.image_url,
+      ...(part.detail === undefined ? {} : { detail: part.detail === "original" ? "high" : part.detail }) } };
+  });
+}
+
+function normalizeResponse(result, registry, model, toolChoice) {
+  const choice = result?.choices?.[0];
+  if (result?.error || !choice?.message || typeof choice.message !== "object" || Array.isArray(choice.message)
+    || !["stop", "tool_calls", "length", "content_filter"].includes(choice.finish_reason)) {
+    fail("invalid chat completion or unsupported finish reason");
+  }
+  const message = choice.message;
+  if (message.content != null && typeof message.content !== "string") fail("unsupported completion content");
+  if (message.tool_calls != null && !Array.isArray(message.tool_calls)) fail("invalid completion tool calls");
+  if (message.refusal) fail("provider refused completion");
+  if (["length", "content_filter"].includes(choice.finish_reason) && message.tool_calls?.length) {
+    fail("incomplete completion cannot dispatch tool calls");
+  }
+  const output = [];
+  const id = `resp_${crypto.randomUUID()}`;
+  const reasoning = chatReasoningText(message);
+  const details = message.reasoning_details;
+  if (details !== undefined && (!Array.isArray(details) || details.some(d => !d || typeof d !== "object" || Array.isArray(d)))) fail("invalid reasoning details");
+  if ((typeof reasoning === "string" && reasoning) || details?.length) {
+    output.push({ type: "reasoning", id: `rs_${crypto.randomUUID()}`, status: "completed",
+      summary: [], content: reasoning ? [{ type: "reasoning_text", text: reasoning }] : [],
+      ...(details?.length ? { encrypted_content: encodeReasoning(details, model) } : {}) });
+  }
+  if (typeof message.content === "string" && message.content) {
+    output.push({ type: "message", id: `msg_${crypto.randomUUID()}`, role: "assistant", status: "completed",
+      content: [{ type: "output_text", text: message.content, annotations: [] }] });
+  }
+  // Validate the caller's tool-choice contract even when a gateway needs to
+  // emulate forcing with a restricted tool set. Never dispatch a violating call.
+  if (toolChoice === "none" && message.tool_calls?.length) fail("tool choice forbids calls");
+  if (choice.finish_reason === "stop" && (toolChoice === "required" || typeof toolChoice === "object")
+    && !message.tool_calls?.length) fail("required tool call missing");
+  const callIds = new Set();
+  for (const call of message.tool_calls ?? []) {
+    if (!call || (call.type !== undefined && call.type !== "function")) fail("unsupported completion tool call");
+    const returnedName = call.function?.name;
+    let entry = registry.get(returnedName);
+    if (!entry && typeof returnedName === "string") {
+      // GLM sometimes returns the original name shown in the description instead
+      // of the advertised alias. Resolve only an exact, unambiguous registered
+      // identity; never guess among namespaces or dispatch an undeclared tool.
+      const matches = [...registry.values()].filter(candidate => returnedName === candidate.name
+        || returnedName === (candidate.namespace ? `${candidate.namespace}.${candidate.name}` : candidate.name));
+      if (matches.length === 1) entry = matches[0];
+    }
+    if (!entry) {
+      const diagnostic = toolAliasFailure(returnedName, registry);
+      fail(diagnostic === "unknown tool alias" ? "model returned an unknown tool alias" : `model returned ${diagnostic}`);
+    }
+    if (toolChoice && typeof toolChoice === "object" && (entry.name !== (toolChoice.name ?? "tool_search")
+      || entry.namespace !== toolChoice.namespace)) fail("model returned a different forced tool");
+    const argumentsText = json(call.function.arguments);
+    let args;
+    try { args = JSON.parse(argumentsText); } catch {
+      const trimmed = typeof argumentsText === "string" ? argumentsText.trimStart() : "";
+      if (entry.type === "custom" && trimmed && !["{", "[", '\"'].includes(trimmed[0])) {
+        // Custom tools natively accept freeform strings. Some Chat providers
+        // return that input without the advertised JSON wrapper. Preserve it
+        // exactly through the existing custom-call path; malformed JSON-looking
+        // wrappers and every non-custom tool still fail closed.
+        args = { input: argumentsText };
+      } else fail("model returned invalid tool JSON");
+    }
+    if (call.id !== undefined && (typeof call.id !== "string" || !call.id)) fail("invalid tool call ID");
+    if (!args || typeof args !== "object" || Array.isArray(args)) fail("tool arguments must be a JSON object");
+    const call_id = call.id || `call_${crypto.randomUUID()}`;
+    if (callIds.has(call_id)) fail("model returned duplicate tool call IDs");
+    callIds.add(call_id);
+    const common = { id: `tool_${crypto.randomUUID()}`, call_id, status: "completed" };
+    if (entry.type === "tool_search") {
+      output.push({ ...common, type: "tool_search_call", execution: "client", arguments: args });
+    } else {
+      const named = { ...common, name: entry.name, ...(entry.namespace ? { namespace: entry.namespace } : {}) };
+      if (entry.type === "custom") {
+        if (typeof args?.input !== "string") fail("custom tool arguments must contain a string input");
+        output.push({ ...named, type: "custom_tool_call", input: args.input });
+      } else output.push({ ...named, type: "function_call", arguments: argumentsText });
+    }
+  }
+  if (choice.finish_reason === "tool_calls" && !callIds.size) fail("tool_calls finish reason omitted tool calls");
+  const incomplete = ["length", "content_filter"].includes(choice.finish_reason);
+  const usage = result.usage ? {
+    input_tokens: result.usage.prompt_tokens ?? 0, output_tokens: result.usage.completion_tokens ?? 0,
+    total_tokens: result.usage.total_tokens ?? (result.usage.prompt_tokens ?? 0) + (result.usage.completion_tokens ?? 0),
+    input_tokens_details: { cached_tokens: result.usage.prompt_tokens_details?.cached_tokens ?? 0 },
+    output_tokens_details: { reasoning_tokens: result.usage.completion_tokens_details?.reasoning_tokens ?? 0 },
+  } : null;
+  const response = { id, object: "response", model, status: incomplete ? "incomplete" : "completed", output,
+    usage, end_turn: !incomplete && !callIds.size,
+    ...(incomplete ? { incomplete_details: { reason: choice.finish_reason === "length" ? "max_output_tokens" : "content_filter" } } : {}) };
+  return response;
+}
+
+function responseEvents(response) {
+  const { output } = response;
+  const incomplete = response.status === "incomplete";
+  const events = [];
+  const emit = (type, fields) => events.push({ type, sequence_number: events.length, ...fields });
+  emit("response.created", { response: { ...response, status: "in_progress", output: [], usage: null } });
+  for (const [output_index, item] of output.entries()) {
+    const fields = { output_index, item_id: item.id };
+    const initial = { ...item, status: "in_progress" };
+    if (item.type === "message" || item.type === "reasoning") initial.content = [];
+    if (item.type === "function_call") initial.arguments = "";
+    if (item.type === "custom_tool_call") initial.input = "";
+    emit("response.output_item.added", { output_index, item: initial });
+    if (item.type === "message") {
+      emit("response.content_part.added", { ...fields, content_index: 0, part: { type: "output_text", text: "", annotations: [] } });
+      emit("response.output_text.delta", { ...fields, content_index: 0, delta: item.content[0].text });
+      emit("response.output_text.done", { ...fields, content_index: 0, text: item.content[0].text });
+      emit("response.content_part.done", { ...fields, content_index: 0, part: item.content[0] });
+    } else if (item.type === "function_call" || item.type === "custom_tool_call") {
+      const custom = item.type === "custom_tool_call";
+      const stem = custom ? "custom_tool_call_input" : "function_call_arguments";
+      const value = custom ? item.input : item.arguments;
+      emit(`response.${stem}.delta`, { ...fields, call_id: item.call_id, delta: value });
+      emit(`response.${stem}.done`, { ...fields, call_id: item.call_id, [custom ? "input" : "arguments"]: value });
+    } else if (item.type === "reasoning" && item.content.length) {
+      emit("response.content_part.added", { ...fields, content_index: 0, part: { type: "reasoning_text", text: "" } });
+      emit("response.reasoning_text.delta", { ...fields, content_index: 0, delta: item.content[0].text });
+      emit("response.reasoning_text.done", { ...fields, content_index: 0, text: item.content[0].text });
+      emit("response.content_part.done", { ...fields, content_index: 0, part: item.content[0] });
+    }
+    emit("response.output_item.done", { output_index, item });
+  }
+  emit(incomplete ? "response.incomplete" : "response.completed", { response });
+  return events;
+}
+
+function toResponse(result, registry, model, toolChoice) {
+  const events = responseEvents(normalizeResponse(result, registry, model, toolChoice));
+  return new Response(events.map(event => `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`).join(""), {
+    headers: { "content-type": "text/event-stream", "cache-control": "no-cache", "x-nanocodex-inference-buffering": "buffered" },
+  });
+}

package/host/Agent.d.mts

@@ -47,7 +47,7 @@ export declare namespace create {
     | {
       durability: DurabilityStore;
       durabilityId: string;
-      /** The root remains durable; clean subagent children are in-memory. */
+      /** The root remains durable; all subagent children are ephemeral. */
       tools?: ToolConfiguration<SubagentTool> | undefined;
     }
   );

package/index.d.mts

@@ -24,6 +24,8 @@ export type {
   AgentEvent,
   AgentLifecycle,
   AgentOptions,
+  BeforeCompactionRequest,
+  CompactionReceipt,
   AgentSessionContext,
   ChatGptCredential,
   ChatGptCredentialSeed,

package/internal.mjs

@@ -30,6 +30,7 @@ export function defineRuntime(definition) {
     type: definition.type ?? "custom",
     create: definition.create,
     dispose: definition.dispose || ((agent) => agent.free()),
+    shutdown: definition.shutdown || ((agent) => agent.shutdown()),
     subscribe: definition.subscribe,
     adopt: definition.adopt,
     release: definition.release,
@@ -228,6 +229,11 @@ export function compact(agent) {
   return agentState(agent).raw.compact();
 }
 
+/** Copies the live agent's latest committed, resumable model boundary. */
+export async function checkpoint(agent) {
+  return JSON.parse(await agentState(agent).raw.checkpoint());
+}
+
 export async function context(agent) {
   return parseSessionContext(await agentState(agent).raw.context());
 }
@@ -315,7 +321,10 @@ export function toWasmConfig(options = {}) {
   copy(config, "thinking", options.thinking);
   copy(config, "reasoning_mode", options.reasoningMode);
   copy(config, "fast_mode", options.fastMode);
+  copy(config, "stateless_http", options.stateless);
+  copy(config, "subagent_routing", options.subagentRouting);
   copy(config, "websocket_warmup", options.websocketWarmup);
+  copy(config, "raw_api_events", options.rawApiEvents);
   copy(config, "websocket_url", options.websocketUrl);
   copy(config, "api_base_url", options.apiBaseUrl);
   copy(config, "instructions", options.instructions);
@@ -343,6 +352,7 @@ export function toWasmConfig(options = {}) {
   copy(config, "terminal_receipt_retention", options.terminalReceiptRetention);
   copy(config, "subagents", options.subagents);
   copy(config, "host_definition_id", options.hostDefinitionId);
+  copy(config, "before_compaction", options.beforeCompaction);
   return config;
 }
 
@@ -427,6 +437,13 @@ export function releaseHostSession(host, sessionId) {
   hostSessions.delete(sessionId);
 }
 
+/** Drops only this host's in-memory registrations. */
+export function releaseHostSessions(host) {
+  for (const [sessionId, owner] of hostSessions) {
+    if (owner === host) releaseHostSession(host, sessionId);
+  }
+}
+
 export function registerDefinitionHost(host, cloudflareReservation) {
   const id = nextDefinitionHost++;
   definitionHosts.set(id, host);
@@ -515,6 +532,27 @@ const hostBridge = Object.freeze({
     }
     return host.sleep(milliseconds);
   },
+  async beforeCompaction(hostDefinitionId, requestJson) {
+    const host = requiredDefinitionHost(hostDefinitionId);
+    return JSON.stringify(await host.beforeCompaction(JSON.parse(requestJson)));
+  },
+  cancelBeforeCompaction(hostDefinitionId, boundaryId) {
+    definitionHosts.get(hostDefinitionId)?.cancelBeforeCompaction(boundaryId);
+  },
+  async routeSubagent(hostDefinitionId, requestJson) {
+    const host = requiredDefinitionHost(hostDefinitionId);
+    if (!cloudflareHostMayBindSubagent(host)) throw new Error("subagent host is no longer active");
+    return JSON.stringify(await host.routeSubagent(JSON.parse(requestJson)));
+  },
+  bindSubagentRoute(hostDefinitionId, requestJson) {
+    const host = requiredDefinitionHost(hostDefinitionId);
+    if (!cloudflareHostMayBindSubagent(host)) throw new Error("subagent host is no longer active");
+    const result = host.bindSubagentRoute(JSON.parse(requestJson));
+    if (result && typeof result.then === "function") {
+      Promise.resolve(result).catch(() => {});
+      throw new TypeError("subagent route binding must be synchronous");
+    }
+  },
   bindSubagentSession(
     hostDefinitionId,
     rootSessionId,
@@ -534,11 +572,7 @@ const hostBridge = Object.freeze({
     if (!cloudflareHostMayBindSubagent(host)) return;
     const existing = hostSessions.get(sessionId);
     if (existing && existing !== host) {
-      const ownerId = cloudflareHostReservations.get(host)?.ownerId;
-      if (ownerId === undefined
-        || cloudflareHostReservations.get(existing)?.ownerId !== ownerId) {
-        throw new Error(`Nanocodex subagent session ID is already active: ${sessionId}`);
-      }
+      throw new Error(`Nanocodex subagent session ID is already active: ${sessionId}`);
     }
     host.bindSubagentSession(sessionId, JSON.parse(contextJson), hostContextRef);
     hostSessions.set(sessionId, host);
@@ -556,10 +590,10 @@ const hostBridge = Object.freeze({
     }
     if (!host || hostSessions.get(sessionId) !== host) return;
     host.releaseSession(sessionId);
-    if (hostSessions.get(sessionId) === host) hostSessions.delete(sessionId);
+    releaseHostSession(host, sessionId);
   },
-  executeCode(source, sessionId, callId, model) {
-    return requiredSessionHost(sessionId).executeCode(source, sessionId, callId, model);
+  executeCode(source, sessionId, callId, model, turnId) {
+    return requiredSessionHost(sessionId).executeCode(source, sessionId, callId, model, turnId);
   },
   waitCode(input, sessionId, callId) {
     return requiredSessionHost(sessionId).waitCode(input, sessionId, callId);
@@ -567,8 +601,8 @@ const hostBridge = Object.freeze({
   nextCodeUpdate(sessionId, callId) {
     return requiredSessionHost(sessionId).nextCodeUpdate(sessionId, callId);
   },
-  executeTool(name, input, sessionId, callId, model) {
-    return requiredSessionHost(sessionId).executeTool(name, input, sessionId, callId, model);
+  executeTool(name, input, sessionId, callId, model, turnId) {
+    return requiredSessionHost(sessionId).executeTool(name, input, sessionId, callId, model, turnId);
   },
   beginCodeTurn(sessionId) {
     hostSessions.get(sessionId)?.beginCodeTurn?.(sessionId);
@@ -827,7 +861,7 @@ export function prepareCloudflareAgentSession(sessionId, ownerId) {
   return reservation;
 }
 
-/** @internal Whether this exact Cloudflare generation may publish child descriptors. */
+/** @internal Whether this exact Cloudflare generation may bind live children. */
 export function mayBindCloudflareSubagentSession(reservation) {
   return cloudflareAgentSessions.has(reservation)
     && !reservation.released
@@ -835,7 +869,7 @@ export function mayBindCloudflareSubagentSession(reservation) {
       || activeAgentSessions.get(reservation.sessionId) === reservation);
 }
 
-/** @internal Whether this committed current generation may delete child descriptors. */
+/** @internal Whether this committed current generation may release live children. */
 export function mayReleaseCloudflareSubagentSession(reservation) {
   return cloudflareAgentSessions.has(reservation)
     && !reservation.released
@@ -871,13 +905,16 @@ export function activateCloudflareAgentSession(reservation) {
 }
 
 /** Internal Cloudflare seam: publishes a reconstructed owner after adapter setup succeeds. */
-export function commitCloudflareAgentSession(reservation) {
+export function commitCloudflareAgentSession(reservation, beforeCommit) {
   if (!cloudflareAgentSessions.has(reservation)
     || reservation.released
     || !reservation.adopted
     || activeAgentSessions.get(reservation.sessionId) !== reservation) {
     throw new Error("Cloudflare Agent session reservation is not ready to commit");
   }
+  // A synchronous durable transition must succeed before rollback authority is
+  // relinquished. No other generation can interleave validation and publication.
+  beforeCommit?.();
   reservation.committed = true;
   reservation.predecessor = undefined;
   reservation.predecessorHost = undefined;
@@ -938,7 +975,9 @@ async function joinAgentShutdown(state) {
   let shutdownFailed = false;
   let shutdownError;
   try {
-    await state.raw.shutdown();
+    await (state.runtime.shutdown === undefined
+      ? state.raw.shutdown()
+      : state.runtime.shutdown(state.raw));
   } catch (error) {
     shutdownFailed = true;
     shutdownError = error;