@x12i/openrouter-runtime 1.0.0

package/dist/index.js

@@ -0,0 +1,1212 @@
+// src/config/defaults.ts
+function resolveRuntimeOptions(options) {
+  return {
+    ...options,
+    baseUrl: options.baseUrl ?? "https://openrouter.ai/api/v1",
+    defaultHeaders: options.defaultHeaders ?? {},
+    fetch: options.fetch ?? globalThis.fetch
+  };
+}
+function resolveDefaults(options) {
+  const retry = options.defaults?.retry;
+  return {
+    ...options.defaults,
+    apiMode: options.defaults?.apiMode ?? "auto",
+    timeoutMs: options.defaults?.timeoutMs ?? 12e4,
+    retry: {
+      enabled: retry?.enabled ?? true,
+      maxAttempts: retry?.maxAttempts ?? options.defaults?.maxRetries ?? 3,
+      baseDelayMs: retry?.baseDelayMs ?? 500,
+      maxDelayMs: retry?.maxDelayMs ?? 5e3
+    },
+    requireCitationsWhenSearchUsed: options.defaults?.requireCitationsWhenSearchUsed ?? true,
+    onPolicyViolation: options.defaults?.onPolicyViolation ?? "return_error",
+    serverTools: options.defaults?.serverTools ?? {
+      datetime: {
+        mode: "allowed",
+        timezone: "UTC"
+      }
+    }
+  };
+}
+
+// src/openrouter/errors.ts
+var RuntimeConfigError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "RuntimeConfigError";
+  }
+  code;
+  details;
+};
+var OpenRouterHttpError = class extends Error {
+  constructor(status, code, message, body, retryable = false) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.body = body;
+    this.retryable = retryable;
+    this.name = "OpenRouterHttpError";
+  }
+  status;
+  code;
+  body;
+  retryable;
+};
+
+// src/utils/delay.ts
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function retryDelay(attempt, baseDelayMs, maxDelayMs) {
+  const exponential = Math.min(maxDelayMs, baseDelayMs * 2 ** Math.max(0, attempt - 1));
+  const jitter = Math.floor(Math.random() * Math.min(250, exponential));
+  return exponential + jitter;
+}
+
+// src/openrouter/http-client.ts
+async function sendOpenRouterRequest(compiled, options, defaults, timeoutMs) {
+  const attempts = defaults.retry.enabled ? defaults.retry.maxAttempts : 1;
+  let lastError;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      return await sendOnce(compiled, options, timeoutMs);
+    } catch (error) {
+      lastError = error;
+      const retryable = error instanceof OpenRouterHttpError ? error.retryable : true;
+      if (!retryable || attempt >= attempts) throw error;
+      await delay(retryDelay(attempt, defaults.retry.baseDelayMs, defaults.retry.maxDelayMs));
+    }
+  }
+  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
+    });
+    const text = await response.text();
+    const body = text ? parseBody(text) : void 0;
+    if (!response.ok) {
+      throw new OpenRouterHttpError(
+        response.status,
+        statusToCode(response.status),
+        extractMessage(body) ?? `OpenRouter request failed with status ${response.status}.`,
+        body,
+        isRetryableStatus(response.status)
+      );
+    }
+    return body;
+  } catch (error) {
+    if (error instanceof OpenRouterHttpError) throw error;
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new OpenRouterHttpError(408, "OPENROUTER_TIMEOUT", "OpenRouter request timed out.", void 0, true);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function parseBody(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function extractMessage(body) {
+  if (typeof body !== "object" || body === null) return void 0;
+  const record = body;
+  const error = record.error;
+  if (typeof error === "object" && error !== null && typeof error.message === "string") {
+    return error.message;
+  }
+  return typeof record.message === "string" ? record.message : void 0;
+}
+function statusToCode(status) {
+  if (status === 401) return "OPENROUTER_AUTH_FAILED";
+  if (status === 429) return "OPENROUTER_RATE_LIMITED";
+  return "OPENROUTER_REQUEST_FAILED";
+}
+function isRetryableStatus(status) {
+  return status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
+}
+
+// src/utils/json.ts
+function parseJsonMaybe(value) {
+  if (typeof value !== "string") return value;
+  if (value.trim() === "") return {};
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function stringifyToolResult(value) {
+  if (typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/function-tools/tool-messages.ts
+function resultToChatToolMessage(result) {
+  return {
+    role: "tool",
+    toolCallId: result.callId,
+    name: result.name,
+    content: stringifyToolResult(result.status === "completed" ? result.result : { error: result.error })
+  };
+}
+function resultToResponsesInput(result) {
+  return {
+    type: "function_call_output",
+    call_id: result.callId,
+    output: stringifyToolResult(result.status === "completed" ? result.result : { error: result.error })
+  };
+}
+
+// src/normalize/citations.ts
+function extractCitations(value) {
+  const citations = [];
+  visit(value, (item) => {
+    const url = pickString(item, ["url", "uri"]);
+    if (!url) return;
+    citations.push({
+      type: "url",
+      url,
+      sourceProvider: "openrouter",
+      raw: item,
+      ...optional("title", pickString(item, ["title", "name"])),
+      ...optional("excerpt", pickString(item, ["excerpt", "content", "text"])),
+      ...optional("startIndex", pickNumber(item, ["start_index", "startIndex"])),
+      ...optional("endIndex", pickNumber(item, ["end_index", "endIndex"]))
+    });
+  });
+  return dedupe(citations);
+}
+function optional(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+function visit(value, onCitation) {
+  if (Array.isArray(value)) {
+    for (const item of value) visit(item, onCitation);
+    return;
+  }
+  if (!isRecord(value)) return;
+  if (value.type === "url_citation" || value.type === "citation" || value.url || value.uri) onCitation(value);
+  for (const key of ["annotations", "citations"]) visit(value[key], onCitation);
+}
+function pickString(record, keys) {
+  for (const key of keys) if (typeof record[key] === "string") return record[key];
+  return void 0;
+}
+function pickNumber(record, keys) {
+  for (const key of keys) if (typeof record[key] === "number") return record[key];
+  return void 0;
+}
+function dedupe(citations) {
+  const seen = /* @__PURE__ */ new Set();
+  return citations.filter((citation) => {
+    const key = `${citation.url}:${citation.startIndex ?? ""}:${citation.endIndex ?? ""}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+// src/normalize/images.ts
+function extractImages(value) {
+  const images = [];
+  visit2(value, (record) => {
+    const imageUrl = stringValue(record.image_url) ?? stringValue(record.url);
+    if (imageUrl) images.push({ imageUrl, status: "ok", raw: record });
+  });
+  return images;
+}
+function visit2(value, onImage) {
+  if (Array.isArray(value)) {
+    for (const item of value) visit2(item, onImage);
+    return;
+  }
+  if (!isRecord(value)) return;
+  if (value.type === "image" || value.type === "image_generation_call" || value.image_url || value.url) {
+    if (value.image_url || value.type === "image_generation_call") onImage(value);
+  }
+  for (const nested of Object.values(value)) visit2(nested, onImage);
+}
+function stringValue(value) {
+  if (typeof value === "string") return value;
+  if (isRecord(value) && typeof value.url === "string") return value.url;
+  return void 0;
+}
+
+// src/normalize/patches.ts
+function extractPatches(value) {
+  const patches = [];
+  visit3(value, (record) => {
+    const operation = normalizeOperation(record);
+    if (!operation) return;
+    patches.push({
+      callId: stringValue2(record.call_id) ?? stringValue2(record.id) ?? "patch_call",
+      status: record.status === "failed" ? "failed" : "completed",
+      operation,
+      raw: record
+    });
+  });
+  return patches;
+}
+function visit3(value, onPatch) {
+  if (Array.isArray(value)) {
+    for (const item of value) visit3(item, onPatch);
+    return;
+  }
+  if (!isRecord(value)) return;
+  if (value.type === "apply_patch_call" || value.type === "patch" || value.operation) onPatch(value);
+  for (const nested of Object.values(value)) visit3(nested, onPatch);
+}
+function normalizeOperation(record) {
+  const operation = isRecord(record.operation) ? record.operation : record;
+  const type = stringValue2(operation.type) ?? stringValue2(operation.operation);
+  const path = stringValue2(operation.path) ?? stringValue2(operation.file);
+  if (!type || !path) return void 0;
+  if (type === "delete_file") return { type, path };
+  if (type === "create_file" || type === "update_file") {
+    return { type, path, diff: stringValue2(operation.diff) ?? stringValue2(operation.patch) ?? "" };
+  }
+  return void 0;
+}
+function stringValue2(value) {
+  return typeof value === "string" ? value : void 0;
+}
+
+// src/normalize/tool-usage.ts
+var serverToolKeys = [
+  "webSearch",
+  "webFetch",
+  "datetime",
+  "imageGeneration",
+  "applyPatch",
+  "fusion",
+  "advisor",
+  "subagent"
+];
+var rawTypeToKey = {
+  "openrouter:web_search": "webSearch",
+  web_search: "webSearch",
+  webSearch: "webSearch",
+  "openrouter:web_fetch": "webFetch",
+  web_fetch: "webFetch",
+  webFetch: "webFetch",
+  "openrouter:datetime": "datetime",
+  datetime: "datetime",
+  "openrouter:image_generation": "imageGeneration",
+  image_generation: "imageGeneration",
+  imageGeneration: "imageGeneration",
+  "openrouter:apply_patch": "applyPatch",
+  apply_patch: "applyPatch",
+  applyPatch: "applyPatch",
+  "openrouter:fusion": "fusion",
+  fusion: "fusion",
+  "openrouter:advisor": "advisor",
+  advisor: "advisor",
+  "openrouter:subagent": "subagent",
+  subagent: "subagent"
+};
+function createToolUsage(policy, raw, functionTools = []) {
+  const counts = detectServerToolCounts(raw);
+  const serverTools = Object.fromEntries(
+    serverToolKeys.map((key) => {
+      const item = policyValue(policy, key);
+      const requested = Array.isArray(item) ? item.some((x) => x.mode !== "disabled") : !!item && item.mode !== "disabled";
+      const required = Array.isArray(item) ? item.some((x) => x.mode === "required") : !!item && item.mode === "required";
+      return [
+        key,
+        {
+          requested,
+          required,
+          used: (counts[key] ?? 0) > 0,
+          callCount: counts[key] ?? 0
+        }
+      ];
+    })
+  );
+  return { serverTools, functionTools };
+}
+function policyValue(policy, key) {
+  return policy?.[key];
+}
+function detectServerToolCounts(raw) {
+  const counts = {};
+  visit4(raw, (type) => {
+    const key = rawTypeToKey[type];
+    if (key) counts[key] = (counts[key] ?? 0) + 1;
+  });
+  return counts;
+}
+function visit4(value, onType) {
+  if (Array.isArray(value)) {
+    for (const item of value) visit4(item, onType);
+    return;
+  }
+  if (typeof value !== "object" || value === null) return;
+  const record = value;
+  if (typeof record.type === "string") onType(record.type);
+  if (typeof record.name === "string") onType(record.name);
+  for (const nested of Object.values(record)) visit4(nested, onType);
+}
+
+// src/normalize/usage.ts
+function normalizeUsage(usage) {
+  if (!isRecord(usage)) return void 0;
+  const details = isRecord(usage.completion_tokens_details) ? usage.completion_tokens_details : void 0;
+  return {
+    raw: usage,
+    ...optional2("inputTokens", numberValue(usage.prompt_tokens) ?? numberValue(usage.input_tokens)),
+    ...optional2("outputTokens", numberValue(usage.completion_tokens) ?? numberValue(usage.output_tokens)),
+    ...optional2("totalTokens", numberValue(usage.total_tokens)),
+    ...optional2("reasoningTokens", numberValue(details?.reasoning_tokens) ?? numberValue(usage.reasoning_tokens)),
+    ...optional2("costUsd", numberValue(usage.cost))
+  };
+}
+function numberValue(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function optional2(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+
+// src/utils/ids.ts
+function createRuntimeId(prefix = "orun") {
+  const cryptoObject = globalThis.crypto;
+  if (cryptoObject?.randomUUID) return `${prefix}_${cryptoObject.randomUUID()}`;
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+}
+
+// src/normalize/normalize-chat-response.ts
+function normalizeChatResponse(params) {
+  const responseRecord = isRecord(params.response) ? params.response : {};
+  const choice = Array.isArray(responseRecord.choices) && isRecord(responseRecord.choices[0]) ? responseRecord.choices[0] : {};
+  const message = isRecord(choice.message) ? choice.message : {};
+  const text = normalizeContentToText(message.content);
+  return {
+    id: typeof responseRecord.id === "string" ? responseRecord.id : createRuntimeId("orresp"),
+    status: "completed",
+    apiMode: params.apiMode,
+    model: typeof responseRecord.model === "string" ? responseRecord.model : params.model,
+    text,
+    citations: extractCitations([message.annotations, responseRecord.citations, params.response]),
+    images: extractImages(params.response),
+    patches: extractPatches(params.response),
+    toolUsage: createToolUsage(params.serverTools, params.response, params.functionToolUsage),
+    warnings: params.warnings,
+    errors: [],
+    raw: {
+      request: params.requestBody,
+      response: params.response
+    },
+    ...optional3("usage", normalizeUsage(responseRecord.usage)),
+    ...optional3("finishReason", typeof choice.finish_reason === "string" ? choice.finish_reason : void 0),
+    ...optional3("metadata", params.metadata)
+  };
+}
+function normalizeContentToText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => {
+    if (typeof part === "string") return part;
+    if (isRecord(part) && typeof part.text === "string") return part.text;
+    if (isRecord(part) && typeof part.content === "string") return part.content;
+    return "";
+  }).filter(Boolean).join("");
+}
+function optional3(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+
+// src/policies/post-response-validation.ts
+async function validatePostResponse(response, defaults) {
+  const errors = [...response.errors];
+  const warnings = [...response.warnings];
+  for (const [key, usage] of Object.entries(response.toolUsage.serverTools)) {
+    if (usage.required && !usage.used) {
+      const code = `${toScreamingSnake(key)}_REQUIRED_BUT_NOT_USED`;
+      usage.policyViolation = code;
+      const violation = { code, message: `${key} was required but no usage evidence was found.` };
+      if (defaults.onPolicyViolation === "throw") {
+        errors.push({ ...violation, source: "policy" });
+      } else {
+        warnings.push(violation);
+      }
+    }
+  }
+  if (defaults.requireCitationsWhenSearchUsed && response.toolUsage.serverTools.webSearch.requested && response.citations.length === 0) {
+    warnings.push({
+      code: "CITATIONS_REQUIRED_BUT_MISSING",
+      message: "Web search was requested but no citations were extracted."
+    });
+  }
+  return {
+    ...response,
+    status: errors.some((error) => error.source === "policy") ? "policy_violation" : response.status,
+    errors,
+    warnings
+  };
+}
+function toScreamingSnake(value) {
+  return value.replace(/[A-Z]/g, (match) => `_${match}`).toUpperCase();
+}
+
+// src/config/normalize-model.ts
+function normalizeModel(model) {
+  if (!model.endsWith(":online")) {
+    return { model, warnings: [] };
+  }
+  return {
+    model: model.slice(0, -":online".length),
+    warnings: [
+      {
+        code: "OPENROUTER_ONLINE_VARIANT_DEPRECATED",
+        message: "The :online model suffix is deprecated. Use serverTools.webSearch instead."
+      }
+    ],
+    impliedServerTools: {
+      webSearch: { mode: "allowed" }
+    }
+  };
+}
+
+// src/config/validate-runtime-request.ts
+function validateRuntimeRequest(request, options, apiMode, model, serverTools) {
+  if (!options.apiKey) throw new RuntimeConfigError("OPENROUTER_API_KEY_MISSING", "OpenRouter API key is required.");
+  if (!model) throw new RuntimeConfigError("MODEL_MISSING", "Runtime request must include a model.");
+  if (!request.messages?.length && !request.input && !request.prompt) {
+    throw new RuntimeConfigError("INPUT_MISSING", "Runtime request must include messages, input, or prompt.");
+  }
+  if (serverTools?.applyPatch?.mode && serverTools.applyPatch.mode !== "disabled" && apiMode !== "responses") {
+    throw new RuntimeConfigError("APPLY_PATCH_REQUIRES_RESPONSES_API", "apply_patch requires the Responses API.");
+  }
+  if (serverTools?.applyPatch?.behavior === "apply_with_callback" && !options.patchApplier) {
+    throw new RuntimeConfigError("PATCH_APPLIER_REQUIRED", "apply_with_callback requires options.patchApplier.");
+  }
+  validateWebSearch(serverTools);
+  validateWebFetch(serverTools);
+  validateDomains(serverTools?.webSearch?.allowedDomains, "allowedDomains");
+  validateDomains(serverTools?.webSearch?.excludedDomains, "excludedDomains");
+  validateDomains(serverTools?.webFetch?.allowedDomains, "allowedDomains");
+  validateDomains(serverTools?.webFetch?.blockedDomains, "blockedDomains");
+  validateFunctionTools(request.functionTools);
+  validateAdvisorNames(serverTools);
+  validateToolChoice(request, serverTools);
+}
+function validateWebSearch(policy) {
+  const search = policy?.webSearch;
+  if (!search || search.mode === "disabled") return;
+  const maxResults = search.maxResults ?? 5;
+  const maxTotalResults = search.maxTotalResults ?? 15;
+  if (maxResults < 1 || maxResults > 25) {
+    throw new RuntimeConfigError("INVALID_WEB_SEARCH_MAX_RESULTS", "webSearch.maxResults must be between 1 and 25.");
+  }
+  if (search.engine === "perplexity" && maxResults > 20) {
+    throw new RuntimeConfigError("PERPLEXITY_MAX_RESULTS_EXCEEDED", "Perplexity search supports at most 20 results.");
+  }
+  if (maxTotalResults < maxResults) {
+    throw new RuntimeConfigError("MAX_TOTAL_RESULTS_LT_MAX_RESULTS", "maxTotalResults must be >= maxResults.");
+  }
+}
+function validateWebFetch(policy) {
+  const fetch = policy?.webFetch;
+  if (!fetch || fetch.mode === "disabled") return;
+  if (fetch.maxUses !== void 0 && fetch.maxUses < 1) {
+    throw new RuntimeConfigError("INVALID_WEB_FETCH_MAX_USES", "webFetch.maxUses must be >= 1.");
+  }
+}
+function validateDomains(domains, field) {
+  for (const domain of domains ?? []) {
+    if (/^https?:\/\//i.test(domain) || domain.includes("/") || domain.trim() !== domain || domain === "") {
+      throw new RuntimeConfigError("INVALID_DOMAIN", `${field} must contain domains, not URLs.`, { domain });
+    }
+  }
+}
+function validateFunctionTools(tools) {
+  const names = /* @__PURE__ */ new Set();
+  for (const tool of tools ?? []) {
+    if (names.has(tool.name)) {
+      throw new RuntimeConfigError("DUPLICATE_FUNCTION_TOOL", `Function tool ${tool.name} is defined more than once.`);
+    }
+    names.add(tool.name);
+  }
+}
+function validateAdvisorNames(policy) {
+  const advisors = Array.isArray(policy?.advisor) ? policy.advisor : policy?.advisor ? [policy.advisor] : [];
+  const names = /* @__PURE__ */ new Set();
+  for (const advisor of advisors) {
+    if (!advisor.name) continue;
+    if (names.has(advisor.name)) {
+      throw new RuntimeConfigError("DUPLICATE_ADVISOR_NAME", `Advisor ${advisor.name} is defined more than once.`);
+    }
+    names.add(advisor.name);
+  }
+}
+function validateToolChoice(request, policy) {
+  const choice = request.toolChoice;
+  if (!choice || typeof choice === "string") return;
+  if (choice.type === "function") {
+    if (!request.functionTools?.some((tool) => tool.name === choice.functionName)) {
+      throw new RuntimeConfigError("TOOL_CHOICE_FUNCTION_NOT_ENABLED", `Function tool ${choice.functionName} is not enabled.`);
+    }
+    return;
+  }
+  const map = {
+    web_search: policy?.webSearch,
+    web_fetch: policy?.webFetch,
+    datetime: policy?.datetime,
+    image_generation: policy?.imageGeneration,
+    apply_patch: policy?.applyPatch,
+    fusion: policy?.fusion,
+    advisor: policy?.advisor,
+    subagent: policy?.subagent
+  };
+  const selected = map[choice.serverTool];
+  const enabled2 = Array.isArray(selected) ? selected.some((item) => item.mode !== "disabled") : !!selected && selected.mode !== "disabled";
+  if (!enabled2) {
+    throw new RuntimeConfigError("TOOL_CHOICE_SERVER_TOOL_NOT_ENABLED", `Server tool ${choice.serverTool} is not enabled.`);
+  }
+}
+
+// src/openrouter/endpoints.ts
+function endpointFor(baseUrl, apiMode) {
+  const trimmed = baseUrl.replace(/\/+$/, "");
+  return apiMode === "chat" ? `${trimmed}/chat/completions` : `${trimmed}/responses`;
+}
+
+// src/openrouter/headers.ts
+function buildHeaders(options) {
+  return {
+    "content-type": "application/json",
+    authorization: `Bearer ${options.apiKey}`,
+    ...options.appAttribution?.siteUrl ? { "HTTP-Referer": options.appAttribution.siteUrl } : {},
+    ...options.appAttribution?.appName ? { "X-Title": options.appAttribution.appName } : {},
+    ...options.defaultHeaders ?? {}
+  };
+}
+
+// src/tools/nested-tools.ts
+var allowedNestedTypes = /* @__PURE__ */ new Set([
+  "openrouter:web_search",
+  "openrouter:web_fetch",
+  "openrouter:datetime",
+  "openrouter:image_generation"
+]);
+function validateNestedTools(tools) {
+  for (const tool of tools ?? []) {
+    if (!allowedNestedTypes.has(tool.type)) {
+      throw new RuntimeConfigError(
+        "INVALID_NESTED_SERVER_TOOL",
+        `Nested server tool ${tool.type} is not allowed.`
+      );
+    }
+  }
+}
+
+// src/tools/server-tools.ts
+function cleanParameters(parameters) {
+  return Object.fromEntries(Object.entries(parameters).filter(([, value]) => value !== void 0));
+}
+function enabled(policy) {
+  return !!policy && policy.mode !== "disabled";
+}
+function buildOpenRouterServerTools(policy) {
+  const tools = [];
+  const webSearch = buildWebSearchTool(policy?.webSearch);
+  if (webSearch) tools.push(webSearch);
+  const webFetch = buildWebFetchTool(policy?.webFetch);
+  if (webFetch) tools.push(webFetch);
+  const datetime = buildDatetimeTool(policy?.datetime);
+  if (datetime) tools.push(datetime);
+  const image = buildImageGenerationTool(policy?.imageGeneration);
+  if (image) tools.push(image);
+  const patch = buildApplyPatchTool(policy?.applyPatch);
+  if (patch) tools.push(patch);
+  const fusion = buildFusionTool(policy?.fusion);
+  if (fusion) tools.push(fusion);
+  tools.push(...buildAdvisorTools(policy?.advisor));
+  const subagent = buildSubagentTool(policy?.subagent);
+  if (subagent) tools.push(subagent);
+  return tools;
+}
+function buildWebSearchTool(policy) {
+  if (!enabled(policy)) return void 0;
+  return {
+    type: "openrouter:web_search",
+    parameters: cleanParameters({
+      engine: policy?.engine ?? "auto",
+      max_results: policy?.maxResults ?? 5,
+      max_total_results: policy?.maxTotalResults ?? 15,
+      search_context_size: policy?.searchContextSize ?? "medium",
+      allowed_domains: policy?.allowedDomains,
+      excluded_domains: policy?.excludedDomains,
+      user_location: policy?.userLocation
+    })
+  };
+}
+function buildWebFetchTool(policy) {
+  if (!enabled(policy)) return void 0;
+  return {
+    type: "openrouter:web_fetch",
+    parameters: cleanParameters({
+      engine: policy?.engine ?? "auto",
+      max_uses: policy?.maxUses ?? 10,
+      max_content_tokens: policy?.maxContentTokens ?? 5e4,
+      allowed_domains: policy?.allowedDomains,
+      blocked_domains: policy?.blockedDomains
+    })
+  };
+}
+function buildDatetimeTool(policy) {
+  if (!enabled(policy)) return void 0;
+  return {
+    type: "openrouter:datetime",
+    parameters: cleanParameters({ timezone: policy?.timezone ?? "UTC" })
+  };
+}
+function buildImageGenerationTool(policy) {
+  if (!enabled(policy)) return void 0;
+  return {
+    type: "openrouter:image_generation",
+    parameters: cleanParameters({
+      model: policy?.model ?? "openai/gpt-5-image",
+      quality: policy?.quality,
+      size: policy?.size,
+      aspect_ratio: policy?.aspectRatio,
+      background: policy?.background,
+      output_format: policy?.outputFormat,
+      output_compression: policy?.outputCompression,
+      moderation: policy?.moderation
+    })
+  };
+}
+function buildApplyPatchTool(policy) {
+  if (!enabled(policy)) return void 0;
+  return { type: "openrouter:apply_patch" };
+}
+function buildFusionTool(policy) {
+  if (!enabled(policy)) return void 0;
+  return {
+    type: "openrouter:fusion",
+    parameters: cleanParameters({
+      analysis_models: policy?.analysisModels,
+      model: policy?.judgeModel,
+      max_tool_calls: policy?.maxToolCalls ?? 8,
+      max_completion_tokens: policy?.maxCompletionTokens,
+      reasoning: policy?.reasoning,
+      temperature: policy?.temperature
+    })
+  };
+}
+function buildAdvisorTools(policy) {
+  const advisors = Array.isArray(policy) ? policy : policy ? [policy] : [];
+  return advisors.filter(enabled).map((advisor) => {
+    validateNestedTools(advisor.tools);
+    return {
+      type: "openrouter:advisor",
+      parameters: cleanParameters({
+        name: advisor.name,
+        model: advisor.model,
+        instructions: advisor.instructions,
+        tools: advisor.tools,
+        forward_transcript: advisor.forwardTranscript ?? false,
+        stream: advisor.stream,
+        max_tool_calls: advisor.maxToolCalls,
+        max_completion_tokens: advisor.maxCompletionTokens,
+        reasoning: advisor.reasoning,
+        temperature: advisor.temperature
+      })
+    };
+  });
+}
+function buildSubagentTool(policy) {
+  if (!policy || policy.mode === "disabled") return void 0;
+  const subagent = policy;
+  validateNestedTools(subagent.tools);
+  return {
+    type: "openrouter:subagent",
+    parameters: cleanParameters({
+      model: subagent.model,
+      instructions: subagent.instructions,
+      tools: subagent.tools,
+      max_tool_calls: subagent.maxToolCalls,
+      max_completion_tokens: subagent.maxCompletionTokens,
+      reasoning: subagent.reasoning,
+      temperature: subagent.temperature
+    })
+  };
+}
+
+// src/runtime/runtime.ts
+function compileRuntimeRequest(request, defaults, options = { apiKey: "" }) {
+  const warnings = [];
+  const requestedModel = request.model ?? options.defaultModel ?? "";
+  const normalized = normalizeModel(requestedModel);
+  warnings.push(...normalized.warnings);
+  const serverTools = mergeServerTools(defaults.serverTools, normalized.impliedServerTools, request.serverTools);
+  const apiMode = resolveApiMode(request, defaults.apiMode, serverTools);
+  validateRuntimeRequest(request, options, apiMode, normalized.model, serverTools);
+  const tools = [
+    ...buildOpenRouterServerTools(serverTools),
+    ...(request.functionTools ?? []).map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters
+      }
+    }))
+  ];
+  const headers = buildHeaders(options);
+  const baseBody = buildBaseBody(request, normalized.model, defaults, tools, serverTools);
+  const body = apiMode === "chat" ? buildChatBody(request, baseBody) : buildResponsesBody(request, baseBody);
+  return {
+    apiMode,
+    url: endpointFor(options.baseUrl ?? "https://openrouter.ai/api/v1", apiMode),
+    headers,
+    body,
+    warnings
+  };
+}
+function resolveApiMode(request, defaultMode = "auto", serverTools) {
+  const mode = request.apiMode ?? defaultMode;
+  if (mode === "chat") return "chat";
+  if (mode === "responses") return "responses";
+  if (serverTools?.applyPatch?.mode && serverTools.applyPatch.mode !== "disabled") return "responses";
+  if (request.input) return "responses";
+  return "chat";
+}
+function mergeServerTools(...policies) {
+  const merged = {};
+  for (const policy of policies) {
+    if (!policy) continue;
+    Object.assign(merged, policy);
+  }
+  return Object.keys(merged).length ? merged : void 0;
+}
+function buildBaseBody(request, model, defaults, tools, serverTools) {
+  const body = {
+    model,
+    temperature: request.temperature ?? defaults.temperature,
+    reasoning: request.reasoning,
+    tools: tools.length ? tools : void 0,
+    tool_choice: compileToolChoice(request.toolChoice, serverTools),
+    ...request.rawOpenRouterOverrides
+  };
+  return clean(body);
+}
+function buildChatBody(request, baseBody) {
+  const messages = compileMessages(request);
+  return clean({
+    ...baseBody,
+    messages,
+    max_tokens: request.maxTokens,
+    response_format: request.responseFormat
+  });
+}
+function buildResponsesBody(request, baseBody) {
+  return clean({
+    ...baseBody,
+    input: request.input ?? compilePromptInput(request),
+    instructions: request.instructions ?? request.system,
+    max_output_tokens: request.maxTokens,
+    text: request.responseFormat
+  });
+}
+function compileMessages(request) {
+  const messages = [];
+  if (request.system) messages.push({ role: "system", content: request.system });
+  if (request.messages) messages.push(...request.messages);
+  if (request.prompt) messages.push({ role: "user", content: request.prompt });
+  return messages;
+}
+function compilePromptInput(request) {
+  if (request.prompt) return request.prompt;
+  return compileMessages(request).map((message) => ({
+    role: message.role,
+    content: message.content
+  }));
+}
+function compileToolChoice(choice, serverTools) {
+  if (!choice || choice === "auto") return void 0;
+  if (choice === "none" || choice === "required") return choice;
+  if (choice.type === "function") {
+    return { type: "function", function: { name: choice.functionName } };
+  }
+  const toolType = `openrouter:${choice.serverTool}`;
+  const matchingPolicy = serverToolPolicyForChoice(choice.serverTool, serverTools);
+  return matchingPolicy === 1 ? { type: toolType } : "required";
+}
+function serverToolPolicyForChoice(name, policy) {
+  const value = {
+    web_search: policy?.webSearch,
+    web_fetch: policy?.webFetch,
+    datetime: policy?.datetime,
+    image_generation: policy?.imageGeneration,
+    apply_patch: policy?.applyPatch,
+    fusion: policy?.fusion,
+    advisor: policy?.advisor,
+    subagent: policy?.subagent
+  }[name];
+  if (!value) return 0;
+  if (Array.isArray(value)) return value.filter((item) => item.mode !== "disabled").length;
+  return value.mode === "disabled" ? 0 : 1;
+}
+function clean(record) {
+  return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== void 0));
+}
+
+// src/function-tools/registry.ts
+function resolveExecutor(name, definitions, options) {
+  return definitions?.find((tool) => tool.name === name)?.executor ?? options.tools?.[name];
+}
+
+// src/function-tools/parse-tool-args.ts
+function parseToolArgs(args) {
+  return parseJsonMaybe(args);
+}
+
+// src/function-tools/execute-function-tool.ts
+async function executeFunctionTool(call, request, definitions, options) {
+  const executor = resolveExecutor(call.name, definitions, options);
+  if (!executor) {
+    throw new RuntimeConfigError("FUNCTION_TOOL_EXECUTOR_MISSING", `No executor registered for ${call.name}.`);
+  }
+  const started = Date.now();
+  const args = parseToolArgs(call.args);
+  try {
+    options.logger?.debug?.("runtime.function_tool.started", { name: call.name, callId: call.callId });
+    await options.hooks?.beforeFunctionToolExecution?.({ ...call, args });
+    const context = {
+      requestId: request.id ?? "",
+      toolName: call.name,
+      callId: call.callId,
+      ...request.metadata ? { metadata: request.metadata } : {}
+    };
+    const result = await executor(args, context);
+    const normalized = {
+      name: call.name,
+      callId: call.callId,
+      status: "completed",
+      result,
+      durationMs: Date.now() - started
+    };
+    await options.hooks?.afterFunctionToolExecution?.(normalized);
+    options.logger?.debug?.("runtime.function_tool.completed", { name: call.name, callId: call.callId });
+    return normalized;
+  } catch (error) {
+    const normalized = {
+      name: call.name,
+      callId: call.callId,
+      status: "failed",
+      error: error instanceof Error ? error.message : String(error),
+      durationMs: Date.now() - started
+    };
+    await options.hooks?.afterFunctionToolExecution?.(normalized);
+    options.logger?.warn?.("runtime.function_tool.failed", normalized);
+    return normalized;
+  }
+}
+
+// src/runtime/tool-loop.ts
+function extractChatFunctionCalls(response) {
+  const record = isRecord(response) ? response : {};
+  const choice = Array.isArray(record.choices) && isRecord(record.choices[0]) ? record.choices[0] : {};
+  const message = isRecord(choice.message) ? choice.message : {};
+  const calls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+  return calls.flatMap((call) => {
+    if (!isRecord(call) || call.type !== "function" || !isRecord(call.function)) return [];
+    const name = typeof call.function.name === "string" ? call.function.name : void 0;
+    if (!name) return [];
+    return [
+      {
+        name,
+        callId: typeof call.id === "string" ? call.id : name,
+        args: call.function.arguments
+      }
+    ];
+  });
+}
+function extractResponsesFunctionCalls(response) {
+  const record = isRecord(response) ? response : {};
+  const output = Array.isArray(record.output) ? record.output : [];
+  return output.flatMap((item) => {
+    if (!isRecord(item) || item.type !== "function_call") return [];
+    const name = typeof item.name === "string" ? item.name : void 0;
+    if (!name) return [];
+    return [
+      {
+        name,
+        callId: typeof item.call_id === "string" ? item.call_id : typeof item.id === "string" ? item.id : name,
+        args: item.arguments
+      }
+    ];
+  });
+}
+async function executeFunctionCalls(params) {
+  if (params.previousUsage.length + params.calls.length > params.maxFunctionToolCalls) {
+    throw new Error("maxFunctionToolCalls exceeded.");
+  }
+  const results = [];
+  for (const call of params.calls) {
+    const result = await executeFunctionTool(call, params.request, params.definitions, params.options);
+    results.push({
+      name: result.name,
+      callId: result.callId,
+      status: result.status,
+      args: call.args,
+      ...result.result !== void 0 ? { result: result.result } : {},
+      ...result.error !== void 0 ? { error: result.error } : {},
+      ...result.durationMs !== void 0 ? { durationMs: result.durationMs } : {}
+    });
+  }
+  return results;
+}
+
+// src/runtime/run-chat.ts
+async function runChat(request, compiled, context) {
+  const maxIterations = request.execution?.maxToolIterations ?? 8;
+  const maxFunctionToolCalls = request.execution?.maxFunctionToolCalls ?? 20;
+  const functionUsage = [];
+  let activeCompiled = compiled;
+  let response;
+  for (let iteration = 0; iteration <= maxIterations; iteration++) {
+    response = await sendOpenRouterRequest(
+      activeCompiled,
+      context.options,
+      context.defaults,
+      request.execution?.timeoutMs ?? context.defaults.timeoutMs
+    );
+    const calls = extractChatFunctionCalls(response);
+    if (!calls.length) break;
+    const results = await executeFunctionCalls({
+      calls,
+      request,
+      definitions: request.functionTools,
+      options: context.options,
+      previousUsage: functionUsage,
+      maxFunctionToolCalls
+    });
+    functionUsage.push(...results);
+    const body = activeCompiled.body;
+    const messages = Array.isArray(body.messages) ? [...body.messages] : [];
+    messages.push(...results.map(resultToChatToolMessage));
+    activeCompiled = { ...activeCompiled, body: { ...body, messages } };
+  }
+  const model = typeof compiled.body.model === "string" ? compiled.body.model : "";
+  const normalized = normalizeChatResponse({
+    requestBody: activeCompiled.body,
+    response,
+    apiMode: "chat",
+    model,
+    warnings: compiled.warnings,
+    functionToolUsage: functionUsage,
+    ...optional4("serverTools", mergeServerTools(context.defaults.serverTools, request.serverTools)),
+    ...optional4("metadata", request.metadata)
+  });
+  return validatePostResponse(normalized, context.defaults);
+}
+function optional4(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+
+// src/normalize/normalize-responses-response.ts
+function normalizeResponsesResponse(params) {
+  const record = isRecord(params.response) ? params.response : {};
+  return {
+    id: typeof record.id === "string" ? record.id : createRuntimeId("orresp"),
+    status: record.status === "requires_action" ? "requires_action" : "completed",
+    apiMode: "responses",
+    model: typeof record.model === "string" ? record.model : params.model,
+    text: extractOutputText(record),
+    citations: extractCitations(params.response),
+    images: extractImages(params.response),
+    patches: extractPatches(params.response),
+    toolUsage: createToolUsage(params.serverTools, params.response, params.functionToolUsage),
+    warnings: params.warnings,
+    errors: [],
+    raw: {
+      request: params.requestBody,
+      response: params.response
+    },
+    ...optional5("usage", normalizeUsage(record.usage)),
+    ...optional5("finishReason", typeof record.status === "string" ? record.status : void 0),
+    ...optional5("metadata", params.metadata)
+  };
+}
+function extractOutputText(record) {
+  if (typeof record.output_text === "string") return record.output_text;
+  const output = Array.isArray(record.output) ? record.output : [];
+  const chunks = [];
+  for (const item of output) {
+    if (!isRecord(item)) continue;
+    if (typeof item.text === "string") chunks.push(item.text);
+    const content = Array.isArray(item.content) ? item.content : [];
+    for (const part of content) {
+      if (isRecord(part) && typeof part.text === "string") chunks.push(part.text);
+    }
+  }
+  return chunks.join("");
+}
+function optional5(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+
+// src/runtime/run-responses.ts
+async function runResponses(request, compiled, context) {
+  const maxIterations = request.execution?.maxToolIterations ?? 8;
+  const maxFunctionToolCalls = request.execution?.maxFunctionToolCalls ?? 20;
+  const functionUsage = [];
+  let activeCompiled = compiled;
+  let response;
+  for (let iteration = 0; iteration <= maxIterations; iteration++) {
+    response = await sendOpenRouterRequest(
+      activeCompiled,
+      context.options,
+      context.defaults,
+      request.execution?.timeoutMs ?? context.defaults.timeoutMs
+    );
+    const calls = extractResponsesFunctionCalls(response);
+    if (!calls.length) break;
+    const results = await executeFunctionCalls({
+      calls,
+      request,
+      definitions: request.functionTools,
+      options: context.options,
+      previousUsage: functionUsage,
+      maxFunctionToolCalls
+    });
+    functionUsage.push(...results);
+    activeCompiled = {
+      ...activeCompiled,
+      body: {
+        ...activeCompiled.body,
+        previous_response_id: isRecord(response) && typeof response.id === "string" ? response.id : void 0,
+        input: results.map(resultToResponsesInput)
+      }
+    };
+  }
+  const model = typeof compiled.body.model === "string" ? compiled.body.model : "";
+  const normalized = normalizeResponsesResponse({
+    requestBody: activeCompiled.body,
+    response,
+    model,
+    warnings: compiled.warnings,
+    functionToolUsage: functionUsage,
+    ...optional6("serverTools", mergeServerTools(context.defaults.serverTools, request.serverTools)),
+    ...optional6("metadata", request.metadata)
+  });
+  return validatePostResponse(normalized, context.defaults);
+}
+function optional6(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+
+// src/runtime/create-runtime.ts
+function createOpenRouterRuntime(options) {
+  const resolvedOptions = resolveRuntimeOptions(options);
+  const defaults = resolveDefaults(options);
+  const context = { options: resolvedOptions, defaults };
+  return {
+    async run(request) {
+      const requestWithId = { ...request, id: request.id ?? createRuntimeId() };
+      try {
+        resolvedOptions.logger?.info?.("runtime.request.started", { requestId: requestWithId.id });
+        await resolvedOptions.hooks?.beforeCompile?.(requestWithId);
+        const compiled = compileRuntimeRequest(requestWithId, defaults, resolvedOptions);
+        await resolvedOptions.hooks?.afterCompile?.(compiled);
+        resolvedOptions.logger?.debug?.("runtime.request.compiled", {
+          requestId: requestWithId.id,
+          apiMode: compiled.apiMode
+        });
+        await resolvedOptions.hooks?.beforeOpenRouterRequest?.(compiled);
+        const response = compiled.apiMode === "chat" ? await runChat(requestWithId, compiled, context) : await runResponses(requestWithId, compiled, context);
+        await resolvedOptions.hooks?.afterOpenRouterResponse?.(response.raw.response);
+        resolvedOptions.logger?.info?.("runtime.response.normalized", { requestId: requestWithId.id, status: response.status });
+        return response;
+      } catch (error) {
+        return errorResponse(requestWithId, error);
+      }
+    }
+  };
+  function errorResponse(request, error) {
+    const runtimeError = normalizeError(error);
+    if (error instanceof RuntimeConfigError && defaults.onPolicyViolation === "throw") throw error;
+    return {
+      id: request.id ?? createRuntimeId("orerr"),
+      status: "failed",
+      apiMode: request.apiMode === "responses" ? "responses" : "chat",
+      model: request.model ?? resolvedOptions.defaultModel ?? "",
+      text: "",
+      citations: [],
+      images: [],
+      patches: [],
+      toolUsage: {
+        serverTools: {
+          webSearch: { requested: false, required: false, used: false },
+          webFetch: { requested: false, required: false, used: false },
+          datetime: { requested: false, required: false, used: false },
+          imageGeneration: { requested: false, required: false, used: false },
+          applyPatch: { requested: false, required: false, used: false },
+          fusion: { requested: false, required: false, used: false },
+          advisor: { requested: false, required: false, used: false },
+          subagent: { requested: false, required: false, used: false }
+        },
+        functionTools: []
+      },
+      warnings: [],
+      errors: [runtimeError],
+      raw: {
+        request,
+        response: error instanceof OpenRouterHttpError ? error.body : void 0
+      },
+      ...request.metadata ? { metadata: request.metadata } : {}
+    };
+  }
+}
+function normalizeError(error) {
+  if (error instanceof RuntimeConfigError) {
+    return {
+      code: error.code,
+      message: error.message,
+      source: "validation",
+      details: error.details
+    };
+  }
+  if (error instanceof OpenRouterHttpError) {
+    return {
+      code: error.code,
+      message: error.message,
+      source: "openrouter",
+      retryable: error.retryable,
+      details: error.body
+    };
+  }
+  return {
+    code: "RUNTIME_ERROR",
+    message: error instanceof Error ? error.message : String(error),
+    source: "runtime"
+  };
+}
+export {
+  OpenRouterHttpError,
+  RuntimeConfigError,
+  buildOpenRouterServerTools,
+  compileRuntimeRequest,
+  createOpenRouterRuntime
+};
+//# sourceMappingURL=index.js.map