@omnicross/core 0.1.0 → 0.1.2

package/dist/chunk-YMFAJFQT.cjs

@@ -0,0 +1,173 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class;// src/usage/pricing-engine.ts
+var _pricingtypes = require('@omnicross/contracts/pricing-types');
+var PricingEngine = (_class = class {
+  constructor(store, logger, options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);
+    this.store = store;
+    this.logger = logger;
+    this.options = options;
+  }
+  
+  
+  
+  __init() {this.cache = /* @__PURE__ */ new Map()}
+  /**
+   * Secondary index keyed by modelId alone. Used as a fallback when no exact
+   * (providerId, modelId) match exists — usage may be recorded under a
+   * runtime provider alias while pricing rows use the canonical provider id,
+   * so matching by model name lets the price still resolve. First
+   * non-wildcard entry per model wins.
+   */
+  __init2() {this.cacheByModel = /* @__PURE__ */ new Map()}
+  __init3() {this.cacheLoaded = false}
+  // ===== Cache management =====
+  /** Lazy-load and cache the full pricing table. */
+  async ensureCache() {
+    if (this.cacheLoaded) return;
+    const rows = await this.store.getAll();
+    this.cache = new Map(rows.map((r) => [keyOf(r.providerId, r.modelId), r]));
+    this.cacheByModel = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      if (r.providerId === "*") continue;
+      if (!this.cacheByModel.has(r.modelId)) this.cacheByModel.set(r.modelId, r);
+    }
+    this.cacheLoaded = true;
+  }
+  /** Force a cache refresh — call after any write. */
+  async invalidateCache() {
+    this.cacheLoaded = false;
+    await this.ensureCache();
+  }
+  // ===== Read API =====
+  async getAll() {
+    await this.ensureCache();
+    return Array.from(this.cache.values());
+  }
+  /**
+   * Look up a price for (provider, model). Resolution order:
+   *   1. exact (providerId, modelId)
+   *   2. wildcard provider ('*', modelId)
+   *   3. model name alone (any provider) — tolerates a runtime-alias vs
+   *      canonical provider-id mismatch for the same model.
+   */
+  async getEntry(providerId, modelId) {
+    await this.ensureCache();
+    return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(this.cache.get(keyOf(providerId, modelId)), () => ( this.cache.get(keyOf("*", modelId)))), () => ( this.cacheByModel.get(modelId))), () => ( null));
+  }
+  // ===== Cost calculation =====
+  /**
+   * Compute the cost (and cache savings) for a single response.
+   *
+   * Cost formula (USD):
+   *   cost = (input  * inputPrice
+   *         + output * outputPrice
+   *         + cacheRead  * (cacheReadPrice  ?? inputPrice)
+   *         + cacheWrite * (cacheWritePrice ?? inputPrice)
+   *        ) / 1e6
+   *
+   * Cache savings:
+   *   savings = cacheRead * (inputPrice - cacheReadPrice) / 1e6
+   *           — clamped at 0 if cacheReadPrice is null or ≥ inputPrice.
+   */
+  async calculateCost(providerId, modelId, usage) {
+    const entry = await this.getEntry(providerId, modelId);
+    if (!entry) {
+      return { costUsd: 0, costSavedByCacheUsd: 0 };
+    }
+    const ip = entry.inputPricePer1m;
+    const op = entry.outputPricePer1m;
+    const crp = _nullishCoalesce(entry.cacheReadPricePer1m, () => ( ip));
+    const cwp = _nullishCoalesce(entry.cacheWritePricePer1m, () => ( ip));
+    const costUsd = (usage.inputTokens * ip + usage.outputTokens * op + usage.cacheReadTokens * crp + usage.cacheCreationTokens * cwp) / 1e6;
+    const savingsRate = entry.cacheReadPricePer1m == null ? 0 : Math.max(0, ip - crp);
+    const costSavedByCacheUsd = usage.cacheReadTokens * savingsRate / 1e6;
+    return { costUsd, costSavedByCacheUsd };
+  }
+  // ===== Manual upsert (used by inline editors) =====
+  async upsertManual(input) {
+    const updated = await this.store.upsert(
+      input,
+      /* asUserEdit */
+      true
+    );
+    this.cache.set(keyOf(updated.providerId, updated.modelId), updated);
+    if (updated.providerId !== "*") this.cacheByModel.set(updated.modelId, updated);
+    return updated;
+  }
+  // ===== Source refresh =====
+  async fetchLatestFromSource() {
+    const sourceUrl = _nullishCoalesce(this.options.sourceUrl, () => ( _pricingtypes.DEFAULT_LITELLM_PRICING_URL));
+    const fetchImpl = _nullishCoalesce(this.options.fetchImpl, () => ( fetch));
+    const fetchedAt = Date.now();
+    let json;
+    try {
+      const res = await fetchImpl(sourceUrl);
+      if (!res.ok) {
+        throw new Error(`Pricing-source fetch failed with status ${res.status}`);
+      }
+      json = await res.json();
+    } catch (e) {
+      this.logger.warn("[PricingEngine] pricing-source fetch failed", {
+        error: e instanceof Error ? e.message : String(e)
+      });
+      throw e;
+    }
+    const incoming = parseLitellmJson(json);
+    const { applied, conflicts } = await this.store.bulkApplyFromSource(incoming);
+    await this.invalidateCache();
+    return {
+      applied,
+      conflicts: conflicts.map((c) => ({
+        providerId: c.current.providerId,
+        modelId: c.current.modelId,
+        current: c.current,
+        incoming: c.incoming
+      })),
+      fetchedAt,
+      sourceUrl
+    };
+  }
+  // ===== Conflict resolution =====
+  async resolveConflicts(decisions, pendingIncoming) {
+    const resolutions = [];
+    for (const d of decisions) {
+      const incoming = pendingIncoming.get(keyOf(d.providerId, d.modelId));
+      if (!incoming) continue;
+      resolutions.push({ incoming, action: d.action });
+    }
+    const result = await this.store.applyResolutions(resolutions);
+    await this.invalidateCache();
+    return result;
+  }
+}, _class);
+var keyOf = (providerId, modelId) => `${providerId}::${modelId}`;
+var PROVIDER_ALIASES = {
+  vertex_ai: "gemini",
+  google: "gemini",
+  bedrock: "anthropic",
+  azure: "openai"
+};
+var parseLitellmJson = (json) => {
+  const out = [];
+  for (const [modelId, entry] of Object.entries(json)) {
+    if (!entry || typeof entry !== "object") continue;
+    if (entry.input_cost_per_token == null || entry.output_cost_per_token == null) {
+      continue;
+    }
+    const rawProvider = _nullishCoalesce(entry.litellm_provider, () => ( ""));
+    const providerId = _nullishCoalesce(PROVIDER_ALIASES[rawProvider], () => ( rawProvider));
+    if (!providerId) continue;
+    out.push({
+      providerId,
+      modelId,
+      inputPricePer1m: entry.input_cost_per_token * 1e6,
+      outputPricePer1m: entry.output_cost_per_token * 1e6,
+      cacheReadPricePer1m: entry.cache_read_input_token_cost != null ? entry.cache_read_input_token_cost * 1e6 : null,
+      cacheWritePricePer1m: entry.cache_creation_input_token_cost != null ? entry.cache_creation_input_token_cost * 1e6 : null
+    });
+  }
+  return out;
+};
+
+
+
+exports.PricingEngine = PricingEngine;

