@omnicross/core 0.1.0 → 0.1.2

package/dist/chunk-HQP3K7PU.cjs

@@ -0,0 +1,431 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/sse-parser.ts
+var DEBUG_SSE = true;
+function debugSSE(prefix, ...args) {
+  if (DEBUG_SSE) {
+    console.log(`[SSE-Parser] ${prefix}`, ...args);
+  }
+}
+function createSSEParser(format, callbacks) {
+  const state = {
+    buffer: "",
+    content: "",
+    reasoning: "",
+    usage: void 0,
+    isDone: false,
+    streamStartTime: void 0,
+    firstTokenTime: void 0,
+    streamEndTime: void 0,
+    blocks: [],
+    currentBlockIndex: -1,
+    currentBlockType: "",
+    inputJsonBuffer: "",
+    audios: [],
+    videos: []
+  };
+  function parseOpenAIEvent(data) {
+    if (data === "[DONE]") {
+      debugSSE("OpenAI [DONE] received, content length:", state.content.length);
+      state.isDone = true;
+      _optionalChain([callbacks, 'access', _ => _.onDone, 'optionalCall', _2 => _2()]);
+      return;
+    }
+    try {
+      const json = JSON.parse(data);
+      _optionalChain([callbacks, 'access', _3 => _3.onRawEvent, 'optionalCall', _4 => _4({ data: json, raw: data })]);
+      const delta = _optionalChain([json, 'access', _5 => _5.choices, 'optionalAccess', _6 => _6[0], 'optionalAccess', _7 => _7.delta]);
+      const finishReason = _optionalChain([json, 'access', _8 => _8.choices, 'optionalAccess', _9 => _9[0], 'optionalAccess', _10 => _10.finish_reason]);
+      if (finishReason) {
+        debugSSE("OpenAI finish_reason:", finishReason, "content length so far:", state.content.length);
+      }
+      if (_optionalChain([delta, 'optionalAccess', _11 => _11.content])) {
+        if (!state.firstTokenTime) {
+          state.firstTokenTime = Date.now();
+        }
+        state.content += delta.content;
+        _optionalChain([callbacks, 'access', _12 => _12.onDelta, 'optionalCall', _13 => _13(delta.content)]);
+      }
+      if (_optionalChain([delta, 'optionalAccess', _14 => _14.reasoning_content])) {
+        state.reasoning += delta.reasoning_content;
+        _optionalChain([callbacks, 'access', _15 => _15.onReasoning, 'optionalCall', _16 => _16(delta.reasoning_content)]);
+      }
+      if (_optionalChain([delta, 'optionalAccess', _17 => _17.audio])) {
+        const audioData = delta.audio;
+        if (audioData.data) {
+          const mimeType = audioData.format ? `audio/${audioData.format}` : "audio/wav";
+          const audio = {
+            url: audioData.data.startsWith("data:") ? audioData.data : `data:${mimeType};base64,${audioData.data}`,
+            mimeType
+          };
+          state.audios.push(audio);
+          _optionalChain([callbacks, 'access', _18 => _18.onAudio, 'optionalCall', _19 => _19(audio)]);
+        }
+      }
+      if (json.usage) {
+        debugSSE("OpenAI usage received:", JSON.stringify(json.usage));
+        debugSSE("OpenAI final chunk full data:", JSON.stringify(json));
+        state.usage = {
+          promptTokens: json.usage.prompt_tokens || 0,
+          completionTokens: json.usage.completion_tokens || 0,
+          totalTokens: json.usage.total_tokens || 0
+        };
+        _optionalChain([callbacks, 'access', _20 => _20.onUsage, 'optionalCall', _21 => _21(state.usage)]);
+      }
+      if (finishReason === "stop" || finishReason === "end_turn" || finishReason === "length") {
+        debugSSE("OpenAI stream marked done due to finish_reason:", finishReason);
+      }
+    } catch (e) {
+    }
+  }
+  function parseAnthropicEvent(data) {
+    try {
+      const json = JSON.parse(data);
+      _optionalChain([callbacks, 'access', _22 => _22.onRawEvent, 'optionalCall', _23 => _23({ type: json.type, data: json, raw: data })]);
+      if (json.type === "content_block_start") {
+        const contentBlock = json.content_block;
+        const blockIndex = _nullishCoalesce(json.index, () => ( -1));
+        if (_optionalChain([contentBlock, 'optionalAccess', _24 => _24.type]) === "thinking") {
+          debugSSE("THINKING BLOCK STARTED!");
+        }
+        if (_optionalChain([contentBlock, 'optionalAccess', _25 => _25.type]) === "server_tool_use") {
+          state.currentBlockIndex = blockIndex;
+          state.currentBlockType = "server_tool_use";
+          state.inputJsonBuffer = "";
+          const toolUseBlock = {
+            id: contentBlock.id || `block_${Date.now()}`,
+            type: "tool_use",
+            toolId: contentBlock.id || "",
+            toolName: contentBlock.name || "web_search",
+            input: contentBlock.input || {},
+            status: "running"
+          };
+          state.blocks.push(toolUseBlock);
+          _optionalChain([callbacks, 'access', _26 => _26.onBlock, 'optionalCall', _27 => _27(toolUseBlock)]);
+        }
+        if (_optionalChain([contentBlock, 'optionalAccess', _28 => _28.type]) === "web_search_tool_result") {
+          state.currentBlockIndex = blockIndex;
+          state.currentBlockType = "web_search_tool_result";
+          const searchResults = contentBlock.content;
+          let output = "";
+          if (Array.isArray(searchResults)) {
+            output = searchResults.filter((r) => r.type === "web_search_result").map(
+              (r) => `**${r.title || "Untitled"}**
+${r.url || ""}
+${r.encrypted_content ? "(encrypted)" : r.page_content || r.snippet || ""}`
+            ).join("\n\n");
+          }
+          const lastToolUse = [...state.blocks].reverse().find(
+            (b) => b.type === "tool_use"
+          );
+          const toolResultBlock = {
+            id: `result_${Date.now()}`,
+            type: "tool_result",
+            toolId: _optionalChain([lastToolUse, 'optionalAccess', _29 => _29.toolId]) || "",
+            toolName: _optionalChain([lastToolUse, 'optionalAccess', _30 => _30.toolName]) || "web_search",
+            output: output || "(no results)"
+          };
+          state.blocks.push(toolResultBlock);
+          _optionalChain([callbacks, 'access', _31 => _31.onBlock, 'optionalCall', _32 => _32(toolResultBlock)]);
+          if (lastToolUse) {
+            lastToolUse.status = "completed";
+            _optionalChain([callbacks, 'access', _33 => _33.onBlock, 'optionalCall', _34 => _34(lastToolUse)]);
+          }
+        }
+      }
+      if (json.type === "content_block_delta") {
+        const delta = json.delta;
+        if (_optionalChain([delta, 'optionalAccess', _35 => _35.type]) === "text_delta" && _optionalChain([delta, 'optionalAccess', _36 => _36.text])) {
+          if (!state.firstTokenTime) {
+            state.firstTokenTime = Date.now();
+          }
+          state.content += delta.text;
+          _optionalChain([callbacks, 'access', _37 => _37.onDelta, 'optionalCall', _38 => _38(delta.text)]);
+        }
+        if (_optionalChain([delta, 'optionalAccess', _39 => _39.type]) === "thinking_delta" && _optionalChain([delta, 'optionalAccess', _40 => _40.thinking])) {
+          state.reasoning += delta.thinking;
+          _optionalChain([callbacks, 'access', _41 => _41.onReasoning, 'optionalCall', _42 => _42(delta.thinking)]);
+        }
+        if (_optionalChain([delta, 'optionalAccess', _43 => _43.type]) === "input_json_delta" && _optionalChain([delta, 'optionalAccess', _44 => _44.partial_json])) {
+          state.inputJsonBuffer += delta.partial_json;
+        }
+      }
+      if (json.type === "content_block_stop") {
+        if (state.currentBlockType === "server_tool_use" && state.inputJsonBuffer) {
+          const lastToolUse = [...state.blocks].reverse().find(
+            (b) => b.type === "tool_use"
+          );
+          if (lastToolUse) {
+            try {
+              lastToolUse.input = JSON.parse(state.inputJsonBuffer);
+            } catch (e2) {
+              lastToolUse.input = { raw: state.inputJsonBuffer };
+            }
+            _optionalChain([callbacks, 'access', _45 => _45.onBlock, 'optionalCall', _46 => _46(lastToolUse)]);
+          }
+        }
+        state.currentBlockIndex = -1;
+        state.currentBlockType = "";
+        state.inputJsonBuffer = "";
+      }
+      if (json.type === "message_delta" && json.usage) {
+        state.usage = {
+          promptTokens: json.usage.input_tokens || 0,
+          completionTokens: json.usage.output_tokens || 0,
+          totalTokens: (json.usage.input_tokens || 0) + (json.usage.output_tokens || 0)
+        };
+        _optionalChain([callbacks, 'access', _47 => _47.onUsage, 'optionalCall', _48 => _48(state.usage)]);
+      }
+      if (json.type === "message_stop") {
+        state.isDone = true;
+        _optionalChain([callbacks, 'access', _49 => _49.onDone, 'optionalCall', _50 => _50()]);
+      }
+      if (json.type === "error") {
+        _optionalChain([callbacks, 'access', _51 => _51.onError, 'optionalCall', _52 => _52(_optionalChain([json, 'access', _53 => _53.error, 'optionalAccess', _54 => _54.message]) || "Unknown error")]);
+      }
+    } catch (e3) {
+    }
+  }
+  function parseGeminiEvent(data) {
+    try {
+      const json = JSON.parse(data);
+      _optionalChain([callbacks, 'access', _55 => _55.onRawEvent, 'optionalCall', _56 => _56({ data: json, raw: data })]);
+      const candidates = json.candidates;
+      if (candidates && candidates.length > 0) {
+        const candidate = candidates[0];
+        const content = candidate.content;
+        if (_optionalChain([content, 'optionalAccess', _57 => _57.parts])) {
+          for (const part of content.parts) {
+            if (part.thought === true && part.text) {
+              state.reasoning += part.text;
+              _optionalChain([callbacks, 'access', _58 => _58.onReasoning, 'optionalCall', _59 => _59(part.text)]);
+            } else if (part.text) {
+              if (!state.firstTokenTime) {
+                state.firstTokenTime = Date.now();
+              }
+              state.content += part.text;
+              _optionalChain([callbacks, 'access', _60 => _60.onDelta, 'optionalCall', _61 => _61(part.text)]);
+            }
+          }
+        }
+        const finishReason = candidate.finishReason;
+        if (finishReason === "STOP" || finishReason === "MAX_TOKENS" || finishReason === "SAFETY") {
+          debugSSE("Gemini finish reason:", finishReason);
+        }
+      }
+      const usage = json.usageMetadata;
+      if (usage) {
+        state.usage = {
+          promptTokens: usage.promptTokenCount || 0,
+          completionTokens: usage.candidatesTokenCount || 0,
+          totalTokens: usage.totalTokenCount || 0
+        };
+        _optionalChain([callbacks, 'access', _62 => _62.onUsage, 'optionalCall', _63 => _63(state.usage)]);
+        debugSSE("Gemini usage:", state.usage);
+      }
+      if (json.error) {
+        _optionalChain([callbacks, 'access', _64 => _64.onError, 'optionalCall', _65 => _65(json.error.message || "Gemini API error")]);
+      }
+    } catch (e4) {
+    }
+  }
+  function parseOpenAIResponseEvent(data) {
+    try {
+      const json = JSON.parse(data);
+      _optionalChain([callbacks, 'access', _66 => _66.onRawEvent, 'optionalCall', _67 => _67({ type: json.type, data: json, raw: data })]);
+      switch (json.type) {
+        case "response.output_text.delta":
+          if (json.delta) {
+            if (!state.firstTokenTime) {
+              state.firstTokenTime = Date.now();
+            }
+            state.content += json.delta;
+            _optionalChain([callbacks, 'access', _68 => _68.onDelta, 'optionalCall', _69 => _69(json.delta)]);
+          }
+          break;
+        case "response.reasoning_summary_text.delta":
+          if (json.delta) {
+            state.reasoning += json.delta;
+            _optionalChain([callbacks, 'access', _70 => _70.onReasoning, 'optionalCall', _71 => _71(json.delta)]);
+          }
+          break;
+        case "response.completed": {
+          const response = json.response;
+          if (_optionalChain([response, 'optionalAccess', _72 => _72.usage])) {
+            state.usage = {
+              promptTokens: response.usage.input_tokens || 0,
+              completionTokens: response.usage.output_tokens || 0,
+              totalTokens: (response.usage.input_tokens || 0) + (response.usage.output_tokens || 0)
+            };
+            _optionalChain([callbacks, 'access', _73 => _73.onUsage, 'optionalCall', _74 => _74(state.usage)]);
+          }
+          state.isDone = true;
+          _optionalChain([callbacks, 'access', _75 => _75.onDone, 'optionalCall', _76 => _76()]);
+          break;
+        }
+        case "error":
+          _optionalChain([callbacks, 'access', _77 => _77.onError, 'optionalCall', _78 => _78(_optionalChain([json, 'access', _79 => _79.error, 'optionalAccess', _80 => _80.message]) || json.message || "Unknown error")]);
+          break;
+        // Informational events — no-op
+        // response.created, response.in_progress, response.output_item.added,
+        // response.content_part.added, response.output_text.done,
+        // response.content_part.done, response.output_item.done, etc.
+        default:
+          break;
+      }
+    } catch (e5) {
+    }
+  }
+  function processEventBlock(eventBlock) {
+    const lines = eventBlock.split("\n");
+    const dataLines = [];
+    for (const line of lines) {
+      if (line.startsWith("data: ")) {
+        dataLines.push(line.slice(6));
+      } else if (line.trim() !== "" && !line.startsWith(":")) {
+      }
+    }
+    if (dataLines.length > 0) {
+      const data = dataLines.join("\n");
+      if (format === "openai") {
+        parseOpenAIEvent(data);
+      } else if (format === "gemini") {
+        parseGeminiEvent(data);
+      } else if (format === "openai-response") {
+        parseOpenAIResponseEvent(data);
+      } else {
+        parseAnthropicEvent(data);
+      }
+    }
+  }
+  return {
+    /**
+     * Push a chunk of data to the parser
+     * @param chunk - Raw SSE chunk from response stream
+     */
+    push(chunk) {
+      if (state.isDone) return;
+      if (!state.streamStartTime) {
+        state.streamStartTime = Date.now();
+      }
+      state.buffer += chunk;
+      const events = state.buffer.split("\n\n");
+      state.buffer = events.pop() || "";
+      for (const eventBlock of events) {
+        processEventBlock(eventBlock);
+        if (state.isDone) break;
+      }
+    },
+    /**
+     * Flush any remaining data in the buffer
+     */
+    flush() {
+      debugSSE("flush() called, buffer length:", state.buffer.length, "isDone:", state.isDone);
+      if (state.buffer.trim()) {
+        debugSSE("flush() processing remaining buffer:", state.buffer.substring(0, 200));
+        processEventBlock(state.buffer);
+        state.buffer = "";
+      }
+      state.streamEndTime = Date.now();
+      if (!state.isDone) {
+        debugSSE("flush() marking stream as done, final content length:", state.content.length);
+        state.isDone = true;
+        _optionalChain([callbacks, 'access', _81 => _81.onDone, 'optionalCall', _82 => _82()]);
+      }
+    },
+    /**
+     * Get accumulated results
+     */
+    getResult() {
+      let metrics;
+      if (state.usage && state.firstTokenTime && state.streamEndTime) {
+        const timeCompletionMs = state.streamEndTime - state.firstTokenTime;
+        const timeFirstTokenMs = state.streamStartTime ? state.firstTokenTime - state.streamStartTime : void 0;
+        metrics = {
+          completionTokens: state.usage.completionTokens,
+          timeCompletionMs: timeCompletionMs > 0 ? timeCompletionMs : 1,
+          // Ensure at least 1ms
+          timeFirstTokenMs
+        };
+      }
+      if (state.reasoning) {
+        const thinkingBlock = {
+          id: `thinking_${Date.now()}`,
+          type: "thinking",
+          content: state.reasoning
+        };
+        state.blocks.unshift(thinkingBlock);
+      }
+      return {
+        content: state.content,
+        reasoning: state.reasoning,
+        usage: state.usage,
+        metrics,
+        blocks: state.blocks,
+        audios: state.audios,
+        videos: state.videos
+      };
+    },
+    /**
+     * Check if stream is complete
+     */
+    isDone() {
+      return state.isDone;
+    },
+    /**
+     * Reset parser state for reuse
+     */
+    reset() {
+      state.buffer = "";
+      state.content = "";
+      state.reasoning = "";
+      state.usage = void 0;
+      state.isDone = false;
+      state.streamStartTime = void 0;
+      state.firstTokenTime = void 0;
+      state.streamEndTime = void 0;
+      state.blocks = [];
+      state.currentBlockIndex = -1;
+      state.currentBlockType = "";
+      state.inputJsonBuffer = "";
+      state.audios = [];
+      state.videos = [];
+    }
+  };
+}
+async function streamSSEResponse(response, format, callbacks) {
+  debugSSE("streamSSEResponse started, format:", format);
+  const reader = _optionalChain([response, 'access', _83 => _83.body, 'optionalAccess', _84 => _84.getReader, 'call', _85 => _85()]);
+  if (!reader) {
+    _optionalChain([callbacks, 'access', _86 => _86.onError, 'optionalCall', _87 => _87("No response body")]);
+    return { content: "", reasoning: "", blocks: [], audios: [], videos: [] };
+  }
+  const decoder = new TextDecoder();
+  const parser = createSSEParser(format, callbacks);
+  let chunkCount = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        debugSSE("Reader done signal received after", chunkCount, "chunks");
+        break;
+      }
+      const chunk = decoder.decode(value, { stream: true });
+      chunkCount++;
+      parser.push(chunk);
+      if (parser.isDone()) {
+        debugSSE("Parser isDone after", chunkCount, "chunks");
+        break;
+      }
+    }
+    parser.flush();
+    const result = parser.getResult();
+    debugSSE("streamSSEResponse complete, content length:", result.content.length, "completionTokens:", _optionalChain([result, 'access', _88 => _88.usage, 'optionalAccess', _89 => _89.completionTokens]), "usage:", result.usage);
+    return result;
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+
+
+
+exports.createSSEParser = createSSEParser; exports.streamSSEResponse = streamSSEResponse;

