@galaxy-yearn/codex-deepseek-gateway 0.1.6 → 0.2.0

package/src/session-store.js

@@ -1,57 +1,272 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { isObject, safeJsonParse } from './common.js';
+
+const SESSION_STORE_VERSION = 4;
+const DEFAULT_MAX_SESSIONS = 500;
+const DEFAULT_MAX_BYTES = 16 * 1024 * 1024;
+
 export class SessionStore {
-  constructor({ maxToolCallMessages = 1000 } = {}) {
+  constructor({
+    maxToolCallMessages = 1000,
+    maxSessions = DEFAULT_MAX_SESSIONS,
+    maxBytes = DEFAULT_MAX_BYTES,
+    persistPath = '',
+  } = {}) {
     this.map = new Map();
     this.toolCallMessages = new Map();
     this.conversations = new Map();
-    this.maxToolCallMessages = maxToolCallMessages;
+    this.maxToolCallMessages = positiveInteger(maxToolCallMessages, 1000);
+    this.maxSessions = positiveInteger(maxSessions, DEFAULT_MAX_SESSIONS);
+    this.maxBytes = positiveInteger(maxBytes, DEFAULT_MAX_BYTES);
+    this.persistPath = persistPath || '';
+    this.lastLoadError = null;
+    this.lastPersistError = null;
+    this.loadFromDisk();
   }
 
   get(id) {
-    return this.map.get(id) || null;
+    if (!id) return null;
+    return this.map.get(String(id)) || null;
   }
 
   set(id, value) {
-    this.map.set(id, value);
-    for (const turn of Array.isArray(value?.history) ? value.history : []) {
-      this.indexAssistantMessage(turn.assistantMessage);
-    }
+    if (!id) return value;
+    const session = normalizeSession(id, value);
+    this.map.set(String(id), session);
+    for (const message of session.messages) this.indexAssistantMessage(message);
+    this.pruneSessions();
+    this.persist();
     return value;
   }
 
   getConversation(id) {
-    const responseId = this.conversations.get(id);
+    if (!id) return null;
+    const responseId = this.conversations.get(String(id));
     return responseId ? this.get(responseId) : null;
   }
 
   setConversation(id, responseId) {
-    if (id && responseId) this.conversations.set(String(id), responseId);
+    if (!id || !responseId) return;
+    this.conversations.set(String(id), String(responseId));
+    this.dropDanglingConversations();
+    this.persist();
   }
 
   indexAssistantMessage(message) {
-    if (message?.role !== 'assistant' || !Array.isArray(message.tool_calls)) return;
+    if (message?.role !== 'assistant' || !Array.isArray(message.tool_calls)) return false;
+    const shared = cloneAssistantMessage(message);
+    let indexed = false;
     for (const toolCall of message.tool_calls) {
       if (!toolCall?.id) continue;
-      this.toolCallMessages.set(toolCall.id, cloneAssistantMessage(message));
+      const key = String(toolCall.id);
+      this.toolCallMessages.delete(key);
+      this.toolCallMessages.set(key, shared);
+      indexed = true;
       while (this.toolCallMessages.size > this.maxToolCallMessages) {
         const oldestKey = this.toolCallMessages.keys().next().value;
         this.toolCallMessages.delete(oldestKey);
       }
     }
+    return indexed;
+  }
+
+  rememberAssistantMessage(message) {
+    if (!this.indexAssistantMessage(message)) return false;
+    this.persist();
+    return true;
   }
 
   getAssistantMessageForToolCall(callId) {
-    return this.toolCallMessages.get(callId) || null;
+    if (!callId) return null;
+    const message = this.toolCallMessages.get(String(callId));
+    return message ? cloneAssistantMessage(message) : null;
   }
 
   delete(id) {
-    return this.map.delete(id);
+    if (!id) return false;
+    const deleted = this.map.delete(String(id));
+    if (deleted) {
+      this.dropDanglingConversations();
+      this.persist();
+    }
+    return deleted;
   }
 
   clear() {
     this.map.clear();
     this.toolCallMessages.clear();
     this.conversations.clear();
+    this.persist();
+  }
+
+  loadFromDisk() {
+    if (!this.persistPath || !existsSync(this.persistPath)) return;
+    try {
+      const parsed = safeJsonParse(readFileSync(this.persistPath, 'utf8').replace(/^/, ''));
+      if (!parsed.ok || !isObject(parsed.value)) return;
+      this.map.clear();
+      this.conversations.clear();
+      this.toolCallMessages.clear();
+      for (const [id, session] of entriesFrom(parsed.value.sessions)) {
+        if (!id || !isObject(session)) continue;
+        this.map.set(String(id), normalizeSession(id, session));
+      }
+      for (const [id, responseId] of entriesFrom(parsed.value.conversations)) {
+        if (!id || !responseId) continue;
+        const normalizedResponseId = String(responseId);
+        if (this.map.has(normalizedResponseId)) this.conversations.set(String(id), normalizedResponseId);
+      }
+      const messagePool = Array.isArray(parsed.value.assistantMessages) ? parsed.value.assistantMessages : [];
+      const storedToolCallMessages = entriesFrom(parsed.value.toolCallMessages);
+      const sharedMessages = new Map();
+      for (const [callId, stored] of storedToolCallMessages) {
+        if (!callId) continue;
+        const message = resolveStoredToolCallMessage(stored, messagePool);
+        if (!message) continue;
+        const fingerprint = JSON.stringify(message);
+        if (!sharedMessages.has(fingerprint)) sharedMessages.set(fingerprint, message);
+        this.toolCallMessages.set(String(callId), sharedMessages.get(fingerprint));
+        while (this.toolCallMessages.size > this.maxToolCallMessages) {
+          this.toolCallMessages.delete(this.toolCallMessages.keys().next().value);
+        }
+      }
+      this.pruneSessions();
+      if (!storedToolCallMessages.length) this.rebuildToolCallIndex();
+    } catch (error) {
+      this.lastLoadError = error;
+      this.map.clear();
+      this.conversations.clear();
+      this.toolCallMessages.clear();
+    }
+  }
+
+  persist() {
+    if (!this.persistPath) return;
+    try {
+      mkdirSync(dirname(this.persistPath), { recursive: true });
+      let serialized = this.serializePayload();
+      while (serialized.length > this.maxBytes && this.map.size > 1) {
+        this.map.delete(this.map.keys().next().value);
+        this.dropDanglingConversations();
+        serialized = this.serializePayload();
+      }
+      while (serialized.length > this.maxBytes && this.toolCallMessages.size > 0) {
+        this.toolCallMessages.delete(this.toolCallMessages.keys().next().value);
+        serialized = this.serializePayload();
+      }
+      const tmpPath = `${this.persistPath}.tmp-${process.pid}-${Date.now()}`;
+      writeFileSync(tmpPath, serialized, 'utf8');
+      renameSync(tmpPath, this.persistPath);
+      this.lastPersistError = null;
+    } catch (error) {
+      this.lastPersistError = error;
+    }
+  }
+
+  serializePayload() {
+    return `${JSON.stringify(this.persistPayload(), null, 2)}\n`;
+  }
+
+  persistPayload() {
+    const assistantMessages = [];
+    const poolIndexes = new Map();
+    const toolCallMessages = [];
+    for (const [callId, message] of this.toolCallMessages.entries()) {
+      const fingerprint = JSON.stringify(message);
+      let index = poolIndexes.get(fingerprint);
+      if (index === undefined) {
+        index = assistantMessages.length;
+        poolIndexes.set(fingerprint, index);
+        assistantMessages.push(message);
+      }
+      toolCallMessages.push([callId, index]);
+    }
+    return {
+      version: SESSION_STORE_VERSION,
+      sessions: Array.from(this.map.entries()),
+      conversations: Array.from(this.conversations.entries()),
+      assistantMessages,
+      toolCallMessages,
+    };
+  }
+
+  pruneSessions() {
+    while (this.map.size > this.maxSessions) {
+      const oldestKey = this.map.keys().next().value;
+      this.map.delete(oldestKey);
+    }
+    this.dropDanglingConversations();
   }
+
+  dropDanglingConversations() {
+    for (const [conversationId, responseId] of this.conversations.entries()) {
+      if (!this.map.has(responseId)) this.conversations.delete(conversationId);
+    }
+  }
+
+  rebuildToolCallIndex() {
+    this.toolCallMessages.clear();
+    for (const session of this.map.values()) {
+      for (const message of Array.isArray(session?.messages) ? session.messages : []) {
+        this.indexAssistantMessage(message);
+      }
+    }
+  }
+}
+
+function normalizeSession(id, value) {
+  const messages = Array.isArray(value?.messages) ? value.messages : legacyHistoryMessages(value?.history);
+  return { id: String(value?.id || id), messages: stripLeadingSystemMessages(messages) };
+}
+
+function legacyHistoryMessages(history) {
+  const turns = Array.isArray(history) ? history : [];
+  if (!turns.length) return [];
+  if (turns.every((turn) => Array.isArray(turn?.historyMessages))) {
+    return turns[turns.length - 1].historyMessages.slice();
+  }
+  const messages = [];
+  for (const turn of turns) {
+    if (Array.isArray(turn?.historyMessages)) {
+      messages.push(...turn.historyMessages);
+      continue;
+    }
+    if (Array.isArray(turn?.inputMessages)) {
+      messages.push(...turn.inputMessages);
+    } else if (Array.isArray(turn?.chatRequest?.messages)) {
+      messages.push(...turn.chatRequest.messages);
+    }
+    if (turn?.assistantMessage) messages.push(turn.assistantMessage);
+  }
+  return messages;
+}
+
+function stripLeadingSystemMessages(messages) {
+  let start = 0;
+  while (start < messages.length && (messages[start]?.role === 'system' || messages[start]?.role === 'developer')) {
+    start += 1;
+  }
+  return start ? messages.slice(start) : messages;
+}
+
+function entriesFrom(value) {
+  if (Array.isArray(value)) return value;
+  if (isObject(value)) return Object.entries(value);
+  return [];
+}
+
+function resolveStoredToolCallMessage(stored, messagePool) {
+  if (isObject(stored)) return stored;
+  if (Number.isInteger(stored) && stored >= 0 && stored < messagePool.length && isObject(messagePool[stored])) {
+    return messagePool[stored];
+  }
+  return null;
+}
+
+function positiveInteger(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallback;
 }
 
 function cloneAssistantMessage(message) {

package/src/tavily.js

@@ -1,4 +1,4 @@
-import { isObject, joinUrl, safeJsonParse } from './common.js';
+import { isObject, joinUrl, parseBoolean, safeJsonParse } from './common.js';
 
 const DEFAULT_MAX_RESULTS = 5;
 const HARD_MAX_RESULTS = 10;
@@ -14,15 +14,6 @@ function clampInteger(value, min, max, fallback) {
   return Math.min(max, Math.max(min, Math.trunc(number)));
 }
 
-function booleanValue(value, fallback) {
-  if (typeof value === 'boolean') return value;
-  if (value == null || value === '') return fallback;
-  const normalized = String(value).trim().toLowerCase();
-  if (['1', 'true', 'yes', 'on'].includes(normalized)) return true;
-  if (['0', 'false', 'no', 'off'].includes(normalized)) return false;
-  return fallback;
-}
-
 function cleanText(value, maxChars = DEFAULT_SNIPPET_CHARS) {
   if (value == null) return '';
   const text = String(value)
@@ -111,7 +102,7 @@ export function buildTavilySearchRequest(args = {}, config = {}) {
     query: normalized.query,
     search_depth: normalized.searchDepth,
     max_results: normalized.maxResults,
-    include_answer: booleanValue(config.tavilyIncludeAnswer, true),
+    include_answer: parseBoolean(config.tavilyIncludeAnswer, true),
     include_raw_content: false,
   };
   if (normalized.topic) body.topic = normalized.topic;

package/src/upstream.js

@@ -82,9 +82,11 @@ export async function relayChatCompletionsResponse({
   onStreamChunk,
   passThrough = true,
   writeHeaders = true,
+  endResponse = true,
 }) {
   const contentType = upstreamResponse.headers.get('content-type') || '';
   const isStream = contentType.includes('text/event-stream');
+  const writable = () => !res.destroyed && !res.writableEnded;
 
   if (!isStream) {
     const data = await readJsonResponse(upstreamResponse);
@@ -92,18 +94,18 @@ export async function relayChatCompletionsResponse({
       onStreamChunk({ data });
       onStreamChunk({ done: true });
     }
-    if (passThrough) {
+    if (passThrough && writable()) {
       res.writeHead(upstreamResponse.status, {
         'content-type': 'application/json; charset=utf-8',
       });
       res.end(JSON.stringify(data));
-    } else {
+    } else if (endResponse && writable()) {
       res.end();
     }
     return;
   }
 
-  if (writeHeaders) {
+  if (writeHeaders && writable()) {
     res.writeHead(upstreamResponse.status, {
       'content-type': 'text/event-stream; charset=utf-8',
       'cache-control': 'no-cache, no-transform',
@@ -114,17 +116,17 @@ export async function relayChatCompletionsResponse({
 
   const reader = upstreamResponse.body?.getReader?.();
   if (!reader) {
-    res.end();
+    if (endResponse && writable()) res.end();
     return;
   }
 
   const parser = new SseParser();
   let sawDone = false;
-  const emitDone = () => {
+  const emitDone = ({ eof = false } = {}) => {
     if (sawDone) return;
     sawDone = true;
-    if (typeof onStreamChunk === 'function') onStreamChunk({ done: true });
-    if (passThrough) res.write(`data: [DONE]\n\n`);
+    if (typeof onStreamChunk === 'function') onStreamChunk(eof ? { done: true, eof: true } : { done: true });
+    if (passThrough && writable()) res.write(`data: [DONE]\n\n`);
   };
 
   while (true) {
@@ -134,11 +136,11 @@ export async function relayChatCompletionsResponse({
     for (const event of events) {
       if (event.done) {
         emitDone();
-        res.end();
+        if (endResponse && writable()) res.end();
         return;
       }
       if (typeof onStreamChunk === 'function') onStreamChunk(event);
-      if (passThrough) res.write(`data: ${event.data}\n\n`);
+      if (passThrough && writable()) res.write(`data: ${event.data}\n\n`);
     }
   }
 
@@ -148,8 +150,8 @@ export async function relayChatCompletionsResponse({
       break;
     }
     if (typeof onStreamChunk === 'function') onStreamChunk(event);
-    if (passThrough) res.write(`data: ${event.data}\n\n`);
+    if (passThrough && writable()) res.write(`data: ${event.data}\n\n`);
   }
-  emitDone();
-  res.end();
+  emitDone({ eof: true });
+  if (endResponse && writable()) res.end();
 }

package/src/web-search-emulator.js

@@ -1,4 +1,4 @@
-import { generateId, isObject, safeJsonParse, toText } from './common.js';
+import { generateId, isObject, parseJsonObject, toText } from './common.js';
 import { callFirecrawlScrape } from './firecrawl.js';
 import { callTavilySearch, formatTavilySearchResult } from './tavily.js';
 
@@ -14,7 +14,7 @@ const INTERNAL_WEB_TOOL_NAMES = new Set([
   INTERNAL_WEB_OPEN_PAGE_TOOL,
   INTERNAL_WEB_FIND_IN_PAGE_TOOL,
 ]);
-const MAX_SEARCH_ROUNDS = 20;
+const MAX_SEARCH_ROUNDS = 40;
 
 const WEB_SEARCH_INSTRUCTIONS = [
   'For live web information, use tavily_search.',
@@ -135,13 +135,6 @@ function clone(value) {
   return value == null ? value : JSON.parse(JSON.stringify(value));
 }
 
-function parseJsonObject(text) {
-  if (isObject(text)) return text;
-  if (typeof text !== 'string' || !text.trim()) return {};
-  const parsed = safeJsonParse(text);
-  return parsed.ok && isObject(parsed.value) ? parsed.value : {};
-}
-
 function webSearchToolOptions(tools) {
   const options = {};
   for (const tool of Array.isArray(tools) ? tools : []) {
@@ -395,7 +388,7 @@ export function knownExternalToolCallsCompletion(completion, tools) {
 
 export function maxWebSearchRounds(config = {}) {
   const value = Number(config.tavilyMaxSearchRounds);
-  if (!Number.isFinite(value)) return 10;
+  if (!Number.isFinite(value)) return 20;
   return Math.min(MAX_SEARCH_ROUNDS, Math.max(0, Math.trunc(value)));
 }
 
@@ -683,6 +676,14 @@ function buildAnnotations(text, searches = [], openedPages = []) {
   return annotations.sort((a, b) => a.start_index - b.start_index);
 }
 
+export function annotateMessagePartWithWebCitations(part, searches = [], openedPages = []) {
+  if (!part || part.type !== 'output_text' || typeof part.text !== 'string') return;
+  if (!(searches || []).length && !(openedPages || []).length) return;
+  const annotations = buildAnnotations(part.text, searches, openedPages);
+  if (!annotations.length) return;
+  part.annotations = [...(Array.isArray(part.annotations) ? part.annotations : []), ...annotations];
+}
+
 export function applyWebSearchOutputCompatibility(payload, searches = [], normalized = payload?.normalized, openedPages = []) {
   if (!payload || !Array.isArray(payload.output)) return payload;
   const explicitOpenedPages = (openedPages || []).filter((page) => !page.auto);
@@ -732,7 +733,7 @@ export function applyWebSearchOutputCompatibility(payload, searches = [], normal
   }
   payload.output = output;
   payload.output_text = output
-    .filter((item) => item?.type === 'message')
+    .filter((item) => item?.type === 'message' && item.phase !== 'commentary')
     .flatMap((item) => Array.isArray(item.content) ? item.content : [])
     .filter((part) => part?.type === 'output_text' && typeof part.text === 'string')
     .map((part) => part.text)

package/state/sessions.example.json

@@ -0,0 +1,72 @@
+{
+  "version": 4,
+  "sessions": [
+    [
+      "resp_0example1234567890abcdef",
+      {
+        "id": "resp_0example1234567890abcdef",
+        "messages": [
+          { "role": "user", "content": "Find the config loader and summarize it." },
+          {
+            "role": "assistant",
+            "content": "",
+            "reasoning_content": "Raw DeepSeek thinking text, kept verbatim so thinking-mode tool turns can be replayed upstream.",
+            "tool_calls": [
+              {
+                "id": "call_example0001",
+                "type": "function",
+                "function": {
+                  "name": "shell_command",
+                  "arguments": "{\"command\":\"rg --files -g 'config*'\"}"
+                }
+              },
+              {
+                "id": "call_example0002",
+                "type": "function",
+                "function": {
+                  "name": "shell_command",
+                  "arguments": "{\"command\":\"rg -n 'loadConfig' src\"}"
+                }
+              }
+            ]
+          },
+          { "role": "tool", "tool_call_id": "call_example0001", "content": "src/config.js" },
+          { "role": "tool", "tool_call_id": "call_example0002", "content": "src/config.js:12" },
+          { "role": "assistant", "content": "src/config.js merges env vars and gateway.local.json into one config object." }
+        ]
+      }
+    ]
+  ],
+  "conversations": [
+    ["conv_example", "resp_0example1234567890abcdef"]
+  ],
+  "assistantMessages": [
+    {
+      "role": "assistant",
+      "content": "",
+      "reasoning_content": "Raw DeepSeek thinking text, kept verbatim so thinking-mode tool turns can be replayed upstream.",
+      "tool_calls": [
+        {
+          "id": "call_example0001",
+          "type": "function",
+          "function": {
+            "name": "shell_command",
+            "arguments": "{\"command\":\"rg --files -g 'config*'\"}"
+          }
+        },
+        {
+          "id": "call_example0002",
+          "type": "function",
+          "function": {
+            "name": "shell_command",
+            "arguments": "{\"command\":\"rg -n 'loadConfig' src\"}"
+          }
+        }
+      ]
+    }
+  ],
+  "toolCallMessages": [
+    ["call_example0001", 0],
+    ["call_example0002", 0]
+  ]
+}