package/dist/chunk-Z7LUNECE.js

@@ -0,0 +1,49 @@
+// src/transformer/transformers/OpenCodeGoTransformer.ts
+var OpenCodeGoTransformer = class {
+  static TransformerName = "opencodego";
+  name = "opencodego";
+  endPoint = "/v1/chat/completions";
+  logger;
+  async auth(request, _provider, _context) {
+    return { body: request, config: { headers: {} } };
+  }
+  /**
+   * Unified → OpenAI Chat Completions.
+   * Unified IS chat completions shape; this is mostly stripping `meta` and
+   * normalizing string-content single-block messages.
+   */
+  async transformRequestIn(request, _provider, _context) {
+    const messages = request.messages.map((m) => {
+      const content = m.content;
+      if (Array.isArray(content) && content.length === 1 && content[0]?.type === "text") {
+        return { ...m, content: content[0].text };
+      }
+      return m;
+    });
+    const out = {
+      model: request.model,
+      messages,
+      stream: request.stream
+    };
+    if (request.temperature !== void 0) out.temperature = request.temperature;
+    if (request.max_tokens !== void 0) out.max_tokens = request.max_tokens;
+    if (request.tools && request.tools.length > 0) out.tools = request.tools;
+    if (request.tool_choice !== void 0) out.tool_choice = request.tool_choice;
+    if (request.reasoning?.effort && request.reasoning.effort !== "none") {
+      out.reasoning_effort = request.reasoning.effort;
+    }
+    return out;
+  }
+  /**
+   * OpenAI Chat Completions response → Unified.
+   * The upstream's response shape already matches Unified — pass through.
+   * The endpoint AnthropicTransformer re-encodes to Anthropic for the SDK.
+   */
+  async transformResponseOut(response, _context) {
+    return response;
+  }
+};
+
+export {
+  OpenCodeGoTransformer
+};