package/dist/chunk-JO5NLTLY.js

@@ -0,0 +1,46 @@
+// src/pipeline/executeProviderCall.ts
+async function executeProviderCall(ctx) {
+  const {
+    executor,
+    request,
+    provider,
+    chain,
+    endpointTransformer,
+    extendedContext,
+    resolveUrl,
+    buildHeaders,
+    prepareBody,
+    fetchFn,
+    runResponseChain = false,
+    responseChainRequest
+  } = ctx;
+  const { requestBody, config } = await executor.executeRequestChain(
+    request,
+    provider,
+    chain,
+    { endpointTransformer, extendedContext }
+  );
+  const finalBody = prepareBody ? await prepareBody(requestBody, config) : requestBody;
+  const url = resolveUrl(config);
+  const headers = buildHeaders(config);
+  const fetched = await fetchFn(url, headers, finalBody);
+  let response = fetched;
+  if (runResponseChain) {
+    response = await executor.executeResponseChain(
+      // Preserve the EXACT first arg each site passed: proxy → requestBody,
+      // unified ingresses → their pre-transform request. The caller supplies
+      // it via `responseChainRequest`; fall back to `requestBody` (the proxy
+      // shape) so the contract is never silently `undefined`.
+      responseChainRequest ?? requestBody,
+      fetched,
+      provider,
+      chain,
+      { endpointTransformer }
+    );
+  }
+  return { response, requestBody, finalBody, config, url, headers };
+}
+
+export {
+  executeProviderCall
+};

