@omnicross/core 0.1.0 → 0.1.1

package/dist/transformer/transformers/ReasoningTransformer.cjs

@@ -0,0 +1,273 @@
+"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);
+
+// src/transformer/transformers/ReasoningTransformer.ts
+var ReasoningTransformer_exports = {};
+__export(ReasoningTransformer_exports, {
+  ReasoningTransformer: () => ReasoningTransformer
+});
+module.exports = __toCommonJS(ReasoningTransformer_exports);
+var import_thinking_config = require("@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 = (0, import_thinking_config.calculateThinkingBudget)(modelId, effortLevel, userMaxTokens);
+      const providerName = provider.name?.toLowerCase() || "";
+      if (providerName === "anthropic" || providerName.includes("claude")) {
+        const thinkingConfig = (0, import_thinking_config.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 = (0, import_thinking_config.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 = (0, import_thinking_config.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"
+      })
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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 };

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

@@ -0,0 +1,47 @@
+import { Transformer, TransformerLogger, TransformerOptions, UnifiedChatRequest, LLMProvider, TransformerContext } from '../types.js';
+
+/**
+ * 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 };

package/dist/transformer/transformers/ReasoningTransformer.js

@@ -0,0 +1,253 @@
+// 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
+};