package/dist/chunk-Z7Y2NPHY.js

@@ -0,0 +1,186 @@
+import {
+  buildRequestBody,
+  transformRequestOut,
+  transformResponseIn,
+  transformResponseOut
+} from "./chunk-S4WBV25P.js";
+
+// 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 (c?.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 = 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 {
+            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 {
+  static TransformerName = "gemini-code-assist";
+  name = "gemini-code-assist";
+  logger;
+  /** 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. */
+  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 = buildRequestBody(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 transformRequestOut(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 transformResponseOut(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 transformResponseIn(response, this.logger);
+    const contentType = 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" }
+    });
+  }
+};
+
+export {
+  resolveCodeAssistEndpoint,
+  resolveCodeAssistApiVersion,
+  buildCodeAssistUrl,
+  GeminiCodeAssistTransformer
+};

package/dist/chunk-ZJZAOKI7.js

@@ -0,0 +1,254 @@
+// src/transformer/transformers/ReasoningTransformer.ts
+import {
+  buildAnthropicThinking,
+  buildQwenThinkingConfig,
+  calculateThinkingBudget,
+  getOpenAIReasoningEffort
+} from "@omnicross/contracts/thinking-config";
+var ReasoningTransformer = class {
+  static TransformerName = "reasoning";
+  name = "reasoning";
+  logger;
+  enabled;
+  constructor(options) {
+    this.enabled = options?.enable !== false;
+  }
+  /**
+   * Transform request: convert reasoning config to thinking parameters
+   * Uses model-specific budget calculation based on effort level
+   */
+  async transformRequestIn(request, provider, _context) {
+    const extendedRequest = request;
+    const modelId = request.model;
+    if (!this.enabled) {
+      extendedRequest.thinking = {
+        type: "disabled",
+        budget_tokens: -1
+      };
+      extendedRequest.enable_thinking = false;
+      return extendedRequest;
+    }
+    if (request.reasoning) {
+      const effortLevel = request.reasoning.effort || "none";
+      const userMaxTokens = request.reasoning.max_tokens || request.max_tokens;
+      const calculatedBudget = calculateThinkingBudget(modelId, effortLevel, userMaxTokens);
+      const providerName = provider.name?.toLowerCase() || "";
+      if (providerName === "anthropic" || providerName.includes("claude")) {
+        const thinkingConfig = buildAnthropicThinking(modelId, effortLevel, userMaxTokens);
+        if (thinkingConfig) {
+          extendedRequest.thinking = thinkingConfig;
+        } else {
+          extendedRequest.thinking = {
+            type: "disabled"
+          };
+        }
+      } else if (providerName === "openai" || modelId.match(/^o[134]/i)) {
+        const reasoningEffort = getOpenAIReasoningEffort(effortLevel);
+        if (reasoningEffort) {
+          extendedRequest.reasoning_effort = reasoningEffort;
+        }
+        extendedRequest.thinking = {
+          type: effortLevel === "none" ? "disabled" : "enabled",
+          budget_tokens: calculatedBudget
+        };
+      } else if (providerName === "deepseek" && modelId?.startsWith("deepseek-v4")) {
+        extendedRequest.thinking = {
+          type: effortLevel === "none" ? "disabled" : "enabled",
+          budget_tokens: calculatedBudget
+        };
+        if (effortLevel !== "none") {
+          extendedRequest.reasoning_effort = effortLevel === "high" ? "max" : "high";
+        }
+      } else if (providerName === "deepseek" || providerName === "qwen" || providerName === "alibaba") {
+        const qwenConfig = buildQwenThinkingConfig(effortLevel, userMaxTokens);
+        extendedRequest.enable_thinking = qwenConfig.enable_thinking;
+        if (qwenConfig.thinking_budget) {
+          extendedRequest.thinking_budget = qwenConfig.thinking_budget;
+        }
+        extendedRequest.thinking = {
+          type: qwenConfig.enable_thinking ? "enabled" : "disabled",
+          budget_tokens: calculatedBudget
+        };
+      } else {
+        extendedRequest.thinking = {
+          type: effortLevel === "none" ? "disabled" : "enabled",
+          budget_tokens: calculatedBudget
+        };
+        extendedRequest.enable_thinking = effortLevel !== "none";
+      }
+      this.logger?.debug(`[ReasoningTransformer] Model: ${modelId}, Effort: ${effortLevel}, Budget: ${calculatedBudget}`);
+    }
+    return extendedRequest;
+  }
+  /**
+   * Transform response: convert reasoning_content to thinking blocks
+   */
+  async transformResponseOut(response, _context) {
+    if (!this.enabled) return response;
+    const contentType = response.headers.get("Content-Type") ?? "";
+    if (contentType.includes("application/json")) {
+      return this.handleJsonResponse(response);
+    } else if (contentType.includes("stream") || contentType.includes("text/event-stream")) {
+      return this.handleStreamResponse(response);
+    }
+    return response;
+  }
+  /**
+   * Handle JSON (non-streaming) response
+   */
+  async handleJsonResponse(response) {
+    const jsonResponse = await response.json();
+    if (jsonResponse.choices?.[0]?.message?.reasoning_content) {
+      jsonResponse.thinking = {
+        content: jsonResponse.choices[0].message.reasoning_content
+      };
+      delete jsonResponse.choices[0].message.reasoning_content;
+    }
+    return new Response(JSON.stringify(jsonResponse), {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  }
+  /**
+   * Handle streaming response - convert reasoning_content to thinking blocks
+   */
+  handleStreamResponse(response) {
+    if (!response.body) {
+      return response;
+    }
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    let reasoningContent = "";
+    let isReasoningComplete = false;
+    let buffer = "";
+    const stream = new ReadableStream({
+      start: async (controller) => {
+        const reader = response.body.getReader();
+        const processLine = (line) => {
+          this.logger?.debug("Processing reasoning line:", line);
+          if (line.startsWith("data: ") && line.trim() !== "data: [DONE]") {
+            try {
+              const data = JSON.parse(line.slice(6));
+              if (data.choices?.[0]?.delta?.reasoning_content) {
+                reasoningContent += data.choices[0].delta.reasoning_content;
+                const thinkingChunk = {
+                  ...data,
+                  choices: [
+                    {
+                      ...data.choices[0],
+                      delta: {
+                        ...data.choices[0].delta,
+                        thinking: {
+                          content: data.choices[0].delta.reasoning_content
+                        }
+                      }
+                    }
+                  ]
+                };
+                delete thinkingChunk.choices[0].delta.reasoning_content;
+                const thinkingLine = `data: ${JSON.stringify(thinkingChunk)}
+
+`;
+                controller.enqueue(encoder.encode(thinkingLine));
+                return;
+              }
+              if ((data.choices?.[0]?.delta?.content || data.choices?.[0]?.delta?.tool_calls) && reasoningContent && !isReasoningComplete) {
+                isReasoningComplete = true;
+                const signature = Date.now().toString();
+                const thinkingChunk = {
+                  ...data,
+                  choices: [
+                    {
+                      ...data.choices[0],
+                      delta: {
+                        ...data.choices[0].delta,
+                        content: null,
+                        thinking: {
+                          signature
+                        }
+                      }
+                    }
+                  ]
+                };
+                delete thinkingChunk.choices[0].delta.reasoning_content;
+                const thinkingLine = `data: ${JSON.stringify(thinkingChunk)}
+
+`;
+                controller.enqueue(encoder.encode(thinkingLine));
+              }
+              if (data.choices?.[0]?.delta?.reasoning_content) {
+                delete data.choices[0].delta.reasoning_content;
+              }
+              if (data.choices?.[0]?.delta && Object.keys(data.choices[0].delta).length > 0) {
+                if (isReasoningComplete) {
+                  data.choices[0].index++;
+                }
+                const modifiedLine = `data: ${JSON.stringify(data)}
+
+`;
+                controller.enqueue(encoder.encode(modifiedLine));
+              }
+            } catch (_e) {
+              controller.enqueue(encoder.encode(line + "\n"));
+            }
+          } else {
+            controller.enqueue(encoder.encode(line + "\n"));
+          }
+        };
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              if (buffer.trim()) {
+                const lines2 = buffer.split("\n");
+                for (const line of lines2) {
+                  if (line.trim()) {
+                    controller.enqueue(encoder.encode(line + "\n"));
+                  }
+                }
+              }
+              break;
+            }
+            const chunk = decoder.decode(value, { stream: true });
+            buffer += chunk;
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (!line.trim()) continue;
+              try {
+                processLine(line);
+              } catch (error) {
+                this.logger?.error("Error processing reasoning stream line:", error);
+                controller.enqueue(encoder.encode(line + "\n"));
+              }
+            }
+          }
+        } catch (error) {
+          this.logger?.error("Reasoning stream error:", error);
+          controller.error(error);
+        } finally {
+          try {
+            reader.releaseLock();
+          } catch (e) {
+            this.logger?.error("Error releasing reader lock:", e);
+          }
+          controller.close();
+        }
+      }
+    });
+    return new Response(stream, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: new Headers({
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      })
+    });
+  }
+};
+
+export {
+  ReasoningTransformer
+};