@x12i/openrouter-runtime 1.0.6 → 1.4.0

package/dist/index.js

@@ -722,13 +722,22 @@ function endpointFor(baseUrl, apiMode) {
 }
 
 // src/openrouter/headers.ts
-function buildHeaders(options) {
+function buildHeaders(options, agentId) {
+  const requestAppName = agentId?.trim();
   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 ?? {}
+    ...appTitleHeaders(options.appAttribution?.appName),
+    ...options.defaultHeaders ?? {},
+    ...requestAppName ? appTitleHeaders(requestAppName) : {}
+  };
+}
+function appTitleHeaders(name) {
+  if (!name) return {};
+  return {
+    "X-Title": name,
+    "X-OpenRouter-Title": name
   };
 }
 
@@ -757,7 +766,7 @@ function cleanParameters(parameters) {
 function enabled(policy) {
   return !!policy && policy.mode !== "disabled";
 }
-function buildOpenRouterServerTools(policy) {
+function buildOpenRouterServerTools(policy, fallbackReasoning) {
   const tools = [];
   const webSearch = buildWebSearchTool(policy?.webSearch);
   if (webSearch) tools.push(webSearch);
@@ -769,10 +778,10 @@ function buildOpenRouterServerTools(policy) {
   if (image) tools.push(image);
   const patch = buildApplyPatchTool(policy?.applyPatch);
   if (patch) tools.push(patch);
-  const fusion = buildFusionTool(policy?.fusion);
+  const fusion = buildFusionTool(policy?.fusion, fallbackReasoning);
   if (fusion) tools.push(fusion);
-  tools.push(...buildAdvisorTools(policy?.advisor));
-  const subagent = buildSubagentTool(policy?.subagent);
+  tools.push(...buildAdvisorTools(policy?.advisor, fallbackReasoning));
+  const subagent = buildSubagentTool(policy?.subagent, fallbackReasoning);
   if (subagent) tools.push(subagent);
   return tools;
 }
@@ -831,7 +840,7 @@ function buildApplyPatchTool(policy) {
   if (!enabled(policy)) return void 0;
   return { type: "openrouter:apply_patch" };
 }
-function buildFusionTool(policy) {
+function buildFusionTool(policy, fallbackReasoning) {
   if (!enabled(policy)) return void 0;
   return {
     type: "openrouter:fusion",
@@ -840,12 +849,12 @@ function buildFusionTool(policy) {
       model: policy?.judgeModel,
       max_tool_calls: policy?.maxToolCalls ?? 8,
       max_completion_tokens: policy?.maxCompletionTokens,
-      reasoning: policy?.reasoning,
+      reasoning: policy?.reasoning ?? fallbackReasoning,
       temperature: policy?.temperature
     })
   };
 }
-function buildAdvisorTools(policy) {
+function buildAdvisorTools(policy, fallbackReasoning) {
   const advisors = Array.isArray(policy) ? policy : policy ? [policy] : [];
   return advisors.filter(enabled).map((advisor) => {
     validateNestedTools(advisor.tools);
@@ -860,13 +869,13 @@ function buildAdvisorTools(policy) {
         stream: advisor.stream,
         max_tool_calls: advisor.maxToolCalls,
         max_completion_tokens: advisor.maxCompletionTokens,
-        reasoning: advisor.reasoning,
+        reasoning: advisor.reasoning ?? fallbackReasoning,
         temperature: advisor.temperature
       })
     };
   });
 }
-function buildSubagentTool(policy) {
+function buildSubagentTool(policy, fallbackReasoning) {
   if (!policy || policy.mode === "disabled") return void 0;
   const subagent = policy;
   validateNestedTools(subagent.tools);
@@ -878,12 +887,86 @@ function buildSubagentTool(policy) {
       tools: subagent.tools,
       max_tool_calls: subagent.maxToolCalls,
       max_completion_tokens: subagent.maxCompletionTokens,
-      reasoning: subagent.reasoning,
+      reasoning: subagent.reasoning ?? fallbackReasoning,
       temperature: subagent.temperature
     })
   };
 }
 
+// src/utils/provider-metadata.ts
+var OPENROUTER_METADATA_LIMITS = {
+  maxPairs: 16,
+  maxKeyLength: 64,
+  maxValueLength: 512
+};
+var PROVIDER_RECORD_CHUNK = 256;
+var PROVIDER_RECORD_MAX_CHUNKS = 16;
+function toProviderMetadata(metadata, agentId, _limits, base) {
+  return encodeProviderRecord(collectProviderStrings(metadata, agentId, base));
+}
+function decodeProviderMetadata(wire) {
+  if (!isRecord2(wire)) return {};
+  const parts = [];
+  for (let index = 0; ; index += 1) {
+    const chunk = wire[`m.${index}`];
+    if (typeof chunk !== "string") break;
+    parts.push(chunk);
+  }
+  if (!parts.length) return {};
+  const parsed = JSON.parse(Buffer.from(parts.join(""), "base64").toString("utf8"));
+  if (!isRecord2(parsed)) return {};
+  const record = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (typeof value === "string") record[key] = value;
+  }
+  return record;
+}
+function encodeProviderRecord(map) {
+  const keys = Object.keys(map).sort();
+  if (!keys.length) return void 0;
+  const ordered = {};
+  for (const key of keys) {
+    const value = map[key];
+    if (value !== void 0) ordered[key] = value;
+  }
+  const encoded = Buffer.from(JSON.stringify(ordered), "utf8").toString("base64");
+  const chunks = Math.ceil(encoded.length / PROVIDER_RECORD_CHUNK);
+  if (chunks > PROVIDER_RECORD_MAX_CHUNKS) {
+    throw new Error(
+      `METADATA_RECORD_TOO_LARGE: provider metadata is ${encoded.length} base64 characters; the maximum is ${PROVIDER_RECORD_CHUNK * PROVIDER_RECORD_MAX_CHUNKS}.`
+    );
+  }
+  const wire = {};
+  for (let index = 0; index < chunks; index += 1) {
+    wire[`m.${index}`] = encoded.slice(index * PROVIDER_RECORD_CHUNK, (index + 1) * PROVIDER_RECORD_CHUNK);
+  }
+  return wire;
+}
+function collectProviderStrings(metadata, agentId, base) {
+  const map = {};
+  appendStrings(map, base);
+  appendStrings(map, metadata);
+  const trimmedAgentId = agentId?.trim();
+  if (trimmedAgentId) map.agentId = trimmedAgentId;
+  return map;
+}
+function appendStrings(target, metadata) {
+  if (!metadata) return;
+  for (const [key, value] of Object.entries(metadata)) {
+    const asString = asMetadataString(value);
+    if (asString !== void 0) target[key] = asString;
+  }
+}
+function asMetadataString(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  return void 0;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/runtime/runtime.ts
 function compileRuntimeRequest(request, defaults, options = { apiKey: "" }, context = {}) {
   const warnings = [];
@@ -895,7 +978,10 @@ function compileRuntimeRequest(request, defaults, options = { apiKey: "" }, cont
   const apiMode = resolveApiMode(request, defaults.apiMode, serverTools);
   validateRuntimeRequest(request, options, apiMode, normalized.model, serverTools);
   const tools = [
-    ...buildOpenRouterServerTools(serverTools),
+    ...buildOpenRouterServerTools(
+      serverTools,
+      effectiveContext.suppressNestedReasoningFallback ? void 0 : request.reasoning
+    ),
     ...(request.functionTools ?? []).map((tool) => ({
       type: "function",
       function: {
@@ -905,10 +991,12 @@ function compileRuntimeRequest(request, defaults, options = { apiKey: "" }, cont
       }
     }))
   ];
-  const headers = buildHeaders(options);
+  const headers = buildHeaders(options, request.agentId);
   const baseBody = buildBaseBody(request, normalized.model, defaults, tools, serverTools);
-  const body = apiMode === "chat" ? buildChatBody(request, baseBody) : buildResponsesBody(request, baseBody);
+  const assembled = apiMode === "chat" ? buildChatBody(request, baseBody) : buildResponsesBody(request, baseBody);
+  let body = effectiveContext.finalizeBody ? effectiveContext.finalizeBody(assembled) : assembled;
   enforceStreamingPolicyForRun(body, warnings, effectiveContext);
+  body = attachProviderMetadata(body, request);
   return {
     apiMode,
     url: endpointFor(options.baseUrl ?? "https://openrouter.ai/api/v1", apiMode),
@@ -917,12 +1005,24 @@ function compileRuntimeRequest(request, defaults, options = { apiKey: "" }, cont
     warnings
   };
 }
+function attachProviderMetadata(body, request) {
+  const fromBody = isRecord(body.metadata) ? body.metadata : void 0;
+  const metadata = toProviderMetadata(request.metadata, request.agentId, OPENROUTER_METADATA_LIMITS, fromBody);
+  if (metadata) return { ...body, metadata };
+  if (body.metadata === void 0) return body;
+  const rest = { ...body };
+  delete rest.metadata;
+  return rest;
+}
 function enforceStreamingPolicyForRun(body, warnings, context) {
-  if (context.streaming) return;
+  if (context.streaming) {
+    body.stream = true;
+    return;
+  }
   if (body.stream !== void 0 && body.stream !== false) {
     warnings.push({
       code: "STREAMING_OVERRIDE_IGNORED_FOR_RUN",
-      message: "runtime.run() is non-streaming. Use runtime.executeStreamingChat() when streaming is implemented.",
+      message: "runtime.run() is non-streaming. Use runtime.executeStreamingChat() for streaming.",
       details: { ignoredStreamValue: body.stream }
     });
   }
@@ -1325,12 +1425,348 @@ function optional6(key, value) {
   return value === void 0 ? {} : { [key]: value };
 }
 
+// src/openrouter/stream-client.ts
+async function openOpenRouterStream(compiled, options, timeoutMs) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  const cleanup = () => clearTimeout(timeout);
+  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 text = await response.text();
+      cleanup();
+      const body = text ? parseBody2(text) : void 0;
+      const message = extractMessage2(body) ?? `OpenRouter stream failed with status ${response.status}.`;
+      throw new OpenRouterHttpError(
+        response.status,
+        classifyProviderFailure2(response.status, message, body),
+        message,
+        body,
+        isRetryableStatus2(response.status)
+      );
+    }
+    return { response, cleanup };
+  } catch (error) {
+    cleanup();
+    if (error instanceof OpenRouterHttpError) throw error;
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new OpenRouterHttpError(408, "PROVIDER_GATEWAY_UNREACHABLE", "OpenRouter stream timed out.", void 0, true);
+    }
+    throw new OpenRouterHttpError(
+      503,
+      "PROVIDER_GATEWAY_UNREACHABLE",
+      error instanceof Error ? error.message : "OpenRouter stream failed before receiving a response.",
+      void 0,
+      true
+    );
+  }
+}
+async function* parseSseStream(response) {
+  const body = response.body;
+  if (!body) {
+    throw new OpenRouterHttpError(
+      503,
+      "PROVIDER_GATEWAY_UNREACHABLE",
+      "OpenRouter stream response had no body.",
+      void 0,
+      true
+    );
+  }
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const parts = buffer.split(/\r?\n/);
+    buffer = parts.pop() ?? "";
+    for (const part of parts) {
+      const line = part.trim();
+      if (!line || line.startsWith(":")) continue;
+      if (!line.startsWith("data:")) continue;
+      const data = line.slice(5).trim();
+      if (!data) continue;
+      if (data === "[DONE]") return;
+      try {
+        yield JSON.parse(data);
+      } catch {
+      }
+    }
+  }
+  const trailing = buffer.trim();
+  if (trailing.startsWith("data:")) {
+    const data = trailing.slice(5).trim();
+    if (data && data !== "[DONE]") {
+      try {
+        yield JSON.parse(data);
+      } catch {
+      }
+    }
+  }
+}
+function parseBody2(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function extractMessage2(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 classifyProviderFailure2(status, message, body) {
+  const haystack = `${message} ${JSON.stringify(body ?? "")}`.toLowerCase();
+  if (status === 401 || status === 403) return "PROVIDER_AUTH_FAILED";
+  if (status === 402 || /\b(quota|credit|credits|billing|balance|insufficient funds|insufficient credit)\b/.test(haystack)) {
+    return "PROVIDER_QUOTA_EXCEEDED";
+  }
+  if (status === 404 || /\bmodel\b.*\b(not found|not a valid|invalid|unavailable)\b/.test(haystack) || /\b(no endpoints found|not a valid model id)\b/.test(haystack)) {
+    return "PROVIDER_MODEL_NOT_FOUND";
+  }
+  if (status === 429) return "PROVIDER_RATE_LIMITED";
+  if (status === 408 || status >= 500) return "PROVIDER_GATEWAY_UNREACHABLE";
+  return "PROVIDER_REQUEST_FAILED";
+}
+function isRetryableStatus2(status) {
+  return status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
+}
+
 // src/runtime/streaming.ts
-async function* executeStreamingChatNotImplemented() {
-  throw new RuntimeConfigError(
-    "STREAMING_NOT_IMPLEMENTED",
-    "executeStreamingChat() is reserved and not implemented yet. Use runtime.run() for non-streaming execution."
-  );
+async function* executeStreamingChat(request, context, call = {}) {
+  const requestId = request.id ?? "unknown";
+  const options = context.options;
+  const defaults = context.defaults;
+  options.logger?.info?.("runtime.executeStreamingChat.started", {
+    requestId,
+    streaming: true,
+    entrypoint: "executeStreamingChat"
+  });
+  try {
+    assertStreamingChatRequest(request, defaults);
+    const streamingRequest = {
+      ...request,
+      apiMode: "chat"
+    };
+    const compiled = compileRuntimeRequest(streamingRequest, defaults, options, {
+      streaming: true,
+      ...call.finalizeBody ? { finalizeBody: call.finalizeBody } : {},
+      ...call.suppressNestedReasoningFallback ? { suppressNestedReasoningFallback: true } : {}
+    });
+    if (compiled.body.stream !== true) {
+      throw new RuntimeConfigError(
+        "STREAMING_CHAT_MISCONFIGURED",
+        "executeStreamingChat() requires stream=true on the compiled OpenRouter body."
+      );
+    }
+    for (const warning of compiled.warnings) {
+      yield warningEvent(requestId, warning);
+    }
+    const model = typeof compiled.body.model === "string" ? compiled.body.model : "";
+    yield startEvent(requestId, model);
+    await options.hooks?.beforeOpenRouterRequest?.(compiled);
+    const timeoutMs = request.execution?.timeoutMs ?? defaults.timeoutMs;
+    const session = await openOpenRouterStream(compiled, options, timeoutMs);
+    let text = "";
+    let finishReason;
+    let resolvedModel = model;
+    try {
+      for await (const chunk of parseSseStream(session.response)) {
+        if (!isRecord(chunk)) continue;
+        if (chunk.error) {
+          const message = isRecord(chunk.error) && typeof chunk.error.message === "string" ? chunk.error.message : "OpenRouter stream returned an error chunk.";
+          const error = {
+            code: "PROVIDER_REQUEST_FAILED",
+            message,
+            source: "openrouter",
+            details: chunk.error
+          };
+          yield errorEvent(requestId, error);
+          throw new OpenRouterHttpError(500, "PROVIDER_REQUEST_FAILED", message, chunk, false);
+        }
+        if (typeof chunk.model === "string") resolvedModel = chunk.model;
+        const choice = Array.isArray(chunk.choices) && isRecord(chunk.choices[0]) ? chunk.choices[0] : void 0;
+        const delta = choice && isRecord(choice.delta) ? choice.delta : void 0;
+        if (delta && call.extractStreamReasoning) {
+          const reasoningText = call.extractStreamReasoning(delta);
+          if (reasoningText) yield reasoningDeltaEvent(requestId, reasoningText);
+        }
+        if (delta && typeof delta.content === "string" && delta.content.length > 0) {
+          text += delta.content;
+          yield textDeltaEvent(requestId, delta.content);
+        }
+        if (delta && Array.isArray(delta.tool_calls)) {
+          for (const toolCall of delta.tool_calls) {
+            if (!isRecord(toolCall)) continue;
+            const index = typeof toolCall.index === "number" ? toolCall.index : 0;
+            const fn = isRecord(toolCall.function) ? toolCall.function : {};
+            yield toolCallDeltaEvent(requestId, {
+              index,
+              ...typeof toolCall.id === "string" ? { id: toolCall.id } : {},
+              ...typeof fn.name === "string" ? { name: fn.name } : {},
+              ...typeof fn.arguments === "string" ? { argumentsDelta: fn.arguments } : {}
+            });
+          }
+        }
+        if (choice && typeof choice.finish_reason === "string") {
+          finishReason = choice.finish_reason;
+        }
+        if (chunk.usage) {
+          const usage = normalizeUsage(chunk.usage);
+          if (usage) yield usageEvent(requestId, usage);
+        }
+      }
+    } finally {
+      session.cleanup();
+    }
+    await options.hooks?.afterOpenRouterResponse?.({ streamed: true, text, finishReason, model: resolvedModel });
+    yield doneEvent(requestId, {
+      text,
+      model: resolvedModel,
+      ...finishReason ? { finishReason } : {}
+    });
+    options.logger?.info?.("runtime.executeStreamingChat.completed", {
+      requestId,
+      streaming: true,
+      entrypoint: "executeStreamingChat",
+      finishReason,
+      textLength: text.length
+    });
+  } catch (error) {
+    const runtimeError = toRuntimeError(error);
+    yield errorEvent(requestId, runtimeError);
+    options.logger?.error?.("runtime.executeStreamingChat.failed", {
+      requestId,
+      streaming: true,
+      code: runtimeError.code,
+      message: runtimeError.message
+    });
+    throw error instanceof Error ? error : new Error(runtimeError.message);
+  }
+}
+function assertStreamingChatRequest(request, defaults) {
+  if (request.apiMode === "responses") {
+    throw new RuntimeConfigError(
+      "STREAMING_CHAT_REQUIRES_CHAT_API",
+      "executeStreamingChat() only supports Chat Completions. Use runtime.run() for Responses API requests."
+    );
+  }
+  if (request.serverTools?.applyPatch?.mode && request.serverTools.applyPatch.mode !== "disabled") {
+    throw new RuntimeConfigError(
+      "STREAMING_CHAT_DOES_NOT_SUPPORT_APPLY_PATCH",
+      "executeStreamingChat() does not support applyPatch. Use runtime.run() instead."
+    );
+  }
+  if (defaults.serverTools?.applyPatch?.mode && defaults.serverTools.applyPatch.mode !== "disabled") {
+    const requestPatch = request.serverTools?.applyPatch;
+    if (!requestPatch || requestPatch.mode !== "disabled") {
+      throw new RuntimeConfigError(
+        "STREAMING_CHAT_DOES_NOT_SUPPORT_APPLY_PATCH",
+        "executeStreamingChat() does not support applyPatch defaults. Use runtime.run() instead."
+      );
+    }
+  }
+}
+function startEvent(requestId, model) {
+  return {
+    type: "stream.start",
+    requestId,
+    data: {
+      model,
+      apiMode: "chat",
+      entrypoint: "executeStreamingChat"
+    }
+  };
+}
+function textDeltaEvent(requestId, text) {
+  return {
+    type: "stream.text.delta",
+    requestId,
+    data: { text }
+  };
+}
+function reasoningDeltaEvent(requestId, text) {
+  return {
+    type: "stream.reasoning.delta",
+    requestId,
+    data: { text }
+  };
+}
+function toolCallDeltaEvent(requestId, data) {
+  return {
+    type: "stream.tool_call.delta",
+    requestId,
+    data
+  };
+}
+function usageEvent(requestId, usage) {
+  return {
+    type: "stream.usage",
+    requestId,
+    data: { usage }
+  };
+}
+function warningEvent(requestId, warning) {
+  return {
+    type: "stream.warning",
+    requestId,
+    data: { warning }
+  };
+}
+function errorEvent(requestId, error) {
+  return {
+    type: "stream.error",
+    requestId,
+    data: { error }
+  };
+}
+function doneEvent(requestId, data) {
+  return {
+    type: "stream.done",
+    requestId,
+    data
+  };
+}
+function toRuntimeError(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: {
+        providerAttempts: error.providerAttempts,
+        ...error.body === void 0 ? {} : { response: error.body }
+      }
+    };
+  }
+  return {
+    code: "RUNTIME_ERROR",
+    message: error instanceof Error ? error.message : String(error),
+    source: "runtime"
+  };
 }
 
 // src/runtime/create-runtime.ts
@@ -1339,7 +1775,14 @@ function createOpenRouterRuntime(options) {
   const defaults = resolveDefaults(options);
   const context = { options: resolvedOptions, defaults };
   return {
-    async run(request) {
+    compile(request, call) {
+      return compileRuntimeRequest(request, defaults, resolvedOptions, {
+        streaming: false,
+        ...call?.finalizeBody ? { finalizeBody: call.finalizeBody } : {},
+        ...call?.suppressNestedReasoningFallback ? { suppressNestedReasoningFallback: true } : {}
+      });
+    },
+    async run(request, call) {
       const requestWithId = { ...request, id: request.id ?? createRuntimeId() };
       try {
         resolvedOptions.logger?.info?.("runtime.request.started", {
@@ -1348,7 +1791,11 @@ function createOpenRouterRuntime(options) {
           entrypoint: "run"
         });
         await resolvedOptions.hooks?.beforeCompile?.(requestWithId);
-        const compiled = compileRuntimeRequest(requestWithId, defaults, resolvedOptions, { streaming: false });
+        const compiled = compileRuntimeRequest(requestWithId, defaults, resolvedOptions, {
+          streaming: false,
+          ...call?.finalizeBody ? { finalizeBody: call.finalizeBody } : {},
+          ...call?.suppressNestedReasoningFallback ? { suppressNestedReasoningFallback: true } : {}
+        });
         await resolvedOptions.hooks?.afterCompile?.(compiled);
         resolvedOptions.logger?.debug?.("runtime.request.compiled", {
           requestId: requestWithId.id,
@@ -1370,14 +1817,9 @@ function createOpenRouterRuntime(options) {
         return errorResponse(requestWithId, error);
       }
     },
-    executeStreamingChat(request) {
-      resolvedOptions.logger?.warn?.("runtime.executeStreamingChat.called", {
-        requestId: request.id,
-        streaming: true,
-        entrypoint: "executeStreamingChat",
-        implemented: false
-      });
-      return executeStreamingChatNotImplemented();
+    executeStreamingChat(request, call) {
+      const requestWithId = { ...request, id: request.id ?? createRuntimeId() };
+      return executeStreamingChat(requestWithId, context, call);
     }
   };
   function errorResponse(request, error) {
@@ -1466,12 +1908,15 @@ function operatorHintFor(code) {
   }
 }
 export {
+  OPENROUTER_METADATA_LIMITS,
   OpenRouterHttpError,
   RuntimeConfigError,
   buildOpenRouterServerTools,
   compileRuntimeRequest,
   createConsoleLogger,
   createOpenRouterRuntime,
-  isRuntimeLoggingEnabled
+  decodeProviderMetadata,
+  isRuntimeLoggingEnabled,
+  toProviderMetadata
 };
 //# sourceMappingURL=index.js.map