n9router 0.4.44 → 0.4.45

package/app/open-sse/executors/codex.js

@@ -1,4 +1,3 @@
-import { createHash } from "crypto";
 import { BaseExecutor } from "./base.js";
 import { CODEX_DEFAULT_INSTRUCTIONS } from "../config/codexInstructions.js";
 import { PROVIDERS } from "../config/providers.js";
@@ -6,34 +5,35 @@ import {
   refreshProviderCredentials,
   shouldRefreshCredentials,
 } from "../services/oauthCredentialManager.js";
-import { normalizeResponsesInput } from "../translator/helpers/responsesApiHelper.js";
-import { fetchImageAsBase64 } from "../translator/helpers/imageHelper.js";
+import { normalizeResponsesInput } from "../translator/formats/responsesApi.js";
+import { fetchImageAsBase64 } from "../translator/concerns/image.js";
 import { getModelUpstreamId } from "../config/providerModels.js";
-import { getConsistentMachineId } from "../../src/shared/utils/machineId.js";
 import { DEFAULT_RETRY_CONFIG, resolveRetryEntry } from "../config/runtimeConfig.js";
 import { dbg } from "../utils/debugLog.js";
+import { resolveSessionId } from "../utils/sessionManager.js";
 
 // SSE error patterns inside 200-OK body that should trigger retry as if 503
 const CODEX_SSE_OVERLOADED_PATTERNS = ["server_is_overloaded", "service_unavailable_error"];
 const CODEX_SSE_PEEK_BYTES = 4096;
 
-// In-memory map: hash(machineId + first assistant content) → { sessionId, lastUsed }
-const SESSION_TTL_MS = 60 * 60 * 1000; // 1 hour
-const assistantSessionMap = new Map();
-
 // Server-generated item id prefixes that Codex /responses cannot resolve when store=false
 const SERVER_ID_PATTERN = /^(rs|fc|resp|msg)_/;
 
 // Hosted tool types that Codex/OpenAI Responses executes server-side
 const CODEX_HOSTED_TOOL_TYPES = new Set([
   "image_generation", "web_search", "web_search_preview", "file_search",
-  "computer", "computer_use_preview", "code_interpreter", "mcp", "local_shell"
+  "computer", "computer_use_preview", "code_interpreter", "mcp", "local_shell",
+  "tool_search"
 ]);
 
+// Responses-native freeform tools carry a name plus format payload and must pass through intact.
+const CODEX_PASSTHROUGH_TOOL_TYPES = new Set(["custom"]);
+
 // Allowlist of fields accepted by Codex Responses API — anything else is stripped
 const RESPONSES_API_ALLOWLIST = new Set([
   "model", "input", "instructions", "tools", "tool_choice", "stream", "store",
-  "reasoning", "service_tier", "include", "prompt_cache_key", "client_metadata"
+  "reasoning", "service_tier", "include", "prompt_cache_key", "client_metadata",
+  "text"
 ]);
 
 // Convert role=system → role=developer in body.input (keeps content in cacheable prefix)
@@ -76,6 +76,7 @@ function normalizeCodexTools(body) {
       return true;
     }
     if (type !== "function") {
+      if (CODEX_PASSTHROUGH_TOOL_TYPES.has(type)) return true;
       if (!type || tool.function || typeof tool.name === "string") return false;
       return CODEX_HOSTED_TOOL_TYPES.has(type);
     }
@@ -104,86 +105,17 @@ function normalizeCodexTools(body) {
   }
 }
 
