@omnicross/core 0.1.0 → 0.1.2

package/dist/transformer/transformers/OpenAIResponseTransformer.js

@@ -1,513 +1,6 @@
-// src/transformer/transformers/OpenAIResponseTransformer.ts
-var OpenAIResponseTransformer = class {
-  static TransformerName = "openai-response";
-  name = "openai-response";
-  endPoint = "/v1/responses";
-  logger;
-  /**
-   * Handle authentication - Bearer token
-   */
-  async auth(request, provider, _context) {
-    return {
-      body: request,
-      config: {
-        headers: {
-          Authorization: `Bearer ${provider.apiKey}`,
-          "Content-Type": "application/json"
-        }
-      }
-    };
-  }
-  /**
-   * Transform unified request → Response API format
-   */
-  async transformRequestIn(request, provider, _context) {
-    const input = [];
-    for (const msg of request.messages) {
-      if (msg.role === "system") {
-        input.push({
-          role: "developer",
-          content: typeof msg.content === "string" ? msg.content : flattenContent(msg.content)
-        });
-      } else if (msg.role === "tool") {
-        input.push({
-          type: "function_call_output",
-          call_id: msg.tool_call_id,
-          output: typeof msg.content === "string" ? msg.content : ""
-        });
-      } else {
-        const entry = {
-          role: msg.role,
-          content: typeof msg.content === "string" ? msg.content : flattenContent(msg.content)
-        };
-        if (msg.role === "assistant" && msg.tool_calls?.length) {
-          input.push(entry);
-          for (const tc of msg.tool_calls) {
-            input.push({
-              type: "function_call",
-              id: tc.id,
-              call_id: tc.id,
-              name: tc.function.name,
-              arguments: tc.function.arguments
-            });
-          }
-          continue;
-        }
-        input.push(entry);
-      }
-    }
-    const body = {
-      model: request.model,
-      input,
-      stream: request.stream ?? false,
-      ...request.max_tokens ? { max_output_tokens: request.max_tokens } : {},
-      ...request.temperature !== void 0 ? { temperature: request.temperature } : {}
-    };
-    if (request.reasoning?.effort && request.reasoning.effort !== "none") {
-      body.reasoning = { effort: request.reasoning.effort, summary: "auto" };
-    }
-    if (request.tools?.length) {
-      body.tools = request.tools.map((tool) => ({
-        type: "function",
-        name: tool.function.name,
-        description: tool.function.description,
-        parameters: tool.function.parameters
-      }));
-    }
-    if (request.tool_choice) {
-      if (typeof request.tool_choice === "string") {
-        body.tool_choice = request.tool_choice;
-      } else if (typeof request.tool_choice === "object" && "function" in request.tool_choice) {
-        body.tool_choice = { type: "function", name: request.tool_choice.function.name };
-      }
-    }
-    const url = new URL("/v1/responses", provider.baseUrl);
-    return { body, config: { url } };
-  }
-  /**
-   * Transform Response API request → unified format
-   */
-  async transformRequestOut(request, _context) {
-    const req = request;
-    const messages = [];
-    if (req.input) {
-      for (const item of req.input) {
-        const entry = item;
-        if (entry.type === "function_call_output") {
-          messages.push({
-            role: "tool",
-            content: entry.output || "",
-            tool_call_id: entry.call_id || void 0
-          });
-          continue;
-        }
-        if (entry.type === "function_call") {
-          const toolCall = {
-            id: (entry.call_id ?? entry.id) || "",
-            type: "function",
-            function: {
-              name: entry.name || "",
-              arguments: typeof entry.arguments === "string" ? entry.arguments : ""
-            }
-          };
-          const last = messages[messages.length - 1];
-          if (last && last.role === "assistant") {
-            (last.tool_calls ??= []).push(toolCall);
-          } else {
-            messages.push({ role: "assistant", content: null, tool_calls: [toolCall] });
-          }
-          continue;
-        }
-        const role = entry.role;
-        if (role === "developer") {
-          messages.push({
-            role: "system",
-            content: typeof entry.content === "string" ? entry.content : JSON.stringify(entry.content)
-          });
-        } else if (role === "user" || role === "assistant") {
-          messages.push({
-            role,
-            content: typeof entry.content === "string" ? entry.content : JSON.stringify(entry.content)
-          });
-        }
-      }
-    }
-    const result = {
-      messages,
-      model: req.model,
-      max_tokens: req.max_output_tokens,
-      temperature: req.temperature,
-      stream: req.stream
-    };
-    if (req.reasoning?.effort) {
-      result.reasoning = {
-        effort: req.reasoning.effort,
-        enabled: true
-      };
-    }
-    if (req.tools?.length) {
-      result.tools = req.tools.filter((t) => t.type === "function").map((t) => ({
-        type: "function",
-        function: {
-          name: t.name || "",
-          description: t.description || "",
-          parameters: t.parameters || {}
-        }
-      }));
-    }
-    return result;
-  }
-  /**
-   * Transform Response API response → unified (OpenAI CC) format
-   */
-  async transformResponseOut(response, _context) {
-    const contentType = response.headers.get("Content-Type") ?? "";
-    if (contentType.includes("text/event-stream")) {
-      if (!response.body) {
-        throw new Error("Stream response body is null");
-      }
-      return new Response(convertResponseApiStreamToOpenAI(response.body), {
-        headers: {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          Connection: "keep-alive"
-        }
-      });
-    }
-    const data = await response.json();
-    return new Response(JSON.stringify(convertResponseApiJsonToOpenAI(data)), {
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-  /**
-   * Transform OpenAI CC response → Response API format
-   */
-  async transformResponseIn(response, _context) {
-    const contentType = response.headers.get("Content-Type") ?? "";
-    if (contentType.includes("text/event-stream")) {
-      if (!response.body) {
-        throw new Error("Stream response body is null");
-      }
-      return new Response(convertOpenAIStreamToResponseApi(response.body), {
-        headers: {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          Connection: "keep-alive"
-        }
-      });
-    }
-    const data = await response.json();
-    return new Response(JSON.stringify(convertOpenAIJsonToResponseApi(data)), {
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-};
-function flattenContent(content) {
-  if (typeof content === "string") return content;
-  if (!content) return "";
-  if (Array.isArray(content)) {
-    return content.filter((c) => c.type === "text").map((c) => c.text || "").join("\n");
-  }
-  return "";
-}
-function convertResponseApiJsonToOpenAI(data) {
-  let textContent = "";
-  const toolCalls = [];
-  const output = data.output;
-  if (output) {
-    for (const item of output) {
-      if (item.type === "message") {
-        const content = item.content;
-        if (content) {
-          for (const part of content) {
-            if (part.type === "output_text" && typeof part.text === "string") {
-              textContent += part.text;
-            }
-          }
-        }
-      } else if (item.type === "function_call") {
-        toolCalls.push({
-          id: item.call_id || item.id || `call_${Date.now()}`,
-          type: "function",
-          function: {
-            name: item.name,
-            arguments: typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments || {})
-          }
-        });
-      }
-    }
-  }
-  const usage = data.usage;
-  const message = {
-    role: "assistant",
-    content: textContent || null
-  };
-  if (toolCalls.length > 0) {
-    message.tool_calls = toolCalls;
-  }
-  return {
-    id: data.id || `chatcmpl-${Date.now()}`,
-    object: "chat.completion",
-    created: Math.floor(Date.now() / 1e3),
-    model: data.model || "unknown",
-    choices: [
-      {
-        index: 0,
-        message,
-        finish_reason: toolCalls.length > 0 ? "tool_calls" : "stop"
-      }
-    ],
-    usage: usage ? {
-      prompt_tokens: usage.input_tokens || 0,
-      completion_tokens: usage.output_tokens || 0,
-      total_tokens: (usage.input_tokens || 0) + (usage.output_tokens || 0)
-    } : void 0
-  };
-}
-function convertOpenAIJsonToResponseApi(data) {
-  const choices = data.choices;
-  const message = choices?.[0]?.message;
-  const output = [];
-  if (message) {
-    const contentParts = [];
-    if (message.content) {
-      contentParts.push({ type: "output_text", text: message.content });
-    }
-    if (contentParts.length > 0) {
-      output.push({ type: "message", role: "assistant", content: contentParts });
-    }
-    const toolCalls = message.tool_calls;
-    if (toolCalls?.length) {
-      for (const tc of toolCalls) {
-        const func = tc.function;
-        output.push({
-          type: "function_call",
-          id: tc.id,
-          call_id: tc.id,
-          name: func?.name,
-          arguments: func?.arguments
-        });
-      }
-    }
-  }
-  const usage = data.usage;
-  return {
-    id: data.id || `resp_${Date.now()}`,
-    object: "response",
-    status: "completed",
-    model: data.model || "unknown",
-    output,
-    usage: usage ? {
-      input_tokens: usage.prompt_tokens || 0,
-      output_tokens: usage.completion_tokens || 0,
-      total_tokens: usage.total_tokens || (usage.prompt_tokens || 0) + (usage.completion_tokens || 0)
-    } : void 0
-  };
-}
-function convertResponseApiStreamToOpenAI(responseApiStream) {
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  return new ReadableStream({
-    start: async (controller) => {
-      const reader = responseApiStream.getReader();
-      let buffer = "";
-      let isClosed = false;
-      const messageId = `chatcmpl-${Date.now()}`;
-      let model = "unknown";
-      let hasEmittedRole = false;
-      const safeEnqueue = (str) => {
-        if (!isClosed) {
-          try {
-            controller.enqueue(encoder.encode(str));
-          } catch {
-            isClosed = true;
-          }
-        }
-      };
-      const emitChunk = (choices, usage) => {
-        const chunk = {
-          id: messageId,
-          object: "chat.completion.chunk",
-          created: Math.floor(Date.now() / 1e3),
-          model,
-          choices
-        };
-        if (usage) chunk.usage = usage;
-        safeEnqueue(`data: ${JSON.stringify(chunk)}
-
-`);
-      };
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split("\n");
-          buffer = lines.pop() || "";
-          for (const line of lines) {
-            if (isClosed) break;
-            if (!line.startsWith("data:")) continue;
-            const data = line.slice(5).trim();
-            if (data === "[DONE]") continue;
-            try {
-              const event = JSON.parse(data);
-              model = event.model || event.response?.model || model;
-              switch (event.type) {
-                case "response.output_text.delta":
-                  if (event.delta) {
-                    if (!hasEmittedRole) {
-                      emitChunk([{ index: 0, delta: { role: "assistant", content: "" }, finish_reason: null }]);
-                      hasEmittedRole = true;
-                    }
-                    emitChunk([{ index: 0, delta: { content: event.delta }, finish_reason: null }]);
-                  }
-                  break;
-                case "response.reasoning_summary_text.delta":
-                  if (event.delta) {
-                    emitChunk([{
-                      index: 0,
-                      delta: { thinking: { content: event.delta } },
-                      finish_reason: null
-                    }]);
-                  }
-                  break;
-                case "response.completed": {
-                  const resp = event.response;
-                  const respUsage = resp?.usage;
-                  const usage = respUsage ? {
-                    prompt_tokens: respUsage.input_tokens || 0,
-                    completion_tokens: respUsage.output_tokens || 0,
-                    total_tokens: (respUsage.input_tokens || 0) + (respUsage.output_tokens || 0)
-                  } : void 0;
-                  emitChunk([{ index: 0, delta: {}, finish_reason: "stop" }], usage);
-                  safeEnqueue("data: [DONE]\n\n");
-                  break;
-                }
-                case "error":
-                  emitChunk([{
-                    index: 0,
-                    delta: { content: `[Error: ${event.error?.message || "Unknown error"}]` },
-                    finish_reason: "stop"
-                  }]);
-                  break;
-                default:
-                  break;
-              }
-            } catch {
-            }
-          }
-        }
-      } catch (e) {
-        if (!isClosed) controller.error(e);
-      } finally {
-        if (!isClosed) {
-          try {
-            controller.close();
-          } catch {
-          }
-        }
-        reader.releaseLock();
-      }
-    }
-  });
-}
-function convertOpenAIStreamToResponseApi(openaiStream) {
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  return new ReadableStream({
-    start: async (controller) => {
-      const reader = openaiStream.getReader();
-      let buffer = "";
-      let isClosed = false;
-      let accumulatedContent = "";
-      let model = "unknown";
-      const responseId = `resp_${Date.now()}`;
-      const safeEnqueue = (str) => {
-        if (!isClosed) {
-          try {
-            controller.enqueue(encoder.encode(str));
-          } catch {
-            isClosed = true;
-          }
-        }
-      };
-      const emitEvent = (event) => {
-        safeEnqueue(`data: ${JSON.stringify(event)}
-
-`);
-      };
-      emitEvent({
-        type: "response.created",
-        response: { id: responseId, status: "in_progress" }
-      });
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split("\n");
-          buffer = lines.pop() || "";
-          for (const line of lines) {
-            if (isClosed) break;
-            if (!line.startsWith("data:")) continue;
-            const data = line.slice(5).trim();
-            if (data === "[DONE]") continue;
-            try {
-              const chunk = JSON.parse(data);
-              const choice = chunk.choices?.[0];
-              model = chunk.model || model;
-              if (!choice) continue;
-              if (choice.delta?.content) {
-                accumulatedContent += choice.delta.content;
-                emitEvent({ type: "response.output_text.delta", delta: choice.delta.content });
-              }
-              if (choice.delta?.thinking?.content) {
-                emitEvent({
-                  type: "response.reasoning_summary_text.delta",
-                  delta: choice.delta.thinking.content
-                });
-              }
-              if (choice.finish_reason) {
-                emitEvent({ type: "response.output_text.done", text: accumulatedContent });
-                emitEvent({
-                  type: "response.completed",
-                  response: {
-                    id: responseId,
-                    status: "completed",
-                    model,
-                    output: [
-                      {
-                        type: "message",
-                        role: "assistant",
-                        content: [{ type: "output_text", text: accumulatedContent }]
-                      }
-                    ],
-                    usage: chunk.usage ? {
-                      input_tokens: chunk.usage.prompt_tokens || 0,
-                      output_tokens: chunk.usage.completion_tokens || 0,
-                      total_tokens: chunk.usage.total_tokens || 0
-                    } : void 0
-                  }
-                });
-              }
-            } catch {
-            }
-          }
-        }
-      } catch (e) {
-        if (!isClosed) controller.error(e);
-      } finally {
-        if (!isClosed) {
-          try {
-            controller.close();
-          } catch {
-          }
-        }
-        reader.releaseLock();
-      }
-    }
-  });
-}
+import {
+  OpenAIResponseTransformer
+} from "../../chunk-5HTVET6E.js";
 export {
   OpenAIResponseTransformer
 };

package/dist/transformer/transformers/OpenCodeGoTransformer.cjs

@@ -1,73 +1,6 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/transformer/transformers/OpenCodeGoTransformer.ts
-var OpenCodeGoTransformer_exports = {};
-__export(OpenCodeGoTransformer_exports, {
-  OpenCodeGoTransformer: () => OpenCodeGoTransformer
-});
-module.exports = __toCommonJS(OpenCodeGoTransformer_exports);
-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;
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  OpenCodeGoTransformer
-});
+var _chunkC72S6TTVcjs = require('../../chunk-C72S6TTV.cjs');
+
+
+exports.OpenCodeGoTransformer = _chunkC72S6TTVcjs.OpenCodeGoTransformer;

