@x12i/ai-dispatcher 1.4.0 → 2.0.0

package/dist/index.cjs

@@ -23,12 +23,60 @@ __export(index_exports, {
   AiDispatcherError: () => AiDispatcherError,
   IMPLEMENTED_AI_PROVIDERS: () => IMPLEMENTED_AI_PROVIDERS,
   createAiDispatcher: () => createAiDispatcher,
+  decodeProviderMetadata: () => import_openrouter_runtime4.decodeProviderMetadata,
   isImplementedAiProvider: () => isImplementedAiProvider,
   providerNotImplemented: () => providerNotImplemented,
   resolveProvider: () => resolveProvider,
   stripReasoningHistoryFields: () => stripReasoningHistoryFields
 });
 module.exports = __toCommonJS(index_exports);
+var import_openrouter_runtime4 = require("@x12i/openrouter-runtime");
+
+// src/cache-usage.ts
+function readCacheTokens(source) {
+  const cached = [];
+  const written = [];
+  for (const usage of usageRecords(source)) {
+    const promptDetails = record(usage.prompt_tokens_details);
+    const inputDetails = record(usage.input_tokens_details);
+    pushNumber(cached, promptDetails?.cached_tokens);
+    pushNumber(cached, inputDetails?.cached_tokens);
+    pushNumber(cached, usage.cacheReadInputTokens);
+    pushNumber(cached, usage.cache_read_input_tokens);
+    pushNumber(cached, usage.cached_tokens);
+    pushNumber(written, promptDetails?.cache_write_tokens);
+    pushNumber(written, inputDetails?.cache_write_tokens);
+    pushNumber(written, usage.cacheWriteInputTokens);
+    pushNumber(written, usage.cache_write_input_tokens);
+    pushNumber(written, usage.cache_write_tokens);
+  }
+  const cachedTokens = cached[0];
+  const cacheWriteTokens = written[0];
+  return {
+    ...cachedTokens !== void 0 ? { cachedTokens } : {},
+    ...cacheWriteTokens !== void 0 ? { cacheWriteTokens } : {}
+  };
+}
+function usageRecords(source) {
+  const root = record(source);
+  if (!root) return [];
+  const records = [];
+  const usage = record(root.usage);
+  if (usage) records.push(usage);
+  const raw = record(root.raw);
+  if (raw) {
+    const rawUsage = record(raw.usage);
+    records.push(rawUsage ?? raw);
+  }
+  records.push(root);
+  return records;
+}
+function pushNumber(target, value) {
+  if (typeof value === "number" && Number.isFinite(value)) target.push(value);
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
 
 // src/json-pointer.ts
 var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
@@ -171,7 +219,7 @@ var ThinkTagSplitter = class {
   push(chunk) {
     this.pending += chunk;
     let answerDelta = "";
-    let reasoningDelta = "";
+    let reasoningDelta2 = "";
     while (this.pending.length > 0) {
       if (!this.inThink) {
         const openAt = this.pending.indexOf(OPEN);
@@ -188,26 +236,26 @@ var ThinkTagSplitter = class {
       }
       const closeAt = this.pending.indexOf(CLOSE);
       if (closeAt >= 0) {
-        reasoningDelta += this.pending.slice(0, closeAt);
+        reasoningDelta2 += this.pending.slice(0, closeAt);
         this.pending = this.pending.slice(closeAt + CLOSE.length);
         this.inThink = false;
         continue;
       }
       const hold = holdSuffix(this.pending, CLOSE);
-      reasoningDelta += this.pending.slice(0, this.pending.length - hold);
+      reasoningDelta2 += this.pending.slice(0, this.pending.length - hold);
       this.pending = this.pending.slice(this.pending.length - hold);
       break;
     }
     this.answer += answerDelta;
-    this.reasoning += reasoningDelta;
-    return { answerDelta, reasoningDelta };
+    this.reasoning += reasoningDelta2;
+    return { answerDelta, reasoningDelta: reasoningDelta2 };
   }
   finish() {
     if (this.inThink) {
-      const reasoningDelta = this.pending;
+      const reasoningDelta2 = this.pending;
       this.pending = "";
-      this.reasoning += reasoningDelta;
-      return { answerDelta: "", reasoningDelta };
+      this.reasoning += reasoningDelta2;
+      return { answerDelta: "", reasoningDelta: reasoningDelta2 };
     }
     const answerDelta = this.pending;
     this.pending = "";
@@ -226,6 +274,11 @@ function splitThinkTags(text) {
 function applyResolution(response, prepared) {
   const result = response;
   if (prepared.resolution) result.reasoningResolution = prepared.resolution;
+  if (prepared.cacheResolution) result.cacheResolution = prepared.cacheResolution;
+  if (prepared.cacheWarnings?.length) {
+    result.warnings = [...result.warnings, ...prepared.cacheWarnings];
+  }
+  applyCacheUsage(result);
   const directive = prepared.directive;
   if (!directive) return result;
   const raw = response.raw?.response;
@@ -241,6 +294,18 @@ function applyResolution(response, prepared) {
   applyUsage(result, raw, directive);
   return result;
 }
+function applyCacheUsage(response) {
+  const fromResponse = readCacheTokens(response.raw?.response);
+  const fromUsage = readCacheTokens(response.usage?.raw);
+  const cachedTokens = fromResponse.cachedTokens ?? fromUsage.cachedTokens;
+  const cacheWriteTokens = fromResponse.cacheWriteTokens ?? fromUsage.cacheWriteTokens;
+  if (cachedTokens === void 0 && cacheWriteTokens === void 0) return;
+  response.usage = {
+    ...response.usage ?? {},
+    ...cachedTokens !== void 0 ? { cachedTokens } : {},
+    ...cacheWriteTokens !== void 0 ? { cacheWriteTokens } : {}
+  };
+}
 function applyUsage(response, raw, directive) {
   const paths = directive.usage?.reasoningTokenPaths;
   if (!paths || paths.length === 0) return;
@@ -265,6 +330,9 @@ async function* decorateStream(prepared, source) {
   for await (const event of source) {
     if (event.type === "stream.start") {
       yield withResolution(event, prepared);
+      for (const warning of prepared.cacheWarnings ?? []) {
+        yield { type: "stream.warning", requestId: event.requestId, data: { warning } };
+      }
       continue;
     }
     if (event.type === "stream.reasoning.delta") {
@@ -315,6 +383,7 @@ async function* decorateStream(prepared, source) {
       if (splitter) data.text = splitter.answer;
       if (reasoningText) data.reasoningText = reasoningText;
       if (prepared.resolution) data.reasoningResolution = prepared.resolution;
+      if (prepared.cacheResolution) data.cacheResolution = prepared.cacheResolution;
       yield { ...event, data };
       continue;
     }
@@ -322,9 +391,10 @@ async function* decorateStream(prepared, source) {
   }
 }
 function withResolution(event, prepared) {
-  if (!prepared.resolution) return event;
+  if (!prepared.resolution && !prepared.cacheResolution) return event;
   const data = isRecord3(event.data) ? { ...event.data } : {};
-  data.reasoningResolution = prepared.resolution;
+  if (prepared.resolution) data.reasoningResolution = prepared.resolution;
+  if (prepared.cacheResolution) data.cacheResolution = prepared.cacheResolution;
   return { ...event, data };
 }
 function textOf(event) {
@@ -332,20 +402,37 @@ function textOf(event) {
   return event.data.text;
 }
 function adjustUsageEvent(event, prepared) {
+  if (!isRecord3(event.data) || !isRecord3(event.data.usage)) return event;
   const paths = prepared.directive?.usage?.reasoningTokenPaths;
-  if (!paths || paths.length === 0 || !isRecord3(event.data) || !isRecord3(event.data.usage)) return event;
   const usage = { ...event.data.usage };
-  const tokens = readReasoningTokens(usage.raw, paths);
-  if (tokens === void 0) {
-    delete usage.reasoningTokens;
-  } else {
-    usage.reasoningTokens = tokens;
+  let changed = false;
+  if (paths && paths.length > 0) {
+    const tokens = readReasoningTokens(usage.raw, paths);
+    if (tokens === void 0) {
+      if (usage.reasoningTokens !== void 0) {
+        delete usage.reasoningTokens;
+        changed = true;
+      }
+    } else if (usage.reasoningTokens !== tokens) {
+      usage.reasoningTokens = tokens;
+      changed = true;
+    }
   }
+  const counts = readCacheTokens(usage.raw);
+  if (counts.cachedTokens !== void 0) {
+    usage.cachedTokens = counts.cachedTokens;
+    changed = true;
+  }
+  if (counts.cacheWriteTokens !== void 0) {
+    usage.cacheWriteTokens = counts.cacheWriteTokens;
+    changed = true;
+  }
+  if (!changed) return event;
   return { ...event, data: { ...event.data, usage } };
 }
 
 // src/types/providers.ts
-var IMPLEMENTED_AI_PROVIDERS = ["openrouter", "bedrock", "openai"];
+var IMPLEMENTED_AI_PROVIDERS = ["openrouter", "bedrock", "openai", "cloudflare"];
 function isImplementedAiProvider(provider) {
   return IMPLEMENTED_AI_PROVIDERS.includes(provider);
 }
@@ -508,101 +595,1768 @@ function resolveAllowlist(filter, tools) {
     if (!known.has(name)) {
       throw new AiDispatcherError("MCP_TOOL_NOT_FOUND", `MCP tool "${name}" is not registered.`);
     }
-  }
-  return new Set(filter);
+  }
+  return new Set(filter);
+}
+function assertServer(server, seen) {
+  if (!isRecord4(server) || typeof server.id !== "string" || server.id.length === 0 || !Array.isArray(server.tools) || typeof server.callTool !== "function") {
+    throw new AiDispatcherError(
+      "MCP_SERVER_INVALID",
+      "An MCP server needs an id, a tools array, and a callTool function."
+    );
+  }
+  if (seen.has(server.id)) {
+    throw new AiDispatcherError("MCP_SERVER_INVALID", `MCP server "${server.id}" is listed more than once.`);
+  }
+  seen.add(server.id);
+  if (!TOOL_TOKEN.test(server.id)) {
+    throw new AiDispatcherError(
+      "MCP_TOOL_NAME_INVALID",
+      `MCP server id "${server.id}" must use letters, numbers, underscores, and hyphens.`
+    );
+  }
+}
+function exposedToolName(serverId, tool) {
+  if (typeof tool.name !== "string" || !TOOL_TOKEN.test(serverId) || !TOOL_TOKEN.test(tool.name)) {
+    throw new AiDispatcherError(
+      "MCP_TOOL_NAME_INVALID",
+      `MCP tool "${serverId}.${typeof tool.name === "string" ? tool.name : ""}" must use letters, numbers, underscores, and hyphens.`
+    );
+  }
+  const exposedName = `${serverId}__${tool.name}`;
+  if (exposedName.length > MAX_EXPOSED_NAME_LENGTH) {
+    throw new AiDispatcherError(
+      "MCP_TOOL_NAME_INVALID",
+      `MCP tool "${exposedName}" is longer than ${MAX_EXPOSED_NAME_LENGTH} characters.`
+    );
+  }
+  return exposedName;
+}
+function toolDescription(tool) {
+  if (tool.description === void 0) return "";
+  if (typeof tool.description !== "string") {
+    throw new AiDispatcherError(
+      "MCP_TOOL_NAME_INVALID",
+      `MCP tool "${tool.name}" description must be a string.`
+    );
+  }
+  return tool.description;
+}
+function toolParameters(tool) {
+  if (tool.inputSchema === void 0) return { ...DEFAULT_PARAMETERS, properties: {} };
+  if (!isRecord4(tool.inputSchema)) {
+    throw new AiDispatcherError(
+      "MCP_TOOL_NAME_INVALID",
+      `MCP tool "${tool.name}" inputSchema must be an object.`
+    );
+  }
+  return tool.inputSchema;
+}
+function textContent(content) {
+  if (!Array.isArray(content)) return void 0;
+  const parts = [];
+  for (const part of content) {
+    if (!isRecord4(part) || part.type !== "text" || typeof part.text !== "string") continue;
+    parts.push(part.text);
+  }
+  if (!parts.length) return void 0;
+  return parts.join("\n");
+}
+function toArgs(args) {
+  if (isRecord4(args)) return args;
+  return {};
+}
+function listFailed(serverId, error) {
+  if (error instanceof AiDispatcherError && error.code === "MCP_LIST_FAILED") return error;
+  const message = error instanceof Error ? error.message : `MCP server "${serverId}" listTools failed.`;
+  return new AiDispatcherError("MCP_LIST_FAILED", message);
+}
+function stringify(result) {
+  const serialized = JSON.stringify(result);
+  return serialized === void 0 ? "null" : serialized;
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/prepare-request.ts
+var import_ai_profiles = require("@x12i/ai-profiles");
+
+// src/cache-apply.ts
+var BREAKPOINT = { mode: "explicit" };
+function applyPromptCache(body, plan) {
+  if (!plan.stripMarkers && !plan.placeBreakpoint && !plan.sendOpenAiOptions) {
+    return { body, placed: false };
+  }
+  let next = plan.stripMarkers || plan.placeBreakpoint ? stripCacheMarkers(body) : body;
+  if (plan.sendOpenAiOptions) next = applyOpenAiOptions(next, plan);
+  if (!plan.placeBreakpoint) return { body: next, placed: false };
+  if (plan.dialect === "bedrock-cachepoint") return placeBedrockBreakpoint(next, plan.ttl);
+  if (plan.dialect === "anthropic-cache-control") return placeAnthropicBreakpoint(next, plan.ttl);
+  if (plan.dialect === "openai-responses") return placeOpenAiBreakpoint(next);
+  return { body: next, placed: false };
+}
+function applyOpenAiOptions(body, plan) {
+  return {
+    ...body,
+    ...plan.key ? { prompt_cache_key: plan.key } : {},
+    prompt_cache_options: {
+      mode: plan.placeBreakpoint ? "explicit" : "implicit",
+      ...plan.ttl ? { ttl: plan.ttl } : {}
+    }
+  };
+}
+function placeOpenAiBreakpoint(body) {
+  const instructions = typeof body.instructions === "string" ? body.instructions.trim() : "";
+  if (instructions) {
+    const rest = inputItems(body.input);
+    return {
+      placed: true,
+      body: {
+        ...omitKey(body, "instructions"),
+        input: [developerBlock(instructions, "prompt_cache_breakpoint", BREAKPOINT), ...rest]
+      }
+    };
+  }
+  if (Array.isArray(body.messages)) {
+    return markMessages(body, "messages", "prompt_cache_breakpoint", BREAKPOINT, "text");
+  }
+  return markInput(body, "prompt_cache_breakpoint", BREAKPOINT, "input_text");
+}
+function placeAnthropicBreakpoint(body, ttl) {
+  const marker = { type: "ephemeral", ...ttl ? { ttl } : {} };
+  if (Array.isArray(body.messages)) {
+    const marked = markMessages(body, "messages", "cache_control", marker, "text");
+    if (marked.placed) return marked;
+    if (typeof body.system === "string" && body.system.trim()) {
+      return {
+        placed: true,
+        body: {
+          ...body,
+          system: [{ type: "text", text: body.system.trim(), cache_control: marker }]
+        }
+      };
+    }
+    return marked;
+  }
+  const instructions = typeof body.instructions === "string" ? body.instructions.trim() : "";
+  if (instructions) {
+    const rest = inputItems(body.input);
+    return {
+      placed: true,
+      body: {
+        ...omitKey(body, "instructions"),
+        input: [developerBlock(instructions, "cache_control", marker), ...rest]
+      }
+    };
+  }
+  return markInput(body, "cache_control", marker, "input_text");
+}
+function placeBedrockBreakpoint(body, ttl) {
+  const point = { cachePoint: { type: "default", ...ttl ? { ttl } : {} } };
+  const system = Array.isArray(body.system) ? body.system.filter(hasBedrockText) : [];
+  if (system.length > 0) {
+    return { placed: true, body: { ...body, system: [...system, point] } };
+  }
+  return { body, placed: false };
+}
+function markMessages(body, field, markerKey, markerValue, textType) {
+  const messages = body[field];
+  if (!Array.isArray(messages)) return { body, placed: false };
+  const index = stableMessageIndex(messages);
+  if (index < 0) return { body, placed: false };
+  const marked = markMessage(messages[index], markerKey, markerValue, textType);
+  if (!marked) return { body, placed: false };
+  const next = messages.slice();
+  next[index] = marked;
+  return { placed: true, body: { ...body, [field]: next } };
+}
+function markInput(body, markerKey, markerValue, textType) {
+  if (!Array.isArray(body.input)) return { body, placed: false };
+  const index = stableInputIndex(body.input);
+  if (index < 0) return { body, placed: false };
+  const marked = markMessage(body.input[index], markerKey, markerValue, textType);
+  if (!marked) return { body, placed: false };
+  const next = body.input.slice();
+  next[index] = marked;
+  return { placed: true, body: { ...body, input: next } };
+}
+function stableMessageIndex(messages) {
+  let lastSystem = -1;
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (isPlainRecord(message) && message.role === "system" && hasText(message.content)) lastSystem = index;
+  }
+  return lastSystem;
+}
+function stableInputIndex(items) {
+  let lastStable = -1;
+  for (let index = 0; index < items.length; index += 1) {
+    const item = items[index];
+    if (!isPlainRecord(item) || !hasText(item.content)) continue;
+    if (item.role === "system" || item.role === "developer") lastStable = index;
+  }
+  return lastStable;
+}
+function markMessage(message, markerKey, markerValue, textType) {
+  if (!isPlainRecord(message) || !hasText(message.content)) return void 0;
+  const content = markContent(message.content, markerKey, markerValue, textType);
+  if (!content) return void 0;
+  return { ...message, content };
+}
+function markContent(content, markerKey, markerValue, textType) {
+  if (typeof content === "string") {
+    if (!content.trim()) return void 0;
+    return [{ type: textType, text: content, [markerKey]: markerValue }];
+  }
+  if (!Array.isArray(content)) return void 0;
+  const parts = content.map((part) => isPlainRecord(part) ? { ...part } : part);
+  for (let index = parts.length - 1; index >= 0; index -= 1) {
+    const part = parts[index];
+    if (!isPlainRecord(part) || typeof part.text !== "string" || !part.text.trim()) continue;
+    parts[index] = { ...part, [markerKey]: markerValue };
+    return parts;
+  }
+  return void 0;
+}
+function developerBlock(text, markerKey, markerValue) {
+  return {
+    role: "developer",
+    content: [{ type: "input_text", text, [markerKey]: markerValue }]
+  };
+}
+function inputItems(input) {
+  if (input === void 0) return [];
+  if (typeof input === "string") {
+    return input.trim() ? [{ role: "user", content: input }] : [];
+  }
+  return Array.isArray(input) ? input : [];
+}
+function hasBedrockText(block) {
+  return isPlainRecord(block) && typeof block.text === "string" && block.text.trim().length > 0;
+}
+function hasText(content) {
+  if (typeof content === "string") return content.trim().length > 0;
+  if (!Array.isArray(content)) return false;
+  return content.some((part) => isPlainRecord(part) && typeof part.text === "string" && part.text.trim().length > 0);
+}
+function stripCacheMarkers(value) {
+  return stripValue(value);
+}
+function stripValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => stripValue(item)).filter((item) => !(isPlainRecord(item) && Object.keys(item).length === 0));
+  }
+  if (!isPlainRecord(value)) return value;
+  const next = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (key === "prompt_cache_breakpoint" || key === "cache_control" || key === "cachePoint") continue;
+    if (key === "prompt_cache_key" || key === "prompt_cache_options") continue;
+    next[key] = stripValue(child);
+  }
+  return next;
+}
+function omitKey(body, key) {
+  const next = { ...body };
+  delete next[key];
+  return next;
+}
+function isPlainRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+// src/cache-profiles.ts
+var TTL_MINUTES = { "5m": 5, "30m": 30, "1h": 60 };
+var TTL_SECONDS = { "5m": 300, "30m": 1800, "1h": 3600 };
+var OPENAI_EXPLICIT = {
+  dialect: "openai-responses",
+  ttlOptions: ["30m"],
+  defaultTtl: "30m"
+};
+var OPENAI_IMPLICIT = {
+  dialect: "implicit-native",
+  ttlOptions: ["30m"],
+  defaultTtl: "30m"
+};
+var ANTHROPIC_EXPLICIT = {
+  dialect: "anthropic-cache-control",
+  ttlOptions: ["5m", "1h"],
+  defaultTtl: "5m"
+};
+var QWEN_EXPLICIT = {
+  dialect: "anthropic-cache-control",
+  ttlOptions: ["5m"],
+  defaultTtl: "5m"
+};
+var BEDROCK_EXPLICIT = {
+  dialect: "bedrock-cachepoint",
+  ttlOptions: ["5m", "1h"],
+  defaultTtl: "5m"
+};
+var ROUTER_IMPLICIT = {
+  dialect: "implicit-native",
+  ttlOptions: ["5m"],
+  defaultTtl: "5m"
+};
+function resolvePromptCache(input) {
+  const mode = normalizeMode(input.policy.mode);
+  const key = input.policy.key?.trim() || void 0;
+  const requestedTtl = normalizeTtl(input.policy.ttl);
+  const model = input.effectiveModel.trim();
+  const resolutionBase = {
+    mode,
+    target: input.target,
+    requestedModel: input.requestedModel,
+    effectiveModel: input.effectiveModel,
+    keyPresent: Boolean(key)
+  };
+  if (input.target === "cloudflare") {
+    return resolveCloudflarePromptCache({ input, mode, key, requestedTtl, resolutionBase, model });
+  }
+  if (mode === "disabled") {
+    return {
+      plan: emptyPlan(mode, "none", key, true),
+      resolution: { ...resolutionBase, outcome: "ignored" },
+      warnings: []
+    };
+  }
+  if (input.policy.mode !== void 0 && mode === "explicit" && !isCacheMode(input.policy.mode)) {
+    return ignored(input, resolutionBase, key, "CACHE_UNSUPPORTED", "cache.mode is not auto, explicit, or disabled. The call still runs without cache markers.");
+  }
+  const matched = matchProfile(input.target, model);
+  if (!matched.profile) {
+    return ignored(
+      input,
+      resolutionBase,
+      key,
+      matched.code,
+      matched.message
+    );
+  }
+  return applyProfile({ input, mode, key, requestedTtl, resolutionBase, model, profile: matched.profile });
+}
+function resolveCloudflarePromptCache(args) {
+  const { input, mode, key, requestedTtl, resolutionBase, model } = args;
+  if (mode === "disabled") {
+    return {
+      plan: { ...emptyPlan(mode, "none", key, true), gateway: gatewayDirective(true, void 0, key) },
+      resolution: { ...resolutionBase, outcome: "applied" },
+      warnings: []
+    };
+  }
+  if (input.policy.mode !== void 0 && mode === "explicit" && !isCacheMode(input.policy.mode)) {
+    return ignored(input, resolutionBase, key, "CACHE_UNSUPPORTED", "cache.mode is not auto, explicit, or disabled. The call still runs without cache markers.");
+  }
+  const profile = matchCloudflareNative(input.cloudflareEndpoint, model);
+  if (!profile) {
+    return {
+      plan: {
+        mode,
+        dialect: "none",
+        placeBreakpoint: false,
+        sendOpenAiOptions: false,
+        stripMarkers: false,
+        gateway: gatewayDirective(false, requestedTtl, key),
+        ...requestedTtl ? { ttl: requestedTtl } : {},
+        ...key ? { key } : {}
+      },
+      resolution: {
+        ...resolutionBase,
+        outcome: "applied",
+        ...requestedTtl ? { ttl: requestedTtl } : {}
+      },
+      warnings: []
+    };
+  }
+  const resolved = applyProfile({ input, mode, key, requestedTtl, resolutionBase, model, profile });
+  const ttl = resolved.plan.ttl ?? requestedTtl;
+  return {
+    ...resolved,
+    plan: { ...resolved.plan, gateway: gatewayDirective(false, ttl, key) }
+  };
+}
+function applyProfile(args) {
+  const { input, mode, key, requestedTtl, resolutionBase, model, profile } = args;
+  const folded = foldTtl(requestedTtl, profile.ttlOptions, profile.defaultTtl);
+  const explicitDialect = profile.dialect === "openai-responses" || profile.dialect === "anthropic-cache-control" || profile.dialect === "bedrock-cachepoint";
+  if (mode === "explicit" && profile.dialect === "implicit-native") {
+    return ignored(
+      input,
+      resolutionBase,
+      key,
+      "CACHE_UNSUPPORTED",
+      "This model caches automatically and does not accept an explicit breakpoint. The call still runs."
+    );
+  }
+  if (mode === "auto" && explicitDialect && profile.dialect !== "openai-responses") {
+    return ignored(
+      input,
+      resolutionBase,
+      key,
+      "CACHE_UNSUPPORTED",
+      "This model only caches when an explicit breakpoint is set. Set cache.mode to explicit. The call still runs."
+    );
+  }
+  const warnings = [];
+  const sendsTtl = profile.dialect === "openai-responses" || mode === "explicit" && explicitDialect;
+  if (requestedTtl && folded.degraded && sendsTtl) {
+    warnings.push({
+      code: "CACHE_TTL_DEGRADED",
+      message: `cache.ttl "${requestedTtl}" is not supported for this model. Using "${folded.ttl}".`,
+      details: { requestedTtl, effectiveTtl: folded.ttl, target: input.target, model }
+    });
+  }
+  const placeBreakpoint = mode === "explicit" && explicitDialect;
+  const sendOpenAiOptions = profile.dialect === "openai-responses" && (mode === "explicit" || mode === "auto");
+  const outcome = folded.degraded && sendsTtl ? "degraded" : "applied";
+  return {
+    plan: {
+      mode,
+      dialect: profile.dialect,
+      placeBreakpoint,
+      sendOpenAiOptions,
+      stripMarkers: placeBreakpoint,
+      ...sendsTtl ? { ttl: folded.ttl } : {},
+      ...key ? { key } : {}
+    },
+    resolution: {
+      ...resolutionBase,
+      outcome,
+      ...sendsTtl ? { ttl: folded.ttl } : {}
+    },
+    warnings
+  };
+}
+function gatewayDirective(skip, ttl, key) {
+  return {
+    skip,
+    ...ttl ? { ttlSeconds: TTL_SECONDS[ttl] } : {},
+    ...key ? { key } : {}
+  };
+}
+function matchCloudflareNative(endpoint, model) {
+  const id = model.toLowerCase();
+  if (endpoint === "responses" && isGptExplicit(id)) return OPENAI_EXPLICIT;
+  if (endpoint === "responses" && isGptImplicit(id)) return OPENAI_IMPLICIT;
+  if (endpoint === "messages" && isClaude(id)) return ANTHROPIC_EXPLICIT;
+  return void 0;
+}
+function ignored(input, resolutionBase, key, code, message) {
+  return {
+    plan: emptyPlan(resolutionBase.mode, "none", key, false),
+    resolution: { ...resolutionBase, outcome: "ignored" },
+    warnings: [{
+      code,
+      message,
+      details: { target: input.target, model: input.effectiveModel.trim() }
+    }]
+  };
+}
+function emptyPlan(mode, dialect, key, stripMarkers) {
+  return {
+    mode,
+    dialect,
+    placeBreakpoint: false,
+    sendOpenAiOptions: false,
+    stripMarkers,
+    ...key ? { key } : {}
+  };
+}
+function matchProfile(target, model) {
+  const id = model.toLowerCase();
+  if (!id) {
+    return {
+      code: "CACHE_UNSUPPORTED",
+      message: "Prompt caching needs a model id. The call still runs without cache markers."
+    };
+  }
+  if (target === "bedrock") {
+    if (isOpenAiBedrockId(id)) {
+      return {
+        code: "CACHE_DIALECT_UNSUPPORTED",
+        message: "OpenAI models on Bedrock cache through the Responses API. This runtime sends Converse and does not add those markers. The call still runs."
+      };
+    }
+    if (isClaude(id) || isNova(id)) return { profile: BEDROCK_EXPLICIT, code: "", message: "" };
+    return {
+      code: "CACHE_UNSUPPORTED",
+      message: "This Bedrock model has no prompt-cache profile. The call still runs without cache markers."
+    };
+  }
+  if (target === "openai") {
+    if (isGptExplicit(id)) return { profile: OPENAI_EXPLICIT, code: "", message: "" };
+    if (isGptImplicit(id)) return { profile: OPENAI_IMPLICIT, code: "", message: "" };
+    return {
+      code: "CACHE_UNSUPPORTED",
+      message: "This OpenAI model has no prompt-cache profile. The call still runs without cache markers."
+    };
+  }
+  if (isClaude(id)) return { profile: ANTHROPIC_EXPLICIT, code: "", message: "" };
+  if (isQwen(id)) return { profile: QWEN_EXPLICIT, code: "", message: "" };
+  if (isGptExplicit(id)) return { profile: OPENAI_EXPLICIT, code: "", message: "" };
+  if (isGptImplicit(id) || isRouterImplicit(id)) return { profile: ROUTER_IMPLICIT, code: "", message: "" };
+  return {
+    code: "CACHE_UNSUPPORTED",
+    message: "This model has no prompt-cache profile. The call still runs without cache markers."
+  };
+}
+function foldTtl(requested, options, defaultTtl) {
+  if (!requested) return { ttl: defaultTtl, degraded: false };
+  if (options.includes(requested)) return { ttl: requested, degraded: false };
+  let best = defaultTtl;
+  let bestDistance = Math.abs(TTL_MINUTES[defaultTtl] - TTL_MINUTES[requested]);
+  for (const option of options) {
+    const distance = Math.abs(TTL_MINUTES[option] - TTL_MINUTES[requested]);
+    if (distance < bestDistance) {
+      best = option;
+      bestDistance = distance;
+    }
+  }
+  return { ttl: best, degraded: true };
+}
+function normalizeMode(mode) {
+  if (mode === "auto" || mode === "disabled") return mode;
+  return "explicit";
+}
+function isCacheMode(mode) {
+  return mode === "auto" || mode === "explicit" || mode === "disabled";
+}
+function normalizeTtl(ttl) {
+  if (ttl === "5m" || ttl === "30m" || ttl === "1h") return ttl;
+  return void 0;
+}
+function isGptExplicit(id) {
+  return /(?:^|\/)gpt-(?:5\.6|6)(?:[.\-:]|$)/i.test(id);
+}
+function isGptImplicit(id) {
+  if (isGptExplicit(id)) return false;
+  return /(?:^|\/)gpt(?:[.\-:]|$)/i.test(id) || /(?:^|\/)o[134](?:[.\-:]|$)/i.test(id);
+}
+function isClaude(id) {
+  return id.includes("claude") || id.startsWith("anthropic.") || id.startsWith("anthropic/");
+}
+function isQwen(id) {
+  return id.includes("qwen");
+}
+function isNova(id) {
+  return /(?:^|[./])nova(?:[.\-:]|$)/i.test(id) || id.includes("amazon.nova");
+}
+function isOpenAiBedrockId(id) {
+  return id.startsWith("openai.") || id.startsWith("openai/") || isGptExplicit(id) || isGptImplicit(id);
+}
+function isRouterImplicit(id) {
+  return /(?:^|\/)(gemini|google|deepseek|x-ai|xai|grok|moonshot|kimi)(?:[./:\-]|$)/i.test(id) || id.includes("gemini") || id.includes("deepseek");
+}
+
+// src/providers/cloudflare.ts
+var import_openrouter_runtime = require("@x12i/openrouter-runtime");
+var DEFAULT_BASE_URL = "https://api.cloudflare.com/client/v4";
+var DEFAULT_TIMEOUT_MS = 12e4;
+var DEFAULT_GATEWAY_ID = "default";
+function selectCloudflareEndpoint(input) {
+  if (input.endpoint && input.endpoint !== "auto") return input.endpoint;
+  if (input.apiMode === "chat") return "chat";
+  if (input.apiMode === "responses") return "responses";
+  const id = input.model.trim().toLowerCase();
+  if (id.startsWith("anthropic/")) return "messages";
+  if (id.startsWith("openai/") || isBareOpenAiModel(id)) return "responses";
+  return "chat";
+}
+function cloudflareCatalogQuery(model) {
+  const id = model.trim();
+  const lower = id.toLowerCase();
+  if (lower.startsWith("openai/")) {
+    const slash = id.indexOf("/");
+    return { target: "openai", model: id.slice(slash + 1), prefix: id.slice(0, slash + 1) };
+  }
+  if (isBareOpenAiModel(id)) return { target: "openai", model: id, prefix: "openai/" };
+  return { target: "openrouter", model: id };
+}
+function restoreCloudflareModel(model, prefix) {
+  if (!prefix || model.includes("/")) return model;
+  return `${prefix}${model}`;
+}
+function createCloudflareProviderAdapter(options = {}) {
+  const resolved = resolveCloudflareOptions(options);
+  return {
+    compile(request, call) {
+      return compileCloudflareRequest(request, resolved, call, false);
+    },
+    async run(request, call) {
+      const requestId = request.id ?? "cloudflare";
+      try {
+        return await runCloudflare(request, resolved, call, requestId);
+      } catch (error) {
+        if (error instanceof AiDispatcherError && isConfigError(error.code)) throw error;
+        return failedResponse(request, requestId, error, "chat");
+      }
+    },
+    executeStreamingChat(request, call) {
+      return streamCloudflare(request, resolved, call);
+    }
+  };
+}
+function compileCloudflareRequest(request, options, call, streaming) {
+  assertSupported(request);
+  assertCredentials(options);
+  const model = (request.model ?? options.defaultModel ?? "").trim();
+  if (!model) {
+    throw new AiDispatcherError(
+      "MODEL_REQUIRED",
+      "A model id is required. Set request.model or cloudflare.defaultModel."
+    );
+  }
+  const endpoint = call?.cloudflare?.endpoint ?? selectCloudflareEndpoint({
+    model,
+    ...options.endpoint ? { endpoint: options.endpoint } : {},
+    ...request.apiMode ? { apiMode: request.apiMode } : {}
+  });
+  if (streaming && endpoint === "run") {
+    throw new AiDispatcherError(
+      "UNSUPPORTED_REQUEST_FIELD",
+      "Cloudflare /ai/run does not stream. Use chat, responses, or messages, or call run()."
+    );
+  }
+  if ((endpoint === "messages" || endpoint === "run") && request.responseFormat !== void 0) {
+    throw new AiDispatcherError(
+      "UNSUPPORTED_REQUEST_FIELD",
+      "responseFormat is supported on Cloudflare chat and responses, not on messages or run."
+    );
+  }
+  const run = endpoint === "run" ? call?.cloudflare?.run : void 0;
+  assertRunOptions(run);
+  let body = endpoint === "responses" ? compileResponsesBody(request, model) : endpoint === "messages" ? compileMessagesBody(request, model) : compileChatBody(request, model);
+  if (call?.finalizeBody) body = call.finalizeBody(body);
+  if (endpoint !== "run") body = { ...body, stream: streaming };
+  const gateway = mergeGateway(options.gateway, call?.cloudflare?.gateway);
+  const fromBody = isRecord5(body.metadata) ? body.metadata : void 0;
+  const record2 = (0, import_openrouter_runtime.toProviderMetadata)(
+    request.metadata,
+    request.agentId,
+    import_openrouter_runtime.OPENROUTER_METADATA_LIMITS,
+    overlayMetadata(gateway?.metadata, fromBody)
+  );
+  body = applyProviderRecord(body, record2);
+  if (endpoint === "run") body = wrapRun(body, run);
+  return {
+    endpoint,
+    url: endpointUrl(options, endpoint),
+    headers: buildHeaders(options, call?.cloudflare, model, record2),
+    body,
+    warnings: []
+  };
+}
+function compileResponsesBody(request, model) {
+  const instructions = compileInstructions(request);
+  const input = compileResponsesInput(request);
+  if (input === void 0) {
+    throw new AiDispatcherError("INPUT_REQUIRED", "Provide request.messages, request.input, or request.prompt.");
+  }
+  return clean({
+    model,
+    input,
+    instructions,
+    temperature: request.temperature,
+    max_output_tokens: request.maxTokens,
+    reasoning: request.reasoning,
+    text: request.responseFormat,
+    tools: compileResponsesTools(request),
+    tool_choice: compileResponsesToolChoice(request)
+  });
+}
+function compileChatBody(request, model) {
+  const messages = compileChatMessages(request);
+  if (!messages.length) {
+    throw new AiDispatcherError("INPUT_REQUIRED", "Provide request.messages, request.input, or request.prompt.");
+  }
+  return clean({
+    model,
+    messages,
+    temperature: request.temperature,
+    max_tokens: request.maxTokens,
+    reasoning: request.reasoning,
+    response_format: request.responseFormat,
+    tools: compileChatTools(request),
+    tool_choice: compileChatToolChoice(request)
+  });
+}
+function compileMessagesBody(request, model) {
+  const system = compileInstructions(request);
+  const messages = compileAnthropicMessages(request);
+  if (!messages.length) {
+    throw new AiDispatcherError("INPUT_REQUIRED", "Provide request.messages, request.input, or request.prompt.");
+  }
+  return clean({
+    model,
+    system,
+    messages,
+    temperature: request.temperature,
+    max_tokens: request.maxTokens,
+    tools: compileAnthropicTools(request),
+    tool_choice: compileAnthropicToolChoice(request)
+  });
+}
+function wrapRun(body, run) {
+  const model = body.model;
+  const input = { ...body };
+  delete input.model;
+  delete input.stream;
+  return clean({
+    model,
+    input,
+    options: runOptions(run)
+  });
+}
+function runOptions(run) {
+  if (!run) return void 0;
+  return clean({
+    background: run.background,
+    webhookUrl: run.webhookUrl,
+    webhookFormat: run.webhookFormat
+  });
+}
+function assertRunOptions(run) {
+  if (!run) return;
+  if (run.webhookUrl && run.background !== true) {
+    throw new AiDispatcherError(
+      "UNSUPPORTED_REQUEST_FIELD",
+      "Cloudflare webhookUrl requires run.background to be true."
+    );
+  }
+  if (run.webhookFormat && !run.webhookUrl) {
+    throw new AiDispatcherError(
+      "UNSUPPORTED_REQUEST_FIELD",
+      "Cloudflare webhookFormat requires run.webhookUrl."
+    );
+  }
+}
+function assertSupported(request) {
+  if (request.serverTools && serverToolsEnabled(request.serverTools)) {
+    throw new AiDispatcherError(
+      "UNSUPPORTED_REQUEST_FIELD",
+      "Cloudflare does not support OpenRouter server tools."
+    );
+  }
+  if (request.rawOpenRouterOverrides !== void 0) {
+    throw new AiDispatcherError(
+      "UNSUPPORTED_REQUEST_FIELD",
+      "rawOpenRouterOverrides cannot be sent to Cloudflare."
+    );
+  }
+  if (request.toolChoice && typeof request.toolChoice === "object" && request.toolChoice.type === "server_tool") {
+    throw new AiDispatcherError(
+      "UNSUPPORTED_REQUEST_FIELD",
+      "Cloudflare does not support OpenRouter server tool choices."
+    );
+  }
+}
+function assertCredentials(options) {
+  if (!options.apiToken) {
+    throw new AiDispatcherError(
+      "CLOUDFLARE_API_TOKEN_MISSING",
+      "Cloudflare API token is required. Set cloudflare.apiToken or CLOUDFLARE_API_TOKEN."
+    );
+  }
+  if (!options.accountId) {
+    throw new AiDispatcherError(
+      "CLOUDFLARE_ACCOUNT_ID_MISSING",
+      "Cloudflare account id is required. Set cloudflare.accountId or CLOUDFLARE_ACCOUNT_ID."
+    );
+  }
+}
+function serverToolsEnabled(policy) {
+  return Object.values(policy).some((value) => {
+    if (Array.isArray(value)) return value.some((item) => isEnabledMode(item));
+    return isEnabledMode(value);
+  });
+}
+function isEnabledMode(value) {
+  return typeof value === "object" && value !== null && "mode" in value && value.mode !== "disabled";
+}
+function compileInstructions(request) {
+  if (request.instructions) return request.instructions;
+  if (request.system) return request.system;
+  const systemMessages = (request.messages ?? []).filter((message) => message.role === "system");
+  if (!systemMessages.length) return void 0;
+  return systemMessages.map((message) => contentToText(message.content)).filter(Boolean).join("\n");
+}
+function compileResponsesInput(request) {
+  if (request.input !== void 0) return request.input;
+  const items = [];
+  for (const message of request.messages ?? []) {
+    if (message.role === "system") continue;
+    items.push(compileResponsesItem(message));
+  }
+  if (typeof request.prompt === "string") items.push({ role: "user", content: request.prompt });
+  return items.length ? items : void 0;
+}
+function compileResponsesItem(message) {
+  if (message.role === "tool") {
+    return {
+      type: "function_call_output",
+      call_id: message.toolCallId ?? message.name ?? "tool",
+      output: contentToText(message.content)
+    };
+  }
+  const role = message.role === "assistant" ? "assistant" : "user";
+  return { role, content: compileResponsesContent(message.content) };
+}
+function compileResponsesContent(content) {
+  if (typeof content === "string") return content;
+  return content.map((part) => {
+    if (part.type === "text") return { type: "input_text", text: part.text };
+    if (part.type === "image_url") return { type: "input_image", image_url: part.imageUrl };
+    return compileFilePart(part, "responses");
+  });
+}
+function compileChatMessages(request) {
+  assertExclusiveInput(request);
+  const messages = [];
+  const system = compileInstructions(request);
+  if (system) messages.push({ role: "system", content: system });
+  for (const message of dialogueMessages(request)) messages.push(compileChatMessage(message));
+  return messages;
+}
+function compileChatMessage(message) {
+  if (message.role === "tool") {
+    return {
+      role: "tool",
+      tool_call_id: message.toolCallId ?? message.name ?? "tool",
+      content: contentToText(message.content)
+    };
+  }
+  return {
+    role: message.role === "assistant" ? "assistant" : "user",
+    content: compileChatContent(message.content)
+  };
+}
+function compileChatContent(content) {
+  if (typeof content === "string") return content;
+  return content.map((part) => {
+    if (part.type === "text") return { type: "text", text: part.text };
+    if (part.type === "image_url") return { type: "image_url", image_url: { url: part.imageUrl } };
+    const file = compileFilePart(part, "chat");
+    return file;
+  });
+}
+function compileAnthropicMessages(request) {
+  assertExclusiveInput(request);
+  return dialogueMessages(request).map(compileAnthropicMessage);
+}
+function compileAnthropicMessage(message) {
+  if (message.role === "tool") {
+    return {
+      role: "user",
+      content: [{
+        type: "tool_result",
+        tool_use_id: message.toolCallId ?? message.name ?? "tool",
+        content: contentToText(message.content)
+      }]
+    };
+  }
+  const role = message.role === "assistant" ? "assistant" : "user";
+  return { role, content: compileAnthropicContent(message.content) };
+}
+function compileAnthropicContent(content) {
+  if (typeof content === "string") return content;
+  return content.map((part) => {
+    if (part.type === "text") return { type: "text", text: part.text };
+    if (part.type === "image_url") return anthropicImage(part.imageUrl);
+    return anthropicFile(part);
+  });
+}
+function dialogueMessages(request) {
+  const source = request.messages?.length ? request.messages.filter((message) => message.role !== "system") : messagesFromInput(request);
+  if (typeof request.prompt === "string" && request.messages?.length) {
+    return [...source, { role: "user", content: request.prompt }];
+  }
+  if (!source.length && typeof request.prompt === "string") return [{ role: "user", content: request.prompt }];
+  return source;
+}
+function messagesFromInput(request) {
+  if (typeof request.input === "string") return [{ role: "user", content: request.input }];
+  if (!Array.isArray(request.input)) return [];
+  const messages = [];
+  for (const item of request.input) {
+    if (typeof item === "string") {
+      messages.push({ role: "user", content: item });
+      continue;
+    }
+    if (!isRecord5(item)) continue;
+    const role = item.role === "assistant" || item.role === "tool" || item.role === "system" ? item.role : "user";
+    if (role === "system") continue;
+    const content = inputContent(item.content);
+    if (content === void 0) continue;
+    const message = { role, content };
+    if (typeof item.toolCallId === "string") message.toolCallId = item.toolCallId;
+    if (typeof item.name === "string") message.name = item.name;
+    messages.push(message);
+  }
+  return messages;
+}
+function inputContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return void 0;
+  const parts = [];
+  for (const part of content) {
+    if (!isRecord5(part)) continue;
+    if ((part.type === "text" || part.type === "input_text") && typeof part.text === "string") {
+      parts.push({ type: "text", text: part.text });
+    } else if (part.type === "image_url" && typeof part.imageUrl === "string") {
+      parts.push({ type: "image_url", imageUrl: part.imageUrl });
+    } else if (part.type === "image_url" && isRecord5(part.image_url) && typeof part.image_url.url === "string") {
+      parts.push({ type: "image_url", imageUrl: part.image_url.url });
+    } else if (part.type === "input_image" && typeof part.image_url === "string") {
+      parts.push({ type: "image_url", imageUrl: part.image_url });
+    }
+  }
+  return parts.length ? parts : void 0;
+}
+function assertExclusiveInput(request) {
+  const hasMessages2 = Array.isArray(request.messages) && request.messages.length > 0;
+  if (hasMessages2 && request.input !== void 0) {
+    throw new AiDispatcherError(
+      "UNSUPPORTED_REQUEST_FIELD",
+      "Cloudflare chat, messages, and run accept messages or input, not both."
+    );
+  }
+}
+function compileFilePart(part, dialect) {
+  if (part.type !== "file") {
+    throw new AiDispatcherError("UNSUPPORTED_REQUEST_FIELD", "File content parts need a url or data.");
+  }
+  if (!part.url && !part.data) {
+    throw new AiDispatcherError("UNSUPPORTED_REQUEST_FIELD", "File content parts need a url or data.");
+  }
+  if (dialect === "responses") {
+    if (part.url) return clean({ type: "input_file", file_url: part.url, filename: part.fileName });
+    return clean({ type: "input_file", file_data: part.data, filename: part.fileName });
+  }
+  return {
+    type: "file",
+    file: clean({
+      filename: part.fileName,
+      ...part.url ? { url: part.url } : {},
+      ...part.data ? { file_data: part.data } : {}
+    })
+  };
+}
+function anthropicImage(imageUrl) {
+  const data = dataUrl(imageUrl);
+  if (data) return { type: "image", source: { type: "base64", media_type: data.mediaType, data: data.data } };
+  return { type: "image", source: { type: "url", url: imageUrl } };
+}
+function anthropicFile(part) {
+  if (part.type !== "file" || !part.url && !part.data) {
+    throw new AiDispatcherError("UNSUPPORTED_REQUEST_FIELD", "File content parts need a url or data.");
+  }
+  if (part.url) {
+    const data = dataUrl(part.url);
+    if (data) return { type: "document", source: { type: "base64", media_type: data.mediaType, data: data.data } };
+    return { type: "document", source: { type: "url", url: part.url } };
+  }
+  return {
+    type: "document",
+    source: {
+      type: "base64",
+      media_type: part.mimeType || "application/octet-stream",
+      data: part.data
+    }
+  };
+}
+function dataUrl(value) {
+  const match = /^data:([^;,]+);base64,([\s\S]+)$/i.exec(value);
+  if (!match) return void 0;
+  return { mediaType: match[1] ?? "application/octet-stream", data: match[2] ?? "" };
+}
+function compileResponsesTools(request) {
+  const tools = request.functionTools ?? [];
+  if (!tools.length || request.toolChoice === "none") return void 0;
+  return tools.map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters
+  }));
+}
+function compileChatTools(request) {
+  const tools = request.functionTools ?? [];
+  if (!tools.length || request.toolChoice === "none") return void 0;
+  return tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    }
+  }));
+}
+function compileAnthropicTools(request) {
+  const tools = request.functionTools ?? [];
+  if (!tools.length || request.toolChoice === "none") return void 0;
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.parameters
+  }));
+}
+function compileResponsesToolChoice(request) {
+  if (!request.functionTools?.length || request.toolChoice === "none") return void 0;
+  const choice = request.toolChoice;
+  if (!choice || choice === "auto") return void 0;
+  if (choice === "required") return "required";
+  if (typeof choice === "object" && choice.type === "function") return { type: "function", name: choice.functionName };
+  return void 0;
+}
+function compileChatToolChoice(request) {
+  if (!request.functionTools?.length || request.toolChoice === "none") return void 0;
+  const choice = request.toolChoice;
+  if (!choice || choice === "auto") return void 0;
+  if (choice === "required") return "required";
+  if (typeof choice === "object" && choice.type === "function") {
+    return { type: "function", function: { name: choice.functionName } };
+  }
+  return void 0;
+}
+function compileAnthropicToolChoice(request) {
+  if (!request.functionTools?.length || request.toolChoice === "none") return void 0;
+  const choice = request.toolChoice;
+  if (!choice || choice === "auto") return void 0;
+  if (choice === "required") return { type: "any" };
+  if (typeof choice === "object" && choice.type === "function") return { type: "tool", name: choice.functionName };
+  return void 0;
+}
+function contentToText(content) {
+  if (typeof content === "string") return content;
+  return content.map((part) => part.type === "text" ? part.text : "").filter(Boolean).join("");
+}
+async function runCloudflare(request, options, call, requestId) {
+  const maxIterations = request.execution?.maxToolIterations ?? 8;
+  const maxFunctionToolCalls = request.execution?.maxFunctionToolCalls ?? 20;
+  const functionUsage = [];
+  let active;
+  try {
+    active = compileCloudflareRequest(request, options, call, false);
+  } catch (error) {
+    if (error instanceof AiDispatcherError && isConfigError(error.code)) throw error;
+    return failedResponse(request, requestId, error, "chat");
+  }
+  let response;
+  try {
+    for (let iteration = 0; iteration <= maxIterations; iteration += 1) {
+      response = await sendWithRetries(active, options, timeoutFor(request, options));
+      if (active.endpoint === "run" && !chatCalls(unwrap(response)).length) break;
+      const calls = extractCalls(active.endpoint, response);
+      if (!calls.length) break;
+      if (!calls.every((item) => resolveExecutor(item.name, request, options))) {
+        return normalizeCloudflareResponse({
+          request,
+          requestId,
+          compiled: active,
+          response,
+          functionTools: [...functionUsage, ...calls],
+          status: "requires_action"
+        });
+      }
+      if (functionUsage.length + calls.length > maxFunctionToolCalls) {
+        throw new AiDispatcherError("FUNCTION_TOOL_LIMIT", "maxFunctionToolCalls exceeded.");
+      }
+      const results = [];
+      for (const item of calls) results.push(await executeTool(item, request, options));
+      functionUsage.push(...results);
+      active = { ...active, body: continueBody(active, response, results) };
+    }
+    return normalizeCloudflareResponse({
+      request,
+      requestId,
+      compiled: active,
+      response,
+      functionTools: functionUsage,
+      status: "completed"
+    });
+  } catch (error) {
+    if (error instanceof AiDispatcherError && isConfigError(error.code)) throw error;
+    return failedResponse(request, requestId, error, responseApiMode(active.endpoint));
+  }
+}
+function continueBody(compiled, response, results) {
+  if (compiled.endpoint === "responses") return continueResponses(compiled.body, response, results);
+  if (compiled.endpoint === "messages") return continueMessages(compiled.body, response, results);
+  if (compiled.endpoint === "run") return continueRun(compiled.body, response, results);
+  return continueChat(compiled.body, response, results);
+}
+function continueResponses(body, response, results) {
+  const record2 = unwrap(response);
+  return clean({
+    ...body,
+    tool_choice: "auto",
+    previous_response_id: typeof record2.id === "string" ? record2.id : void 0,
+    input: results.map(toFunctionCallOutput)
+  });
+}
+function continueChat(body, response, results) {
+  const messages = Array.isArray(body.messages) ? [...body.messages] : [];
+  const assistant = chatAssistantMessage(unwrap(response));
+  if (assistant) messages.push(assistant);
+  for (const result of results) {
+    messages.push({
+      role: "tool",
+      tool_call_id: result.callId,
+      content: outputText(result)
+    });
+  }
+  return { ...body, messages, ...body.tool_choice !== void 0 ? { tool_choice: "auto" } : {} };
+}
+function continueMessages(body, response, results) {
+  const messages = Array.isArray(body.messages) ? [...body.messages] : [];
+  const record2 = unwrap(response);
+  messages.push({ role: "assistant", content: Array.isArray(record2.content) ? record2.content : [] });
+  messages.push({
+    role: "user",
+    content: results.map((result) => ({
+      type: "tool_result",
+      tool_use_id: result.callId,
+      content: outputText(result),
+      ...result.status === "failed" ? { is_error: true } : {}
+    }))
+  });
+  return { ...body, messages };
+}
+function continueRun(body, response, results) {
+  const input = isRecord5(body.input) ? body.input : {};
+  const continued = continueChat({ messages: input.messages }, response, results);
+  return { ...body, input: { ...input, messages: continued.messages } };
+}
+function toFunctionCallOutput(result) {
+  return {
+    type: "function_call_output",
+    call_id: result.callId,
+    output: outputText(result)
+  };
+}
+function outputText(result) {
+  const output = result.status === "completed" ? result.result : { error: result.error };
+  return typeof output === "string" ? output : JSON.stringify(output);
+}
+function resolveExecutor(name, request, options) {
+  return request.functionTools?.find((tool) => tool.name === name)?.executor ?? options.tools?.[name];
+}
+async function executeTool(call, request, options) {
+  const executor = resolveExecutor(call.name, request, options);
+  if (!executor) return call;
+  const started = Date.now();
+  try {
+    options.logger?.debug?.("runtime.function_tool.started", { name: call.name, callId: call.callId });
+    const result = await executor(call.args, {
+      requestId: request.id ?? "",
+      toolName: call.name,
+      callId: call.callId,
+      ...request.metadata ? { metadata: request.metadata } : {}
+    });
+    const usage = {
+      name: call.name,
+      callId: call.callId,
+      status: "completed",
+      args: call.args,
+      result,
+      durationMs: Date.now() - started
+    };
+    options.logger?.debug?.("runtime.function_tool.completed", { name: call.name, callId: call.callId });
+    return usage;
+  } catch (error) {
+    const usage = {
+      name: call.name,
+      callId: call.callId,
+      status: "failed",
+      args: call.args,
+      error: error instanceof Error ? error.message : String(error),
+      durationMs: Date.now() - started
+    };
+    options.logger?.warn?.("runtime.function_tool.failed", usage);
+    return usage;
+  }
+}
+async function* streamCloudflare(request, options, call) {
+  const requestId = request.id ?? "";
+  let compiled;
+  try {
+    compiled = compileCloudflareRequest(request, options, call, true);
+  } catch (error) {
+    yield errorEvent(requestId, error);
+    throw error;
+  }
+  yield {
+    type: "stream.start",
+    requestId,
+    data: {
+      model: modelOf(compiled),
+      apiMode: responseApiMode(compiled.endpoint),
+      entrypoint: "executeStreamingChat"
+    }
+  };
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutFor(request, options));
+  let text = "";
+  let reported = false;
+  try {
+    const response = await options.fetch(compiled.url, {
+      method: "POST",
+      headers: { ...compiled.headers, Accept: "text/event-stream" },
+      body: JSON.stringify(compiled.body),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      const failure = await readFailure(response);
+      reported = true;
+      yield errorEvent(requestId, failure);
+      throw failure;
+    }
+    for await (const event of parseSse(response)) {
+      if (!isRecord5(event)) continue;
+      const catalogReasoning = call?.extractStreamReasoning?.(event);
+      const reasoningText = catalogReasoning || reasoningDelta(event);
+      if (reasoningText) yield { type: "stream.reasoning.delta", requestId, data: { text: reasoningText } };
+      const delta = textDelta(event);
+      if (delta) {
+        text += delta;
+        yield { type: "stream.text.delta", requestId, data: { text: delta } };
+      }
+      const toolDelta = toolCallDelta(event);
+      if (toolDelta) yield { type: "stream.tool_call.delta", requestId, data: toolDelta };
+      const usage = streamUsage(event);
+      if (usage) yield { type: "stream.usage", requestId, data: { usage } };
+      if (event.type === "error") {
+        const failure = new AiDispatcherError(
+          "PROVIDER_REQUEST_FAILED",
+          typeof event.message === "string" ? event.message : "Cloudflare stream returned an error event.",
+          event
+        );
+        reported = true;
+        yield errorEvent(requestId, failure);
+        throw failure;
+      }
+    }
+    yield { type: "stream.done", requestId, data: { text, model: modelOf(compiled) } };
+  } catch (error) {
+    const failure = error instanceof Error && error.name === "AbortError" ? new AiDispatcherError("PROVIDER_GATEWAY_UNREACHABLE", "Cloudflare request timed out.") : error instanceof AiDispatcherError ? error : new AiDispatcherError(
+      "PROVIDER_GATEWAY_UNREACHABLE",
+      error instanceof Error ? error.message : "Cloudflare request failed before receiving a response."
+    );
+    if (!reported) yield errorEvent(requestId, failure);
+    throw failure;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function sendWithRetries(compiled, options, timeoutMs) {
+  let lastError;
+  for (let attempt = 1; attempt <= options.maxAttempts; attempt += 1) {
+    try {
+      return await sendOnce(compiled, options, timeoutMs);
+    } catch (error) {
+      lastError = error;
+      const retryable = error instanceof AiDispatcherError && error.code === "PROVIDER_RETRYABLE";
+      if (!retryable || attempt >= options.maxAttempts) throw asTerminalError(error);
+      await delay(Math.min(500 * 2 ** (attempt - 1), 5e3));
+    }
+  }
+  throw lastError;
+}
+async function sendOnce(compiled, options, timeoutMs) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await options.fetch(compiled.url, {
+      method: "POST",
+      headers: compiled.headers,
+      body: JSON.stringify(compiled.body),
+      signal: controller.signal
+    });
+    if (!response.ok) throw await readFailure(response);
+    const text = await response.text();
+    const parsed = text ? JSON.parse(text) : {};
+    if (isRecord5(parsed) && parsed.success === false) {
+      throw new AiDispatcherError(
+        "PROVIDER_REQUEST_FAILED",
+        messageFrom(parsed) ?? "Cloudflare request failed.",
+        { body: parsed }
+      );
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof AiDispatcherError) throw error;
+    if (error instanceof SyntaxError) {
+      throw new AiDispatcherError("PROVIDER_REQUEST_FAILED", "Cloudflare returned a response that was not JSON.");
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new AiDispatcherError("PROVIDER_GATEWAY_UNREACHABLE", "Cloudflare request timed out.");
+    }
+    throw new AiDispatcherError(
+      "PROVIDER_GATEWAY_UNREACHABLE",
+      error instanceof Error ? error.message : "Cloudflare request failed before receiving a response."
+    );
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function readFailure(response) {
+  const text = await response.text();
+  let body = text;
+  try {
+    body = text ? JSON.parse(text) : void 0;
+  } catch {
+    body = text;
+  }
+  const message = messageFrom(body) ?? `Cloudflare request failed with status ${response.status}.`;
+  const retryable = response.status === 429 || response.status === 408 || response.status >= 500;
+  return new AiDispatcherError(classifyStatus(response.status), message, {
+    status: response.status,
+    body,
+    retryable
+  });
+}
+function classifyStatus(status) {
+  if (status === 401 || status === 403) return "PROVIDER_AUTH_FAILED";
+  if (status === 404) return "PROVIDER_MODEL_NOT_FOUND";
+  if (status === 429 || status === 408 || status >= 500) return "PROVIDER_RETRYABLE";
+  return "PROVIDER_REQUEST_FAILED";
+}
+function isConfigError(code) {
+  return code === "CLOUDFLARE_API_TOKEN_MISSING" || code === "CLOUDFLARE_ACCOUNT_ID_MISSING" || code === "MODEL_REQUIRED" || code === "INPUT_REQUIRED" || code === "UNSUPPORTED_REQUEST_FIELD";
+}
+function asTerminalError(error) {
+  if (error instanceof AiDispatcherError && error.code === "PROVIDER_RETRYABLE") {
+    const status = isRecord5(error.details) ? error.details.status : void 0;
+    if (status === 429) return new AiDispatcherError("PROVIDER_RATE_LIMITED", error.message, error.details);
+    return new AiDispatcherError("PROVIDER_GATEWAY_UNREACHABLE", error.message, error.details);
+  }
+  if (error instanceof AiDispatcherError) return error;
+  return new AiDispatcherError("PROVIDER_REQUEST_FAILED", error instanceof Error ? error.message : String(error));
+}
+function normalizeCloudflareResponse(params) {
+  const payload = unwrap(params.response);
+  const calls = params.functionTools ?? extractCalls(params.compiled.endpoint, params.response);
+  const usage = normalizeUsage(payload.usage) ?? normalizeUsage(isRecord5(params.response) ? params.response.usage : void 0);
+  const status = params.status ?? (calls.length ? "requires_action" : "completed");
+  return {
+    id: typeof payload.id === "string" ? payload.id : params.requestId,
+    status,
+    apiMode: responseApiMode(params.compiled.endpoint),
+    model: typeof payload.model === "string" ? payload.model : modelOf(params.compiled),
+    text: answerText(payload),
+    citations: [],
+    images: [],
+    patches: [],
+    toolUsage: emptyToolUsage(calls),
+    ...usage ? { usage } : {},
+    warnings: params.compiled.warnings,
+    errors: [],
+    raw: { request: params.compiled.body, response: params.response },
+    ...params.request.metadata ? { metadata: params.request.metadata } : {}
+  };
+}
+function responseApiMode(endpoint) {
+  return endpoint === "responses" ? "responses" : "chat";
+}
+function answerText(response) {
+  if (typeof response.output_text === "string") return response.output_text;
+  if (typeof response.text === "string" && !Array.isArray(response.choices) && !Array.isArray(response.content)) {
+    return response.text;
+  }
+  const responses = responsesAnswer(response);
+  if (responses) return responses;
+  const chat = chatAnswer(response);
+  if (chat) return chat;
+  const anthropic = anthropicAnswer(response);
+  if (anthropic) return anthropic;
+  if (isRecord5(response.result)) return answerText(response.result);
+  return "";
+}
+function responsesAnswer(response) {
+  if (!Array.isArray(response.output)) return "";
+  const parts = [];
+  for (const item of response.output) {
+    if (!isRecord5(item) || item.type !== "message" || !Array.isArray(item.content)) continue;
+    for (const part of item.content) {
+      if (isRecord5(part) && part.type === "output_text" && typeof part.text === "string") parts.push(part.text);
+    }
+  }
+  return parts.join("");
+}
+function chatAnswer(response) {
+  const message = chatAssistantMessage(response);
+  if (!message) return "";
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => isRecord5(part) && typeof part.text === "string" ? part.text : "").filter(Boolean).join("");
+}
+function anthropicAnswer(response) {
+  if (!Array.isArray(response.content)) return "";
+  return response.content.map((part) => isRecord5(part) && part.type === "text" && typeof part.text === "string" ? part.text : "").filter(Boolean).join("");
+}
+function chatAssistantMessage(response) {
+  if (!Array.isArray(response.choices) || !isRecord5(response.choices[0])) return void 0;
+  const message = response.choices[0].message;
+  return isRecord5(message) ? message : void 0;
+}
+function extractCalls(endpoint, response) {
+  const record2 = unwrap(response);
+  if (endpoint === "responses") return responsesCalls(record2);
+  if (endpoint === "messages") return anthropicCalls(record2);
+  return chatCalls(record2);
+}
+function responsesCalls(response) {
+  if (!Array.isArray(response.output)) return [];
+  const calls = [];
+  for (const item of response.output) {
+    if (!isRecord5(item) || item.type !== "function_call") continue;
+    calls.push(callUsage(
+      typeof item.name === "string" ? item.name : "function",
+      typeof item.call_id === "string" ? item.call_id : "function",
+      item.arguments
+    ));
+  }
+  return calls;
+}
+function chatCalls(response) {
+  const message = chatAssistantMessage(response);
+  if (!message || !Array.isArray(message.tool_calls)) return [];
+  const calls = [];
+  for (const item of message.tool_calls) {
+    if (!isRecord5(item) || !isRecord5(item.function)) continue;
+    const name = typeof item.function.name === "string" ? item.function.name : "function";
+    calls.push(callUsage(
+      name,
+      typeof item.id === "string" ? item.id : name,
+      item.function.arguments
+    ));
+  }
+  return calls;
+}
+function anthropicCalls(response) {
+  if (!Array.isArray(response.content)) return [];
+  const calls = [];
+  for (const item of response.content) {
+    if (!isRecord5(item) || item.type !== "tool_use") continue;
+    const name = typeof item.name === "string" ? item.name : "function";
+    calls.push({
+      name,
+      callId: typeof item.id === "string" ? item.id : name,
+      status: "completed",
+      args: item.input
+    });
+  }
+  return calls;
+}
+function callUsage(name, callId, rawArgs) {
+  let args = rawArgs;
+  if (typeof rawArgs === "string") {
+    try {
+      args = JSON.parse(rawArgs);
+    } catch {
+      args = rawArgs;
+    }
+  }
+  return { name, callId, status: "completed", args };
+}
+function emptyToolUsage(calls) {
+  const unused = { requested: false, required: false, used: false };
+  return {
+    serverTools: {
+      webSearch: unused,
+      webFetch: unused,
+      datetime: unused,
+      imageGeneration: unused,
+      applyPatch: unused,
+      fusion: unused,
+      advisor: unused,
+      subagent: unused
+    },
+    functionTools: calls
+  };
+}
+function normalizeUsage(usage) {
+  if (!isRecord5(usage)) return void 0;
+  const inputTokens = numberValue(usage.input_tokens) ?? numberValue(usage.prompt_tokens);
+  const outputTokens = numberValue(usage.output_tokens) ?? numberValue(usage.completion_tokens);
+  const totalTokens = numberValue(usage.total_tokens) ?? (inputTokens !== void 0 || outputTokens !== void 0 ? (inputTokens ?? 0) + (outputTokens ?? 0) : void 0);
+  if (inputTokens === void 0 && outputTokens === void 0 && totalTokens === void 0) return { raw: usage };
+  return {
+    raw: usage,
+    ...inputTokens !== void 0 ? { inputTokens } : {},
+    ...outputTokens !== void 0 ? { outputTokens } : {},
+    ...totalTokens !== void 0 ? { totalTokens } : {}
+  };
+}
+function failedResponse(request, requestId, error, apiMode) {
+  const normalized = error instanceof AiDispatcherError ? error : new AiDispatcherError("PROVIDER_REQUEST_FAILED", error instanceof Error ? error.message : String(error));
+  return {
+    id: requestId,
+    status: "failed",
+    apiMode,
+    model: request.model ?? "",
+    text: "",
+    citations: [],
+    images: [],
+    patches: [],
+    toolUsage: emptyToolUsage([]),
+    warnings: [],
+    errors: [{
+      code: normalized.code,
+      message: normalized.message,
+      source: "runtime",
+      details: normalized.details
+    }],
+    raw: { request, response: void 0 }
+  };
+}
+function errorEvent(requestId, error) {
+  const normalized = error instanceof AiDispatcherError ? error : new AiDispatcherError("PROVIDER_REQUEST_FAILED", error instanceof Error ? error.message : String(error));
+  return {
+    type: "stream.error",
+    requestId,
+    data: {
+      error: {
+        code: normalized.code,
+        message: normalized.message,
+        source: "runtime",
+        details: normalized.details
+      }
+    }
+  };
 }
-function assertServer(server, seen) {
-  if (!isRecord4(server) || typeof server.id !== "string" || server.id.length === 0 || !Array.isArray(server.tools) || typeof server.callTool !== "function") {
-    throw new AiDispatcherError(
-      "MCP_SERVER_INVALID",
-      "An MCP server needs an id, a tools array, and a callTool function."
-    );
-  }
-  if (seen.has(server.id)) {
-    throw new AiDispatcherError("MCP_SERVER_INVALID", `MCP server "${server.id}" is listed more than once.`);
+function textDelta(event) {
+  if (event.type === "response.output_text.delta" && typeof event.delta === "string" && event.delta) return event.delta;
+  if (event.type === "content_block_delta" && isRecord5(event.delta) && event.delta.type === "text_delta" && typeof event.delta.text === "string" && event.delta.text) {
+    return event.delta.text;
   }
-  seen.add(server.id);
-  if (!TOOL_TOKEN.test(server.id)) {
-    throw new AiDispatcherError(
-      "MCP_TOOL_NAME_INVALID",
-      `MCP server id "${server.id}" must use letters, numbers, underscores, and hyphens.`
-    );
+  const choice = firstChoiceDelta(event);
+  if (choice && typeof choice.content === "string" && choice.content) return choice.content;
+  return void 0;
+}
+function reasoningDelta(event) {
+  if (event.type === "response.reasoning_summary_text.delta" && typeof event.delta === "string" && event.delta) return event.delta;
+  if (event.type === "content_block_delta" && isRecord5(event.delta) && event.delta.type === "thinking_delta" && typeof event.delta.thinking === "string" && event.delta.thinking) {
+    return event.delta.thinking;
   }
+  const choice = firstChoiceDelta(event);
+  if (!choice) return void 0;
+  if (typeof choice.reasoning === "string" && choice.reasoning) return choice.reasoning;
+  if (typeof choice.reasoning_content === "string" && choice.reasoning_content) return choice.reasoning_content;
+  return void 0;
 }
-function exposedToolName(serverId, tool) {
-  if (typeof tool.name !== "string" || !TOOL_TOKEN.test(serverId) || !TOOL_TOKEN.test(tool.name)) {
-    throw new AiDispatcherError(
-      "MCP_TOOL_NAME_INVALID",
-      `MCP tool "${serverId}.${typeof tool.name === "string" ? tool.name : ""}" must use letters, numbers, underscores, and hyphens.`
-    );
+function toolCallDelta(event) {
+  if (event.type === "response.function_call_arguments.delta" && typeof event.delta === "string") {
+    return {
+      index: 0,
+      ...typeof event.name === "string" ? { name: event.name } : {},
+      argumentsDelta: event.delta
+    };
   }
-  const exposedName = `${serverId}__${tool.name}`;
-  if (exposedName.length > MAX_EXPOSED_NAME_LENGTH) {
-    throw new AiDispatcherError(
-      "MCP_TOOL_NAME_INVALID",
-      `MCP tool "${exposedName}" is longer than ${MAX_EXPOSED_NAME_LENGTH} characters.`
-    );
+  if (event.type === "content_block_delta" && isRecord5(event.delta) && event.delta.type === "input_json_delta" && typeof event.delta.partial_json === "string") {
+    return { index: typeof event.index === "number" ? event.index : 0, argumentsDelta: event.delta.partial_json };
   }
-  return exposedName;
+  const choice = firstChoiceDelta(event);
+  if (!choice || !Array.isArray(choice.tool_calls) || !isRecord5(choice.tool_calls[0])) return void 0;
+  const tool = choice.tool_calls[0];
+  const fn = isRecord5(tool.function) ? tool.function : void 0;
+  const args = fn && typeof fn.arguments === "string" ? fn.arguments : void 0;
+  if (!args && !(fn && typeof fn.name === "string")) return void 0;
+  return {
+    index: typeof tool.index === "number" ? tool.index : 0,
+    ...fn && typeof fn.name === "string" ? { name: fn.name } : {},
+    ...args ? { argumentsDelta: args } : {}
+  };
 }
-function toolDescription(tool) {
-  if (tool.description === void 0) return "";
-  if (typeof tool.description !== "string") {
-    throw new AiDispatcherError(
-      "MCP_TOOL_NAME_INVALID",
-      `MCP tool "${tool.name}" description must be a string.`
-    );
+function streamUsage(event) {
+  if (event.type === "response.completed" && isRecord5(event.response)) return normalizeUsage(event.response.usage);
+  if (isRecord5(event.usage)) return normalizeUsage(event.usage);
+  return void 0;
+}
+function firstChoiceDelta(event) {
+  if (!Array.isArray(event.choices) || !isRecord5(event.choices[0])) return void 0;
+  const delta = event.choices[0].delta;
+  return isRecord5(delta) ? delta : void 0;
+}
+function unwrap(response) {
+  if (!isRecord5(response)) return {};
+  if (response.success === true && isRecord5(response.result)) return response.result;
+  return response;
+}
+function modelOf(compiled) {
+  if (typeof compiled.body.model === "string") return compiled.body.model;
+  return "";
+}
+function messageFrom(body) {
+  if (!isRecord5(body)) return void 0;
+  if (typeof body.message === "string") return body.message;
+  if (isRecord5(body.error) && typeof body.error.message === "string") return body.error.message;
+  if (Array.isArray(body.errors)) {
+    for (const error of body.errors) {
+      if (isRecord5(error) && typeof error.message === "string") return error.message;
+    }
   }
-  return tool.description;
+  return void 0;
 }
-function toolParameters(tool) {
-  if (tool.inputSchema === void 0) return { ...DEFAULT_PARAMETERS, properties: {} };
-  if (!isRecord4(tool.inputSchema)) {
-    throw new AiDispatcherError(
-      "MCP_TOOL_NAME_INVALID",
-      `MCP tool "${tool.name}" inputSchema must be an object.`
-    );
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function applyProviderRecord(body, metadata) {
+  if (metadata) return { ...body, metadata };
+  if (body.metadata === void 0) return body;
+  const rest = { ...body };
+  delete rest.metadata;
+  return rest;
+}
+function overlayMetadata(base, extra) {
+  if (!base) return extra;
+  if (!extra) return base;
+  return { ...base, ...extra };
+}
+function endpointUrl(options, endpoint) {
+  const account = encodeURIComponent(options.accountId);
+  const root = `${options.baseUrl}/accounts/${account}/ai`;
+  if (endpoint === "chat") return `${root}/v1/chat/completions`;
+  if (endpoint === "responses") return `${root}/v1/responses`;
+  if (endpoint === "messages") return `${root}/v1/messages`;
+  return `${root}/run`;
+}
+function buildHeaders(options, call, model, metadata) {
+  const gatewayId = call?.gatewayId?.trim() || options.gatewayId?.trim() || (isWorkersModel(model) ? DEFAULT_GATEWAY_ID : void 0);
+  const gateway = mergeGateway(options.gateway, call?.gateway);
+  const cache = call?.cache;
+  const skip = gateway?.skipCache !== void 0 ? gateway.skipCache : cache?.skip === true ? true : void 0;
+  const ttl = gateway?.cacheTtlSeconds ?? cache?.ttlSeconds;
+  const key = gateway?.cacheKey ?? cache?.key;
+  return clean({
+    "content-type": "application/json",
+    authorization: `Bearer ${options.apiToken}`,
+    ...gatewayId ? { "cf-aig-gateway-id": gatewayId } : {},
+    ...skip !== void 0 ? { "cf-aig-skip-cache": String(skip) } : {},
+    ...ttl !== void 0 ? { "cf-aig-cache-ttl": String(ttl) } : {},
+    ...key ? { "cf-aig-cache-key": key } : {},
+    ...gateway?.collectLog !== void 0 ? { "cf-aig-collect-log": String(gateway.collectLog) } : {},
+    ...gateway?.requestTimeoutMs !== void 0 ? { "cf-aig-request-timeout": String(gateway.requestTimeoutMs) } : {},
+    ...gateway?.maxGatewayAttempts !== void 0 ? { "cf-aig-max-attempts": String(gateway.maxGatewayAttempts) } : {},
+    ...gateway?.retryDelayMs !== void 0 ? { "cf-aig-retry-delay": String(gateway.retryDelayMs) } : {},
+    ...isBackoff(gateway?.backoff) ? { "cf-aig-backoff": gateway.backoff } : {},
+    ...metadata ? { "cf-aig-metadata": JSON.stringify(metadata) } : {}
+  });
+}
+function mergeGateway(base, over) {
+  if (!base && !over) return void 0;
+  return { ...base, ...over };
+}
+function isBackoff(value) {
+  return value === "constant" || value === "linear" || value === "exponential";
+}
+function isWorkersModel(model) {
+  return model.trim().toLowerCase().startsWith("@cf/");
+}
+function isBareOpenAiModel(id) {
+  return /^(gpt|o[134])(?:[.\-:]|$)/i.test(id.trim());
+}
+function timeoutFor(request, options) {
+  return request.execution?.timeoutMs ?? options.timeoutMs;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function* parseSse(response) {
+  const body = response.body;
+  if (!body) throw new AiDispatcherError("PROVIDER_GATEWAY_UNREACHABLE", "Cloudflare stream response had no body.");
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    buffer += decoder.decode(chunk.value, { stream: true });
+    const parts = buffer.split("\n\n");
+    buffer = parts.pop() ?? "";
+    for (const part of parts) {
+      const parsed = parseSsePart(part);
+      if (parsed !== void 0) yield parsed;
+    }
   }
-  return tool.inputSchema;
+  const trailing = parseSsePart(buffer);
+  if (trailing !== void 0) yield trailing;
 }
-function textContent(content) {
-  if (!Array.isArray(content)) return void 0;
-  const parts = [];
-  for (const part of content) {
-    if (!isRecord4(part) || part.type !== "text" || typeof part.text !== "string") continue;
-    parts.push(part.text);
+function parseSsePart(part) {
+  const data = part.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim()).join("\n");
+  if (!data || data === "[DONE]") return void 0;
+  try {
+    return JSON.parse(data);
+  } catch {
+    return void 0;
   }
-  if (!parts.length) return void 0;
-  return parts.join("\n");
 }
-function toArgs(args) {
-  if (isRecord4(args)) return args;
-  return {};
+function resolveCloudflareOptions(options) {
+  const {
+    apiToken,
+    accountId,
+    baseUrl,
+    defaultModel,
+    endpoint,
+    gatewayId,
+    timeoutMs,
+    maxAttempts,
+    fetch,
+    tools,
+    logger,
+    run,
+    ...gateway
+  } = options;
+  void run;
+  return {
+    apiToken: apiToken ?? readEnv("CLOUDFLARE_API_TOKEN") ?? "",
+    accountId: accountId ?? readEnv("CLOUDFLARE_ACCOUNT_ID") ?? "",
+    baseUrl: (baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, ""),
+    ...defaultModel ? { defaultModel } : {},
+    ...endpoint ? { endpoint } : {},
+    ...gatewayId ? { gatewayId } : {},
+    ...hasGateway(gateway) ? { gateway } : {},
+    timeoutMs: timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    maxAttempts: maxAttempts ?? 2,
+    fetch: fetch ?? globalThis.fetch,
+    ...tools ? { tools } : {},
+    ...logger ? { logger } : {}
+  };
 }
-function listFailed(serverId, error) {
-  if (error instanceof AiDispatcherError && error.code === "MCP_LIST_FAILED") return error;
-  const message = error instanceof Error ? error.message : `MCP server "${serverId}" listTools failed.`;
-  return new AiDispatcherError("MCP_LIST_FAILED", message);
+function hasGateway(gateway) {
+  return Object.values(gateway).some((value) => value !== void 0);
 }
-function stringify(result) {
-  const serialized = JSON.stringify(result);
-  return serialized === void 0 ? "null" : serialized;
+function clean(body) {
+  return Object.fromEntries(Object.entries(body).filter(([, value]) => value !== void 0));
 }
-function isRecord4(value) {
+function readEnv(name) {
+  if (typeof process === "undefined") return void 0;
+  return process.env[name];
+}
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/prepare-request.ts
-var import_ai_profiles = require("@x12i/ai-profiles");
 function prepareDispatchRequest(params) {
   const cloned = cloneRequest(params.request);
+  applyDispatchIdentity(cloned);
+  absorbOverrideMetadata(cloned);
   const provider = params.provider;
   const reasoningEffort = cloned.reasoningEffort;
   const bedrockControls = cloned.bedrockControls;
+  const cachePolicy = cloned.cache;
+  const cloudflareRequest = cloned.cloudflare;
   delete cloned.provider;
   delete cloned.reasoningEffort;
   delete cloned.bedrockControls;
+  delete cloned.cache;
+  delete cloned.cloudflare;
   if (provider === "openai") assertOpenAiConfigured(params.options);
+  if (provider === "cloudflare") assertCloudflareConfigured(params.options);
   if (provider === "bedrock" && cloned.reasoning !== void 0) {
     if (bedrockControls?.additionalModelRequestFields === void 0 && reasoningEffort === void 0) {
       throw new AiDispatcherError(
@@ -615,6 +2369,7 @@ function prepareDispatchRequest(params) {
   const requestedModel = cloned.model ?? defaultModelFor(provider, params.options) ?? "";
   const explicit = hasExplicitControl(provider, cloned, bedrockControls);
   let directive;
+  let catalogPrefix;
   if (!explicit && reasoningEffort !== void 0) {
     if (!requestedModel) {
       throw new AiDispatcherError(
@@ -622,26 +2377,69 @@ function prepareDispatchRequest(params) {
         "reasoningEffort requires a model id. Set request.model or the provider defaultModel."
       );
     }
-    directive = resolveCatalog({
-      target: provider,
-      model: requestedModel,
-      effort: reasoningEffort
-    });
+    if (provider === "cloudflare") {
+      const query = cloudflareCatalogQuery(requestedModel);
+      catalogPrefix = query.prefix;
+      directive = resolveCatalog({ target: query.target, model: query.model, effort: reasoningEffort }, true);
+    } else if (isReasoningTarget(provider)) {
+      directive = resolveCatalog({ target: provider, model: requestedModel, effort: reasoningEffort }, false);
+    }
   }
   if (provider === "openrouter") {
     applyNestedReasoning(cloned, reasoningEffort);
   }
-  if (directive?.model) cloned.model = directive.model;
+  if (directive?.model) {
+    cloned.model = provider === "cloudflare" ? restoreCloudflareModel(directive.model, catalogPrefix) : directive.model;
+  }
   if (directive?.promptPrefix) applyPromptPrefix(cloned, directive.promptPrefix);
   const effectiveModel = cloned.model ?? requestedModel;
+  const requestedEndpoint = cloudflareRequest?.endpoint ?? params.options.cloudflare?.endpoint;
+  const cloudflareEndpoint = provider === "cloudflare" ? selectCloudflareEndpoint({
+    model: effectiveModel,
+    ...requestedEndpoint ? { endpoint: requestedEndpoint } : {},
+    ...cloned.apiMode ? { apiMode: cloned.apiMode } : {}
+  }) : void 0;
   const call = {};
   if (reasoningEffort !== void 0 && provider === "openrouter") {
     call.suppressNestedReasoningFallback = true;
   }
   const overlay = directive && hasOwnKeys(directive.body) ? directive.body : explicit && provider === "bedrock" && bedrockControls?.additionalModelRequestFields ? { additionalModelRequestFields: bedrockControls.additionalModelRequestFields } : void 0;
-  if (overlay) {
+  const cache = cachePolicy ? resolvePromptCache({
+    target: provider,
+    requestedModel,
+    effectiveModel,
+    policy: cachePolicy,
+    ...cloudflareEndpoint ? { cloudflareEndpoint } : {}
+  }) : void 0;
+  const cachePlan = cache?.plan;
+  const cacheWarnings = cache?.warnings;
+  const cacheResolution = cache?.resolution;
+  const cacheTouchesBody = Boolean(
+    cachePlan && (cachePlan.stripMarkers || cachePlan.placeBreakpoint || cachePlan.sendOpenAiOptions)
+  );
+  if (overlay || cacheTouchesBody) {
     const bodyOverlay = overlay;
-    call.finalizeBody = (body) => (0, import_ai_profiles.mergeReasoningBody)(body, bodyOverlay);
+    call.finalizeBody = (body) => {
+      const merged = bodyOverlay ? (0, import_ai_profiles.mergeReasoningBody)(body, bodyOverlay) : body;
+      if (!cacheTouchesBody || !cachePlan) return merged;
+      const applied = applyPromptCache(merged, cachePlan);
+      if (cachePlan.placeBreakpoint && !applied.placed) {
+        noteUnplacedCache(cacheResolution, cacheWarnings, provider, effectiveModel);
+        return merged;
+      }
+      return applied.body;
+    };
+  }
+  if (provider === "cloudflare" && cloudflareEndpoint) {
+    const gateway = mergeCloudflareGateway(params.options.cloudflare, cloudflareRequest);
+    const gatewayId = cloudflareRequest?.gatewayId ?? params.options.cloudflare?.gatewayId;
+    call.cloudflare = {
+      endpoint: cloudflareEndpoint,
+      ...gatewayId ? { gatewayId } : {},
+      ...cloudflareRequest?.run ? { run: cloudflareRequest.run } : {},
+      ...gateway ? { gateway } : {},
+      ...cache?.plan.gateway ? { cache: cache.plan.gateway } : {}
+    };
   }
   if (directive && hasStreamMetadata(directive)) {
     const response = directive.response;
@@ -662,19 +2460,51 @@ function prepareDispatchRequest(params) {
     effectiveModel,
     ...resolution ? { resolution } : {},
     ...directive ? { directive } : {},
+    ...cacheResolution ? { cacheResolution } : {},
+    ...cacheWarnings ? { cacheWarnings } : {},
     call
   };
 }
-function resolveCatalog(input) {
+function noteUnplacedCache(resolution, warnings, target, model) {
+  if (resolution) {
+    resolution.outcome = "ignored";
+    delete resolution.ttl;
+  }
+  if (!warnings) return;
+  const kept = warnings.filter((warning) => warning.code !== "CACHE_TTL_DEGRADED");
+  warnings.length = 0;
+  warnings.push(...kept, {
+    code: "CACHE_UNSUPPORTED",
+    message: "Explicit prompt caching needs a system or instructions prefix. The call still runs without a breakpoint.",
+    details: { target, model }
+  });
+}
+function resolveCatalog(input, ignoreUnknown) {
   try {
     return (0, import_ai_profiles.resolveReasoning)(input);
   } catch (error) {
     if (error instanceof import_ai_profiles.AIProfilesError) {
+      if (ignoreUnknown && (error.code === "UNKNOWN_MODEL" || error.code === "REASONING_MAPPING_MISSING")) {
+        return {
+          outcome: "ignored",
+          body: {},
+          response: {
+            reasoningTextPaths: [],
+            streamReasoningKeys: [],
+            streamReasoningPaths: [],
+            stripFromHistoryPaths: [],
+            stripThinkTags: false
+          }
+        };
+      }
       throw new AiDispatcherError(error.code, error.message, error.details);
     }
     throw error;
   }
 }
+function isReasoningTarget(provider) {
+  return provider === "openrouter" || provider === "bedrock" || provider === "openai";
+}
 function hasExplicitControl(provider, request, bedrockControls) {
   if (provider === "bedrock") return bedrockControls?.additionalModelRequestFields !== void 0;
   return request.reasoning !== void 0;
@@ -708,12 +2538,12 @@ function settleNested(policy, kind, parentEffort) {
   if (!effort) return next;
   const model = kind === "fusion" ? next.judgeModel : next.model;
   if (!model) return next;
-  const directive = resolveCatalog({ target: "openrouter", model, effort });
+  const directive = resolveCatalog({ target: "openrouter", model, effort }, false);
   if (directive.model) {
     if (kind === "fusion") next.judgeModel = directive.model;
     else next.model = directive.model;
   }
-  if (isRecord5(directive.body.reasoning)) next.reasoning = directive.body.reasoning;
+  if (isRecord6(directive.body.reasoning)) next.reasoning = directive.body.reasoning;
   return next;
 }
 function applyPromptPrefix(request, prefix) {
@@ -763,7 +2593,7 @@ function prefixInputItems(items, prefix) {
     }
     if (!Array.isArray(item.content)) continue;
     for (const part of item.content) {
-      if (!isRecord5(part) || typeof part.text !== "string") continue;
+      if (!isRecord6(part) || typeof part.text !== "string") continue;
       if (part.type === "text" || part.type === "input_text") {
         part.text = prefix + part.text;
         return true;
@@ -772,8 +2602,40 @@ function prefixInputItems(items, prefix) {
   }
   return false;
 }
+function mergeCloudflareGateway(base, over) {
+  const gateway = {};
+  for (const source of [base, over]) {
+    if (!source) continue;
+    if (source.skipCache !== void 0) gateway.skipCache = source.skipCache;
+    if (source.cacheTtlSeconds !== void 0) gateway.cacheTtlSeconds = source.cacheTtlSeconds;
+    if (source.cacheKey !== void 0) gateway.cacheKey = source.cacheKey;
+    if (source.collectLog !== void 0) gateway.collectLog = source.collectLog;
+    if (source.requestTimeoutMs !== void 0) gateway.requestTimeoutMs = source.requestTimeoutMs;
+    if (source.maxGatewayAttempts !== void 0) gateway.maxGatewayAttempts = source.maxGatewayAttempts;
+    if (source.retryDelayMs !== void 0) gateway.retryDelayMs = source.retryDelayMs;
+    if (source.backoff !== void 0) gateway.backoff = source.backoff;
+    if (source.metadata !== void 0) gateway.metadata = source.metadata;
+  }
+  return Object.keys(gateway).length ? gateway : void 0;
+}
+function assertCloudflareConfigured(options) {
+  const apiToken = options.cloudflare?.apiToken ?? readEnv2("CLOUDFLARE_API_TOKEN");
+  if (!apiToken) {
+    throw new AiDispatcherError(
+      "CLOUDFLARE_API_TOKEN_MISSING",
+      "Cloudflare API token is required. Set cloudflare.apiToken or CLOUDFLARE_API_TOKEN."
+    );
+  }
+  const accountId = options.cloudflare?.accountId ?? readEnv2("CLOUDFLARE_ACCOUNT_ID");
+  if (!accountId) {
+    throw new AiDispatcherError(
+      "CLOUDFLARE_ACCOUNT_ID_MISSING",
+      "Cloudflare account id is required. Set cloudflare.accountId or CLOUDFLARE_ACCOUNT_ID."
+    );
+  }
+}
 function assertOpenAiConfigured(options) {
-  const apiKey = options.openai?.apiKey ?? readEnv("OPENAI_API_KEY");
+  const apiKey = options.openai?.apiKey ?? readEnv2("OPENAI_API_KEY");
   if (!apiKey) {
     throw new AiDispatcherError(
       "OPENAI_API_KEY_MISSING",
@@ -784,8 +2646,40 @@ function assertOpenAiConfigured(options) {
 function defaultModelFor(provider, options) {
   if (provider === "openrouter") return options.openrouter?.defaultModel;
   if (provider === "bedrock") return options.bedrock?.defaultModel;
+  if (provider === "cloudflare") return options.cloudflare?.defaultModel;
   return options.openai?.defaultModel;
 }
+var DISPATCH_IDENTITY_FIELDS = ["orgId", "stepId", "skillId"];
+function absorbOverrideMetadata(request) {
+  const overrides = request.rawOpenRouterOverrides;
+  if (!isRecord6(overrides) || !Object.prototype.hasOwnProperty.call(overrides, "metadata")) return;
+  if (isRecord6(overrides.metadata)) {
+    const current = { ...request.metadata ?? {} };
+    const extra = {};
+    for (const [key, value] of Object.entries(overrides.metadata)) {
+      if (!Object.prototype.hasOwnProperty.call(current, key)) extra[key] = value;
+    }
+    request.metadata = { ...current, ...extra };
+  }
+  const remaining = {};
+  for (const [key, value] of Object.entries(overrides)) {
+    if (key !== "metadata") remaining[key] = value;
+  }
+  if (Object.keys(remaining).length === 0) delete request.rawOpenRouterOverrides;
+  else request.rawOpenRouterOverrides = remaining;
+}
+function applyDispatchIdentity(request) {
+  const identity = {};
+  for (const field of DISPATCH_IDENTITY_FIELDS) {
+    const value = request[field]?.trim();
+    if (value) identity[field] = value;
+    delete request[field];
+  }
+  if (!Object.keys(identity).length) return;
+  const rest = { ...request.metadata ?? {} };
+  for (const key of Object.keys(identity)) delete rest[key];
+  request.metadata = { ...identity, ...rest };
+}
 function cloneRequest(request) {
   const functionTools = request.functionTools?.map((tool) => ({ ...tool }));
   const cloned = JSON.parse(JSON.stringify(request));
@@ -798,10 +2692,10 @@ function hasOwnKeys(value) {
 function hasStreamMetadata(directive) {
   return directive.response.streamReasoningKeys.length > 0 || directive.response.streamReasoningPaths.length > 0;
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function readEnv(name) {
+function readEnv2(name) {
   if (typeof process === "undefined") return void 0;
   return process.env[name];
 }
@@ -864,11 +2758,12 @@ function toBedrockRequest(request) {
       ...request.execution.timeoutMs !== void 0 ? { timeoutMs: request.execution.timeoutMs } : {}
     };
   }
+  if (request.agentId !== void 0) mapped.agentId = request.agentId;
   if (request.metadata !== void 0) mapped.metadata = request.metadata;
   return mapped;
 }
 function assertBedrockSupported(request) {
-  if (request.serverTools && serverToolsEnabled(request.serverTools)) {
+  if (request.serverTools && serverToolsEnabled2(request.serverTools)) {
     throw new AiDispatcherError(
       "UNSUPPORTED_REQUEST_FIELD",
       "Bedrock does not support OpenRouter server tools."
@@ -902,13 +2797,13 @@ function assertBedrockSupported(request) {
 function hasMessages(request) {
   return Array.isArray(request.messages) && request.messages.length > 0;
 }
-function serverToolsEnabled(policy) {
+function serverToolsEnabled2(policy) {
   return Object.values(policy).some((value) => {
-    if (Array.isArray(value)) return value.some((item) => isEnabledMode(item));
-    return isEnabledMode(value);
+    if (Array.isArray(value)) return value.some((item) => isEnabledMode2(item));
+    return isEnabledMode2(value);
   });
 }
-function isEnabledMode(value) {
+function isEnabledMode2(value) {
   return typeof value === "object" && value !== null && "mode" in value && value.mode !== "disabled";
 }
 function inputItemsToMessages(items) {
@@ -940,8 +2835,9 @@ function isBedrockToolChoice(toolChoice) {
 }
 
 // src/providers/openai.ts
-var DEFAULT_BASE_URL = "https://api.openai.com/v1";
-var DEFAULT_TIMEOUT_MS = 12e4;
+var import_openrouter_runtime2 = require("@x12i/openrouter-runtime");
+var DEFAULT_BASE_URL2 = "https://api.openai.com/v1";
+var DEFAULT_TIMEOUT_MS2 = 12e4;
 function createOpenAiProviderAdapter(options = {}) {
   const resolved = resolveOpenAiOptions(options);
   return {
@@ -953,8 +2849,8 @@ function createOpenAiProviderAdapter(options = {}) {
       try {
         return await runOpenAi(request, resolved, call, requestId);
       } catch (error) {
-        if (error instanceof AiDispatcherError && isConfigError(error.code)) throw error;
-        return failedResponse(request, requestId, error);
+        if (error instanceof AiDispatcherError && isConfigError2(error.code)) throw error;
+        return failedResponse2(request, requestId, error);
       }
     },
     executeStreamingChat(request, call) {
@@ -963,7 +2859,7 @@ function createOpenAiProviderAdapter(options = {}) {
   };
 }
 function compileOpenAiRequest(request, options, call, streaming) {
-  assertSupported(request);
+  assertSupported2(request);
   const model = (request.model ?? options.defaultModel ?? "").trim();
   if (!model) {
     throw new AiDispatcherError(
@@ -977,12 +2873,12 @@ function compileOpenAiRequest(request, options, call, streaming) {
       "OpenAI API key is required. Set openai.apiKey or OPENAI_API_KEY."
     );
   }
-  const instructions = compileInstructions(request);
+  const instructions = compileInstructions2(request);
   const input = compileInput(request);
   if (input === void 0) {
     throw new AiDispatcherError("INPUT_REQUIRED", "Provide request.messages, request.input, or request.prompt.");
   }
-  let body = clean({
+  let body = clean2({
     model,
     input,
     instructions,
@@ -996,15 +2892,16 @@ function compileOpenAiRequest(request, options, call, streaming) {
   if (call?.finalizeBody) body = call.finalizeBody(body);
   if (streaming) body = { ...body, stream: true };
   else body = { ...body, stream: false };
+  body = attachProviderMetadata(body, request);
   return {
     url: `${options.baseUrl}/responses`,
-    headers: buildHeaders(options),
+    headers: buildHeaders2(options),
     body,
     warnings: []
   };
 }
-function assertSupported(request) {
-  if (request.serverTools && serverToolsEnabled2(request.serverTools)) {
+function assertSupported2(request) {
+  if (request.serverTools && serverToolsEnabled3(request.serverTools)) {
     throw new AiDispatcherError(
       "UNSUPPORTED_REQUEST_FIELD",
       "Direct OpenAI does not support OpenRouter server tools."
@@ -1029,21 +2926,21 @@ function assertSupported(request) {
     );
   }
 }
-function serverToolsEnabled2(policy) {
+function serverToolsEnabled3(policy) {
   return Object.values(policy).some((value) => {
-    if (Array.isArray(value)) return value.some((item) => isEnabledMode2(item));
-    return isEnabledMode2(value);
+    if (Array.isArray(value)) return value.some((item) => isEnabledMode3(item));
+    return isEnabledMode3(value);
   });
 }
-function isEnabledMode2(value) {
+function isEnabledMode3(value) {
   return typeof value === "object" && value !== null && "mode" in value && value.mode !== "disabled";
 }
-function compileInstructions(request) {
+function compileInstructions2(request) {
   if (request.instructions) return request.instructions;
   if (request.system) return request.system;
   const systemMessages = (request.messages ?? []).filter((message) => message.role === "system");
   if (!systemMessages.length) return void 0;
-  return systemMessages.map((message) => contentToText(message.content)).filter(Boolean).join("\n");
+  return systemMessages.map((message) => contentToText2(message.content)).filter(Boolean).join("\n");
 }
 function compileInput(request) {
   if (request.input !== void 0) return request.input;
@@ -1063,7 +2960,7 @@ function compileInputItem(message) {
     return {
       type: "function_call_output",
       call_id: message.toolCallId ?? message.name ?? "tool",
-      output: contentToText(message.content)
+      output: contentToText2(message.content)
     };
   }
   const role = message.role === "assistant" ? "assistant" : "user";
@@ -1075,10 +2972,10 @@ function compileContent(content) {
     if (part.type === "text") return { type: "input_text", text: part.text };
     if (part.type === "image_url") return { type: "input_image", image_url: part.imageUrl };
     if (part.url) {
-      return clean({ type: "input_file", file_url: part.url, filename: part.fileName });
+      return clean2({ type: "input_file", file_url: part.url, filename: part.fileName });
     }
     if (part.data) {
-      return clean({ type: "input_file", file_data: part.data, filename: part.fileName });
+      return clean2({ type: "input_file", file_data: part.data, filename: part.fileName });
     }
     throw new AiDispatcherError(
       "UNSUPPORTED_REQUEST_FIELD",
@@ -1112,10 +3009,10 @@ async function runOpenAi(request, options, call, requestId) {
   let active = compileOpenAiRequest(request, options, call, false);
   let response;
   for (let iteration = 0; iteration <= maxIterations; iteration += 1) {
-    response = await sendWithRetries(active, options, timeoutFor(request, options));
-    const calls = functionCalls(isRecord6(response) ? response : {});
+    response = await sendWithRetries2(active, options, timeoutFor2(request, options));
+    const calls = functionCalls(isRecord7(response) ? response : {});
     if (!calls.length) break;
-    if (!calls.every((item) => resolveExecutor(item.name, request, options))) {
+    if (!calls.every((item) => resolveExecutor2(item.name, request, options))) {
       return normalizeOpenAiResponse({
         request,
         requestId,
@@ -1133,14 +3030,14 @@ async function runOpenAi(request, options, call, requestId) {
       results.push(await executeOpenAiTool(item, request, options));
     }
     functionUsage.push(...results);
-    const record = isRecord6(response) ? response : {};
+    const record2 = isRecord7(response) ? response : {};
     active = {
       ...active,
-      body: clean({
+      body: clean2({
         ...active.body,
         tool_choice: "auto",
-        previous_response_id: typeof record.id === "string" ? record.id : void 0,
-        input: results.map(toFunctionCallOutput)
+        previous_response_id: typeof record2.id === "string" ? record2.id : void 0,
+        input: results.map(toFunctionCallOutput2)
       })
     };
   }
@@ -1153,11 +3050,11 @@ async function runOpenAi(request, options, call, requestId) {
     status: "completed"
   });
 }
-function resolveExecutor(name, request, options) {
+function resolveExecutor2(name, request, options) {
   return request.functionTools?.find((tool) => tool.name === name)?.executor ?? options.tools?.[name];
 }
 async function executeOpenAiTool(call, request, options) {
-  const executor = resolveExecutor(call.name, request, options);
+  const executor = resolveExecutor2(call.name, request, options);
   if (!executor) {
     return call;
   }
@@ -1193,7 +3090,7 @@ async function executeOpenAiTool(call, request, options) {
     return usage;
   }
 }
-function toFunctionCallOutput(result) {
+function toFunctionCallOutput2(result) {
   const output = result.status === "completed" ? result.result : { error: result.error };
   return {
     type: "function_call_output",
@@ -1201,7 +3098,7 @@ function toFunctionCallOutput(result) {
     output: typeof output === "string" ? output : JSON.stringify(output)
   };
 }
-function contentToText(content) {
+function contentToText2(content) {
   if (typeof content === "string") return content;
   return content.map((part) => part.type === "text" ? part.text : "").filter(Boolean).join("");
 }
@@ -1211,7 +3108,7 @@ async function* streamOpenAi(request, options, call) {
   try {
     compiled = compileOpenAiRequest(request, options, call, true);
   } catch (error) {
-    yield errorEvent(requestId, error);
+    yield errorEvent2(requestId, error);
     throw error;
   }
   yield {
@@ -1224,7 +3121,7 @@ async function* streamOpenAi(request, options, call) {
     }
   };
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), timeoutFor(request, options));
+  const timeout = setTimeout(() => controller.abort(), timeoutFor2(request, options));
   let text = "";
   let reported = false;
   const report = (error) => {
@@ -1242,13 +3139,13 @@ async function* streamOpenAi(request, options, call) {
       signal: controller.signal
     });
     if (!response.ok) {
-      const failure = await readFailure(response);
+      const failure = await readFailure2(response);
       reported = true;
-      yield errorEvent(requestId, failure);
+      yield errorEvent2(requestId, failure);
       throw failure;
     }
-    for await (const event of parseSse(response)) {
-      if (!isRecord6(event)) continue;
+    for await (const event of parseSse2(response)) {
+      if (!isRecord7(event)) continue;
       if (event.type === "response.output_text.delta" && typeof event.delta === "string" && event.delta) {
         text += event.delta;
         yield { type: "stream.text.delta", requestId, data: { text: event.delta } };
@@ -1267,8 +3164,8 @@ async function* streamOpenAi(request, options, call) {
             argumentsDelta: event.delta
           }
         };
-      } else if (event.type === "response.completed" && isRecord6(event.response)) {
-        const usage = normalizeUsage(event.response.usage);
+      } else if (event.type === "response.completed" && isRecord7(event.response)) {
+        const usage = normalizeUsage2(event.response.usage);
         if (usage) yield { type: "stream.usage", requestId, data: { usage } };
       } else if (event.type === "error") {
         const failure = new AiDispatcherError(
@@ -1277,7 +3174,7 @@ async function* streamOpenAi(request, options, call) {
           event
         );
         reported = true;
-        yield errorEvent(requestId, failure);
+        yield errorEvent2(requestId, failure);
         throw failure;
       }
     }
@@ -1291,28 +3188,28 @@ async function* streamOpenAi(request, options, call) {
     };
   } catch (error) {
     const failure = error instanceof Error && error.name === "AbortError" ? new AiDispatcherError("PROVIDER_GATEWAY_UNREACHABLE", "OpenAI request timed out.") : report(error);
-    if (!reported) yield errorEvent(requestId, failure);
+    if (!reported) yield errorEvent2(requestId, failure);
     throw failure;
   } finally {
     clearTimeout(timeout);
   }
 }
-async function sendWithRetries(compiled, options, timeoutMs) {
+async function sendWithRetries2(compiled, options, timeoutMs) {
   const attempts = options.maxAttempts;
   let lastError;
   for (let attempt = 1; attempt <= attempts; attempt += 1) {
     try {
-      return await sendOnce(compiled, options, timeoutMs);
+      return await sendOnce2(compiled, options, timeoutMs);
     } catch (error) {
       lastError = error;
       const retryable = error instanceof AiDispatcherError && error.code === "PROVIDER_RETRYABLE";
-      if (!retryable || attempt >= attempts) throw asTerminalError(error);
-      await delay(Math.min(500 * 2 ** (attempt - 1), 5e3));
+      if (!retryable || attempt >= attempts) throw asTerminalError2(error);
+      await delay2(Math.min(500 * 2 ** (attempt - 1), 5e3));
     }
   }
   throw lastError;
 }
-async function sendOnce(compiled, options, timeoutMs) {
+async function sendOnce2(compiled, options, timeoutMs) {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
   try {
@@ -1322,7 +3219,7 @@ async function sendOnce(compiled, options, timeoutMs) {
       body: JSON.stringify(compiled.body),
       signal: controller.signal
     });
-    if (!response.ok) throw await readFailure(response);
+    if (!response.ok) throw await readFailure2(response);
     const text = await response.text();
     return text ? JSON.parse(text) : {};
   } catch (error) {
@@ -1338,7 +3235,7 @@ async function sendOnce(compiled, options, timeoutMs) {
     clearTimeout(timeout);
   }
 }
-async function readFailure(response) {
+async function readFailure2(response) {
   const text = await response.text();
   let body = text;
   try {
@@ -1346,21 +3243,21 @@ async function readFailure(response) {
   } catch {
     body = text;
   }
-  const message = messageFrom(body) ?? `OpenAI request failed with status ${response.status}.`;
+  const message = messageFrom2(body) ?? `OpenAI request failed with status ${response.status}.`;
   const retryable = response.status === 429 || response.status >= 500;
-  return new AiDispatcherError(classifyStatus(response.status), message, { status: response.status, body, retryable });
+  return new AiDispatcherError(classifyStatus2(response.status), message, { status: response.status, body, retryable });
 }
-function classifyStatus(status) {
+function classifyStatus2(status) {
   if (status === 401 || status === 403) return "PROVIDER_AUTH_FAILED";
   if (status === 404) return "PROVIDER_MODEL_NOT_FOUND";
   if (status === 429) return "PROVIDER_RATE_LIMITED";
   if (status === 408 || status >= 500) return "PROVIDER_RETRYABLE";
   return "PROVIDER_REQUEST_FAILED";
 }
-function isConfigError(code) {
+function isConfigError2(code) {
   return code === "OPENAI_API_KEY_MISSING" || code === "MODEL_REQUIRED" || code === "INPUT_REQUIRED" || code === "UNSUPPORTED_REQUEST_FIELD";
 }
-function asTerminalError(error) {
+function asTerminalError2(error) {
   if (error instanceof AiDispatcherError && error.code === "PROVIDER_RETRYABLE") {
     return new AiDispatcherError("PROVIDER_GATEWAY_UNREACHABLE", error.message, error.details);
   }
@@ -1368,16 +3265,16 @@ function asTerminalError(error) {
   return new AiDispatcherError("PROVIDER_REQUEST_FAILED", error instanceof Error ? error.message : String(error));
 }
 function normalizeOpenAiResponse(params) {
-  const record = isRecord6(params.response) ? params.response : {};
-  const text = answerText(record);
-  const calls = params.functionTools ?? functionCalls(record);
-  const usage = normalizeUsage(record.usage);
+  const record2 = isRecord7(params.response) ? params.response : {};
+  const text = answerText2(record2);
+  const calls = params.functionTools ?? functionCalls(record2);
+  const usage = normalizeUsage2(record2.usage);
   const status = params.status ?? (calls.length ? "requires_action" : "completed");
   return {
-    id: typeof record.id === "string" ? record.id : params.requestId,
+    id: typeof record2.id === "string" ? record2.id : params.requestId,
     status,
     apiMode: "responses",
-    model: typeof record.model === "string" ? record.model : modelOf(params.compiled),
+    model: typeof record2.model === "string" ? record2.model : modelOf2(params.compiled),
     text,
     citations: [],
     images: [],
@@ -1390,14 +3287,14 @@ function normalizeOpenAiResponse(params) {
     ...params.request.metadata ? { metadata: params.request.metadata } : {}
   };
 }
-function answerText(response) {
+function answerText2(response) {
   const output = response.output;
   if (Array.isArray(output)) {
     const parts = [];
     for (const item of output) {
-      if (!isRecord6(item) || item.type === "reasoning" || item.type !== "message" || !Array.isArray(item.content)) continue;
+      if (!isRecord7(item) || item.type === "reasoning" || item.type !== "message" || !Array.isArray(item.content)) continue;
       for (const part of item.content) {
-        if (isRecord6(part) && part.type === "output_text" && typeof part.text === "string") parts.push(part.text);
+        if (isRecord7(part) && part.type === "output_text" && typeof part.text === "string") parts.push(part.text);
       }
     }
     if (parts.length > 0) return parts.join("");
@@ -1408,7 +3305,7 @@ function functionCalls(response) {
   if (!Array.isArray(response.output)) return [];
   const calls = [];
   for (const item of response.output) {
-    if (!isRecord6(item) || item.type !== "function_call") continue;
+    if (!isRecord7(item) || item.type !== "function_call") continue;
     const name = typeof item.name === "string" ? item.name : "function";
     const callId = typeof item.call_id === "string" ? item.call_id : name;
     let args = item.arguments;
@@ -1439,11 +3336,11 @@ function toolUsage(calls) {
     functionTools: calls
   };
 }
-function normalizeUsage(usage) {
-  if (!isRecord6(usage)) return void 0;
-  const inputTokens = numberValue(usage.input_tokens);
-  const outputTokens = numberValue(usage.output_tokens);
-  const totalTokens = numberValue(usage.total_tokens) ?? (inputTokens !== void 0 || outputTokens !== void 0 ? (inputTokens ?? 0) + (outputTokens ?? 0) : void 0);
+function normalizeUsage2(usage) {
+  if (!isRecord7(usage)) return void 0;
+  const inputTokens = numberValue2(usage.input_tokens);
+  const outputTokens = numberValue2(usage.output_tokens);
+  const totalTokens = numberValue2(usage.total_tokens) ?? (inputTokens !== void 0 || outputTokens !== void 0 ? (inputTokens ?? 0) + (outputTokens ?? 0) : void 0);
   return {
     raw: usage,
     ...inputTokens !== void 0 ? { inputTokens } : {},
@@ -1451,7 +3348,7 @@ function normalizeUsage(usage) {
     ...totalTokens !== void 0 ? { totalTokens } : {}
   };
 }
-function failedResponse(request, requestId, error) {
+function failedResponse2(request, requestId, error) {
   const normalized = error instanceof AiDispatcherError ? error : new AiDispatcherError("PROVIDER_REQUEST_FAILED", error instanceof Error ? error.message : String(error));
   return {
     id: requestId,
@@ -1473,7 +3370,7 @@ function failedResponse(request, requestId, error) {
     raw: { request, response: void 0 }
   };
 }
-function errorEvent(requestId, error) {
+function errorEvent2(requestId, error) {
   const normalized = error instanceof AiDispatcherError ? error : new AiDispatcherError("PROVIDER_REQUEST_FAILED", error instanceof Error ? error.message : String(error));
   return {
     type: "stream.error",
@@ -1488,22 +3385,31 @@ function errorEvent(requestId, error) {
     }
   };
 }
-function modelOf(compiled) {
+function modelOf2(compiled) {
   return typeof compiled.body.model === "string" ? compiled.body.model : "";
 }
-function messageFrom(body) {
-  if (!isRecord6(body)) return void 0;
+function messageFrom2(body) {
+  if (!isRecord7(body)) return void 0;
   if (typeof body.message === "string") return body.message;
-  if (isRecord6(body.error) && typeof body.error.message === "string") return body.error.message;
+  if (isRecord7(body.error) && typeof body.error.message === "string") return body.error.message;
   return void 0;
 }
-function numberValue(value) {
+function numberValue2(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function clean(body) {
+function attachProviderMetadata(body, request) {
+  const fromBody = isRecord7(body.metadata) ? body.metadata : void 0;
+  const metadata = (0, import_openrouter_runtime2.toProviderMetadata)(request.metadata, request.agentId, import_openrouter_runtime2.OPENROUTER_METADATA_LIMITS, fromBody);
+  if (metadata) return { ...body, metadata };
+  if (body.metadata === void 0) return body;
+  const rest = { ...body };
+  delete rest.metadata;
+  return rest;
+}
+function clean2(body) {
   return Object.fromEntries(Object.entries(body).filter(([, value]) => value !== void 0));
 }
-function buildHeaders(options) {
+function buildHeaders2(options) {
   return {
     "content-type": "application/json",
     authorization: `Bearer ${options.apiKey}`,
@@ -1511,13 +3417,13 @@ function buildHeaders(options) {
     ...options.project ? { "OpenAI-Project": options.project } : {}
   };
 }
-function timeoutFor(request, options) {
+function timeoutFor2(request, options) {
   return request.execution?.timeoutMs ?? options.timeoutMs;
 }
-function delay(ms) {
+function delay2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function* parseSse(response) {
+async function* parseSse2(response) {
   const body = response.body;
   if (!body) throw new AiDispatcherError("PROVIDER_GATEWAY_UNREACHABLE", "OpenAI stream response had no body.");
   const reader = body.getReader();
@@ -1530,14 +3436,14 @@ async function* parseSse(response) {
     const parts = buffer.split("\n\n");
     buffer = parts.pop() ?? "";
     for (const part of parts) {
-      const parsed = parseSsePart(part);
+      const parsed = parseSsePart2(part);
       if (parsed !== void 0) yield parsed;
     }
   }
-  const trailing = parseSsePart(buffer);
+  const trailing = parseSsePart2(buffer);
   if (trailing !== void 0) yield trailing;
 }
-function parseSsePart(part) {
+function parseSsePart2(part) {
   const data = part.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim()).join("\n");
   if (!data || data === "[DONE]") return void 0;
   try {
@@ -1547,32 +3453,32 @@ function parseSsePart(part) {
   }
 }
 function resolveOpenAiOptions(options) {
-  const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL2).replace(/\/+$/, "");
   return {
-    apiKey: options.apiKey ?? readEnv2("OPENAI_API_KEY") ?? "",
+    apiKey: options.apiKey ?? readEnv3("OPENAI_API_KEY") ?? "",
     baseUrl,
     ...options.defaultModel ? { defaultModel: options.defaultModel } : {},
     ...options.organization ? { organization: options.organization } : {},
     ...options.project ? { project: options.project } : {},
-    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS2,
     maxAttempts: options.maxAttempts ?? 3,
     fetch: options.fetch ?? globalThis.fetch,
     ...options.tools ? { tools: options.tools } : {},
     ...options.logger ? { logger: options.logger } : {}
   };
 }
-function readEnv2(name) {
+function readEnv3(name) {
   if (typeof process === "undefined") return void 0;
   return process.env[name];
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/providers/openrouter.ts
-var import_openrouter_runtime = require("@x12i/openrouter-runtime");
+var import_openrouter_runtime3 = require("@x12i/openrouter-runtime");
 function createOpenRouterProviderAdapter(options = {}) {
-  const runtime = (0, import_openrouter_runtime.createOpenRouterRuntime)(options);
+  const runtime = (0, import_openrouter_runtime3.createOpenRouterRuntime)(options);
   return {
     run(request, call) {
       return runtime.run(request, toCall2(call));
@@ -1638,6 +3544,13 @@ function createAiDispatcher(options = {}) {
       };
       return createOpenAiProviderAdapter(openaiOptions);
     }
+    if (provider === "cloudflare") {
+      const cloudflareOptions = {
+        ...options.cloudflare,
+        ...options.logger && !options.cloudflare?.logger ? { logger: options.logger } : {}
+      };
+      return createCloudflareProviderAdapter(cloudflareOptions);
+    }
     throw new AiDispatcherError(
       "PROVIDER_ADAPTER_MISSING",
       `No adapter registered for provider "${provider}".`
@@ -1699,22 +3612,27 @@ function createAiDispatcher(options = {}) {
 function providerTools(provider, options) {
   if (provider === "openrouter") return options.openrouter?.tools;
   if (provider === "bedrock") return options.bedrock?.tools;
+  if (provider === "cloudflare") return options.cloudflare?.tools;
   return options.openai?.tools;
 }
 function callOf(call) {
-  if (!call.finalizeBody && !call.extractStreamReasoning && !call.suppressNestedReasoningFallback) return void 0;
+  if (!call.finalizeBody && !call.extractStreamReasoning && !call.suppressNestedReasoningFallback && !call.cloudflare) {
+    return void 0;
+  }
   return call;
 }
 function attachCompileMeta(prepared, compiled) {
-  const record = compiled;
-  const headers = isRecord7(record.headers) ? redactHeaders(record.headers) : void 0;
+  const record2 = compiled;
+  const headers = isRecord8(record2.headers) ? redactHeaders(record2.headers) : void 0;
   return {
-    ...record,
+    ...record2,
     ...headers ? { headers } : {},
     provider: prepared.provider,
     requestedModel: prepared.requestedModel,
     effectiveModel: prepared.effectiveModel,
-    ...prepared.resolution ? { reasoningResolution: prepared.resolution } : {}
+    ...prepared.resolution ? { reasoningResolution: prepared.resolution } : {},
+    ...prepared.cacheResolution ? { cacheResolution: prepared.cacheResolution } : {},
+    ...prepared.cacheWarnings?.length ? { warnings: [...Array.isArray(record2.warnings) ? record2.warnings : [], ...prepared.cacheWarnings] } : {}
   };
 }
 function redactHeaders(headers) {
@@ -1735,10 +3653,11 @@ function log(options, event, prepared, entrypoint, streaming) {
   if (prepared.request.id) payload.requestId = prepared.request.id;
   if (prepared.resolution?.outcome) payload.outcome = prepared.resolution.outcome;
   if (prepared.resolution) payload.bypassed = prepared.resolution.bypassed;
+  if (prepared.cacheResolution) payload.cacheOutcome = prepared.cacheResolution.outcome;
   if (event.endsWith("compiled")) options.logger?.debug?.(event, payload);
   else options.logger?.info?.(event, payload);
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -1753,6 +3672,7 @@ function stripReasoningHistoryFields(message, paths) {
   AiDispatcherError,
   IMPLEMENTED_AI_PROVIDERS,
   createAiDispatcher,
+  decodeProviderMetadata,
   isImplementedAiProvider,
   providerNotImplemented,
   resolveProvider,