package/dist/chunk-JWC6APFQ.js

@@ -0,0 +1,23 @@
+// src/pipeline/resolveProviderChain.ts
+async function resolveProviderChain(llmConfig, providerId, model) {
+  const cachedChain = await llmConfig.resolveTransformerChain(providerId, model);
+  const mainTransformer = await llmConfig.getMainTransformer(providerId);
+  const chain = {
+    providerTransformers: [...cachedChain.providerTransformers],
+    modelTransformers: [...cachedChain.modelTransformers]
+  };
+  if (mainTransformer) {
+    const alreadyInChain = chain.providerTransformers.some(
+      (t) => t.name === mainTransformer.name
+    );
+    if (!alreadyInChain) {
+      chain.providerTransformers.unshift(mainTransformer);
+    }
+  }
+  const hasTransformers = chain.providerTransformers.length > 0 || chain.modelTransformers.length > 0;
+  return { chain, mainTransformer, hasTransformers };
+}
+
+export {
+  resolveProviderChain
+};

package/dist/chunk-KUU2RNG6.cjs

@@ -0,0 +1,46 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/pipeline/executeProviderCall.ts
+async function executeProviderCall(ctx) {
+  const {
+    executor,
+    request,
+    provider,
+    chain,
+    endpointTransformer,
+    extendedContext,
+    resolveUrl,
+    buildHeaders,
+    prepareBody,
+    fetchFn,
+    runResponseChain = false,
+    responseChainRequest
+  } = ctx;
+  const { requestBody, config } = await executor.executeRequestChain(
+    request,
+    provider,
+    chain,
+    { endpointTransformer, extendedContext }
+  );
+  const finalBody = prepareBody ? await prepareBody(requestBody, config) : requestBody;
+  const url = resolveUrl(config);
+  const headers = buildHeaders(config);
+  const fetched = await fetchFn(url, headers, finalBody);
+  let response = fetched;
+  if (runResponseChain) {
+    response = await executor.executeResponseChain(
+      // Preserve the EXACT first arg each site passed: proxy → requestBody,
+      // unified ingresses → their pre-transform request. The caller supplies
+      // it via `responseChainRequest`; fall back to `requestBody` (the proxy
+      // shape) so the contract is never silently `undefined`.
+      _nullishCoalesce(responseChainRequest, () => ( requestBody)),
+      fetched,
+      provider,
+      chain,
+      { endpointTransformer }
+    );
+  }
+  return { response, requestBody, finalBody, config, url, headers };
+}
+
+
+
+exports.executeProviderCall = executeProviderCall;

