nanocodex 0.6.4 → 0.6.6

package/cloudflare/agent-settings.mjs

@@ -0,0 +1,135 @@
+export const AGENT_MODELS = [
+    "gpt-6.1-sol",
+    "gpt-6-luna",
+    "gpt-6-astra",
+    "@cf/zai-org/glm-5.3",
+    "kimi-k3",
+    "mimo-v2.6-pro",
+];
+export const AGENT_THINKING = [
+    "none",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
+export const AGENT_REASONING_MODES = ["standard", "pro"];
+export const DEFAULT_AGENT_SETTINGS = Object.freeze({
+    model: "gpt-6-astra",
+    thinking: "low",
+    reasoning_mode: "standard",
+    fast_mode: false,
+});
+const QUERY_KEYS = new Set([
+    "model",
+    "thinking",
+    "reasoning_mode",
+    "fast_mode",
+]);
+export function parseAgentSettingsQuery(search) {
+    for (const key of search.keys()) {
+        if (!QUERY_KEYS.has(key)
+            || search.getAll(key).length !== 1) {
+            throw new TypeError("invalid agent settings query");
+        }
+    }
+    const model = search.get("model") ?? DEFAULT_AGENT_SETTINGS.model;
+    const thinking = search.get("thinking") ?? DEFAULT_AGENT_SETTINGS.thinking;
+    const reasoningMode = search.get("reasoning_mode")
+        ?? DEFAULT_AGENT_SETTINGS.reasoning_mode;
+    const encodedFastMode = search.get("fast_mode");
+    if (!isAgentModel(model)
+        || !isAgentThinking(thinking)
+        || !isAgentReasoningMode(reasoningMode)
+        || (encodedFastMode !== null
+            && encodedFastMode !== "true"
+            && encodedFastMode !== "false")) {
+        throw new TypeError("invalid agent settings query");
+    }
+    return validateAgentSettings({
+        model,
+        thinking,
+        reasoning_mode: reasoningMode,
+        fast_mode: encodedFastMode === null
+            ? DEFAULT_AGENT_SETTINGS.fast_mode
+            : encodedFastMode === "true",
+    });
+}
+export function agentSettingsQuery(settings) {
+    return new URLSearchParams({
+        model: settings.model,
+        thinking: settings.thinking,
+        reasoning_mode: settings.reasoning_mode,
+        fast_mode: String(settings.fast_mode),
+    });
+}
+export function parseAgentSettingsPatch(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new TypeError("agent settings must be a JSON object");
+    }
+    const input = value;
+    const keys = Object.keys(input);
+    if (keys.length === 0 || keys.some((key) => !QUERY_KEYS.has(key))) {
+        throw new TypeError("agent settings contain unsupported fields");
+    }
+    if (Object.hasOwn(input, "model") && !isAgentModel(input.model)) {
+        throw new TypeError("invalid agent model");
+    }
+    if (Object.hasOwn(input, "thinking") && !isAgentThinking(input.thinking)) {
+        throw new TypeError("invalid agent thinking");
+    }
+    if (Object.hasOwn(input, "reasoning_mode") && !isAgentReasoningMode(input.reasoning_mode)) {
+        throw new TypeError("invalid agent reasoning mode");
+    }
+    if (Object.hasOwn(input, "fast_mode") && typeof input.fast_mode !== "boolean") {
+        throw new TypeError("invalid agent fast mode");
+    }
+    return {
+        ...(Object.hasOwn(input, "model") ? { model: input.model } : {}),
+        ...(Object.hasOwn(input, "thinking")
+            ? { thinking: input.thinking }
+            : {}),
+        ...(Object.hasOwn(input, "reasoning_mode")
+            ? { reasoning_mode: input.reasoning_mode }
+            : {}),
+        ...(Object.hasOwn(input, "fast_mode") ? { fast_mode: input.fast_mode } : {}),
+    };
+}
+export function parseCompleteAgentSettings(value) {
+    const settings = parseAgentSettingsPatch(value);
+    if (Object.keys(settings).length !== 4) {
+        throw new TypeError("agent settings must contain all four fields");
+    }
+    return validateAgentSettings(settings);
+}
+export function validateAgentSettings(settings) {
+    if (["@cf/zai-org/glm-5.3", "kimi-k3", "mimo-v2.6-pro"].includes(settings.model)
+        && (!(settings.model === "kimi-k3" ? ["low", "high"] : ["low", "medium", "high"]).includes(settings.thinking) || settings.reasoning_mode !== "standard" || settings.fast_mode)) {
+        throw new TypeError("Gateway model requires a supported effort, standard mode, and no fast mode");
+    }
+    if (["gpt-6-astra", "gpt-6.1-sol"].includes(settings.model) && settings.thinking === "none") {
+        throw new TypeError("GPT-6 Astra and GPT-6.1 Sol require low, medium, high, xhigh, or max thinking");
+    }
+    if (settings.model === "gpt-6-astra" && settings.reasoning_mode === "pro") {
+        throw new TypeError("GPT-6 Astra does not support pro reasoning mode");
+    }
+    return settings;
+}
+/** Public admission cannot select the OSS model without a committed thread route. */
+export function validateAgentAdmissionSettings(settings) {
+    if (["@cf/zai-org/glm-5.3", "kimi-k3", "mimo-v2.6-pro"].includes(settings.model)) {
+        throw new TypeError("Gateway model is available only through model_routing; omit explicit model settings");
+    }
+    return validateAgentSettings(settings);
+}
+export function isAgentModel(value) {
+    return typeof value === "string" && AGENT_MODELS.includes(value);
+}
+export function isAgentThinking(value) {
+    return typeof value === "string" && AGENT_THINKING.includes(value);
+}
+export function isAgentReasoningMode(value) {
+    return typeof value === "string"
+        && AGENT_REASONING_MODES.includes(value);
+}