package/dist/transformer/transformers/OpenCodeGoTransformer.js

@@ -1,48 +1,6 @@
-// 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;
-  }
-};
+import {
+  OpenCodeGoTransformer
+} from "../../chunk-Z7LUNECE.js";
 export {
   OpenCodeGoTransformer
 };

package/dist/transformer/transformers/ReasoningTransformer.cjs

@@ -0,0 +1,6 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkDWKQZ2SKcjs = require('../../chunk-DWKQZ2SK.cjs');
+
+
+exports.ReasoningTransformer = _chunkDWKQZ2SKcjs.ReasoningTransformer;

package/dist/transformer/transformers/ReasoningTransformer.d.cts

@@ -0,0 +1,47 @@
+import { Transformer, TransformerLogger, TransformerOptions, UnifiedChatRequest, LLMProvider, TransformerContext } from '../types.cjs';
+
+/**
+ * ReasoningTransformer - Transformer for reasoning/thinking mode support
+ *
+ * Handles:
+ * - Converting reasoning config to thinking API parameters
+ * - Converting reasoning_content in responses to thinking blocks
+ * - Calculating thinking budget based on model and effort level
+ *
+ * @module transformer/transformers/ReasoningTransformer
+ */
+
+/**
+ * ReasoningTransformer handles reasoning/thinking mode for compatible models
+ *
+ * Features:
+ * - Converts reasoning config to thinking API parameters
+ * - Can be enabled/disabled via options
+ * - Converts reasoning_content in stream responses to thinking blocks
+ */
+declare class ReasoningTransformer implements Transformer {
+    static TransformerName: string;
+    name: string;
+    logger?: TransformerLogger;
+    private enabled;
+    constructor(options?: TransformerOptions);
+    /**
+     * Transform request: convert reasoning config to thinking parameters
+     * Uses model-specific budget calculation based on effort level
+     */
+    transformRequestIn(request: UnifiedChatRequest, provider: LLMProvider, _context: TransformerContext): Promise<Record<string, unknown>>;
+    /**
+     * Transform response: convert reasoning_content to thinking blocks
+     */
+    transformResponseOut(response: Response, _context: TransformerContext): Promise<Response>;
+    /**
+     * Handle JSON (non-streaming) response
+     */
+    private handleJsonResponse;
+    /**
+     * Handle streaming response - convert reasoning_content to thinking blocks
+     */
+    private handleStreamResponse;
+}
+
+export { ReasoningTransformer };