@omnicross/core 0.1.1 → 0.1.2

package/dist/chunk-PXUJF5HS.js

@@ -0,0 +1,124 @@
+import {
+  resolveApiFormat
+} from "./chunk-H5JUT3KV.js";
+import {
+  OPENROUTER_APP_HEADERS,
+  isOpenRouterProvider
+} from "./chunk-E3WHL7CO.js";
+
+// src/completion/header-builder.ts
+function getProviderHeaders(provider, apiKey) {
+  const format = resolveApiFormat(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 (isOpenRouterProvider(provider)) {
+    return { ...headers, ...OPENROUTER_APP_HEADERS };
+  }
+  return headers;
+}
+
+// src/pipeline/LlmConfigProviderAuth.ts
+function isReportableStatus(status) {
+  return status === 429 || status === 529 || status === 401 || status === 403;
+}
+var LlmConfigProviderAuth = class {
+  provider;
+  apiKeyPool;
+  providerId;
+  sessionId;
+  /**
+   * 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`).
+   */
+  apiKey;
+  constructor(opts) {
+    this.provider = opts.provider;
+    this.apiKey = opts.apiKey;
+    this.apiKeyPool = 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 };
+  }
+};
+
+export {
+  getProviderHeaders,
+  LlmConfigProviderAuth
+};

package/dist/chunk-QBZJ7P2T.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/outbound-api/subscriptionRegistryPort.ts
+var _registry = null;
+function setSubscriptionRegistryForOutbound(registry) {
+  _registry = registry;
+}
+function getSubscriptionRegistryForOutbound() {
+  return _registry;
+}
+
+
+
+
+exports.setSubscriptionRegistryForOutbound = setSubscriptionRegistryForOutbound; exports.getSubscriptionRegistryForOutbound = getSubscriptionRegistryForOutbound;

package/dist/chunk-QOCNX236.js

@@ -0,0 +1,46 @@
+// src/provider-proxy/matchText.ts
+var MATCH_TEXT_PER_MESSAGE_CAP = 8192;
+var MATCH_TEXT_RECENT_MESSAGES = 6;
+function flattenMatchText(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    const parts = [];
+    for (const item of value) {
+      const text = flattenMatchText(item);
+      if (text) parts.push(text);
+    }
+    return parts.join("\n");
+  }
+  if (value && typeof value === "object") {
+    const obj = value;
+    if (obj.type === "tool_result" && obj.content !== void 0) {
+      return flattenMatchText(obj.content);
+    }
+    if (typeof obj.text === "string") return obj.text;
+  }
+  return "";
+}
+function collectMatchText(anthropicBody) {
+  const messages = Array.isArray(anthropicBody.messages) ? anthropicBody.messages : [];
+  const slices = [];
+  const sys = flattenMatchText(anthropicBody.system).trim();
+  if (sys) slices.push(sys.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  const recent = [];
+  for (let i = messages.length - 1; i >= 0 && recent.length < MATCH_TEXT_RECENT_MESSAGES; i--) {
+    const message = messages[i];
+    if (!message || typeof message !== "object") continue;
+    const role = message.role;
+    if (role !== "user" && role !== "system") continue;
+    const text = flattenMatchText(message.content).trim();
+    if (text) recent.push(text.slice(0, MATCH_TEXT_PER_MESSAGE_CAP));
+  }
+  for (let i = recent.length - 1; i >= 0; i--) slices.push(recent[i]);
+  return slices;
+}
+
+export {
+  MATCH_TEXT_PER_MESSAGE_CAP,
+  MATCH_TEXT_RECENT_MESSAGES,
+  flattenMatchText,
+  collectMatchText
+};

package/dist/chunk-QXD4MV2X.cjs

@@ -0,0 +1,23 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// 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 };
+}
+
+
+
+exports.resolveProviderChain = resolveProviderChain;

package/dist/chunk-R3HK6R4B.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/ports/gemini-code-assist-resolver.ts
+var resolver = null;
+function setGeminiCodeAssistResolver(impl) {
+  resolver = impl;
+}
+function getGeminiCodeAssistResolver() {
+  return resolver;
+}
+
+
+
+
+exports.setGeminiCodeAssistResolver = setGeminiCodeAssistResolver; exports.getGeminiCodeAssistResolver = getGeminiCodeAssistResolver;

package/dist/chunk-RSJ3TWJQ.cjs