package/cloudflare/chat-reasoning.mjs

@@ -0,0 +1,20 @@
+// OpenRouter can mirror visible reasoning in both its legacy string fields and
+// reasoning_details. Project one representation per chunk; retain the original
+// details separately for tool-history replay, including opaque signatures/data.
+export function chatReasoningText(message) {
+  const text = message.reasoning_content ?? message.reasoning;
+  if (text != null && typeof text !== "string") throw new Error("Responses: invalid reasoning text");
+  const details = message.reasoning_details;
+  if (details != null && (!Array.isArray(details)
+    || details.some(detail => !detail || typeof detail !== "object" || Array.isArray(detail)))) {
+    throw new Error("Responses: invalid reasoning details");
+  }
+  let visible = "";
+  for (const detail of details ?? []) {
+    const value = detail.type === "reasoning.text" ? detail.text
+      : detail.type === "reasoning.summary" ? detail.summary : undefined;
+    if (value != null && typeof value !== "string") throw new Error("Responses: invalid reasoning detail text");
+    visible += value ?? "";
+  }
+  return text || visible;
+}

package/cloudflare/durable-placement.d.mts

@@ -0,0 +1,12 @@
+/** Trusted metadata retained from the initial user ingress, never a public header. */
+export interface IngressPlacement { trustedClientIngressColo?: string | null }
+export type PlacementRegion = "wnam" | "enam" | "sam" | "weur" | "eeur" | "apac" | "oc";
+export const TRUSTED_INGRESS_HEADER: "x-nanocodex-placement-colo";
+export function ingressColo(value: unknown): string | null;
+export function placementRegion(value: unknown): PlacementRegion | undefined;
+/** Best-effort first-use hint. Does not rename or move an existing object. */
+export function durablePlacementOptions(colo: unknown): { locationHint: PlacementRegion } | undefined;
+export function placementHeaders(headers: HeadersInit | undefined, colo: unknown): Headers;
+type PlacementBinding = { fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> };
+/** Scope only a request's environment; keep retained DO environments unchanged. */
+export function withIngressPlacement<T extends { NANOCODEX?: PlacementBinding }>(env: T, colo: unknown): T & IngressPlacement;

package/cloudflare/durable-placement.mjs

