@galaxy-yearn/codex-deepseek-gateway 0.1.0 → 0.1.2

package/src/protocol.js

@@ -25,6 +25,8 @@ const TOOL_OUTPUT_TYPES = new Set([
   'code_interpreter_call_output',
   'image_generation_call_output',
 ]);
+const CHAT_HISTORY_IGNORED_TOOL_ITEM_TYPES = new Set(['web_search_call', 'web_search_call_output']);
+const EMULATED_HOSTED_TOOL_TYPES = new Set(['web_search', 'web_search_preview']);
 
 function jsonString(value) {
   if (typeof value === 'string') return value;
@@ -288,6 +290,11 @@ function extractMessagesFromResponsesInput(input) {
         if (normalized) messages.push(normalized);
         continue;
       }
+      if (CHAT_HISTORY_IGNORED_TOOL_ITEM_TYPES.has(item.type)) {
+        flushPendingUserContent();
+        flushPendingAssistantToolMessage();
+        continue;
+      }
       if (TOOL_OUTPUT_TYPES.has(item.type) || String(item.type || '').endsWith('_call_output')) {
         flushPendingUserContent();
         flushPendingAssistantToolMessage();
@@ -339,6 +346,9 @@ function extractMessagesFromResponsesInput(input) {
 
 function normalizeTool(tool) {
   if (!isObject(tool)) return tool;
+  if (typeof tool.type === 'string' && EMULATED_HOSTED_TOOL_TYPES.has(tool.type)) {
+    return null;
+  }
   if (tool.type === 'function' && isObject(tool.function)) {
     return {
       ...tool,
@@ -360,17 +370,6 @@ function normalizeTool(tool) {
       }),
     };
   }
-  if (typeof tool.type === 'string') {
-    return {
-      type: 'function',
-      function: omitUndefined({
-        name: sanitizeFunctionName(tool.name || tool.type),
-        description: tool.description || `Gateway shim for Responses tool type ${tool.type}.`,
-        parameters: normalizeJsonSchemaObject(tool.parameters || tool.input_schema),
-        strict: tool.strict,
-      }),
-    };
-  }
   return null;
 }
 

package/src/server.js

@@ -15,6 +15,19 @@ import {
 } from './protocol.js';
 import { SessionStore } from './session-store.js';
 import { callChatCompletions, callModels, readJsonResponse, relayChatCompletionsResponse } from './upstream.js';
+import {
+  applyWebSearchOutputCompatibility,
+  buildWebSearchCallItem,
+  containsWebSearchTool,
+  executeWebSearchCalls,
+  hasAnyToolCalls,
+  INTERNAL_WEB_SEARCH_TOOL,
+  maxWebSearchRounds,
+  prepareWebSearchRequest,
+  shouldIncludeSearchSources,
+  shouldContinueWebSearchLoop,
+  unhandledToolMessagesFromCompletion,
+} from './web-search-emulator.js';
 
 function sendJson(res, statusCode, payload, headers = {}) {
   res.writeHead(statusCode, {
@@ -53,6 +66,10 @@ function historyMessagesFromSession(session) {
   if (!session?.history?.length) return [];
   const messages = [];
   for (const turn of session.history) {
+    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)) {
@@ -128,6 +145,361 @@ function resolveReasoningStreamMode(config, upstreamRequest) {
   return { emitReasoningSummary: false, emitReasoningText: false };
 }
 
+function hasTavilyWebSearch(config, normalized) {
+  return Boolean(config.tavilyWebSearchEnabled && config.tavilyApiKey && containsWebSearchTool(normalized));
+}
+
+function disableStreaming(request) {
+  return {
+    ...request,
+    stream: false,
+    stream_options: undefined,
+  };
+}
+
+function webToolTimeoutMs(config = {}) {
+  const tavilyTimeout = Number(config.tavilyTimeoutMs) || 15000;
+  if (!config.firecrawlWebFetchEnabled || !config.firecrawlApiKey) return tavilyTimeout;
+  const firecrawlTimeout = Number(config.firecrawlTimeoutMs) || 30000;
+  return Math.max(tavilyTimeout, firecrawlTimeout);
+}
+
+function addUsage(left, right) {
+  if (!left) return right || null;
+  if (!right) return left;
+  return {
+    prompt_tokens: (left.prompt_tokens || 0) + (right.prompt_tokens || 0),
+    completion_tokens: (left.completion_tokens || 0) + (right.completion_tokens || 0),
+    total_tokens: (left.total_tokens || 0) + (right.total_tokens || 0),
+    reasoning_tokens: (left.reasoning_tokens || 0) + (right.reasoning_tokens || 0),
+    prompt_tokens_details: {
+      cached_tokens: (left.prompt_tokens_details?.cached_tokens || 0) + (right.prompt_tokens_details?.cached_tokens || 0),
+    },
+    completion_tokens_details: {
+      reasoning_tokens:
+        (left.completion_tokens_details?.reasoning_tokens || 0) +
+        (right.completion_tokens_details?.reasoning_tokens || 0),
+    },
+  };
+}
+
+function combineUsage(completions) {
+  return completions.reduce((usage, completion) => addUsage(usage, completion?.usage), null);
+}
+
+function cloneCompletionWithUsage(completion, usage) {
+  if (!usage) return completion;
+  return {
+    ...completion,
+    usage,
+  };
+}
+
+function toolCallsToFinalAnswerRequest(request) {
+  return {
+    ...request,
+    tool_choice: 'none',
+    tools: undefined,
+    messages: request.messages.concat({
+      role: 'user',
+      content: [
+        'Do not call more tools.',
+        'Use the completed tool results already provided in this conversation.',
+        'Give the final answer now.',
+        'If the available tool results are incomplete, say what is missing and answer only what the provided context supports.',
+      ].join(' '),
+    }),
+  };
+}
+
+async function callUpstreamJson({ upstreamRequest, config }) {
+  const response = await callChatCompletions({
+    baseUrl: config.upstreamBaseUrl,
+    apiKey: config.upstreamApiKey,
+    request: upstreamRequest,
+    timeoutMs: config.upstreamTimeoutMs,
+  });
+  const data = await readJsonResponse(response);
+  return { response, data };
+}
+
+async function runWebSearchChatLoop({ normalized, chatRequest, config, onSearchStart, onSearchDone }) {
+  const effectiveChatRequest = { ...chatRequest, normalized };
+  const state = prepareWebSearchRequest({ normalized, chatRequest: effectiveChatRequest, config });
+  const searchConfig = state.config || config;
+  let currentChatRequest = state.enabled ? state.chatRequest : effectiveChatRequest;
+  const completions = [];
+  const searches = [];
+  const openedPages = [];
+  let finalCompletion = null;
+  let finalResponse = null;
+  let forcedFinalAnswer = false;
+  const maxRounds = maxWebSearchRounds(searchConfig);
+
+  for (let round = 0; round <= maxRounds + 1; round += 1) {
+    const upstreamRequest = toProviderChatCompletionsRequest(currentChatRequest, config);
+    if (!upstreamRequest.model) upstreamRequest.model = config.upstreamModel || currentChatRequest.model;
+    const { response, data } = await callUpstreamJson({
+      upstreamRequest: disableStreaming(upstreamRequest),
+      config,
+    });
+    finalResponse = response;
+    if (!response.ok) return { ok: false, status: response.status, data };
+    completions.push(data);
+    finalCompletion = data;
+
+    if (!state.enabled || !shouldContinueWebSearchLoop(data) || round >= maxRounds) {
+      if (state.enabled && hasAnyToolCalls(data) && !forcedFinalAnswer) {
+        const unsupportedMessages = unhandledToolMessagesFromCompletion(data);
+        currentChatRequest = toolCallsToFinalAnswerRequest({
+          ...currentChatRequest,
+          messages: currentChatRequest.messages.concat(unsupportedMessages),
+        });
+        forcedFinalAnswer = true;
+        if (unsupportedMessages.length) {
+          finalCompletion = null;
+          completions.pop();
+        }
+        continue;
+      }
+      break;
+    }
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), webToolTimeoutMs(searchConfig));
+    let toolResult;
+    try {
+      toolResult = await executeWebSearchCalls({
+        completion: data,
+        config: searchConfig,
+        signal: controller.signal,
+        onSearchStart,
+        onSearchDone,
+      });
+    } finally {
+      clearTimeout(timeout);
+    }
+    searches.push(...toolResult.searches);
+    openedPages.push(...(toolResult.openedPages || []));
+    currentChatRequest = {
+      ...currentChatRequest,
+      messages: currentChatRequest.messages.concat(toolResult.messages),
+      tool_choice:
+        currentChatRequest.tool_choice?.function?.name === INTERNAL_WEB_SEARCH_TOOL
+          ? 'auto'
+          : currentChatRequest.tool_choice,
+    };
+  }
+
+  return {
+    ok: true,
+    response: finalResponse,
+    completion: cloneCompletionWithUsage(finalCompletion, combineUsage(completions)),
+    searches,
+    openedPages,
+    chatRequest: currentChatRequest,
+  };
+}
+
+const REPLAY_REASONING_DELTA_CHARS = 1200;
+
+function splitReplayText(text, maxChars = REPLAY_REASONING_DELTA_CHARS) {
+  const value = String(text ?? '');
+  if (!value) return [];
+  const chunks = [];
+  for (let index = 0; index < value.length; index += maxChars) {
+    chunks.push(value.slice(index, index + maxChars));
+  }
+  return chunks;
+}
+
+function replayReasoningItemEvents({ item, outputIndex, mapper }) {
+  const events = [];
+  const summaries = Array.isArray(item.summary) ? item.summary : [];
+  const content = Array.isArray(item.content) ? item.content : [];
+  const addedItem = {
+    ...item,
+    status: 'in_progress',
+    summary: [],
+    content: content.map((part) => (part?.type === 'reasoning_text' ? { ...part, text: '' } : part)),
+  };
+
+  events.push({
+    type: 'response.output_item.added',
+    sequence_number: mapper.nextSequence(),
+    output_index: outputIndex,
+    item: addedItem,
+  });
+
+  for (const [summaryIndex, part] of summaries.entries()) {
+    if (part?.type !== 'summary_text') continue;
+    const text = String(part.text ?? '');
+    events.push({
+      type: 'response.reasoning_summary_part.added',
+      sequence_number: mapper.nextSequence(),
+      output_index: outputIndex,
+      item_id: item.id,
+      summary_index: summaryIndex,
+      part: { ...part, text: '' },
+    });
+    for (const delta of splitReplayText(text)) {
+      events.push({
+        type: 'response.reasoning_summary_text.delta',
+        sequence_number: mapper.nextSequence(),
+        output_index: outputIndex,
+        item_id: item.id,
+        summary_index: summaryIndex,
+        delta,
+      });
+    }
+    events.push({
+      type: 'response.reasoning_summary_text.done',
+      sequence_number: mapper.nextSequence(),
+      output_index: outputIndex,
+      item_id: item.id,
+      summary_index: summaryIndex,
+      text,
+    });
+    events.push({
+      type: 'response.reasoning_summary_part.done',
+      sequence_number: mapper.nextSequence(),
+      output_index: outputIndex,
+      item_id: item.id,
+      summary_index: summaryIndex,
+      part,
+    });
+  }
+
+  events.push({
+    type: 'response.output_item.done',
+    sequence_number: mapper.nextSequence(),
+    output_index: outputIndex,
+    item,
+  });
+  return events;
+}
+
+function outputEventsFromPayload(payload, mapper, { skipTypes = new Set() } = {}) {
+  const events = [];
+  const output = Array.isArray(payload.output) ? payload.output : [];
+  for (const [outputIndex, item] of output.entries()) {
+    if (skipTypes.has(item?.type)) continue;
+    mapper.output[outputIndex] = item;
+    if (item?.type === 'reasoning') {
+      events.push(...replayReasoningItemEvents({ item, outputIndex, mapper }));
+      continue;
+    }
+    events.push({
+      type: 'response.output_item.added',
+      sequence_number: mapper.nextSequence(),
+      output_index: outputIndex,
+      item,
+    });
+    if (item.type === 'message' && Array.isArray(item.content)) {
+      for (const [contentIndex, part] of item.content.entries()) {
+        events.push({
+          type: 'response.content_part.added',
+          sequence_number: mapper.nextSequence(),
+          output_index: outputIndex,
+          content_index: contentIndex,
+          item_id: item.id,
+          part: part.type === 'output_text' ? { ...part, text: '', annotations: [] } : part,
+        });
+        if (part.type === 'output_text' && part.text) {
+          events.push({
+            type: 'response.output_text.delta',
+            sequence_number: mapper.nextSequence(),
+            output_index: outputIndex,
+            content_index: contentIndex,
+            item_id: item.id,
+            delta: part.text,
+            logprobs: [],
+          });
+          for (const [annotationIndex, annotation] of (Array.isArray(part.annotations) ? part.annotations : []).entries()) {
+            events.push({
+              type: 'response.output_text.annotation.added',
+              sequence_number: mapper.nextSequence(),
+              output_index: outputIndex,
+              content_index: contentIndex,
+              item_id: item.id,
+              annotation_index: annotationIndex,
+              annotation,
+            });
+          }
+          events.push({
+            type: 'response.output_text.done',
+            sequence_number: mapper.nextSequence(),
+            output_index: outputIndex,
+            content_index: contentIndex,
+            item_id: item.id,
+            text: part.text,
+            logprobs: [],
+          });
+        }
+        events.push({
+          type: 'response.content_part.done',
+          sequence_number: mapper.nextSequence(),
+          output_index: outputIndex,
+          content_index: contentIndex,
+          item_id: item.id,
+          part,
+        });
+      }
+    }
+    events.push({
+      type: 'response.output_item.done',
+      sequence_number: mapper.nextSequence(),
+      output_index: outputIndex,
+      item,
+    });
+  }
+  return events;
+}
+
+function completedEventFromPayload(payload, mapper) {
+  return {
+    type: payload.status === 'incomplete' ? 'response.incomplete' : 'response.completed',
+    sequence_number: mapper.nextSequence(),
+    response: payload,
+  };
+}
+
+function writeSseEvent(res, event) {
+  res.write(serializeResponsesSseEvent(event));
+}
+
+function writeSseDone(res) {
+  writeSseEvent(res, { done: true });
+}
+
+function webSearchSseWriter({ res, mapper, outputIndexBySearch, includeSources = false }) {
+  return {
+    start(search) {
+      const outputIndex = mapper.output.length;
+      outputIndexBySearch.set(search.id, outputIndex);
+      const item = buildWebSearchCallItem(search, { status: 'in_progress', includeSources });
+      mapper.output.push(item);
+      writeSseEvent(res, {
+        type: 'response.output_item.added',
+        sequence_number: mapper.nextSequence(),
+        output_index: outputIndex,
+        item,
+      });
+    },
+    done(search) {
+      const outputIndex = outputIndexBySearch.get(search.id);
+      const item = buildWebSearchCallItem(search, { includeSources });
+      if (Number.isInteger(outputIndex)) mapper.output[outputIndex] = item;
+      writeSseEvent(res, {
+        type: 'response.output_item.done',
+        sequence_number: mapper.nextSequence(),
+        output_index: Number.isInteger(outputIndex) ? outputIndex : mapper.output.indexOf(item),
+        item,
+      });
+    },
+  };
+}
+
 export function createProxyServer({ config = loadConfig(), sessions = new SessionStore() } = {}) {
   let modelCache = null;
 
@@ -177,9 +549,9 @@ export function createProxyServer({ config = loadConfig(), sessions = new Sessio
     normalized.messages = prependMissingAssistantToolMessages(normalized.messages, sessions);
 
     const chatRequest = toChatCompletionsRequest(normalized);
-    const upstreamRequest = toProviderChatCompletionsRequest(chatRequest, config);
+    const useWebSearchEmulator = hasTavilyWebSearch(config, normalized);
+    let upstreamRequest = toProviderChatCompletionsRequest(chatRequest, config);
     if (!upstreamRequest.model) upstreamRequest.model = config.upstreamModel || normalized.model;
-    logDebugPayload(config, upstreamRequest);
 
     if (!upstreamRequest.model) {
       sendJson(res, 400, { error: { message: 'Missing model' } });
@@ -193,6 +565,110 @@ export function createProxyServer({ config = loadConfig(), sessions = new Sessio
     const responseId = generateId('resp');
     const nextSession = { id: responseId, history: [] };
 
+    if (useWebSearchEmulator) {
+      const streamWebSearch = Boolean(request.stream);
+      let streamMapper = null;
+      let streamSearchWriter = null;
+      const streamSearchItems = new Set();
+      if (streamWebSearch) {
+        const createdAt = Math.floor(Date.now() / 1000);
+        streamMapper = new ResponsesStreamMapper({
+          responseId,
+          model: upstreamRequest.model,
+          createdAt,
+          previousResponseId,
+          normalized,
+          emitReasoningSummary: true,
+          emitReasoningText: false,
+        });
+        streamSearchWriter = webSearchSseWriter({
+          res,
+          mapper: streamMapper,
+          outputIndexBySearch: new Map(),
+          includeSources: shouldIncludeSearchSources(normalized),
+        });
+        res.writeHead(200, {
+          'content-type': 'text/event-stream; charset=utf-8',
+          'cache-control': 'no-cache, no-transform',
+          connection: 'keep-alive',
+          'x-accel-buffering': 'no',
+        });
+        writeSseEvent(res, streamMapper.createdEvent());
+        writeSseEvent(res, streamMapper.inProgressEvent());
+      }
+
+      const loop = await runWebSearchChatLoop({
+        normalized,
+        chatRequest,
+        config,
+        onSearchStart: streamWebSearch
+          ? (search) => {
+              if (search.action && search.auto) return;
+              streamSearchItems.add(search);
+              streamSearchWriter.start(search);
+            }
+          : undefined,
+        onSearchDone: streamWebSearch
+          ? (search) => {
+              if (!streamSearchItems.has(search)) return;
+              streamSearchWriter.done(search);
+            }
+          : undefined,
+      });
+      if (!loop.ok) {
+        if (streamWebSearch) {
+          writeSseEvent(res, {
+            type: 'response.failed',
+            sequence_number: streamMapper.nextSequence(),
+            response: streamMapper.response('failed'),
+          });
+          writeSseDone(res);
+          res.end();
+          return;
+        }
+        sendJson(res, loop.status || 500, loop.data);
+        return;
+      }
+      upstreamRequest = toProviderChatCompletionsRequest(loop.chatRequest, config);
+      if (!upstreamRequest.model) upstreamRequest.model = config.upstreamModel || normalized.model;
+      const model = upstreamRequest.model;
+      const payload = applyWebSearchOutputCompatibility(convertChatCompletionToResponses({
+        completion: loop.completion,
+        model,
+        previousResponseId,
+        normalized,
+        responseId,
+      }), loop.searches, normalized, loop.openedPages);
+      const assistantMessage = assistantMessageFromResponseOutput(payload.output);
+
+      nextSession.history.push({
+        request: normalized,
+        chatRequest: loop.chatRequest,
+        upstreamRequest,
+        inputMessages: currentInputMessages,
+        historyMessages: loop.chatRequest.messages.concat(assistantMessage),
+        assistantMessage,
+        createdAt: Date.now(),
+      });
+      sessions.set(responseId, nextSession);
+      sessions.setConversation(conversationId, responseId);
+
+      if (!streamWebSearch) {
+        sendJson(res, 200, payload);
+        return;
+      }
+
+      for (const event of outputEventsFromPayload(payload, streamMapper, { skipTypes: new Set(['web_search_call']) })) {
+        writeSseEvent(res, event);
+      }
+      writeSseEvent(res, completedEventFromPayload(payload, streamMapper));
+      writeSseDone(res);
+      res.end();
+      return;
+    }
+
+    logDebugPayload(config, upstreamRequest);
+
     const upstreamResponse = await callChatCompletions({
       baseUrl: config.upstreamBaseUrl,
       apiKey: config.upstreamApiKey,
@@ -335,6 +811,20 @@ export function createProxyServer({ config = loadConfig(), sessions = new Sessio
 
       sendJson(res, 404, { error: { message: 'Not found' } });
     } catch (error) {
+      if (res.headersSent) {
+        if (!res.writableEnded) {
+          res.write(serializeResponsesSseEvent({
+            type: 'response.failed',
+            response: {
+              status: 'failed',
+              error: { message: error.message || 'Internal server error' },
+            },
+          }));
+          res.write(serializeResponsesSseEvent({ done: true }));
+          res.end();
+        }
+        return;
+      }
       sendJson(res, 500, { error: { message: error.message || 'Internal server error' } });
     }
   });