package/dist/chunk-LKZJEL6E.cjs

@@ -0,0 +1,124 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkA2YMUCBTcjs = require('./chunk-A2YMUCBT.cjs');
+
+
+
+var _chunk6VIXXLMXcjs = require('./chunk-6VIXXLMX.cjs');
+
+// src/completion/header-builder.ts
+function getProviderHeaders(provider, apiKey) {
+  const format = _chunkA2YMUCBTcjs.resolveApiFormat.call(void 0, provider);
+  let headers;
+  switch (format) {
+    case "anthropic":
+      headers = {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2025-01-10"
+        // Required for extended thinking feature
+      };
+      break;
+    case "google":
+      headers = {
+        "Content-Type": "application/json",
+        "x-goog-api-key": apiKey
+      };
+      break;
+    case "azure-openai":
+      headers = {
+        "Content-Type": "application/json",
+        "api-key": apiKey
+      };
+      break;
+    case "openai":
+    case "openai-response":
+    default:
+      headers = {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      };
+      break;
+  }
+  if (_chunk6VIXXLMXcjs.isOpenRouterProvider.call(void 0, provider)) {
+    return { ...headers, ..._chunk6VIXXLMXcjs.OPENROUTER_APP_HEADERS };
+  }
+  return headers;
+}
+
+// src/pipeline/LlmConfigProviderAuth.ts
+function isReportableStatus(status) {
+  return status === 429 || status === 529 || status === 401 || status === 403;
+}
+var LlmConfigProviderAuth = class {
+  
+  
+  
+  
+  /**
+   * The current resolved key. Mutable so a Phase-3 caller can read the
+   * rotated key after `onResult`; this phase it is only set at construction
+   * and updated inside `onResult` (mirroring the inline re-point in
+   * `callWithPoolReporting`).
+   */
+  
+  constructor(opts) {
+    this.provider = opts.provider;
+    this.apiKey = opts.apiKey;
+    this.apiKeyPool = _nullishCoalesce(opts.apiKeyPool, () => ( null));
+    this.providerId = opts.providerId;
+    this.sessionId = opts.sessionId;
+  }
+  /**
+   * Merge the provider auth headers (and content-type / OpenRouter app
+   * headers) into `headers`, exactly as a direct `getProviderHeaders` call
+   * would produce them. `hints` are accepted for contract symmetry but the
+   * provider-key path does not vary headers by URL/model.
+   */
+  applyHeaders(headers, _hints) {
+    const authHeaders = getProviderHeaders(this.provider, this.apiKey);
+    for (const [k, v] of Object.entries(authHeaders)) {
+      headers[k] = v;
+    }
+  }
+  /**
+   * React to the final HTTP status — the pool-rotation seam (design D5).
+   *
+   * Reproduces `callWithPoolReporting`'s reportable + success branches:
+   *  - reportable status (429/529/401/403) on a pool-backed request →
+   *    `reportError(providerId, sessionId, status)`; when it hands back a
+   *    `newKey` the session was re-bound, so we adopt it (`this.apiKey`) and
+   *    return `{ rebound: true, newKey }`. When no key is available it returns
+   *    `{ rebound: false }` (the session is still cooled/disabled by the report).
+   *  - success / any 2xx → `reportSuccess(sessionId)`; `{ rebound: false }`.
+   *  - non-reportable, non-success, or non-pool request → no-op
+   *    `{ rebound: false }`.
+   *
+   * NOTE: no caller invokes this in Phase 2; it is unit-tested in isolation.
+   */
+  async onResult(status) {
+    const pool = this.apiKeyPool;
+    const providerId = this.providerId;
+    const sessionId = this.sessionId;
+    if (!pool || !providerId || !sessionId) {
+      return { rebound: false };
+    }
+    if (isReportableStatus(status)) {
+      const newKey = await pool.reportError(providerId, sessionId, status);
+      if (newKey) {
+        this.apiKey = newKey;
+        return { rebound: true, newKey };
+      }
+      return { rebound: false };
+    }
+    if (status !== null && status >= 200 && status < 300) {
+      pool.reportSuccess(sessionId);
+    }
+    return { rebound: false };
+  }
+};
+
+
+
+
+exports.getProviderHeaders = getProviderHeaders; exports.LlmConfigProviderAuth = LlmConfigProviderAuth;