@@ -0,0 +1,82 @@
+/** Cloudflare hints affect only first use and never change object identity.
+ * Hints are best effort, not jurisdiction or execution-colo assertions.
+ * https://developers.cloudflare.com/durable-objects/reference/data-location/ */
+const TRUSTED_INGRESS_HEADER = "x-nanocodex-placement-colo";
+const COLOS = {
+  SFO: "wnam",
+  SJC: "wnam",
+  LAX: "wnam",
+  SEA: "wnam",
+  PDX: "wnam",
+  PHX: "wnam",
+  DEN: "wnam",
+  LAS: "wnam",
+  SLC: "wnam",
+  IAD: "enam",
+  EWR: "enam",
+  BOS: "enam",
+  ATL: "enam",
+  ORD: "enam",
+  MIA: "enam",
+  LHR: "weur",
+  CDG: "weur",
+  FRA: "weur",
+  AMS: "weur",
+  MXP: "weur",
+  MAD: "weur",
+  DUB: "weur",
+  ZRH: "weur",
+  WAW: "eeur",
+  OTP: "eeur",
+  ATH: "eeur",
+  SIN: "apac",
+  NRT: "apac",
+  HKG: "apac",
+  SYD: "oc",
+  MEL: "oc",
+  AKL: "oc",
+  GRU: "sam",
+  SCL: "sam",
+  EZE: "sam"
+};
+function ingressColo(value) {
+  return typeof value === "string" && /^[A-Z]{3}$/.test(value) ? value : null;
+}
+function placementRegion(value) {
+  const colo = ingressColo(value);
+  return colo === null ? void 0 : COLOS[colo];
+}
+function durablePlacementOptions(colo) {
+  const locationHint = placementRegion(colo);
+  return locationHint ? { locationHint } : void 0;
+}
+/** Replace any caller assertion with platform or retained Session metadata. */
+function placementHeaders(headers, colo) {
+  const result = new Headers(headers);
+  result.delete(TRUSTED_INGRESS_HEADER);
+  const trusted = ingressColo(colo);
+  if (trusted) result.set(TRUSTED_INGRESS_HEADER, trusted);
+  return result;
+}
+/** Scope a request-local env only; never replace a retained DO env or its
+ * discovery-cache/model-transport binding identities. */
+function withIngressPlacement(env, colo) {
+  const trustedClientIngressColo = ingressColo(colo);
+  const binding = env.NANOCODEX;
+  return { ...env, trustedClientIngressColo, ...binding ? {
+    NANOCODEX: {
+      fetch(input, init) {
+        const request = new Request(input, init);
+        return binding.fetch(new Request(request, { headers: placementHeaders(request.headers, trustedClientIngressColo) }));
+      }
+    }
+  } : {} };
+}
+export {
+  TRUSTED_INGRESS_HEADER,
+  durablePlacementOptions,
+  ingressColo,
+  placementHeaders,
+  placementRegion,
+  withIngressPlacement
+};

package/cloudflare/egress.d.mts

@@ -9,6 +9,37 @@ export type CloudflareEgressBinding = Readonly<{
   fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
 }>;
 
