@x12i/ai-dispatcher 1.4.0

package/dist/index.cjs

@@ -0,0 +1,1761 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AiDispatcherError: () => AiDispatcherError,
+  IMPLEMENTED_AI_PROVIDERS: () => IMPLEMENTED_AI_PROVIDERS,
+  createAiDispatcher: () => createAiDispatcher,
+  isImplementedAiProvider: () => isImplementedAiProvider,
+  providerNotImplemented: () => providerNotImplemented,
+  resolveProvider: () => resolveProvider,
+  stripReasoningHistoryFields: () => stripReasoningHistoryFields
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/json-pointer.ts
+var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unescapeToken(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function tokensFor(pointer) {
+  if (pointer === "") return [];
+  if (!pointer.startsWith("/")) return void 0;
+  const tokens = pointer.split("/").slice(1).map(unescapeToken);
+  if (tokens.some((token) => UNSAFE_KEYS.has(token))) return void 0;
+  return tokens;
+}
+function walk(current, tokens) {
+  if (tokens.length === 0) return [current];
+  const [head, ...rest] = tokens;
+  if (head === void 0) return [];
+  if (head === "*") {
+    if (!Array.isArray(current)) return [];
+    return current.flatMap((item) => walk(item, rest));
+  }
+  if (Array.isArray(current)) {
+    if (!/^\d+$/.test(head)) return [];
+    const index = Number(head);
+    if (index >= current.length) return [];
+    return walk(current[index], rest);
+  }
+  if (!isRecord(current) || !Object.prototype.hasOwnProperty.call(current, head)) return [];
+  return walk(current[head], rest);
+}
+function valuesAtPointer(root, pointer) {
+  const tokens = tokensFor(pointer);
+  if (!tokens) return [];
+  return walk(root, tokens);
+}
+function firstConcatenatedText(root, paths) {
+  for (const path of paths) {
+    const strings = valuesAtPointer(root, path).filter((value) => typeof value === "string" && value.length > 0);
+    if (strings.length > 0) return strings.join("");
+  }
+  return void 0;
+}
+function firstNumber(root, paths) {
+  for (const path of paths) {
+    for (const value of valuesAtPointer(root, path)) {
+      if (typeof value === "number" && Number.isFinite(value)) return value;
+    }
+  }
+  return void 0;
+}
+function collectParents(current, tokens) {
+  if (tokens.length === 0) return [current];
+  const [head, ...rest] = tokens;
+  if (head === void 0) return [];
+  if (head === "*") {
+    if (!Array.isArray(current)) return [];
+    return current.flatMap((item) => collectParents(item, rest));
+  }
+  if (Array.isArray(current)) {
+    if (!/^\d+$/.test(head)) return [];
+    const index = Number(head);
+    if (index >= current.length) return [];
+    return collectParents(current[index], rest);
+  }
+  if (!isRecord(current) || !Object.prototype.hasOwnProperty.call(current, head)) return [];
+  return collectParents(current[head], rest);
+}
+function deletePointer(root, pointer) {
+  const tokens = tokensFor(pointer);
+  if (!tokens || tokens.length === 0) return;
+  const last = tokens[tokens.length - 1];
+  if (last === void 0 || last === "*") return;
+  const parents = collectParents(root, tokens.slice(0, -1));
+  for (const parent of parents) {
+    if (Array.isArray(parent)) {
+      if (!/^\d+$/.test(last)) continue;
+      const index = Number(last);
+      if (index < parent.length) parent.splice(index, 1);
+      continue;
+    }
+    if (isRecord(parent) && Object.prototype.hasOwnProperty.call(parent, last)) {
+      delete parent[last];
+    }
+  }
+}
+
+// src/reasoning-extract.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function textFromValue(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value.map(textFromValue).join("");
+  if (!isRecord2(value)) return "";
+  if (typeof value.text === "string") return value.text;
+  if (typeof value.summary === "string") return value.summary;
+  return "";
+}
+function extractStreamReasoningText(event, response) {
+  if (response.streamReasoningKeys.length > 0) {
+    if (!isRecord2(event)) return void 0;
+    for (const key of response.streamReasoningKeys) {
+      const text = textFromValue(event[key]);
+      if (text) return text;
+    }
+    return void 0;
+  }
+  return firstConcatenatedText(event, response.streamReasoningPaths);
+}
+function readReasoningTokens(root, paths) {
+  for (const path of paths) {
+    const absolute = firstNumber(root, [path]);
+    if (absolute !== void 0) return absolute;
+    if (path.startsWith("/usage/")) {
+      const relative = firstNumber(root, [path.slice("/usage".length)]);
+      if (relative !== void 0) return relative;
+    }
+  }
+  return void 0;
+}
+
+// src/think-tags.ts
+var OPEN = "<think>";
+var CLOSE = "</think>";
+function holdSuffix(buffer, tag) {
+  const max = Math.min(buffer.length, tag.length - 1);
+  for (let size = max; size > 0; size -= 1) {
+    if (tag.startsWith(buffer.slice(buffer.length - size))) return size;
+  }
+  return 0;
+}
+var ThinkTagSplitter = class {
+  pending = "";
+  inThink = false;
+  answer = "";
+  reasoning = "";
+  push(chunk) {
+    this.pending += chunk;
+    let answerDelta = "";
+    let reasoningDelta = "";
+    while (this.pending.length > 0) {
+      if (!this.inThink) {
+        const openAt = this.pending.indexOf(OPEN);
+        if (openAt >= 0) {
+          answerDelta += this.pending.slice(0, openAt);
+          this.pending = this.pending.slice(openAt + OPEN.length);
+          this.inThink = true;
+          continue;
+        }
+        const hold2 = holdSuffix(this.pending, OPEN);
+        answerDelta += this.pending.slice(0, this.pending.length - hold2);
+        this.pending = this.pending.slice(this.pending.length - hold2);
+        break;
+      }
+      const closeAt = this.pending.indexOf(CLOSE);
+      if (closeAt >= 0) {
+        reasoningDelta += 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);
+      this.pending = this.pending.slice(this.pending.length - hold);
+      break;
+    }
+    this.answer += answerDelta;
+    this.reasoning += reasoningDelta;
+    return { answerDelta, reasoningDelta };
+  }
+  finish() {
+    if (this.inThink) {
+      const reasoningDelta = this.pending;
+      this.pending = "";
+      this.reasoning += reasoningDelta;
+      return { answerDelta: "", reasoningDelta };
+    }
+    const answerDelta = this.pending;
+    this.pending = "";
+    this.answer += answerDelta;
+    return { answerDelta, reasoningDelta: "" };
+  }
+};
+function splitThinkTags(text) {
+  const splitter = new ThinkTagSplitter();
+  splitter.push(text);
+  splitter.finish();
+  return { answer: splitter.answer, reasoning: splitter.reasoning };
+}
+
+// src/apply-resolution.ts
+function applyResolution(response, prepared) {
+  const result = response;
+  if (prepared.resolution) result.reasoningResolution = prepared.resolution;
+  const directive = prepared.directive;
+  if (!directive) return result;
+  const raw = response.raw?.response;
+  const pathText = firstConcatenatedText(raw, directive.response.reasoningTextPaths);
+  let tagText;
+  if (directive.response.stripThinkTags) {
+    const split = splitThinkTags(result.text);
+    result.text = split.answer;
+    if (split.reasoning) tagText = split.reasoning;
+  }
+  const reasoningText = pathText ?? tagText;
+  if (reasoningText) result.reasoningText = reasoningText;
+  applyUsage(result, raw, directive);
+  return result;
+}
+function applyUsage(response, raw, directive) {
+  const paths = directive.usage?.reasoningTokenPaths;
+  if (!paths || paths.length === 0) return;
+  const tokens = readReasoningTokens(raw, paths);
+  if (tokens === void 0) {
+    if (!response.usage || response.usage.reasoningTokens === void 0) return;
+    const usage = { ...response.usage };
+    delete usage.reasoningTokens;
+    response.usage = usage;
+    return;
+  }
+  response.usage = { ...response.usage ?? {}, reasoningTokens: tokens };
+}
+
+// src/decorate-stream.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function* decorateStream(prepared, source) {
+  const splitter = prepared.directive?.response.stripThinkTags ? new ThinkTagSplitter() : void 0;
+  let reasoningText = "";
+  for await (const event of source) {
+    if (event.type === "stream.start") {
+      yield withResolution(event, prepared);
+      continue;
+    }
+    if (event.type === "stream.reasoning.delta") {
+      const text = textOf(event);
+      if (text) reasoningText += text;
+      yield event;
+      continue;
+    }
+    if (event.type === "stream.text.delta" && splitter) {
+      const pushed = splitter.push(textOf(event));
+      if (pushed.reasoningDelta) {
+        reasoningText += pushed.reasoningDelta;
+        yield {
+          type: "stream.reasoning.delta",
+          requestId: event.requestId,
+          data: { text: pushed.reasoningDelta }
+        };
+      }
+      if (pushed.answerDelta) {
+        yield { ...event, data: { text: pushed.answerDelta } };
+      }
+      continue;
+    }
+    if (event.type === "stream.usage") {
+      yield adjustUsageEvent(event, prepared);
+      continue;
+    }
+    if (event.type === "stream.done") {
+      if (splitter) {
+        const finished = splitter.finish();
+        if (finished.reasoningDelta) {
+          reasoningText += finished.reasoningDelta;
+          yield {
+            type: "stream.reasoning.delta",
+            requestId: event.requestId,
+            data: { text: finished.reasoningDelta }
+          };
+        }
+        if (finished.answerDelta) {
+          yield {
+            type: "stream.text.delta",
+            requestId: event.requestId,
+            data: { text: finished.answerDelta }
+          };
+        }
+      }
+      const data = isRecord3(event.data) ? { ...event.data } : {};
+      if (splitter) data.text = splitter.answer;
+      if (reasoningText) data.reasoningText = reasoningText;
+      if (prepared.resolution) data.reasoningResolution = prepared.resolution;
+      yield { ...event, data };
+      continue;
+    }
+    yield event;
+  }
+}
+function withResolution(event, prepared) {
+  if (!prepared.resolution) return event;
+  const data = isRecord3(event.data) ? { ...event.data } : {};
+  data.reasoningResolution = prepared.resolution;
+  return { ...event, data };
+}
+function textOf(event) {
+  if (!isRecord3(event.data) || typeof event.data.text !== "string") return "";
+  return event.data.text;
+}
+function adjustUsageEvent(event, prepared) {
+  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;
+  }
+  return { ...event, data: { ...event.data, usage } };
+}
+
+// src/types/providers.ts
+var IMPLEMENTED_AI_PROVIDERS = ["openrouter", "bedrock", "openai"];
+function isImplementedAiProvider(provider) {
+  return IMPLEMENTED_AI_PROVIDERS.includes(provider);
+}
+
+// src/errors.ts
+var AiDispatcherError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "AiDispatcherError";
+  }
+  code;
+  details;
+};
+function providerNotImplemented(provider) {
+  const implemented = [...IMPLEMENTED_AI_PROVIDERS];
+  return new AiDispatcherError(
+    "PROVIDER_NOT_IMPLEMENTED",
+    `AI provider "${provider}" is not implemented yet. Supported by @x12i/ai-dispatcher: ${implemented.map((id) => `"${id}"`).join(", ")}.`,
+    {
+      provider,
+      implementedProviders: implemented,
+      operatorHint: `Pass provider: "${implemented[0]}" (or omit provider to use the default).`
+    }
+  );
+}
+
+// src/mcp.ts
+var TOOL_TOKEN = /^[A-Za-z0-9_-]+$/;
+var MAX_EXPOSED_NAME_LENGTH = 64;
+var DEFAULT_PARAMETERS = { type: "object", properties: {} };
+function createMcpCatalog(mcp) {
+  if (mcp === void 0) return { servers: [], tools: [] };
+  if (!Array.isArray(mcp.servers)) {
+    throw new AiDispatcherError("MCP_SERVER_INVALID", "mcp.servers must be an array.");
+  }
+  return {
+    servers: mcp.servers,
+    tools: indexMcpServers(mcp.servers)
+  };
+}
+function indexMcpServers(servers) {
+  const seenServers = /* @__PURE__ */ new Set();
+  const seenTools = /* @__PURE__ */ new Set();
+  const indexed = [];
+  for (const server of servers) {
+    assertServer(server, seenServers);
+    for (const tool of server.tools) {
+      if (!isRecord4(tool)) {
+        throw new AiDispatcherError(
+          "MCP_TOOL_NAME_INVALID",
+          `MCP server "${server.id}" has a tool that is not an object.`
+        );
+      }
+      const exposedName = exposedToolName(server.id, tool);
+      if (seenTools.has(exposedName)) {
+        throw new AiDispatcherError(
+          "MCP_TOOL_NAME_CONFLICT",
+          `MCP tool "${exposedName}" is defined more than once.`
+        );
+      }
+      seenTools.add(exposedName);
+      indexed.push({
+        exposedName,
+        rawName: tool.name,
+        description: toolDescription(tool),
+        parameters: toolParameters(tool),
+        server
+      });
+    }
+  }
+  return indexed;
+}
+async function refreshMcpCatalog(catalog) {
+  const listed = /* @__PURE__ */ new Map();
+  for (const server of catalog.servers) {
+    if (!server.listTools) continue;
+    let tools;
+    try {
+      tools = await server.listTools();
+    } catch (error) {
+      throw listFailed(server.id, error);
+    }
+    if (!Array.isArray(tools)) {
+      throw new AiDispatcherError(
+        "MCP_LIST_FAILED",
+        `MCP server "${server.id}" listTools did not return an array.`
+      );
+    }
+    listed.set(server.id, tools);
+  }
+  const draft = catalog.servers.map((server) => {
+    const tools = listed.get(server.id);
+    return tools ? { ...server, tools } : server;
+  });
+  try {
+    indexMcpServers(draft);
+  } catch (error) {
+    throw new AiDispatcherError(
+      "MCP_LIST_FAILED",
+      error instanceof Error ? error.message : "MCP tool list is invalid."
+    );
+  }
+  for (const server of catalog.servers) {
+    const tools = listed.get(server.id);
+    if (tools) server.tools = tools;
+  }
+  catalog.tools = indexMcpServers(catalog.servers);
+}
+function applyMcpCatalog(params) {
+  const filter = params.request.mcp;
+  delete params.request.mcp;
+  if (!params.includeMcp || filter === false || Array.isArray(filter) && filter.length === 0) return;
+  const allowed = resolveAllowlist(filter, params.catalog.tools);
+  const requestTools = params.request.functionTools ?? [];
+  const requestNames = new Set(requestTools.map((tool) => tool.name));
+  const injected = [];
+  for (const entry of params.catalog.tools) {
+    if (allowed && !allowed.has(entry.exposedName)) continue;
+    if (requestNames.has(entry.exposedName)) continue;
+    const clientExecutor = params.providerTools?.[entry.exposedName];
+    injected.push({
+      name: entry.exposedName,
+      description: entry.description,
+      parameters: entry.parameters,
+      ...typeof clientExecutor === "function" ? {} : { executor: createMcpExecutor(entry.server, entry.rawName) }
+    });
+  }
+  if (injected.length) {
+    params.request.functionTools = [...injected, ...requestTools];
+  }
+}
+function createMcpExecutor(server, rawName) {
+  return async (args, context) => {
+    const result = await server.callTool(rawName, toArgs(args), context);
+    return flattenMcpResult(result);
+  };
+}
+function flattenMcpResult(result) {
+  if (typeof result === "string") return result;
+  if (!isRecord4(result)) return stringify(result);
+  const text = textContent(result.content);
+  if (result.isError === true) {
+    throw new Error(text ?? stringify(result));
+  }
+  if (text !== void 0) return text;
+  return stringify(result);
+}
+function resolveAllowlist(filter, tools) {
+  if (filter === void 0) return void 0;
+  if (!Array.isArray(filter) || filter.some((name) => typeof name !== "string")) {
+    throw new AiDispatcherError(
+      "MCP_TOOL_NOT_FOUND",
+      "request.mcp must be false or a list of exposed tool names."
+    );
+  }
+  const known = new Set(tools.map((tool) => tool.exposedName));
+  for (const name of filter) {
+    if (!known.has(name)) {
+      throw new AiDispatcherError("MCP_TOOL_NOT_FOUND", `MCP tool "${name}" is not registered.`);
+    }
+  }
+  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");
+function prepareDispatchRequest(params) {
+  const cloned = cloneRequest(params.request);
+  const provider = params.provider;
+  const reasoningEffort = cloned.reasoningEffort;
+  const bedrockControls = cloned.bedrockControls;
+  delete cloned.provider;
+  delete cloned.reasoningEffort;
+  delete cloned.bedrockControls;
+  if (provider === "openai") assertOpenAiConfigured(params.options);
+  if (provider === "bedrock" && cloned.reasoning !== void 0) {
+    if (bedrockControls?.additionalModelRequestFields === void 0 && reasoningEffort === void 0) {
+      throw new AiDispatcherError(
+        "UNSUPPORTED_REQUEST_FIELD",
+        "Bedrock does not accept an OpenRouter reasoning object. Set reasoningEffort, or set bedrockControls.additionalModelRequestFields."
+      );
+    }
+    delete cloned.reasoning;
+  }
+  const requestedModel = cloned.model ?? defaultModelFor(provider, params.options) ?? "";
+  const explicit = hasExplicitControl(provider, cloned, bedrockControls);
+  let directive;
+  if (!explicit && reasoningEffort !== void 0) {
+    if (!requestedModel) {
+      throw new AiDispatcherError(
+        "REASONING_MODEL_REQUIRED",
+        "reasoningEffort requires a model id. Set request.model or the provider defaultModel."
+      );
+    }
+    directive = resolveCatalog({
+      target: provider,
+      model: requestedModel,
+      effort: reasoningEffort
+    });
+  }
+  if (provider === "openrouter") {
+    applyNestedReasoning(cloned, reasoningEffort);
+  }
+  if (directive?.model) cloned.model = directive.model;
+  if (directive?.promptPrefix) applyPromptPrefix(cloned, directive.promptPrefix);
+  const effectiveModel = cloned.model ?? requestedModel;
+  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 bodyOverlay = overlay;
+    call.finalizeBody = (body) => (0, import_ai_profiles.mergeReasoningBody)(body, bodyOverlay);
+  }
+  if (directive && hasStreamMetadata(directive)) {
+    const response = directive.response;
+    call.extractStreamReasoning = (event) => extractStreamReasoningText(event, response);
+  }
+  const resolution = reasoningEffort !== void 0 || explicit ? buildResolution({
+    requestedEffort: reasoningEffort,
+    target: provider,
+    requestedModel,
+    effectiveModel,
+    bypassed: explicit,
+    outcome: explicit ? void 0 : directive?.outcome
+  }) : void 0;
+  return {
+    provider,
+    request: cloned,
+    requestedModel,
+    effectiveModel,
+    ...resolution ? { resolution } : {},
+    ...directive ? { directive } : {},
+    call
+  };
+}
+function resolveCatalog(input) {
+  try {
+    return (0, import_ai_profiles.resolveReasoning)(input);
+  } catch (error) {
+    if (error instanceof import_ai_profiles.AIProfilesError) {
+      throw new AiDispatcherError(error.code, error.message, error.details);
+    }
+    throw error;
+  }
+}
+function hasExplicitControl(provider, request, bedrockControls) {
+  if (provider === "bedrock") return bedrockControls?.additionalModelRequestFields !== void 0;
+  return request.reasoning !== void 0;
+}
+function buildResolution(params) {
+  return {
+    target: params.target,
+    requestedModel: params.requestedModel,
+    effectiveModel: params.effectiveModel,
+    bypassed: params.bypassed,
+    ...params.requestedEffort ? { requestedEffort: params.requestedEffort } : {},
+    ...params.outcome ? { outcome: params.outcome } : {}
+  };
+}
+function applyNestedReasoning(request, parentEffort) {
+  const serverTools = request.serverTools;
+  if (!serverTools) return;
+  if (serverTools.fusion) serverTools.fusion = settleNested(serverTools.fusion, "fusion", parentEffort);
+  if (serverTools.advisor) {
+    serverTools.advisor = Array.isArray(serverTools.advisor) ? serverTools.advisor.map((advisor) => settleNested(advisor, "advisor", parentEffort)) : settleNested(serverTools.advisor, "advisor", parentEffort);
+  }
+  if (serverTools.subagent) serverTools.subagent = settleNested(serverTools.subagent, "subagent", parentEffort);
+}
+function settleNested(policy, kind, parentEffort) {
+  const current = policy;
+  const childEffort = current.reasoningEffort;
+  const next = { ...current };
+  delete next.reasoningEffort;
+  if (next.reasoning !== void 0) return next;
+  const effort = childEffort ?? parentEffort;
+  if (!effort) return next;
+  const model = kind === "fusion" ? next.judgeModel : next.model;
+  if (!model) return next;
+  const directive = resolveCatalog({ target: "openrouter", model, effort });
+  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;
+  return next;
+}
+function applyPromptPrefix(request, prefix) {
+  if (typeof request.prompt === "string") {
+    request.prompt = prefix + request.prompt;
+    return;
+  }
+  if (prefixMessages(request.messages, prefix)) return;
+  if (typeof request.input === "string") {
+    request.input = prefix + request.input;
+    return;
+  }
+  if (Array.isArray(request.input) && prefixInputItems(request.input, prefix)) return;
+  throw new AiDispatcherError(
+    "REASONING_PREFIX_UNSUPPORTED",
+    "The catalog prompt prefix cannot be applied because the request has no user text to prefix."
+  );
+}
+function prefixMessages(messages, prefix) {
+  if (!messages) return false;
+  for (const message of messages) {
+    if (message.role !== "user") continue;
+    if (typeof message.content === "string") {
+      message.content = prefix + message.content;
+      return true;
+    }
+    for (const part of message.content) {
+      if (part.type === "text") {
+        part.text = prefix + part.text;
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function prefixInputItems(items, prefix) {
+  for (let index = 0; index < items.length; index += 1) {
+    const item = items[index];
+    if (typeof item === "string") {
+      items[index] = prefix + item;
+      return true;
+    }
+    if (!item || item.role === "system") continue;
+    if (typeof item.content === "string" && (item.role === "user" || item.role === void 0)) {
+      item.content = prefix + item.content;
+      return true;
+    }
+    if (!Array.isArray(item.content)) continue;
+    for (const part of item.content) {
+      if (!isRecord5(part) || typeof part.text !== "string") continue;
+      if (part.type === "text" || part.type === "input_text") {
+        part.text = prefix + part.text;
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function assertOpenAiConfigured(options) {
+  const apiKey = options.openai?.apiKey ?? readEnv("OPENAI_API_KEY");
+  if (!apiKey) {
+    throw new AiDispatcherError(
+      "OPENAI_API_KEY_MISSING",
+      "OpenAI API key is required. Set openai.apiKey or OPENAI_API_KEY."
+    );
+  }
+}
+function defaultModelFor(provider, options) {
+  if (provider === "openrouter") return options.openrouter?.defaultModel;
+  if (provider === "bedrock") return options.bedrock?.defaultModel;
+  return options.openai?.defaultModel;
+}
+function cloneRequest(request) {
+  const functionTools = request.functionTools?.map((tool) => ({ ...tool }));
+  const cloned = JSON.parse(JSON.stringify(request));
+  if (functionTools) cloned.functionTools = functionTools;
+  return cloned;
+}
+function hasOwnKeys(value) {
+  return Object.keys(value).length > 0;
+}
+function hasStreamMetadata(directive) {
+  return directive.response.streamReasoningKeys.length > 0 || directive.response.streamReasoningPaths.length > 0;
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readEnv(name) {
+  if (typeof process === "undefined") return void 0;
+  return process.env[name];
+}
+
+// src/providers/bedrock.ts
+var import_bedrock_runtime = require("@x12i/bedrock-runtime");
+function createBedrockProviderAdapter(options = {}) {
+  const runtime = (0, import_bedrock_runtime.createBedrockRuntime)(options);
+  return {
+    run(request, call) {
+      return runtime.run(toBedrockRequest(request), toCall(call));
+    },
+    executeStreamingChat(request, call) {
+      return runtime.executeStreamingChat(
+        toBedrockRequest(request),
+        toCall(call)
+      );
+    },
+    compile(request, call) {
+      return runtime.compile(toBedrockRequest(request), toCall(call));
+    }
+  };
+}
+function toCall(call) {
+  if (!call) return void 0;
+  return {
+    ...call.finalizeBody ? { finalizeBody: call.finalizeBody } : {},
+    ...call.extractStreamReasoning ? { extractStreamReasoning: call.extractStreamReasoning } : {}
+  };
+}
+function toBedrockRequest(request) {
+  assertBedrockSupported(request);
+  const mapped = {};
+  if (request.id !== void 0) mapped.id = request.id;
+  if (request.model !== void 0) mapped.model = request.model;
+  const hasMessages2 = Array.isArray(request.messages) && request.messages.length > 0;
+  if (hasMessages2) {
+    mapped.messages = request.messages;
+  } else if (Array.isArray(request.input)) {
+    mapped.messages = inputItemsToMessages(request.input);
+  }
+  const system = request.system?.trim() ? request.system : request.instructions;
+  if (system !== void 0) mapped.system = system;
+  if (request.prompt !== void 0) mapped.prompt = request.prompt;
+  else if (!hasMessages2 && !Array.isArray(request.input) && typeof request.input === "string") {
+    mapped.prompt = request.input;
+  }
+  if (request.temperature !== void 0) mapped.temperature = request.temperature;
+  if (request.maxTokens !== void 0) mapped.maxTokens = request.maxTokens;
+  if (request.functionTools !== void 0) {
+    mapped.functionTools = request.functionTools;
+  }
+  if (request.toolChoice !== void 0 && isBedrockToolChoice(request.toolChoice)) {
+    mapped.toolChoice = request.toolChoice;
+  }
+  if (request.execution !== void 0) {
+    mapped.execution = {
+      ...request.execution.maxToolIterations !== void 0 ? { maxToolIterations: request.execution.maxToolIterations } : {},
+      ...request.execution.maxFunctionToolCalls !== void 0 ? { maxFunctionToolCalls: request.execution.maxFunctionToolCalls } : {},
+      ...request.execution.timeoutMs !== void 0 ? { timeoutMs: request.execution.timeoutMs } : {}
+    };
+  }
+  if (request.metadata !== void 0) mapped.metadata = request.metadata;
+  return mapped;
+}
+function assertBedrockSupported(request) {
+  if (request.serverTools && serverToolsEnabled(request.serverTools)) {
+    throw new AiDispatcherError(
+      "UNSUPPORTED_REQUEST_FIELD",
+      "Bedrock does not support OpenRouter server tools."
+    );
+  }
+  if (request.responseFormat !== void 0) {
+    throw new AiDispatcherError("UNSUPPORTED_REQUEST_FIELD", "Bedrock does not accept responseFormat.");
+  }
+  if (request.rawOpenRouterOverrides !== void 0) {
+    throw new AiDispatcherError(
+      "UNSUPPORTED_REQUEST_FIELD",
+      "rawOpenRouterOverrides cannot be sent to Bedrock."
+    );
+  }
+  if (request.apiMode !== void 0) {
+    throw new AiDispatcherError("UNSUPPORTED_REQUEST_FIELD", "Bedrock does not accept apiMode.");
+  }
+  if (request.toolChoice && typeof request.toolChoice === "object" && request.toolChoice.type === "server_tool") {
+    throw new AiDispatcherError(
+      "UNSUPPORTED_REQUEST_FIELD",
+      "Bedrock does not support OpenRouter server tool choices."
+    );
+  }
+  if (hasMessages(request) && Array.isArray(request.input)) {
+    throw new AiDispatcherError(
+      "UNSUPPORTED_REQUEST_FIELD",
+      "Bedrock accepts messages or input items, not both."
+    );
+  }
+}
+function hasMessages(request) {
+  return Array.isArray(request.messages) && request.messages.length > 0;
+}
+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 inputItemsToMessages(items) {
+  return items.map((item) => {
+    if (typeof item === "string") return { role: "user", content: item };
+    const role = item.role;
+    if (role !== "system" && role !== "user" && role !== "assistant" && role !== "tool" || !hasContent(item.content)) {
+      throw new AiDispatcherError(
+        "UNSUPPORTED_REQUEST_FIELD",
+        "Bedrock input items must be text or messages with role and content."
+      );
+    }
+    return {
+      role,
+      content: item.content,
+      ...typeof item.name === "string" ? { name: item.name } : {},
+      ...typeof item.toolCallId === "string" ? { toolCallId: item.toolCallId } : {}
+    };
+  });
+}
+function hasContent(content) {
+  return typeof content === "string" || Array.isArray(content);
+}
+function isBedrockToolChoice(toolChoice) {
+  if (toolChoice === void 0) return false;
+  if (toolChoice === "auto" || toolChoice === "none" || toolChoice === "required") return true;
+  if (typeof toolChoice === "object" && toolChoice.type === "function") return true;
+  return false;
+}
+
+// src/providers/openai.ts
+var DEFAULT_BASE_URL = "https://api.openai.com/v1";
+var DEFAULT_TIMEOUT_MS = 12e4;
+function createOpenAiProviderAdapter(options = {}) {
+  const resolved = resolveOpenAiOptions(options);
+  return {
+    compile(request, call) {
+      return compileOpenAiRequest(request, resolved, call, false);
+    },
+    async run(request, call) {
+      const requestId = request.id ?? "openai";
+      try {
+        return await runOpenAi(request, resolved, call, requestId);
+      } catch (error) {
+        if (error instanceof AiDispatcherError && isConfigError(error.code)) throw error;
+        return failedResponse(request, requestId, error);
+      }
+    },
+    executeStreamingChat(request, call) {
+      return streamOpenAi(request, resolved, call);
+    }
+  };
+}
+function compileOpenAiRequest(request, options, call, streaming) {
+  assertSupported(request);
+  const model = (request.model ?? options.defaultModel ?? "").trim();
+  if (!model) {
+    throw new AiDispatcherError(
+      "MODEL_REQUIRED",
+      "A model id is required. Set request.model or openai.defaultModel."
+    );
+  }
+  if (!options.apiKey) {
+    throw new AiDispatcherError(
+      "OPENAI_API_KEY_MISSING",
+      "OpenAI API key is required. Set openai.apiKey or OPENAI_API_KEY."
+    );
+  }
+  const instructions = compileInstructions(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({
+    model,
+    input,
+    instructions,
+    temperature: request.temperature,
+    max_output_tokens: request.maxTokens,
+    reasoning: request.reasoning,
+    text: request.responseFormat,
+    tools: compileTools(request),
+    tool_choice: compileToolChoice(request)
+  });
+  if (call?.finalizeBody) body = call.finalizeBody(body);
+  if (streaming) body = { ...body, stream: true };
+  else body = { ...body, stream: false };
+  return {
+    url: `${options.baseUrl}/responses`,
+    headers: buildHeaders(options),
+    body,
+    warnings: []
+  };
+}
+function assertSupported(request) {
+  if (request.serverTools && serverToolsEnabled2(request.serverTools)) {
+    throw new AiDispatcherError(
+      "UNSUPPORTED_REQUEST_FIELD",
+      "Direct OpenAI does not support OpenRouter server tools."
+    );
+  }
+  if (request.rawOpenRouterOverrides !== void 0) {
+    throw new AiDispatcherError(
+      "UNSUPPORTED_REQUEST_FIELD",
+      "rawOpenRouterOverrides cannot be sent to the OpenAI Responses API."
+    );
+  }
+  if (request.apiMode === "chat") {
+    throw new AiDispatcherError(
+      "UNSUPPORTED_REQUEST_FIELD",
+      "Direct OpenAI uses the Responses API. Do not set apiMode to chat."
+    );
+  }
+  if (request.toolChoice && typeof request.toolChoice === "object" && request.toolChoice.type === "server_tool") {
+    throw new AiDispatcherError(
+      "UNSUPPORTED_REQUEST_FIELD",
+      "Direct OpenAI does not support OpenRouter server tool choices."
+    );
+  }
+}
+function serverToolsEnabled2(policy) {
+  return Object.values(policy).some((value) => {
+    if (Array.isArray(value)) return value.some((item) => isEnabledMode2(item));
+    return isEnabledMode2(value);
+  });
+}
+function isEnabledMode2(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 compileInput(request) {
+  if (request.input !== void 0) return request.input;
+  const items = [];
+  for (const message of request.messages ?? []) {
+    if (message.role === "system" && !request.instructions && !request.system) continue;
+    if (message.role === "system") continue;
+    items.push(compileInputItem(message));
+  }
+  if (typeof request.prompt === "string") {
+    items.push({ role: "user", content: request.prompt });
+  }
+  return items.length ? items : void 0;
+}
+function compileInputItem(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: compileContent(message.content) };
+}
+function compileContent(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 };
+    if (part.url) {
+      return clean({ 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 });
+    }
+    throw new AiDispatcherError(
+      "UNSUPPORTED_REQUEST_FIELD",
+      "File content parts need a url or data."
+    );
+  });
+}
+function compileTools(request) {
+  const tools = request.functionTools ?? [];
+  if (!tools.length) return void 0;
+  return tools.map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters
+  }));
+}
+function compileToolChoice(request) {
+  const choice = request.toolChoice;
+  if (!choice || choice === "auto") return void 0;
+  if (choice === "none" || choice === "required") return choice;
+  if (typeof choice === "object" && choice.type === "function") {
+    return { type: "function", name: choice.functionName };
+  }
+  return void 0;
+}
+async function runOpenAi(request, options, call, requestId) {
+  const maxIterations = request.execution?.maxToolIterations ?? 8;
+  const maxFunctionToolCalls = request.execution?.maxFunctionToolCalls ?? 20;
+  const functionUsage = [];
+  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 : {});
+    if (!calls.length) break;
+    if (!calls.every((item) => resolveExecutor(item.name, request, options))) {
+      return normalizeOpenAiResponse({
+        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 executeOpenAiTool(item, request, options));
+    }
+    functionUsage.push(...results);
+    const record = isRecord6(response) ? response : {};
+    active = {
+      ...active,
+      body: clean({
+        ...active.body,
+        tool_choice: "auto",
+        previous_response_id: typeof record.id === "string" ? record.id : void 0,
+        input: results.map(toFunctionCallOutput)
+      })
+    };
+  }
+  return normalizeOpenAiResponse({
+    request,
+    requestId,
+    compiled: active,
+    response,
+    functionTools: functionUsage,
+    status: "completed"
+  });
+}
+function resolveExecutor(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);
+  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;
+  }
+}
+function toFunctionCallOutput(result) {
+  const output = result.status === "completed" ? result.result : { error: result.error };
+  return {
+    type: "function_call_output",
+    call_id: result.callId,
+    output: typeof output === "string" ? output : JSON.stringify(output)
+  };
+}
+function contentToText(content) {
+  if (typeof content === "string") return content;
+  return content.map((part) => part.type === "text" ? part.text : "").filter(Boolean).join("");
+}
+async function* streamOpenAi(request, options, call) {
+  const requestId = request.id ?? "";
+  let compiled;
+  try {
+    compiled = compileOpenAiRequest(request, options, call, true);
+  } catch (error) {
+    yield errorEvent(requestId, error);
+    throw error;
+  }
+  yield {
+    type: "stream.start",
+    requestId,
+    data: {
+      model: typeof compiled.body.model === "string" ? compiled.body.model : "",
+      apiMode: "responses",
+      entrypoint: "executeStreamingChat"
+    }
+  };
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutFor(request, options));
+  let text = "";
+  let reported = false;
+  const report = (error) => {
+    const failure = error instanceof AiDispatcherError ? error : new AiDispatcherError(
+      "PROVIDER_GATEWAY_UNREACHABLE",
+      error instanceof Error ? error.message : "OpenAI request failed before receiving a response."
+    );
+    return failure;
+  };
+  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 (!isRecord6(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 } };
+      } else if (event.type === "response.reasoning_summary_text.delta" && call?.extractStreamReasoning) {
+        const reasoningText = call.extractStreamReasoning(event);
+        if (reasoningText) {
+          yield { type: "stream.reasoning.delta", requestId, data: { text: reasoningText } };
+        }
+      } else if (event.type === "response.function_call_arguments.delta" && typeof event.delta === "string") {
+        yield {
+          type: "stream.tool_call.delta",
+          requestId,
+          data: {
+            index: 0,
+            ...typeof event.name === "string" ? { name: event.name } : {},
+            argumentsDelta: event.delta
+          }
+        };
+      } else if (event.type === "response.completed" && isRecord6(event.response)) {
+        const usage = normalizeUsage(event.response.usage);
+        if (usage) yield { type: "stream.usage", requestId, data: { usage } };
+      } else if (event.type === "error") {
+        const failure = new AiDispatcherError(
+          "PROVIDER_REQUEST_FAILED",
+          typeof event.message === "string" ? event.message : "OpenAI stream returned an error event.",
+          event
+        );
+        reported = true;
+        yield errorEvent(requestId, failure);
+        throw failure;
+      }
+    }
+    yield {
+      type: "stream.done",
+      requestId,
+      data: {
+        text,
+        model: typeof compiled.body.model === "string" ? compiled.body.model : ""
+      }
+    };
+  } 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);
+    throw failure;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function sendWithRetries(compiled, options, timeoutMs) {
+  const attempts = options.maxAttempts;
+  let lastError;
+  for (let attempt = 1; attempt <= attempts; 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 >= attempts) 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();
+    return text ? JSON.parse(text) : {};
+  } catch (error) {
+    if (error instanceof AiDispatcherError) throw error;
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new AiDispatcherError("PROVIDER_GATEWAY_UNREACHABLE", "OpenAI request timed out.");
+    }
+    throw new AiDispatcherError(
+      "PROVIDER_GATEWAY_UNREACHABLE",
+      error instanceof Error ? error.message : "OpenAI 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) ?? `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 });
+}
+function classifyStatus(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) {
+  return code === "OPENAI_API_KEY_MISSING" || code === "MODEL_REQUIRED" || code === "INPUT_REQUIRED" || code === "UNSUPPORTED_REQUEST_FIELD";
+}
+function asTerminalError(error) {
+  if (error instanceof AiDispatcherError && error.code === "PROVIDER_RETRYABLE") {
+    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 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 status = params.status ?? (calls.length ? "requires_action" : "completed");
+  return {
+    id: typeof record.id === "string" ? record.id : params.requestId,
+    status,
+    apiMode: "responses",
+    model: typeof record.model === "string" ? record.model : modelOf(params.compiled),
+    text,
+    citations: [],
+    images: [],
+    patches: [],
+    toolUsage: toolUsage(calls),
+    ...usage ? { usage } : {},
+    warnings: params.compiled.warnings,
+    errors: [],
+    raw: { request: params.compiled.body, response: params.response },
+    ...params.request.metadata ? { metadata: params.request.metadata } : {}
+  };
+}
+function answerText(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;
+      for (const part of item.content) {
+        if (isRecord6(part) && part.type === "output_text" && typeof part.text === "string") parts.push(part.text);
+      }
+    }
+    if (parts.length > 0) return parts.join("");
+  }
+  return typeof response.output_text === "string" ? response.output_text : "";
+}
+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;
+    const name = typeof item.name === "string" ? item.name : "function";
+    const callId = typeof item.call_id === "string" ? item.call_id : name;
+    let args = item.arguments;
+    if (typeof item.arguments === "string") {
+      try {
+        args = JSON.parse(item.arguments);
+      } catch {
+        args = item.arguments;
+      }
+    }
+    calls.push({ name, callId, status: "completed", args });
+  }
+  return calls;
+}
+function toolUsage(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 (!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);
+  return {
+    raw: usage,
+    ...inputTokens !== void 0 ? { inputTokens } : {},
+    ...outputTokens !== void 0 ? { outputTokens } : {},
+    ...totalTokens !== void 0 ? { totalTokens } : {}
+  };
+}
+function failedResponse(request, requestId, error) {
+  const normalized = error instanceof AiDispatcherError ? error : new AiDispatcherError("PROVIDER_REQUEST_FAILED", error instanceof Error ? error.message : String(error));
+  return {
+    id: requestId,
+    status: "failed",
+    apiMode: "responses",
+    model: request.model ?? "",
+    text: "",
+    citations: [],
+    images: [],
+    patches: [],
+    toolUsage: toolUsage([]),
+    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 modelOf(compiled) {
+  return typeof compiled.body.model === "string" ? compiled.body.model : "";
+}
+function messageFrom(body) {
+  if (!isRecord6(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;
+  return void 0;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function clean(body) {
+  return Object.fromEntries(Object.entries(body).filter(([, value]) => value !== void 0));
+}
+function buildHeaders(options) {
+  return {
+    "content-type": "application/json",
+    authorization: `Bearer ${options.apiKey}`,
+    ...options.organization ? { "OpenAI-Organization": options.organization } : {},
+    ...options.project ? { "OpenAI-Project": options.project } : {}
+  };
+}
+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", "OpenAI 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;
+    }
+  }
+  const trailing = parseSsePart(buffer);
+  if (trailing !== void 0) yield trailing;
+}
+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;
+  }
+}
+function resolveOpenAiOptions(options) {
+  const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  return {
+    apiKey: options.apiKey ?? readEnv2("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,
+    maxAttempts: options.maxAttempts ?? 3,
+    fetch: options.fetch ?? globalThis.fetch,
+    ...options.tools ? { tools: options.tools } : {},
+    ...options.logger ? { logger: options.logger } : {}
+  };
+}
+function readEnv2(name) {
+  if (typeof process === "undefined") return void 0;
+  return process.env[name];
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/providers/openrouter.ts
+var import_openrouter_runtime = require("@x12i/openrouter-runtime");
+function createOpenRouterProviderAdapter(options = {}) {
+  const runtime = (0, import_openrouter_runtime.createOpenRouterRuntime)(options);
+  return {
+    run(request, call) {
+      return runtime.run(request, toCall2(call));
+    },
+    executeStreamingChat(request, call) {
+      return runtime.executeStreamingChat(request, toCall2(call));
+    },
+    compile(request, call) {
+      return runtime.compile(request, toCall2(call));
+    }
+  };
+}
+function toCall2(call) {
+  if (!call) return void 0;
+  return {
+    ...call.finalizeBody ? { finalizeBody: call.finalizeBody } : {},
+    ...call.extractStreamReasoning ? { extractStreamReasoning: call.extractStreamReasoning } : {},
+    ...call.suppressNestedReasoningFallback ? { suppressNestedReasoningFallback: true } : {}
+  };
+}
+
+// src/resolve-provider.ts
+function resolveProvider(requestProvider, defaultProvider) {
+  const provider = requestProvider ?? defaultProvider;
+  if (!provider || typeof provider !== "string") {
+    throw new AiDispatcherError(
+      "PROVIDER_REQUIRED",
+      "An AI provider is required. Set options.provider or request.provider."
+    );
+  }
+  if (!isImplementedAiProvider(provider)) {
+    throw providerNotImplemented(provider);
+  }
+  return provider;
+}
+
+// src/create-dispatcher.ts
+var SECRET_HEADERS = /* @__PURE__ */ new Set(["authorization", "x-api-key", "api-key"]);
+function createAiDispatcher(options = {}) {
+  const defaultProvider = resolveProvider(options.provider, "openrouter");
+  const catalog = createMcpCatalog(options.mcp);
+  let refreshChain = Promise.resolve();
+  const adapters = /* @__PURE__ */ new Map();
+  function createAdapter(provider) {
+    if (provider === "openrouter") {
+      const openrouterOptions = {
+        ...options.openrouter,
+        ...options.logger && !options.openrouter?.logger ? { logger: options.logger } : {}
+      };
+      return createOpenRouterProviderAdapter(openrouterOptions);
+    }
+    if (provider === "bedrock") {
+      const bedrockOptions = {
+        ...options.bedrock,
+        ...options.logger && !options.bedrock?.logger ? { logger: options.logger } : {}
+      };
+      return createBedrockProviderAdapter(bedrockOptions);
+    }
+    if (provider === "openai") {
+      const openaiOptions = {
+        ...options.openai,
+        ...options.logger && !options.openai?.logger ? { logger: options.logger } : {}
+      };
+      return createOpenAiProviderAdapter(openaiOptions);
+    }
+    throw new AiDispatcherError(
+      "PROVIDER_ADAPTER_MISSING",
+      `No adapter registered for provider "${provider}".`
+    );
+  }
+  function getAdapter(provider) {
+    let adapter = adapters.get(provider);
+    if (!adapter) {
+      adapter = createAdapter(provider);
+      adapters.set(provider, adapter);
+    }
+    return adapter;
+  }
+  getAdapter(defaultProvider);
+  return {
+    provider: defaultProvider,
+    async run(request) {
+      const prepared = prepare(request, true);
+      log(options, "ai-dispatcher.request.started", prepared, "run", false);
+      const response = await getAdapter(prepared.provider).run(prepared.request, callOf(prepared.call));
+      return applyResolution(response, prepared);
+    },
+    executeStreamingChat(request) {
+      const prepared = prepare(request, false);
+      log(options, "ai-dispatcher.request.started", prepared, "executeStreamingChat", true);
+      return decorateStream(
+        prepared,
+        getAdapter(prepared.provider).executeStreamingChat(prepared.request, callOf(prepared.call))
+      );
+    },
+    compile(request) {
+      const prepared = prepare(request, true);
+      log(options, "ai-dispatcher.request.compiled", prepared, "compile", false);
+      const compiled = getAdapter(prepared.provider).compile(prepared.request, callOf(prepared.call));
+      return attachCompileMeta(prepared, compiled);
+    },
+    refreshMcp() {
+      const pending = refreshChain.then(() => refreshMcpCatalog(catalog));
+      refreshChain = pending.then(
+        () => void 0,
+        () => void 0
+      );
+      return pending;
+    }
+  };
+  function prepare(request, includeMcp) {
+    const provider = resolveProvider(request.provider, defaultProvider);
+    const prepared = prepareDispatchRequest({ request, provider, options });
+    const tools = providerTools(provider, options);
+    applyMcpCatalog({
+      request: prepared.request,
+      catalog,
+      ...tools ? { providerTools: tools } : {},
+      includeMcp
+    });
+    return prepared;
+  }
+}
+function providerTools(provider, options) {
+  if (provider === "openrouter") return options.openrouter?.tools;
+  if (provider === "bedrock") return options.bedrock?.tools;
+  return options.openai?.tools;
+}
+function callOf(call) {
+  if (!call.finalizeBody && !call.extractStreamReasoning && !call.suppressNestedReasoningFallback) return void 0;
+  return call;
+}
+function attachCompileMeta(prepared, compiled) {
+  const record = compiled;
+  const headers = isRecord7(record.headers) ? redactHeaders(record.headers) : void 0;
+  return {
+    ...record,
+    ...headers ? { headers } : {},
+    provider: prepared.provider,
+    requestedModel: prepared.requestedModel,
+    effectiveModel: prepared.effectiveModel,
+    ...prepared.resolution ? { reasoningResolution: prepared.resolution } : {}
+  };
+}
+function redactHeaders(headers) {
+  const redacted = {};
+  for (const [key, value] of Object.entries(headers)) {
+    redacted[key] = SECRET_HEADERS.has(key.toLowerCase()) ? "[redacted]" : value;
+  }
+  return redacted;
+}
+function log(options, event, prepared, entrypoint, streaming) {
+  const payload = {
+    provider: prepared.provider,
+    entrypoint,
+    streaming,
+    requestedModel: prepared.requestedModel,
+    effectiveModel: prepared.effectiveModel
+  };
+  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 (event.endsWith("compiled")) options.logger?.debug?.(event, payload);
+  else options.logger?.info?.(event, payload);
+}
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/history.ts
+function stripReasoningHistoryFields(message, paths) {
+  const clone = structuredClone(message);
+  for (const path of paths) deletePointer(clone, path);
+  return clone;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AiDispatcherError,
+  IMPLEMENTED_AI_PROVIDERS,
+  createAiDispatcher,
+  isImplementedAiProvider,
+  providerNotImplemented,
+  resolveProvider,
+  stripReasoningHistoryFields
+});
+//# sourceMappingURL=index.cjs.map