open-sse 1.0.0 → 1.0.2

package/README.md

@@ -110,6 +110,24 @@ import { createSSETransformStreamWithLogger } from "open-sse";
 
 ## Configuration
 
+### Environment Variables
+
+```bash
+# Enable detailed request/response logging (default: false)
+ENABLE_REQUEST_LOGS=true
+```
+
+When enabled, logs are saved to `logs/` directory with structure:
+```
+logs/
+  └── {sourceFormat}_{targetFormat}_{model}_{timestamp}/
+      ├── 0_client_raw_request.json
+      ├── 1_raw_request.json
+      ├── 2_converted_request.json
+      ├── 3_raw_response.json
+      └── 4_converted_response.json
+```
+
 ### Provider Models
 
 ```javascript

package/config/constants.js

@@ -179,6 +179,9 @@ export const CACHE_TTL = {
 // Default max tokens
 export const DEFAULT_MAX_TOKENS = 64000;
 
+// Minimum max tokens for tool calling (to prevent truncated arguments)
+export const DEFAULT_MIN_TOKENS = 32000;
+
 // Exponential backoff config for rate limits (like CLIProxyAPI)
 export const BACKOFF_CONFIG = {
   base: 1000,              // 1 second base

package/handlers/chatCore.js

@@ -41,7 +41,7 @@ export async function handleChatCore({ body, modelInfo, credentials, log, onCred
   const stream = body.stream !== false;
 
   // Create request logger for this session: sourceFormat_targetFormat_model
-  const reqLogger = createRequestLogger(sourceFormat, targetFormat, model);
+  const reqLogger = await createRequestLogger(sourceFormat, targetFormat, model);
   
   // 0. Log client raw request (before any conversion)
   if (clientRawRequest) {

package/index.js

@@ -64,6 +64,3 @@ export {
   createSSETransformStreamWithLogger, 
   createPassthroughStreamWithLogger 
 } from "./utils/stream.js";
-
-export { createRequestLogger } from "./utils/requestLogger.js";
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-sse",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Universal AI proxy library with SSE streaming support for OpenAI, Claude, Gemini and more",
   "type": "module",
   "main": "index.js",
@@ -21,7 +21,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/yourusername/router4.git",
+    "url": "https://github.com/yourusername/9router.git",
     "directory": "open-sse"
   },
   "keywords": [

package/services/accountFallback.js

@@ -19,22 +19,7 @@ export function getQuotaCooldown(backoffLevel = 0) {
  * @returns {{ shouldFallback: boolean, cooldownMs: number, newBackoffLevel?: number }}
  */
 export function checkFallbackError(status, errorText, backoffLevel = 0) {
-  // 401 - Authentication error (token expired/invalid)
-  if (status === 401) {
-    return { shouldFallback: true, cooldownMs: COOLDOWN_MS.unauthorized };
-  }
-
-  // 402/403 - Payment required / Forbidden (quota/permission)
-  if (status === 402 || status === 403) {
-    return { shouldFallback: true, cooldownMs: COOLDOWN_MS.paymentRequired };
-  }
-
-  // 404 - Model not found (long cooldown)
-  if (status === 404) {
-    return { shouldFallback: true, cooldownMs: COOLDOWN_MS.notFound };
-  }
-
-  // Check error message FIRST (before status codes) for specific patterns
+  // Check error message FIRST - specific patterns take priority over status codes
   if (errorText) {
     const lowerError = errorText.toLowerCase();
     
@@ -60,6 +45,21 @@ export function checkFallbackError(status, errorText, backoffLevel = 0) {
     }
   }
 
+  // 401 - Authentication error (token expired/invalid)
+  if (status === 401) {
+    return { shouldFallback: true, cooldownMs: COOLDOWN_MS.unauthorized };
+  }
+
+  // 402/403 - Payment required / Forbidden (quota/permission)
+  if (status === 402 || status === 403) {
+    return { shouldFallback: true, cooldownMs: COOLDOWN_MS.paymentRequired };
+  }
+
+  // 404 - Model not found (long cooldown)
+  if (status === 404) {
+    return { shouldFallback: true, cooldownMs: COOLDOWN_MS.notFound };
+  }
+
   // 429 - Rate limit with exponential backoff
   if (status === 429) {
     const newLevel = Math.min(backoffLevel + 1, BACKOFF_CONFIG.maxLevel);

package/translator/from-openai/claude.js

@@ -27,6 +27,8 @@ function claudeToOpenAIResponse(chunk, state) {
     case "message_start": {
       state.messageId = chunk.message?.id || `msg_${Date.now()}`;
       state.model = chunk.message?.model;
+      state.toolCallIndex = 0; // Reset tool call counter for OpenAI format
+      console.log("🔍 ----------- toolCallIndex", state.toolCallIndex);
       results.push(createChunk(state, { role: "assistant" }));
       break;
     }
@@ -41,8 +43,10 @@ function claudeToOpenAIResponse(chunk, state) {
         state.currentBlockIndex = chunk.index;
         results.push(createChunk(state, { content: "<think>" }));
       } else if (block?.type === "tool_use") {
+        // OpenAI format: tool_calls index must be independent and start from 0
+        const toolCallIndex = state.toolCallIndex++;
         const toolCall = {
-          index: chunk.index || 0,
+          index: toolCallIndex,
           id: block.id,
           type: "function",
           function: {
@@ -50,6 +54,7 @@ function claudeToOpenAIResponse(chunk, state) {
             arguments: ""
           }
         };
+        // Map Claude content_block index to OpenAI tool_call index
         state.toolCalls.set(chunk.index, toolCall);
         results.push(createChunk(state, { tool_calls: [toolCall] }));
       }
@@ -67,9 +72,11 @@ function claudeToOpenAIResponse(chunk, state) {
         const toolCall = state.toolCalls.get(chunk.index);
         if (toolCall) {
           toolCall.function.arguments += delta.partial_json;
+          // Include both index and id for better client compatibility
           results.push(createChunk(state, {
             tool_calls: [{
               index: toolCall.index,
+              id: toolCall.id,
               function: { arguments: delta.partial_json }
             }]
           }));

package/translator/helpers/maxTokensHelper.js

@@ -0,0 +1,22 @@
+import { DEFAULT_MAX_TOKENS, DEFAULT_MIN_TOKENS } from "../../config/constants.js";
+
+/**
+ * Adjust max_tokens based on request context
+ * @param {object} body - Request body
+ * @returns {number} Adjusted max_tokens
+ */
+export function adjustMaxTokens(body) {
+  let maxTokens = body.max_tokens || DEFAULT_MAX_TOKENS;
+  
+  // Auto-increase for tool calling to prevent truncated arguments
+  // Tool calls with large content (like writing files) need more tokens
+  if (body.tools && Array.isArray(body.tools) && body.tools.length > 0) {
+    if (maxTokens < DEFAULT_MIN_TOKENS) {
+      console.log(`[AUTO-ADJUST] max_tokens: ${maxTokens} → ${DEFAULT_MIN_TOKENS} (tool calling detected)`);
+      maxTokens = DEFAULT_MIN_TOKENS;
+    }
+  }
+  
+  return maxTokens;
+}
+

package/translator/to-openai/claude.js

@@ -1,5 +1,6 @@
 import { register } from "../index.js";
 import { FORMATS } from "../formats.js";
+import { adjustMaxTokens } from "../helpers/maxTokensHelper.js";
 
 // Convert Claude request to OpenAI format
 function claudeToOpenAI(model, body, stream) {
@@ -11,7 +12,7 @@ function claudeToOpenAI(model, body, stream) {
 
   // Max tokens
   if (body.max_tokens) {
-    result.max_tokens = body.max_tokens;
+    result.max_tokens = adjustMaxTokens(body);
   }
 
   // Temperature

package/translator/to-openai/gemini.js

@@ -1,5 +1,6 @@
 import { register } from "../index.js";
 import { FORMATS } from "../formats.js";
+import { adjustMaxTokens } from "../helpers/maxTokensHelper.js";
 
 // Convert Gemini request to OpenAI format
 function geminiToOpenAI(model, body, stream) {
@@ -13,7 +14,9 @@ function geminiToOpenAI(model, body, stream) {
   if (body.generationConfig) {
     const config = body.generationConfig;
     if (config.maxOutputTokens) {
-      result.max_tokens = config.maxOutputTokens;
+      // Create temporary body object for adjustMaxTokens
+      const tempBody = { max_tokens: config.maxOutputTokens, tools: body.tools };
+      result.max_tokens = adjustMaxTokens(tempBody);
     }
     if (config.temperature !== undefined) {
       result.temperature = config.temperature;

package/translator/to-openai/openai.js

@@ -1,12 +1,13 @@
 import { register } from "../index.js";
 import { FORMATS } from "../formats.js";
-import { CLAUDE_SYSTEM_PROMPT, DEFAULT_MAX_TOKENS } from "../../config/constants.js";
+import { CLAUDE_SYSTEM_PROMPT } from "../../config/constants.js";
+import { adjustMaxTokens } from "../helpers/maxTokensHelper.js";
 
 // Convert OpenAI request to Claude format
 function openaiToClaude(model, body, stream) {
   const result = {
     model: model,
-    max_tokens: body.max_tokens || DEFAULT_MAX_TOKENS,
+    max_tokens: adjustMaxTokens(body),
     stream: stream
   };
 

package/utils/bypassHandler.js

@@ -32,6 +32,14 @@ export function handleBypassRequest(body, model) {
   const firstText = getText(messages[0]?.content);
   if (firstText === "Warmup") shouldBypass = true;
 
+  // Check count pattern: [{"role":"user","content":"count"}]
+  if (!shouldBypass && 
+      messages.length === 1 && 
+      messages[0]?.role === "user" && 
+      firstText === "count") {
+    shouldBypass = true;
+  }
+
   // Check skip patterns
   if (!shouldBypass && SKIP_PATTERNS?.length) {
     const allText = messages.map(m => getText(m.content)).join(" ");

package/utils/requestLogger.js

@@ -1,18 +1,22 @@
 // Check if running in Node.js environment (has fs module)
-const isNode = typeof process !== "undefined" && process.versions?.node;
+const isNode = typeof process !== "undefined" && process.versions?.node && typeof window === "undefined";
+
+// Check if logging is enabled via environment variable (default: false)
+const LOGGING_ENABLED = typeof process !== "undefined" && process.env?.ENABLE_REQUEST_LOGS === 'true';
 
 let fs = null;
 let path = null;
 let LOGS_DIR = null;
 
-// Only import fs/path in Node.js environment
-if (isNode) {
+// Lazy load Node.js modules (avoid top-level await)
+async function ensureNodeModules() {
+  if (!isNode || !LOGGING_ENABLED || fs) return;
   try {
     fs = await import("fs");
     path = await import("path");
-    LOGS_DIR = path.join(process.cwd(), "logs");
+    LOGS_DIR = path.join(typeof process !== "undefined" && process.cwd ? process.cwd() : ".", "logs");
   } catch {
-    // Running in non-Node environment (Worker, etc.)
+    // Running in non-Node environment (Worker, Browser, etc.)
   }
 }
 
@@ -29,7 +33,8 @@ function formatTimestamp(date = new Date()) {
 }
 
 // Create log session folder: {sourceFormat}_{targetFormat}_{model}_{timestamp}
-function createLogSession(sourceFormat, targetFormat, model) {
+async function createLogSession(sourceFormat, targetFormat, model) {
+  await ensureNodeModules();
   if (!fs || !LOGS_DIR) return null;
   
   try {
@@ -81,18 +86,40 @@ function maskSensitiveHeaders(headers) {
   return masked;
 }
 
+// No-op logger when logging is disabled
+function createNoOpLogger() {
+  return {
+    sessionPath: null,
+    logClientRawRequest() {},
+    logRawRequest() {},
+    logFormatInfo() {},
+    logConvertedRequest() {},
+    logRawResponse() {},
+    logConvertedResponse() {},
+    logStreamChunk() {},
+    logStreamComplete() {},
+    logError() {}
+  };
+}
+
 /**
  * Create a new log session and return logger functions
  * @param {string} sourceFormat - Source format from client (claude, openai, etc.)
  * @param {string} targetFormat - Target format to provider (antigravity, gemini-cli, etc.)
  * @param {string} model - Model name
- * @returns {object} Logger object with methods to log each stage
+ * @returns {Promise<object>} Promise that resolves to logger object with methods to log each stage
  */
-export function createRequestLogger(sourceFormat, targetFormat, model) {
-  const sessionPath = createLogSession(sourceFormat, targetFormat, model);
+export async function createRequestLogger(sourceFormat, targetFormat, model) {
+  // Return no-op logger if logging is disabled
+  if (!LOGGING_ENABLED) {
+    return createNoOpLogger();
+  }
+  
+  // Wait for session to be created before returning logger
+  const sessionPath = await createLogSession(sourceFormat, targetFormat, model);
   
   return {
-    sessionPath,
+    get sessionPath() { return sessionPath; },
     
     // 0. Log client raw request (before any conversion)
     logClientRawRequest(endpoint, body, headers = {}) {

package/utils/stream.js

@@ -74,7 +74,11 @@ function parseSSELine(line) {
 
   try {
     return JSON.parse(data);
-  } catch {
+  } catch (error) {
+    // Log parse errors for debugging incomplete chunks
+    if (data.length > 0 && data.length < 1000) {
+      console.log(`[WARN] Failed to parse SSE line (${data.length} chars): ${data.substring(0, 100)}...`);
+    }
     return null;
   }
 }