+/** Plain private discovery results. Consumers must validate and project current authority. */
+export type CloudflareAccountCatalogResult = Readonly<{ status: number; catalog: unknown }>;
+export type CloudflareAccountVaultResult = Readonly<{ status: number; vault: unknown }>;
+
+export type CloudflareAccountMetadataComponent = "catalog" | "vault";
+export type CloudflareAccountDiscoveryOptions = Readonly<{
+  /** Current caller authority partition, at most 4096 UTF-8 bytes; not authorization. */
+  authorityKey: string;
+  /** Always read the backend. Does not globally invalidate other isolates. */
+  reload?: boolean;
+}>;
+/** Original backend-read expiry. Consumers must not start another 15-minute TTL. */
+export type CloudflareAccountDiscoveryResult = Readonly<{
+  schema: 1;
+  status: number;
+  data: unknown;
+  expiresAt: number;
+}>;
+
+/** Metadata only; this surface never returns provider credentials or Vault secrets. */
+export type CloudflareAccountMetadataBinding = CloudflareEgressBinding & Readonly<{
+  readAccountCatalog?: (userId: string) => Promise<CloudflareAccountCatalogResult>;
+  readAccountVault?: (userId: string) => Promise<CloudflareAccountVaultResult>;
+  /** Opt-in discovery cache. Live methods above and HTTP retain their existing defaults.
+   * Other isolates may see older metadata within its original 15-minute lifetime.
+   * Callers must project current authority; these snapshots never authorize execution.
+   */
+  readAccountDiscovery?: (userId: string, component: CloudflareAccountMetadataComponent,
+    options: CloudflareAccountDiscoveryOptions) => Promise<CloudflareAccountDiscoveryResult>;
+}>;
+
 export type CloudflareEgressOptions = Readonly<{
   /** The managed Worker's private EGRESS Service Binding. */
   binding: CloudflareEgressBinding;

package/cloudflare/gateway-binding-responses.mjs

@@ -0,0 +1,84 @@
+// The portable adapter owns tool aliases and full-history validation. This
+// bridge only changes wire formats: Cloudflare's OpenAI binding takes Responses,
+// including for models that do not offer Chat Completions.
+const fail = () => { throw new Error("Gateway Responses: invalid binding response"); };
+
+export function toBindingResponsesInput(chat, effort) {
+  const input = [];
+  for (const message of chat.messages) {
+    if (message.role === "tool") {
+      input.push({ type: "function_call_output", call_id: message.tool_call_id, output: message.content });
+      continue;
+    }
+    // Portable reasoning is plaintext history, never a provider-issued opaque
+    // reasoning item or encrypted state. Replay it as assistant text.
+    if (message.reasoning_content) input.push({ role: "assistant", content: message.reasoning_content });
+    if (message.content != null) input.push({ role: message.role, content: Array.isArray(message.content)
+      ? message.content.map(part => part.type === "image_url"
+        ? { type: "input_image", image_url: part.image_url.url, ...(part.image_url.detail ? { detail: part.image_url.detail } : {}) }
+        : { type: message.role === "assistant" ? "output_text" : "input_text", text: part.text })
+      : message.content });
+    for (const call of message.tool_calls ?? []) input.push({ type: "function_call", call_id: call.id,
+      name: call.function.name, arguments: call.function.arguments });
+  }
+  const payload = { input, stream: chat.stream === true, store: false, reasoning: { effort } };
+  if (chat.tools) payload.tools = chat.tools.map(tool => ({ type: "function", ...tool.function,
+    // Responses normalizes omitted strict to true; preserve explicit strict
+    // functions while leaving legacy optional/loose schemas non-strict.
+    strict: tool.function.strict === true }));
+  if (chat.tool_choice !== undefined) payload.tool_choice = typeof chat.tool_choice === "string"
+    ? chat.tool_choice : { type: "function", name: chat.tool_choice.function.name };
+  if (chat.max_completion_tokens !== undefined) payload.max_output_tokens = chat.max_completion_tokens;
+  for (const field of ["temperature", "top_p", "parallel_tool_calls"]) {
+    if (chat[field] !== undefined) payload[field] = chat[field];
+  }
+  return payload;
+}
+
+export function fromBindingResponsesResult(result) {
+  if (!result || typeof result !== "object" || result.error || result.object !== "response"
+    || !["completed", "incomplete"].includes(result.status) || !Array.isArray(result.output)) fail();
+  let finish_reason = "stop";
+  if (result.status === "incomplete") {
+    const reason = result.incomplete_details?.reason;
+    if (!["max_output_tokens", "content_filter"].includes(reason)) fail();
+    finish_reason = reason === "max_output_tokens" ? "length" : "content_filter";
+  }
+  const texts = [], reasoning = [], tool_calls = [];
+  for (const item of result.output) {
+    if (!item || typeof item !== "object") fail();
+    if (item.status !== undefined && item.status !== "completed"
+      && !(result.status === "incomplete" && item.status === "incomplete")) fail();
+    if (item.type === "message") {
+      if (item.role !== "assistant" || !Array.isArray(item.content)) fail();
+      for (const part of item.content) {
+        if (part?.type !== "output_text" || typeof part.text !== "string") fail();
+        texts.push(part.text);
+      }
+    } else if (item.type === "reasoning") {
+      for (const [field, type] of [["summary", "summary_text"], ["content", "reasoning_text"]]) {
+        if (item[field] !== undefined && !Array.isArray(item[field])) fail();
+        for (const part of item[field] ?? []) {
+          if (part?.type !== type || typeof part.text !== "string") fail();
+          reasoning.push(part.text);
+        }
+      }
+      // encrypted_content intentionally stays upstream: full history is portable.
+    } else if (item.type === "function_call") {
+      if (result.status !== "completed" || typeof item.call_id !== "string" || !item.call_id
+        || typeof item.name !== "string" || typeof item.arguments !== "string") fail();
+      tool_calls.push({ id: item.call_id, type: "function", function: { name: item.name, arguments: item.arguments } });
+    } else fail(); // Never accept provider-hosted tools or unsupported modalities.
+  }
+  if (tool_calls.length) finish_reason = "tool_calls";
+  const message = { content: texts.join("\n"), reasoning_content: reasoning.join("\n"), tool_calls };
+  let usage;
+  if (result.usage != null) {
+    const count = value => { if (value !== undefined && (!Number.isSafeInteger(value) || value < 0)) fail(); return value; };
+    usage = { prompt_tokens: count(result.usage.input_tokens), completion_tokens: count(result.usage.output_tokens),
+      total_tokens: count(result.usage.total_tokens),
+      prompt_tokens_details: { cached_tokens: count(result.usage.input_tokens_details?.cached_tokens) },
+      completion_tokens_details: { reasoning_tokens: count(result.usage.output_tokens_details?.reasoning_tokens) } };
+  }
+  return { choices: [{ message, finish_reason }], ...(usage ? { usage } : {}) };
+}

package/cloudflare/gateway-responses.d.mts

@@ -0,0 +1,48 @@
+import type { ResponsesCanonicalModel, WorkersAiResponsesTransport } from "./workers-ai-responses.mjs";
+/** Content-free, attempt-level telemetry. No requests, URLs, errors or response bodies are exposed. */
+export type GatewayRequestOutcome = "success" | "http_error" | "network_error" | "protocol_error" | "timeout" | "cancelled";
+export type GatewayRequestObserver = Readonly<{
+  /** HTTP only; binding attempts leave the status unset. */
+  headers(status: number): void;
+  /** First emitted nonempty text or validated tool output; excludes reasoning and HTTP headers. */
+  firstToken?(): void;
+  /** Success follows body consumption and protocol validation; HTTP headers are not TTFT. */
+  finish(outcome: GatewayRequestOutcome): void | boolean | Promise<void | boolean>;
+}>;
+type GatewayResponsesCommonOptions = Readonly<{
+  reasoningEffort: "none" | "low" | "medium" | "high" | "xhigh" | "max";
+  /** Called once immediately before each outbound attempt. Failures cannot break generation. */
+  onRequest?: () => GatewayRequestObserver;
+}>;
+export type GatewayResponsesOptions = GatewayResponsesCommonOptions & (Readonly<{
+  provider: "openrouter" | "vercel";
+  model: ResponsesCanonicalModel;
+  /** Server-side credential. Never include in browser state or persisted routing metadata. */
+  apiKey: string;
+  /** Injectable HTTP transport, defaulting to global fetch. */
+  fetch?: typeof globalThis.fetch;
+  ai?: never;
+  accountId?: never;
+}> | Readonly<{
+  provider: "cloudflare";
+  model: Extract<ResponsesCanonicalModel, `gpt-${string}`>;
+  /** Native Responses binding; credentials stay with Cloudflare. Cancellation stops waiting, not inference. */
+  ai: { run(model: `openai/${Extract<ResponsesCanonicalModel, `gpt-${string}`>}`, input: Record<string, unknown>): Promise<unknown> };
+  apiKey?: never;
+  fetch?: never;
+  accountId?: never;
+}> | Readonly<{
+  provider: "cloudflare";
+  model: Extract<ResponsesCanonicalModel, `gpt-${string}`>;
+  /** Account-scoped native Responses REST; no provider API key or connector access. */
+  accountId: string;
+  /** Deployment-owned Cloudflare API token with inference access. */
+  apiKey: string;
+  fetch?: typeof globalThis.fetch;
+  ai?: never;
+}>);
+/** Incremental (stream:true) or buffered Responses SSE with complete replay and pinned model/effort.
+ * Text/reasoning stream incrementally; tools are emitted only after terminal validation.
+ * x-nanocodex-inference-buffering reports streaming or buffered binding fallback.
+ */
+export function createGatewayResponses(options: GatewayResponsesOptions): WorkersAiResponsesTransport & Readonly<{ stateless: true }>;

package/cloudflare/gateway-responses.mjs

@@ -0,0 +1,191 @@
+import { providerStream } from "./provider-stream.mjs";
+import { createWorkersAiResponses } from "./workers-ai-responses.mjs";
+import { toBindingResponsesInput, fromBindingResponsesResult } from "./gateway-binding-responses.mjs";
+
+const ENDPOINTS = Object.freeze({
+  openrouter: "https://openrouter.ai/api/v1/chat/completions",
+  vercel: "https://ai-gateway.vercel.sh/v1/chat/completions",
+});
+const MODELS = ["@cf/zai-org/glm-5.3", "gpt-6-astra", "gpt-6.1-sol", "gpt-6-luna", "kimi-k3", "mimo-v2.6-pro"];
+const fail = message => { throw new Error(`Gateway Responses: ${message}`); };
+
+/** Server-side, full-history transport; no WebSocket or opaque compaction. */
+export function createGatewayResponses(options) {
+  const { provider, model, reasoningEffort, apiKey, fetch: fetchImpl = globalThis.fetch } = options;
+  if (provider !== "cloudflare" && !Object.hasOwn(ENDPOINTS, provider)) fail("unsupported provider");
+  if (!MODELS.includes(model)) fail("unsupported canonical model");
+  if (!(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(reasoningEffort)) fail("unsupported reasoning effort");
+  const cloudflareHttp = provider === "cloudflare" && (options.accountId !== undefined || apiKey !== undefined);
+  if (provider === "cloudflare") {
+    if (!model.startsWith("gpt-")) fail("Cloudflare gateway requires an OpenAI canonical model");
+    if (cloudflareHttp) {
+      if (options.ai !== undefined) fail("choose one Cloudflare transport");
+      if (typeof options.accountId !== "string" || !/^[a-f0-9]{32}$/i.test(options.accountId)) fail("a valid Cloudflare account ID is required");
+    } else if (typeof options.ai?.run !== "function") fail("an AI binding is required");
+  }
+  if (provider !== "cloudflare" || cloudflareHttp) {
+    if (typeof apiKey !== "string" || !apiKey.trim() || /[\r\n]/.test(apiKey)
+      || (cloudflareHttp && !/^[\x21-\x7e]+$/.test(apiKey))) fail("a server-side API key is required");
+    if (typeof fetchImpl !== "function") fail("fetch is required");
+  }
+  const endpoint = cloudflareHttp
+    ? `https://api.cloudflare.com/client/v4/accounts/${options.accountId}/ai/v1/responses` : ENDPOINTS[provider];
+  const gatewayModel = model === MODELS[0]
+    ? (provider === "openrouter" ? "z-ai/glm-5.3" : "zai/glm-5.3") : model === "kimi-k3" ? "moonshotai/kimi-k3" : model === "mimo-v2.6-pro" ? "xiaomi/mimo-v2.6-pro" : `openai/${model}`;
+  const apiBaseUrl = `https://${provider}-responses.invalid/v1`;
+  const adapter = (signal, attempt, reasoningMode) => createWorkersAiResponses({
+    async run(_model, input) {
+      signal?.throwIfAborted();
+      if (provider !== "cloudflare" && input.tools?.length && (model === "gpt-6.1-sol" || model === "gpt-6-luna" && reasoningEffort !== "none")) {
+        fail("pinned Chat model/effort cannot call tools; use Responses");
+      }
+      if (input.reasoning_effort !== undefined && input.reasoning_effort !== reasoningEffort) fail("reasoning override does not match pinned effort");
+      if (provider === "cloudflare" && !cloudflareHttp) {
+        const payload = toBindingResponsesInput(input, reasoningEffort);
+        if (reasoningMode !== undefined) payload.reasoning.mode = reasoningMode;
+        attempt.outcome = "network_error";
+        try { attempt.observer = options.onRequest?.(); } catch { /* telemetry is best effort */ }
+        let value;
+        try { value = await options.ai.run(gatewayModel, payload); }
+        catch {
+          signal?.throwIfAborted();
+          fail("provider request failed");
+        }
+        if (signal?.aborted) {
+          if (value instanceof ReadableStream) void value.cancel().catch(() => {});
+          signal.throwIfAborted();
+        }
+        // A binding has no observable HTTP headers/status. Protocol validation
+        // and the existing portable adapter must both succeed before finish().
+        attempt.outcome = "protocol_error";
+        if (input.stream && value instanceof ReadableStream) {
+          attempt.streaming = true;
+          return providerStream(value, "responses", attempt.hooks);
+        }
+        return fromBindingResponsesResult(value);
+      }
+      // Vercel documents reasoning_effort as the Chat Completions alias:
+      // https://vercel.com/docs/ai-gateway/sdks-and-apis/openai-chat-completions/reasoning
+      const payload = cloudflareHttp
+        ? { ...toBindingResponsesInput(input, reasoningEffort), model: gatewayModel }
+        : { ...input, model: gatewayModel, reasoning_effort: reasoningEffort };
+      if (cloudflareHttp && reasoningMode !== undefined) payload.reasoning.mode = reasoningMode;
+      if (["kimi-k3", "mimo-v2.6-pro"].includes(model)) {
+        // Both providers document these models through the unified reasoning field.
+        delete payload.reasoning_effort;
+        payload.reasoning = { effort: reasoningEffort };
+        if (payload.max_completion_tokens !== undefined) {
+          payload.max_tokens = payload.max_completion_tokens;
+          delete payload.max_completion_tokens;
+        }
+        if (payload.parallel_tool_calls === false) delete payload.parallel_tool_calls;
+      }
+      if (provider === "openrouter") {
+        delete payload.reasoning_effort;
+        payload.reasoning = { effort: reasoningEffort };
+        payload.provider = { require_parameters: true };
+        // OpenRouter filters on parameter presence, including false. Its catalog
+        // omits parallel_tool_calls for otherwise tool-capable endpoints. The host
+        // scheduler controls concurrency for all validated returned calls.
+        if (input.parallel_tool_calls === false) delete payload.parallel_tool_calls;
+      }
+      let response;
+      if (provider === "openrouter" && model === "mimo-v2.6-pro") {
+        // MiMo endpoints currently support automatic tool selection only. Keep
+        // forced-choice semantics locally: restrict advertised tools, then the
+        // portable normalizer validates the completed call before dispatch.
+        if (payload.tool_choice === "none") {
+          delete payload.tools;
+          delete payload.tool_choice;
+        } else if (payload.tool_choice === "required" || typeof payload.tool_choice === "object") {
+          if (typeof payload.tool_choice === "object") payload.tools = payload.tools.filter(tool => tool.function.name === payload.tool_choice.function.name);
+          payload.tool_choice = "auto";
+        }
+      }
+      attempt.outcome = "network_error";
+      try { attempt.observer = options.onRequest?.(); } catch { /* telemetry is best effort */ }
+      try {
+        response = await fetchImpl(endpoint, { method: "POST", redirect: "manual", signal,
+          headers: { "content-type": "application/json", authorization: `Bearer ${apiKey}` },
+          body: JSON.stringify(payload) });
+      } catch {
+        signal?.throwIfAborted();
+        fail("provider request failed");
+      }
+      if (signal?.aborted) {
+        try { await response.body?.cancel(); } catch { /* best effort release */ }
+        signal.throwIfAborted();
+      }
+      try { attempt.observer?.headers(response.status); } catch { /* telemetry is best effort */ }
+      if (!response.ok) {
+        attempt.outcome = "http_error";
+        // Never parse, quote, or retain an upstream error body or status text.
+        try { await response.body?.cancel(); } catch { /* best effort release */ }
+        fail("provider rejected request");
+      }
+      attempt.outcome = "protocol_error";
+      if (input.stream) {
+        if (!response.headers.get("content-type")?.toLowerCase().startsWith("text/event-stream")) {
+          try { await response.body?.cancel(); } catch { /* best effort */ }
+          fail("invalid provider stream");
+        }
+        attempt.streaming = true;
+        return providerStream(response.body, cloudflareHttp ? "responses" : "chat", attempt.hooks);
+      }
+      let value;
+      try { value = await response.json(); }
+      catch (error) {
+        signal?.throwIfAborted();
+        attempt.outcome = error instanceof SyntaxError ? "protocol_error" : "network_error";
+        fail("invalid provider response");
+      }
+      return cloudflareHttp ? fromBindingResponsesResult(value) : value;
+    },
+  }, { model, apiBaseUrl });
+  return Object.freeze({ apiBaseUrl, stateless: true,
+    async createResponse(endpoint, sessionId, request) {
+      const attempt = {};
+      let deferred = false, finished = false;
+      const finish = async outcome => {
+        if (finished) return;
+        finished = true;
+        if (request.signal?.aborted) outcome = request.signal.reason?.name === "TimeoutError" ? "timeout" : "cancelled";
+        try { await attempt.observer?.finish(outcome); } catch { /* best effort */ }
+      };
+      attempt.hooks = {
+        firstToken() { try { attempt.observer?.firstToken?.(); } catch { /* best effort */ } },
+        finish,
+      };
+      try {
+        // The portable Chat translator has no reasoning.mode field. Preserve it
+        // explicitly on Responses transports and reject unsupported pro requests.
+        const body = JSON.parse(request.body);
+        const supportsMode = ["gpt-6.1-sol", "gpt-6-luna"].includes(model);
+        const validateMode = value => {
+          if (value !== undefined && !["standard", "pro"].includes(value)) fail("unsupported reasoning mode");
+          if (value === "pro" && (provider !== "cloudflare" || !supportsMode)) fail("pro reasoning requires a supported Responses model");
+          return value;
+        };
+        let reasoningMode = validateMode(body.reasoning?.mode);
+        if (Array.isArray(body.input)) for (const item of body.input) {
+          if (item.type === "configuration_update") reasoningMode = validateMode(item.reasoning?.mode) ?? reasoningMode;
+        }
+        if (provider !== "cloudflare" || !supportsMode) reasoningMode = undefined;
+        const response = await adapter(request.signal, attempt, reasoningMode).createResponse(endpoint, sessionId, request);
+        attempt.outcome = "success";
+        deferred = attempt.streaming === true;
+        return response;
+      }
+      catch {
+        request.signal?.throwIfAborted();
+        // Adapter validation must not echo untrusted request/provider fields either.
+        fail("request failed or is incompatible with the pinned model and effort");
+      } finally {
+        if (request.signal?.aborted) {
+          attempt.outcome = request.signal.reason?.name === "TimeoutError" ? "timeout" : "cancelled";
+        }
+        if (!deferred) await finish(attempt.outcome);
+      }
+    },
+  });
+}

package/cloudflare/index.d.mts

@@ -5,3 +5,9 @@ export type {
   CloudflareEgressOptions,
   CloudflareEgressTransportOptions,
 } from "./egress.mjs";
+export { createWorkersAiResponses } from "./workers-ai-responses.mjs";
+export { createGatewayResponses } from "./gateway-responses.mjs";
+export type { GatewayResponsesOptions } from "./gateway-responses.mjs";
+export type { ResponsesCanonicalModel } from "./workers-ai-responses.mjs";
+export { createSubagentRouting } from "../runtime/subagent-routing.mjs";
+export type { ChildRoute, ChildRouteRequest, ChildRouteBinding, SubagentRouting } from "../runtime/subagent-routing.mjs";

package/cloudflare/index.mjs

@@ -4,3 +4,6 @@ import { bindAgent } from "./Agent.mjs";
 /** Cloudflare Durable Object Agent backed by the package's compiled WASM. */
 export const Agent = bindAgent(module);
 export { cloudflareEgress } from "./egress.mjs";
+export { createWorkersAiResponses } from "./workers-ai-responses.mjs";
+export { createGatewayResponses } from "./gateway-responses.mjs";
+export { createSubagentRouting } from "../runtime/subagent-routing.mjs";

package/cloudflare/managed-auth.d.mts

@@ -0,0 +1,15 @@
+export type OrganizationCapability = "agents:read" | "agents:portability" | "agents:write" | "api_keys:read" | "api_keys:write" | "history:read" | "memory:read" | "memory:write" | "tools:use" | "organization:read" | "organization:write";
+export type ApiKeyBase = Readonly<{ id: string; label: string; prefix: string; createdAt: number; digest: string; userId: string }>;
+export type StoredApiKey = ApiKeyBase & Readonly<{ organizationId: string; teamId: string; role: "owner" | "writer" | "reader"; capabilities: readonly OrganizationCapability[]; authorizationEpoch: number }>;
+export type ApiKeyPrincipal = Readonly<{ kind: "api_key"; userId: string; organizationId: string; teamId: string; role: StoredApiKey["role"]; subjectId: `api_key:${string}`; credentialId: string; authorizationEpoch: number; capabilities: readonly OrganizationCapability[] }>;
+export type AdmissionPrincipal = Readonly<{ kind: "api_key" | "account_session" | "connect_grant" | "service"; userId: string; organizationId: string; teamId: string; authorizationEpoch: number; capabilities: readonly string[]; connectGrant?: Readonly<{ grantId: string; connectors: readonly string[]; connectorConnections?: unknown; mcpIds: readonly string[]; appToolCatalogDigest?: string; sandboxExecution?: true; outputCheckpoints?: true }> }>;
+export const API_KEY: RegExp;
+export function isUserId(value: unknown): value is string;
+export function isOrganizationCapabilities(value: unknown): value is readonly OrganizationCapability[];
+export function isApiKeyBase(value: unknown): value is ApiKeyBase;
+export function isStoredApiKey(value: unknown): value is StoredApiKey;
+export function apiKeyDigest(request: Request): Promise<string | undefined>;
+/** Only a record returned by live authorized key resolution may be projected. */
+export function apiKeyPrincipal(record: unknown, digest: string): ApiKeyPrincipal | undefined;
+/** Replace all authority assertions; callers must supply a live authenticated principal. */
+export function forwardPrincipalAssertions(headers: Headers, principal: AdmissionPrincipal): void;