@@ -0,0 +1,186 @@
+"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; } var _class;
+
+
+
+
+var _chunkYGXJGRFIcjs = require('./chunk-YGXJGRFI.cjs');
+
+// src/transformer/transformers/GeminiCodeAssistTransformer.ts
+var DEFAULT_CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
+var DEFAULT_CODE_ASSIST_API_VERSION = "v1internal";
+function resolveCodeAssistEndpoint() {
+  return (process.env.CODE_ASSIST_ENDPOINT || DEFAULT_CODE_ASSIST_ENDPOINT).replace(/\/+$/, "");
+}
+function resolveCodeAssistApiVersion() {
+  return process.env.CODE_ASSIST_API_VERSION || DEFAULT_CODE_ASSIST_API_VERSION;
+}
+function buildCodeAssistUrl(stream) {
+  const base = resolveCodeAssistEndpoint();
+  const version = resolveCodeAssistApiVersion();
+  const method = stream ? "streamGenerateContent?alt=sse" : "generateContent";
+  return `${base}/${version}:${method}`;
+}
+function generateUserPromptId() {
+  const c = globalThis.crypto;
+  if (_optionalChain([c, 'optionalAccess', _ => _.randomUUID])) return c.randomUUID();
+  return `omnicross-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function peelResponseEnvelope(parsed) {
+  if (parsed && typeof parsed === "object" && "response" in parsed) {
+    return parsed.response;
+  }
+  return parsed;
+}
+async function unwrapCodeAssistResponse(response) {
+  const contentType = _nullishCoalesce(response.headers.get("Content-Type"), () => ( ""));
+  if (contentType.includes("stream") || contentType.includes("text/event-stream")) {
+    const sourceBody = response.body;
+    if (!sourceBody) return response;
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    const peeled = new ReadableStream({
+      async start(controller) {
+        const reader = sourceBody.getReader();
+        let buffer = "";
+        const processLine = (line) => {
+          if (!line.startsWith("data:")) {
+            if (line.length > 0) controller.enqueue(encoder.encode(`${line}
+`));
+            return;
+          }
+          const payload = line.slice(line.indexOf(":") + 1).trim();
+          if (!payload || payload === "[DONE]") {
+            controller.enqueue(encoder.encode(`${line}
+`));
+            return;
+          }
+          try {
+            const parsed = JSON.parse(payload);
+            const inner2 = peelResponseEnvelope(parsed);
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(inner2)}
+`));
+          } catch (e) {
+            controller.enqueue(encoder.encode(`${line}
+`));
+          }
+        };
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              if (buffer) processLine(buffer);
+              break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) processLine(line);
+          }
+        } catch (err) {
+          controller.error(err);
+        } finally {
+          controller.close();
+        }
+      }
+    });
+    return new Response(peeled, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  }
+  const raw = await response.json().catch(() => null);
+  const inner = peelResponseEnvelope(raw);
+  return new Response(JSON.stringify(inner), {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+var GeminiCodeAssistTransformer = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
+  static __initStatic() {this.TransformerName = "gemini-code-assist"}
+  __init() {this.name = "gemini-code-assist"}
+  
+  /** Code Assist has no fixed `/models/:modelAndAction` endpoint pattern — the
+   *  URL is built per-request in `transformRequestIn`. Left undefined so the
+   *  TransformerService does NOT treat this as an endpoint (reverse) transformer. */
+  __init2() {this.endPoint = void 0}
+  /**
+   * unified → Code Assist envelope.
+   *
+   * Builds the inner public-Gemini body via the shared `buildRequestBody`, then
+   * wraps it as `{ model, project, user_prompt_id, request: <inner> }` and sets
+   * the Code Assist URL + Bearer-only headers.
+   *
+   * The resolved Code Assist `project` is threaded in via `provider.geminiProject`
+   * (stashed by the subscription dispatch seam — see SubscriptionDispatcher /
+   * openaiResponsesIngress). `undefined` is the valid fresh free-tier value.
+   */
+  async transformRequestIn(request, provider, _context) {
+    const inner = _chunkYGXJGRFIcjs.buildRequestBody.call(void 0, request);
+    const envelope = {
+      model: request.model,
+      project: provider.geminiProject,
+      user_prompt_id: generateUserPromptId(),
+      request: inner
+    };
+    const url = buildCodeAssistUrl(Boolean(request.stream));
+    const headers = {
+      "x-goog-api-key": void 0,
+      "X-Goog-Api-Key": void 0
+    };
+    return {
+      body: envelope,
+      config: { url, headers }
+    };
+  }
+  /**
+   * Code Assist request → unified (endpoint-decode parity with GeminiTransformer).
+   * Peels the top-level `request` envelope first, then delegates to the shared
+   * gemini request decoder. Not used on the subscription dispatch path (the
+   * endpoint transformer there is Anthropic/OpenAI-Response), but provided for
+   * completeness so this transformer is a drop-in for the gemini one.
+   */
+  async transformRequestOut(request, _context) {
+    const r = request;
+    const inner = r && typeof r === "object" && "request" in r ? r.request : r;
+    if (inner && typeof inner === "object" && !("model" in inner) && "model" in r) {
+      inner.model = r.model;
+    }
+    return _chunkYGXJGRFIcjs.transformRequestOut.call(void 0, inner);
+  }
+  /**
+   * Code Assist response → OpenAI-compatible. PEEL the `.response` envelope from
+   * the body / each SSE chunk, then DELEGATE to the existing gemini parser.
+   */
+  async transformResponseOut(response, _context) {
+    const unwrapped = await unwrapCodeAssistResponse(response);
+    return _chunkYGXJGRFIcjs.transformResponseOut.call(void 0, unwrapped, this.name, this.logger);
+  }
+  /**
+   * OpenAI-compatible response → Code Assist (endpoint-encode parity). Re-wraps
+   * the standard gemini response under the top-level `response` key after the
+   * shared gemini encoder produces a public-Gemini body. Symmetric with
+   * `transformResponseOut`'s peel.
+   */
+  async transformResponseIn(response, _context) {
+    const geminiResponse = await _chunkYGXJGRFIcjs.transformResponseIn.call(void 0, response, this.logger);
+    const contentType = _nullishCoalesce(geminiResponse.headers.get("Content-Type"), () => ( ""));
+    if (contentType.includes("text/event-stream")) {
+      return geminiResponse;
+    }
+    const data = await geminiResponse.json().catch(() => null);
+    return new Response(JSON.stringify({ response: data }), {
+      status: geminiResponse.status,
+      statusText: geminiResponse.statusText,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+}, _class.__initStatic(), _class);
+
+
+
+
+
+
+exports.resolveCodeAssistEndpoint = resolveCodeAssistEndpoint; exports.resolveCodeAssistApiVersion = resolveCodeAssistApiVersion; exports.buildCodeAssistUrl = buildCodeAssistUrl; exports.GeminiCodeAssistTransformer = GeminiCodeAssistTransformer;