@omnicross/core 0.1.1 → 0.1.2

package/dist/chunk-2DCNB7DF.cjs

@@ -0,0 +1,514 @@
+"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;// src/transformer/transformers/OpenAIResponseTransformer.ts
+var OpenAIResponseTransformer = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
+  static __initStatic() {this.TransformerName = "openai-response"}
+  __init() {this.name = "openai-response"}
+  __init2() {this.endPoint = "/v1/responses"}
+  
+  /**
+   * 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" && _optionalChain([msg, 'access', _ => _.tool_calls, 'optionalAccess', _2 => _2.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: _nullishCoalesce(request.stream, () => ( false)),
+      ...request.max_tokens ? { max_output_tokens: request.max_tokens } : {},
+      ...request.temperature !== void 0 ? { temperature: request.temperature } : {}
+    };
+    if (_optionalChain([request, 'access', _3 => _3.reasoning, 'optionalAccess', _4 => _4.effort]) && request.reasoning.effort !== "none") {
+      body.reasoning = { effort: request.reasoning.effort, summary: "auto" };
+    }
+    if (_optionalChain([request, 'access', _5 => _5.tools, 'optionalAccess', _6 => _6.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: (_nullishCoalesce(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 (_optionalChain([req, 'access', _7 => _7.reasoning, 'optionalAccess', _8 => _8.effort])) {
+      result.reasoning = {
+        effort: req.reasoning.effort,
+        enabled: true
+      };
+    }
+    if (_optionalChain([req, 'access', _9 => _9.tools, 'optionalAccess', _10 => _10.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 = _nullishCoalesce(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 = _nullishCoalesce(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" }
+    });
+  }
+}, _class.__initStatic(), _class);
+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 = _optionalChain([choices, 'optionalAccess', _11 => _11[0], 'optionalAccess', _12 => _12.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 (_optionalChain([toolCalls, 'optionalAccess', _13 => _13.length])) {
+      for (const tc of toolCalls) {
+        const func = tc.function;
+        output.push({
+          type: "function_call",
+          id: tc.id,
+          call_id: tc.id,
+          name: _optionalChain([func, 'optionalAccess', _14 => _14.name]),
+          arguments: _optionalChain([func, 'optionalAccess', _15 => _15.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 (e2) {
+            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 || _optionalChain([event, 'access', _16 => _16.response, 'optionalAccess', _17 => _17.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 = _optionalChain([resp, 'optionalAccess', _18 => _18.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: ${_optionalChain([event, 'access', _19 => _19.error, 'optionalAccess', _20 => _20.message]) || "Unknown error"}]` },
+                    finish_reason: "stop"
+                  }]);
+                  break;
+                default:
+                  break;
+              }
+            } catch (e3) {
+            }
+          }
+        }
+      } catch (e) {
+        if (!isClosed) controller.error(e);
+      } finally {
+        if (!isClosed) {
+          try {
+            controller.close();
+          } catch (e4) {
+          }
+        }
+        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 (e5) {
+            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 = _optionalChain([chunk, 'access', _21 => _21.choices, 'optionalAccess', _22 => _22[0]]);
+              model = chunk.model || model;
+              if (!choice) continue;
+              if (_optionalChain([choice, 'access', _23 => _23.delta, 'optionalAccess', _24 => _24.content])) {
+                accumulatedContent += choice.delta.content;
+                emitEvent({ type: "response.output_text.delta", delta: choice.delta.content });
+              }
+              if (_optionalChain([choice, 'access', _25 => _25.delta, 'optionalAccess', _26 => _26.thinking, 'optionalAccess', _27 => _27.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 (e6) {
+            }
+          }
+        }
+      } catch (e) {
+        if (!isClosed) controller.error(e);
+      } finally {
+        if (!isClosed) {
+          try {
+            controller.close();
+          } catch (e7) {
+          }
+        }
+        reader.releaseLock();
+      }
+    }
+  });
+}
+
+
+
+exports.OpenAIResponseTransformer = OpenAIResponseTransformer;