@omnicross/core 0.1.0 → 0.1.2

package/dist/chunk-5ERIZW3D.js

@@ -0,0 +1,44 @@
+// src/pipeline/resolveSubscriptionChain.ts
+function resolveOne(transformerService, name) {
+  const t = transformerService.getTransformer(name);
+  if (!t) return null;
+  return typeof t === "function" ? new t() : t;
+}
+function resolveSubscriptionChain(profile, transformerService, fallbackEndpoint, overrideNames) {
+  const providerNames = overrideNames ?? profile.providerTransformerNames ?? [];
+  const modelNames = profile.modelTransformerNames ?? [];
+  if (providerNames.length === 0) {
+    return { providerTransformers: [fallbackEndpoint], modelTransformers: [] };
+  }
+  if (!transformerService) {
+    throw new Error(
+      "[resolveSubscriptionChain] profile declares providerTransformerNames but no TransformerService is wired"
+    );
+  }
+  const providerTransformers = [];
+  for (const name of providerNames) {
+    const instance = resolveOne(transformerService, name);
+    if (!instance) {
+      console.warn(`[resolveSubscriptionChain] Transformer not registered: ${name}`);
+      continue;
+    }
+    providerTransformers.push(instance);
+  }
+  const modelTransformers = [];
+  for (const name of modelNames) {
+    const instance = resolveOne(transformerService, name);
+    if (!instance) {
+      console.warn(`[resolveSubscriptionChain] Model transformer not registered: ${name}`);
+      continue;
+    }
+    modelTransformers.push(instance);
+  }
+  if (providerTransformers.length === 0) {
+    return { providerTransformers: [fallbackEndpoint], modelTransformers };
+  }
+  return { providerTransformers, modelTransformers };
+}
+
+export {
+  resolveSubscriptionChain
+};

package/dist/chunk-5HTVET6E.js

@@ -0,0 +1,514 @@
+// 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();
+      }
+    }
+  });
+}
+
+export {
+  OpenAIResponseTransformer
+};