-// Cache machine ID at module level (resolved once)
-let cachedMachineId = null;
-getConsistentMachineId().then(id => { cachedMachineId = id; });
-
-function hashContent(text) {
-  return createHash("sha256").update(text).digest("hex").slice(0, 16);
-}
-
-function generateSessionId() {
-  return `sess_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 9)}`;
-}
-
-// Extract text content from an input item
-function extractItemText(item) {
-  if (!item) return "";
-  if (typeof item.content === "string") return item.content;
-  if (Array.isArray(item.content)) {
-    return item.content.map(c => c.text || c.output || "").filter(Boolean).join("");
-  }
-  return "";
-}
-
-// Normalize a session id candidate (trim, length cap)
-function normalizeSessionId(value) {
-  if (typeof value !== "string") return null;
-  const v = value.trim();
-  if (!v || v.length > 256) return null;
-  return v;
-}
-
-// Resolve prompt-cache session id with priority: body → assistant-text-hash → workspaceId → machineId
-function resolveCacheSessionId(body, credentials, machineId) {
-  // 1. Client-provided session/conversation id (highest priority — stable per conversation)
-  const fromBody =
-    normalizeSessionId(body?.prompt_cache_key) ||
-    normalizeSessionId(body?.session_id) ||
-    normalizeSessionId(body?.conversation_id);
-  if (fromBody) return fromBody;
-
-  // 2. Hash accumulated assistant text (≥50 chars) — sticky session across turns
-  if (Array.isArray(body?.input) && body.input.length > 0) {
-    let text = "";
-    const MIN_LEN = 50;
-    const CAP_LEN = 200;
-    for (const item of body.input) {
-      if (item?.role !== "assistant") continue;
-      const t = extractItemText(item);
-      if (!t) continue;
-      text += t;
-      if (text.length >= CAP_LEN) break;
-    }
-    if (text.length >= MIN_LEN) {
-      const hash = hashContent((machineId || "") + text.slice(0, CAP_LEN));
-      const entry = assistantSessionMap.get(hash);
-      if (entry) {
-        entry.lastUsed = Date.now();
-        return entry.sessionId;
-      }
-      const sessionId = generateSessionId();
-      assistantSessionMap.set(hash, { sessionId, lastUsed: Date.now() });
-      return sessionId;
-    }
-  }
-
-  // 3. Account-wide fallback (workspaceId from connection)
-  const workspaceId = normalizeSessionId(credentials?.providerSpecificData?.workspaceId);
-  if (workspaceId) return workspaceId;
-
-  // 4. Last resort — stable per-machine id
-  return machineId ? `sess_${hashContent(machineId)}` : generateSessionId();
+// Resolve prompt-cache session id: client session → assistant-text-hash → workspaceId → connection
+function resolveCacheSessionId(body, credentials) {
+  return resolveSessionId({
+    headers: credentials?.rawHeaders,
+    body,
+    connectionId: credentials?.connectionId,
+    workspaceId: credentials?.providerSpecificData?.workspaceId,
+    scope: "codex"
+  });
 }
 
-// Cleanup expired entries periodically
-setInterval(() => {
-  const now = Date.now();
-  for (const [key, entry] of assistantSessionMap) {
-    if (now - entry.lastUsed > SESSION_TTL_MS) assistantSessionMap.delete(key);
-  }
-}, 10 * 60 * 1000);
-
 /**
  * Codex Executor - handles OpenAI Codex API (Responses API format)
  * Automatically injects default instructions if missing
@@ -377,7 +309,7 @@ export class CodexExecutor extends BaseExecutor {
     this._isCompact = !!body._compact;
     delete body._compact;
     // Resolve conversation-stable session_id (priority: body → assistant-text → workspace → machine)
-    this._currentSessionId = resolveCacheSessionId(body, credentials, cachedMachineId);
+    this._currentSessionId = resolveCacheSessionId(body, credentials);
     // Convert string input to array format (Codex API requires input as array)
     const normalized = normalizeResponsesInput(body.input);
     if (normalized) body.input = normalized;

package/app/open-sse/executors/commandcode.js

@@ -1,7 +1,8 @@
 import { randomUUID } from "crypto";
 import { BaseExecutor } from "./base.js";
 import { PROVIDERS } from "../config/providers.js";
-import { convertCommandCodeToOpenAI } from "../translator/response/commandcode-to-openai.js";
+import { commandCodeToOpenAIResponse } from "../translator/response/commandcode-to-openai.js";
+import { SSE_DONE } from "../utils/sseConstants.js";
 
 /**
  * CommandCodeExecutor — talks to https://api.commandcode.ai/alpha/generate
@@ -19,6 +20,11 @@ export class CommandCodeExecutor extends BaseExecutor {
     super("commandcode", PROVIDERS.commandcode);
   }
 
+  transformRequest(model, body, stream, credentials) {
+    body.stream = true;
+    return body;
+  }
+
   buildHeaders(credentials, stream = true) {
     const headers = {
       "Content-Type": "application/json",
@@ -65,15 +71,15 @@ function wrapNdjsonAsOpenAISse(originalResponse, model) {
         const trimmed = line.trim();
         if (!trimmed) continue;
         // Translate AI SDK v5 NDJSON line to one or more OpenAI chunks
-        emitChunks(convertCommandCodeToOpenAI(trimmed, state), controller);
+        emitChunks(commandCodeToOpenAIResponse(trimmed, state), controller);
       }
     },
     flush(controller) {
       const trimmed = buffer.trim();
       if (trimmed) {
-        emitChunks(convertCommandCodeToOpenAI(trimmed, state), controller);
+        emitChunks(commandCodeToOpenAIResponse(trimmed, state), controller);
       }
-      controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+      controller.enqueue(encoder.encode(SSE_DONE));
     },
   });
 

package/app/open-sse/executors/cursor.js

@@ -8,6 +8,8 @@ import {
 } from "../utils/cursorProtobuf.js";
 import { buildCursorHeaders } from "../utils/cursorChecksum.js";
 import { estimateUsage } from "../utils/usageTracking.js";
+import { SSE_DONE, SSE_HEADERS } from "../utils/sseConstants.js";
+import { chatChunkSse } from "../utils/sse.js";
 import { FORMATS } from "../translator/formats.js";
 import { proxyAwareFetch } from "../utils/proxyFetch.js";
 import zlib from "zlib";
@@ -98,6 +100,32 @@ function decompressPayload(payload, flags) {
   return payload;
 }
 
+// Read one cursor protobuf frame: header + bounds + decompress. Returns status + payload + new offset.
+function readCursorFrame(buffer, offset, frameNum, tag) {
+  if (offset + 5 > buffer.length) {
+    debugLog(`[CURSOR BUFFER${tag}] Reached end, offset=${offset}, remaining=${buffer.length - offset}`);
+    return { status: "done" };
+  }
+
+  const flags = buffer[offset];
+  const length = buffer.readUInt32BE(offset + 1);
+  debugLog(`[CURSOR BUFFER${tag}] Frame ${frameNum + 1}: flags=0x${flags.toString(16).padStart(2, "0")}, length=${length}`);
+
+  if (offset + 5 + length > buffer.length) {
+    debugLog(`[CURSOR BUFFER${tag}] Incomplete frame, offset=${offset}, length=${length}, buffer.length=${buffer.length}`);
+    return { status: "done" };
+  }
+
+  let payload = buffer.slice(offset + 5, offset + 5 + length);
+  const newOffset = offset + 5 + length;
+  payload = decompressPayload(payload, flags);
+  if (!payload) {
+    debugLog(`[CURSOR BUFFER${tag}] Frame ${frameNum + 1}: decompression failed, skipping`);
+    return { status: "skip", offset: newOffset };
+  }
+  return { status: "ok", payload, offset: newOffset };
+}
+
 function createErrorResponse(jsonError) {
   const errorMsg = jsonError?.error?.details?.[0]?.debug?.details?.title
     || jsonError?.error?.details?.[0]?.debug?.details?.detail
@@ -141,7 +169,7 @@ export class CursorExecutor extends BaseExecutor {
 
   transformRequest(model, body, stream, credentials) {
     // Messages are already translated by chatCore (claude→openai→cursor)
-    // Do NOT call buildCursorRequest again — double-translation drops tool_results
+    // Do NOT call openaiToCursorRequest again — double-translation drops tool_results
     const messages = body.messages || [];
     const tools = body.tools || [];
     const reasoningEffort = body.reasoning_effort || null;
@@ -286,36 +314,12 @@ export class CursorExecutor extends BaseExecutor {
     debugLog(`[CURSOR BUFFER] Total length: ${buffer.length} bytes`);
 
     while (offset < buffer.length) {
-      if (offset + 5 > buffer.length) {
-        debugLog(
-          `[CURSOR BUFFER] Reached end, offset=${offset}, remaining=${buffer.length - offset}`
-        );
-        break;
-      }
-
-      const flags = buffer[offset];
-      const length = buffer.readUInt32BE(offset + 1);
-
-      debugLog(
-        `[CURSOR BUFFER] Frame ${frameCount + 1}: flags=0x${flags.toString(16).padStart(2, "0")}, length=${length}`
-      );
-
-      if (offset + 5 + length > buffer.length) {
-        debugLog(
-          `[CURSOR BUFFER] Incomplete frame, offset=${offset}, length=${length}, buffer.length=${buffer.length}`
-        );
-        break;
-      }
-
-      let payload = buffer.slice(offset + 5, offset + 5 + length);
-      offset += 5 + length;
+      const frame = readCursorFrame(buffer, offset, frameCount, "");
+      if (frame.status === "done") break;
+      offset = frame.offset;
       frameCount++;
-
-      payload = decompressPayload(payload, flags);
-      if (!payload) {
-        debugLog(`[CURSOR BUFFER] Frame ${frameCount}: decompression failed, skipping`);
-        continue;
-      }
+      if (frame.status === "skip") continue;
+      const payload = frame.payload;
 
       // Check for JSON error frames (byte guard: skip toString on non-JSON frames)
       if (payload.length > 0 && payload[0] === 0x7b) {
@@ -466,36 +470,12 @@ export class CursorExecutor extends BaseExecutor {
     debugLog(`[CURSOR BUFFER SSE] Total length: ${buffer.length} bytes`);
 
     while (offset < buffer.length) {
-      if (offset + 5 > buffer.length) {
-        debugLog(
-          `[CURSOR BUFFER SSE] Reached end, offset=${offset}, remaining=${buffer.length - offset}`
-        );
-        break;
-      }
-
-      const flags = buffer[offset];
-      const length = buffer.readUInt32BE(offset + 1);
-
-      debugLog(
-        `[CURSOR BUFFER SSE] Frame ${frameCount + 1}: flags=0x${flags.toString(16).padStart(2, "0")}, length=${length}`
-      );
-
-      if (offset + 5 + length > buffer.length) {
-        debugLog(
-          `[CURSOR BUFFER SSE] Incomplete frame, offset=${offset}, length=${length}, buffer.length=${buffer.length}`
-        );
-        break;
-      }
-
-      let payload = buffer.slice(offset + 5, offset + 5 + length);
-      offset += 5 + length;
+      const frame = readCursorFrame(buffer, offset, frameCount, " SSE");
+      if (frame.status === "done") break;
+      offset = frame.offset;
       frameCount++;
-
-      payload = decompressPayload(payload, flags);
-      if (!payload) {
-        debugLog(`[CURSOR BUFFER SSE] Frame ${frameCount}: decompression failed, skipping`);
-        continue;
-      }
+      if (frame.status === "skip") continue;
+      const payload = frame.payload;
 
       // Check for JSON error frames (byte-guard: only decode if starts with '{')
       if (payload[0] === 0x7b) {
@@ -542,21 +522,7 @@ export class CursorExecutor extends BaseExecutor {
         const tc = result.toolCall;
 
         if (chunks.length === 0) {
-          chunks.push(
-            `data: ${JSON.stringify({
-              id: responseId,
-              object: "chat.completion.chunk",
-              created,
-              model,
-              choices: [
-                {
-                  index: 0,
-                  delta: { role: "assistant", content: "" },
-                  finish_reason: null
-                }
-              ]
-            })}\n\n`
-          );
+          chunks.push(chatChunkSse({ id: responseId, created, model, delta: { role: "assistant", content: "" } }));
         }
 
         if (toolCallsMap.has(tc.id)) {
@@ -569,33 +535,22 @@ export class CursorExecutor extends BaseExecutor {
           // Stream the delta arguments
           if (tc.function.arguments) {
             emittedToolCallIds.add(tc.id);
-            chunks.push(
-              `data: ${JSON.stringify({
-                id: responseId,
-                object: "chat.completion.chunk",
-                created,
-                model,
-                choices: [
+            chunks.push(chatChunkSse({
+              id: responseId, created, model,
+              delta: {
+                tool_calls: [
                   {
-                    index: 0,
-                    delta: {
-                      tool_calls: [
-                        {
-                          index: existing.index,
-                          id: tc.id,
-                          type: "function",
-                          function: {
-                            name: tc.function.name,
-                            arguments: tc.function.arguments
-                          }
-                        }
-                      ]
-                    },
-                    finish_reason: null
+                    index: existing.index,
+                    id: tc.id,
+                    type: "function",
+                    function: {
+                      name: tc.function.name,
+                      arguments: tc.function.arguments
+                    }
                   }
                 ]
-              })}\n\n`
-            );
+              }
+            }));
           }
         } else {
           // New tool call - assign index and add to map
@@ -606,56 +561,34 @@ export class CursorExecutor extends BaseExecutor {
 
           // Stream initial tool call with name
           emittedToolCallIds.add(tc.id);
-          chunks.push(
-            `data: ${JSON.stringify({
-              id: responseId,
-              object: "chat.completion.chunk",
-              created,
-              model,
-              choices: [
+          chunks.push(chatChunkSse({
+            id: responseId, created, model,
+            delta: {
+              tool_calls: [
                 {
-                  index: 0,
-                  delta: {
-                    tool_calls: [
-                      {
-                        index: toolCallIndex,
-                        id: tc.id,
-                        type: "function",
-                        function: {
-                          name: tc.function.name,
-                          arguments: tc.function.arguments
-                        }
-                      }
-                    ]
-                  },
-                  finish_reason: null
+                  index: toolCallIndex,
+                  id: tc.id,
+                  type: "function",
+                  function: {
+                    name: tc.function.name,
+                    arguments: tc.function.arguments
+                  }
                 }
               ]
-            })}\n\n`
-          );
+            }
+          }));
         }
       }
 
       if (result.text) {
         totalContent += result.text;
-        chunks.push(
-          `data: ${JSON.stringify({
-            id: responseId,
-            object: "chat.completion.chunk",
-            created,
-            model,
-            choices: [
-              {
-                index: 0,
-                delta:
-                  chunks.length === 0 && toolCalls.length === 0
-                    ? { role: "assistant", content: result.text }
-                    : { content: result.text },
-                finish_reason: null
-              }
-            ]
-          })}\n\n`
-        );
+        chunks.push(chatChunkSse({
+          id: responseId, created, model,
+          delta:
+            chunks.length === 0 && toolCalls.length === 0
+              ? { role: "assistant", content: result.text }
+              : { content: result.text }
+        }));
       }
 
       if (isComposerModel(model) && result.thinking) {
@@ -665,24 +598,13 @@ export class CursorExecutor extends BaseExecutor {
           const deltaContent = visibleContent.slice(emittedComposerThinkingContentLength);
           emittedComposerThinkingContentLength = visibleContent.length;
           totalContent += deltaContent;
-          chunks.push(
-            `data: ${JSON.stringify({
-              id: responseId,
-              object: "chat.completion.chunk",
-              created,
-              model,
-              choices: [
-                {
-                  index: 0,
-                  delta:
-                    chunks.length === 0 && toolCalls.length === 0
-                      ? { role: "assistant", content: deltaContent }
-                      : { content: deltaContent },
-                  finish_reason: null
-                }
-              ]
-            })}\n\n`
-          );
+          chunks.push(chatChunkSse({
+            id: responseId, created, model,
+            delta:
+              chunks.length === 0 && toolCalls.length === 0
+                ? { role: "assistant", content: deltaContent }
+                : { content: deltaContent }
+          }));
         }
       }
     }
@@ -708,53 +630,28 @@ export class CursorExecutor extends BaseExecutor {
 
         // Emit SSE chunk for the finalized tool call if not already emitted
         if (!emittedToolCallIds.has(tc.id)) {
-          chunks.push(
-            `data: ${JSON.stringify({
-              id: responseId,
-              object: "chat.completion.chunk",
-              created,
-              model,
-              choices: [
+          chunks.push(chatChunkSse({
+            id: responseId, created, model,
+            delta: {
+              tool_calls: [
                 {
-                  index: 0,
-                  delta: {
-                    tool_calls: [
-                      {
-                        index: toolCallIndex,
-                        id: tc.id,
-                        type: "function",
-                        function: {
-                          name: tc.function.name,
-                          arguments: tc.function.arguments
-                        }
-                      }
-                    ]
-                  },
-                  finish_reason: null
+                  index: toolCallIndex,
+                  id: tc.id,
+                  type: "function",
+                  function: {
+                    name: tc.function.name,
+                    arguments: tc.function.arguments
+                  }
                 }
               ]
-            })}\n\n`
-          );
+            }
+          }));
         }
       }
     }
 
     if (chunks.length === 0 && toolCalls.length === 0) {
-      chunks.push(
-        `data: ${JSON.stringify({
-          id: responseId,
-          object: "chat.completion.chunk",
-          created,
-          model,
-          choices: [
-            {
-              index: 0,
-              delta: { role: "assistant", content: "" },
-              finish_reason: null
-            }
-          ]
-        })}\n\n`
-      );
+      chunks.push(chatChunkSse({ id: responseId, created, model, delta: { role: "assistant", content: "" } }));
     }
 
     const usage = estimateUsage(body, totalContent.length, FORMATS.OPENAI);
@@ -775,15 +672,11 @@ export class CursorExecutor extends BaseExecutor {
         usage
       })}\n\n`
     );
-    chunks.push("data: [DONE]\n\n");
+    chunks.push(SSE_DONE);
 
     return new Response(chunks.join(""), {
       status: 200,
-      headers: {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        "Connection": "keep-alive"
-      }
+      headers: { ...SSE_HEADERS }
     });
   }