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

package/src/protocol.js

@@ -1,5 +1,10 @@
 import { generateId, isObject, normalizeRole, toText } from './common.js';
-import { deepseekReasoningPayload, resolveModelAlias } from './model-map.js';
+import {
+  DEFAULT_MODEL_ALIASES,
+  deepseekReasoningPayload,
+  isDeprecatedModel,
+  resolveModelAlias,
+} from './model-map.js';
 
 const TEXT_PART_TYPES = new Set(['input_text', 'output_text', 'text']);
 const INPUT_CONTENT_PART_TYPES = new Set(['input_text', 'input_image', 'input_file', 'input_audio']);
@@ -10,6 +15,7 @@ const TOOL_CALL_TYPES = new Set([
   'computer_call',
   'mcp_call',
   'web_search_call',
+  'tool_search_call',
   'file_search_call',
   'code_interpreter_call',
   'image_generation_call',
@@ -21,18 +27,47 @@ const TOOL_OUTPUT_TYPES = new Set([
   'computer_call_output',
   'mcp_call_output',
   'web_search_call_output',
+  'tool_search_output',
   'file_search_call_output',
   '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 CHAT_HISTORY_IGNORED_TOOL_ITEM_TYPES = new Set([
+  'web_search_call',
+  'web_search_call_output',
+  'tool_search_call',
+  'tool_search_output',
+]);
 const EMULATED_HOSTED_TOOL_TYPES = new Set(['web_search', 'web_search_preview']);
+const DEEPSEEK_TOOL_INSTRUCTIONS_MARKER = 'The tools in this request are real callable functions available now.';
+const DEEPSEEK_TOOL_INSTRUCTIONS = [
+  DEEPSEEK_TOOL_INSTRUCTIONS_MARKER,
+  'When a tool is needed, respond with Chat Completions tool_calls and JSON arguments matching the schema.',
+  'Do not write pseudo XML, DSML, or JSON tool calls in assistant text.',
+  'Do not claim a listed function is unavailable because its name is unfamiliar.',
+].join(' ');
+const DEEPSEEK_TOOL_DESCRIPTION_CHARS = 220;
+const DEEPSEEK_SCHEMA_DESCRIPTION_CHARS = 160;
+const CODEX_REASONING_EFFORTS = ['low', 'medium', 'high', 'xhigh'];
+const CODEX_SPAWN_AGENT_TOOL_NAME = 'multi_agent_v1__spawn_agent';
+const CODEX_TOOL_SEARCH_TOOL_NAME = 'tool_search';
 
 function jsonString(value) {
   if (typeof value === 'string') return value;
   return JSON.stringify(value ?? {});
 }
 
+function parseJsonObject(value) {
+  if (isObject(value)) return value;
+  if (typeof value !== 'string') return {};
+  try {
+    const parsed = JSON.parse(value);
+    return isObject(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
 function sanitizeFunctionName(name, fallback = 'tool_call') {
   const candidate = String(name || fallback)
     .replace(/[^a-zA-Z0-9_-]/g, '_')
@@ -41,6 +76,34 @@ function sanitizeFunctionName(name, fallback = 'tool_call') {
   return candidate || fallback;
 }
 
+function toolNamespace(tool) {
+  if (!isObject(tool)) return '';
+  return String(tool.namespace || tool.function?.namespace || '').trim();
+}
+
+function toolBaseName(tool, fallback = 'tool_call') {
+  if (!isObject(tool)) return fallback;
+  if (isObject(tool.function) && tool.function.name) return tool.function.name;
+  return tool.name || tool.tool_name || tool.toolName || tool.server_label || fallback;
+}
+
+function encodeToolName(namespace, name, fallback = 'tool_call') {
+  const baseName = sanitizeFunctionName(name, fallback);
+  if (!namespace) return baseName;
+  const encodedNamespace = sanitizeFunctionName(namespace, 'namespace');
+  return sanitizeFunctionName(`${encodedNamespace}__${baseName}`, fallback);
+}
+
+function decodedToolName(name, toolNames) {
+  const value = String(name || '');
+  const known = toolNames?.get(value);
+  return known ? { ...known } : { name: value };
+}
+
+function isCodexToolSearchTool(name) {
+  return String(name || '') === CODEX_TOOL_SEARCH_TOOL_NAME;
+}
+
 function omitUndefined(value) {
   if (!isObject(value)) return value;
   const result = {};
@@ -50,6 +113,19 @@ function omitUndefined(value) {
   return result;
 }
 
+function compactText(value) {
+  return String(value ?? '').replace(/\s+/g, ' ').trim();
+}
+
+function shortenText(value, maxChars) {
+  const text = compactText(value);
+  if (!text || text.length <= maxChars) return text;
+  const softLimit = Math.max(24, Math.floor(maxChars * 0.65));
+  const slice = text.slice(0, maxChars - 3);
+  const breakAt = Math.max(slice.lastIndexOf('. '), slice.lastIndexOf('; '), slice.lastIndexOf(', '), slice.lastIndexOf(' '));
+  return `${slice.slice(0, breakAt >= softLimit ? breakAt : slice.length).trimEnd()}...`;
+}
+
 function textPart(text) {
   return { type: 'text', text: String(text ?? '') };
 }
@@ -137,8 +213,9 @@ function toolCallId(item) {
 }
 
 function toolName(item) {
-  return sanitizeFunctionName(
-    item.name ||
+  return encodeToolName(
+    toolNamespace(item),
+      item.name ||
       item.tool_name ||
       item.toolName ||
       item.server_label ||
@@ -148,6 +225,7 @@ function toolName(item) {
 
 function toolArguments(item) {
   if (item.type === 'function_call') return jsonString(item.arguments ?? {});
+  if (item.type === 'tool_search_call') return jsonString(item.arguments ?? {});
   if (item.arguments !== undefined) return jsonString(item.arguments);
   if (item.input !== undefined) return jsonString({ input: item.input });
   if (item.action !== undefined) return jsonString({ action: item.action });
@@ -170,35 +248,55 @@ function chatToolCallFromResponseItem(item) {
 
 function reasoningTextFromItem(item) {
   if (!isObject(item)) return '';
-  const parts = [];
-  if (typeof item.reasoning_content === 'string') parts.push(item.reasoning_content);
-  if (typeof item.text === 'string') parts.push(item.text);
-  if (typeof item.content === 'string') parts.push(item.content);
+  if (typeof item.reasoning_content === 'string') return normalizeReasoningContent(item.reasoning_content);
+  const rawParts = [];
+  if (typeof item.text === 'string') rawParts.push(item.text);
+  if (typeof item.content === 'string') rawParts.push(item.content);
   if (Array.isArray(item.content)) {
     for (const part of item.content) {
       if (typeof part === 'string') {
-        parts.push(part);
+        rawParts.push(part);
         continue;
       }
       if (!isObject(part)) continue;
       if (part.type === 'reasoning_text' || part.type === 'text' || part.type === 'output_text') {
-        parts.push(String(part.text ?? part.content ?? ''));
+        rawParts.push(String(part.text ?? part.content ?? ''));
       }
     }
   }
-  if (Array.isArray(item.summary)) {
-    for (const part of item.summary) {
-      if (typeof part === 'string') {
-        parts.push(part);
-        continue;
-      }
-      if (!isObject(part)) continue;
-      if (part.type === 'summary_text' || part.type === 'text') {
-        parts.push(String(part.text ?? part.content ?? ''));
-      }
-    }
-  }
-  return parts.filter(Boolean).join('');
+  const rawText = rawParts.filter(Boolean).join('');
+  return normalizeReasoningContent(rawText);
+}
+
+function normalizeReasoningContent(text) {
+  return String(text ?? '').replace(/\r\n?/g, '\n').trimEnd();
+}
+
+function normalizeReasoningDisplayText(text) {
+  const value = normalizeReasoningContent(text);
+  if (!value) return '';
+  const plain = value
+    .split('\n')
+    .map((line) => line
+      .replace(/^[ \t]{0,3}(?:`{3,}|~{3,}).*$/, '')
+      .replace(/^[ \t]{0,3}#{1,6}[ \t]+/, '')
+      .replace(/^[ \t]{0,3}>[ \t]?/, '')
+      .replace(/^[ \t]*[-*+][ \t]+(?:\[[ xX]\][ \t]+)?/, '\u2022 ')
+      .replace(/^[ \t]*(\d+)\.[ \t]+/, '$1) ')
+      .replace(/!\[([^\]]*)\]\([^)]+\)/g, '$1')
+      .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+      .replace(/`([^`]*)`/g, '$1')
+      .replace(/(\*\*|__)([^*_]+)\1/g, '$2')
+      .replace(/(\*|_)([^*_]+)\1/g, '$2')
+      .replace(/[*_`~]/g, '')
+      .replace(/\\([\\`*_{}[\]()#+\-.!>])/g, '$1')
+      .trimEnd())
+    .join('\n');
+  return plain.replace(/^\n+/, '').trimEnd();
+}
+
+function reasoningDisplayText(text) {
+  return normalizeReasoningDisplayText(text);
 }
 
 function toolOutputContent(item) {
@@ -346,24 +444,28 @@ function extractMessagesFromResponsesInput(input) {
 
 function normalizeTool(tool) {
   if (!isObject(tool)) return tool;
+  if (tool.type === 'namespace') return null;
   if (typeof tool.type === 'string' && EMULATED_HOSTED_TOOL_TYPES.has(tool.type)) {
     return null;
   }
   if (tool.type === 'function' && isObject(tool.function)) {
+    const { namespace, ...fn } = tool.function;
     return {
-      ...tool,
-      function: {
-        ...tool.function,
-        name: sanitizeFunctionName(tool.function.name),
-        parameters: normalizeJsonSchemaObject(tool.function.parameters),
-      },
+      type: 'function',
+      function: omitUndefined({
+        ...fn,
+        name: encodeToolName(toolNamespace(tool), fn.name),
+        description: fn.description ?? tool.description,
+        parameters: normalizeJsonSchemaObject(fn.parameters ?? tool.parameters ?? tool.input_schema),
+        strict: fn.strict ?? tool.strict,
+      }),
     };
   }
   if (tool.type === 'function' || tool.type === 'custom' || tool.name || tool.parameters || tool.input_schema) {
     return {
       type: 'function',
       function: omitUndefined({
-        name: sanitizeFunctionName(tool.name || tool.type),
+        name: encodeToolName(toolNamespace(tool), toolBaseName(tool, tool.type)),
         description: tool.description,
         parameters: normalizeJsonSchemaObject(tool.parameters || tool.input_schema),
         strict: tool.strict,
@@ -373,6 +475,75 @@ function normalizeTool(tool) {
   return null;
 }
 
+function expandNamespaceTool(tool) {
+  if (!isObject(tool) || tool.type !== 'namespace') return [tool];
+  const namespace = tool.name || tool.namespace || tool.server_label;
+  const children = Array.isArray(tool.tools) ? tool.tools : [];
+  return children
+    .filter(isObject)
+    .map((child) => {
+      if (child.type === 'function' && isObject(child.function)) {
+        return {
+          ...child,
+          namespace: child.namespace || namespace,
+          function: {
+            ...child.function,
+            namespace: child.function.namespace || child.namespace || namespace,
+          },
+        };
+      }
+      return {
+        ...child,
+        namespace: child.namespace || namespace,
+      };
+    });
+}
+
+function expandTools(tools) {
+  if (!Array.isArray(tools)) return [];
+  return tools.flatMap(expandNamespaceTool);
+}
+
+function normalizeTools(tools) {
+  const seen = new Set();
+  const normalized = [];
+  for (const tool of expandTools(tools).map(normalizeTool).filter(Boolean)) {
+    const name = tool?.type === 'function' ? tool.function?.name : '';
+    if (name) {
+      if (seen.has(name)) continue;
+      seen.add(name);
+    }
+    normalized.push(tool);
+  }
+  return normalized.length ? normalized : undefined;
+}
+
+function collectToolSearchOutputTools(input) {
+  const discovered = [];
+  const scan = (value) => {
+    if (Array.isArray(value)) {
+      for (const item of value) scan(item);
+      return;
+    }
+    if (!isObject(value)) return;
+    if (value.type === 'tool_search_output' && Array.isArray(value.tools)) {
+      discovered.push(...value.tools.filter(isObject));
+      return;
+    }
+    if (Array.isArray(value.input)) scan(value.input);
+    if (Array.isArray(value.content)) scan(value.content);
+  };
+  scan(input);
+  return discovered;
+}
+
+function mergeToolsWithToolSearchOutput(requestTools, input) {
+  const discovered = collectToolSearchOutputTools(input);
+  if (!discovered.length) return requestTools;
+  const base = Array.isArray(requestTools) ? requestTools : [];
+  return base.concat(discovered);
+}
+
 function normalizeJsonSchemaObject(schema) {
   if (!isObject(schema)) {
     return { type: 'object', properties: {}, additionalProperties: true };
@@ -405,7 +576,7 @@ function normalizeToolChoice(toolChoice) {
   if (toolChoice.type === 'function' && toolChoice.name) {
     return {
       type: 'function',
-      function: { name: sanitizeFunctionName(toolChoice.name) },
+      function: { name: encodeToolName(toolNamespace(toolChoice), toolChoice.name) },
     };
   }
   if (toolChoice.type === 'function' && isObject(toolChoice.function)) {
@@ -413,7 +584,7 @@ function normalizeToolChoice(toolChoice) {
       ...toolChoice,
       function: {
         ...toolChoice.function,
-        name: sanitizeFunctionName(toolChoice.function.name),
+        name: encodeToolName(toolNamespace(toolChoice), toolChoice.function.name),
       },
     };
   }
@@ -424,7 +595,8 @@ function normalizeToolChoice(toolChoice) {
     return {
       type: 'function',
       function: {
-        name: sanitizeFunctionName(
+        name: encodeToolName(
+          toolNamespace(toolChoice),
           toolChoice.name ||
             toolChoice.tool_name ||
             toolChoice.toolName ||
@@ -437,6 +609,45 @@ function normalizeToolChoice(toolChoice) {
   return toolChoice;
 }
 
+function toolChoiceEntryName(entry) {
+  if (!isObject(entry)) return '';
+  if (entry.type === 'function' && entry.name) return encodeToolName(toolNamespace(entry), entry.name);
+  if (entry.type === 'function' && isObject(entry.function)) {
+    return encodeToolName(toolNamespace(entry), entry.function.name);
+  }
+  return encodeToolName(
+    toolNamespace(entry),
+    entry.name ||
+      entry.tool_name ||
+      entry.toolName ||
+      entry.server_label ||
+      entry.type,
+  );
+}
+
+function allowedToolNames(toolChoice) {
+  if (!isObject(toolChoice) || toolChoice.type !== 'allowed_tools') return null;
+  const entries = Array.isArray(toolChoice.tools)
+    ? toolChoice.tools
+    : Array.isArray(toolChoice.allowed_tools)
+    ? toolChoice.allowed_tools
+    : Array.isArray(toolChoice.names)
+    ? toolChoice.names.map((name) => ({ type: 'function', name }))
+    : [];
+  const names = entries.map(toolChoiceEntryName).filter(Boolean);
+  return names.length ? new Set(names) : null;
+}
+
+function applyAllowedTools(tools, toolChoice) {
+  const allowed = allowedToolNames(toolChoice);
+  if (!allowed || !Array.isArray(tools)) return tools;
+  const filtered = tools.filter((tool) => {
+    const name = tool?.type === 'function' ? tool.function?.name : '';
+    return !name || allowed.has(name);
+  });
+  return filtered.length ? filtered : undefined;
+}
+
 function unwrapJsonString(value) {
   if (typeof value !== 'string') return value;
   const trimmed = value.trim();
@@ -469,10 +680,63 @@ function coerceValueForSchema(value, schema) {
   return value;
 }
 
+function toolSearchArgumentsFromText(argumentsText) {
+  const parsed = parseJsonObject(argumentsText);
+  const args = {};
+  if (parsed.limit !== undefined) {
+    const limit = Number(parsed.limit);
+    if (Number.isFinite(limit)) args.limit = limit;
+  }
+  if (parsed.query !== undefined) args.query = String(parsed.query);
+  return args;
+}
+
+function finalizeToolSearchCallItemArguments(item) {
+  if (!item || item.type !== 'tool_search_call') return;
+  if (typeof item.arguments === 'string') {
+    item.arguments = toolSearchArgumentsFromText(item.arguments);
+  } else if (!isObject(item.arguments)) {
+    item.arguments = {};
+  }
+}
+
+function convertItemToToolSearchCall(item) {
+  if (!item || item.type === 'tool_search_call') return item;
+  item.type = 'tool_search_call';
+  item.id = generateId('tsc');
+  item.execution = 'client';
+  delete item.name;
+  delete item.namespace;
+  return item;
+}
+
+function responseItemFromChatToolCall(toolCall, toolNames) {
+  const callId = toolCall.id || generateId('call');
+  if (isCodexToolSearchTool(toolCall.function?.name)) {
+    return {
+      type: 'tool_search_call',
+      id: generateId('tsc'),
+      call_id: callId,
+      status: 'completed',
+      execution: 'client',
+      arguments: toolSearchArgumentsFromText(toolCall.function?.arguments || ''),
+    };
+  }
+  const decoded = decodedToolName(toolCall.function?.name, toolNames);
+  return omitUndefined({
+    type: 'function_call',
+    id: callId,
+    call_id: callId,
+    name: decoded.name,
+    namespace: decoded.namespace,
+    arguments: toolCall.function?.arguments || '',
+    status: 'completed',
+  });
+}
+
 function buildToolSchemas(tools) {
   const schemas = new Map();
-  if (!Array.isArray(tools)) return schemas;
-  for (const tool of tools) {
+  for (const tool of expandTools(tools)) {
     const normalizedTool = normalizeTool(tool);
     const fn = normalizedTool?.type === 'function' ? normalizedTool.function : null;
     if (!fn?.name) continue;
@@ -481,6 +745,160 @@ function buildToolSchemas(tools) {
   return schemas;
 }
 
+function buildToolNames(tools) {
+  const names = new Map();
+  for (const tool of expandTools(tools)) {
+    const namespace = toolNamespace(tool);
+    if (!namespace) continue;
+    const normalizedTool = normalizeTool(tool);
+    const fn = normalizedTool?.type === 'function' ? normalizedTool.function : null;
+    if (!fn?.name) continue;
+    names.set(fn.name, {
+      namespace: sanitizeFunctionName(namespace, 'namespace'),
+      name: sanitizeFunctionName(toolBaseName(tool, tool.type)),
+    });
+  }
+  return names;
+}
+
+function simplifyJsonSchemaDescriptions(schema) {
+  if (Array.isArray(schema)) return schema.map(simplifyJsonSchemaDescriptions);
+  if (!isObject(schema)) return schema;
+  const next = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === 'description' && typeof value === 'string') {
+      const description = shortenText(value, DEEPSEEK_SCHEMA_DESCRIPTION_CHARS);
+      if (description) next.description = description;
+      continue;
+    }
+    next[key] = isObject(value) || Array.isArray(value) ? simplifyJsonSchemaDescriptions(value) : value;
+  }
+  return next;
+}
+
+function readableToolName(name) {
+  return compactText(String(name || '').replace(/[_-]+/g, ' '));
+}
+
+function requiredParametersText(parameters) {
+  const required = Array.isArray(parameters?.required) ? parameters.required.filter((name) => typeof name === 'string') : [];
+  return required.length ? ` Required: ${required.join(', ')}.` : '';
+}
+
+function defaultDeepSeekToolDescription(name) {
+  const readable = readableToolName(name);
+  return compactText(`Call ${readable || name || 'this function'} when needed.`);
+}
+
+function deepSeekGatewayModelAliases(config = {}) {
+  const aliases = isObject(config.modelAliases) && Object.keys(config.modelAliases).length
+    ? config.modelAliases
+    : DEFAULT_MODEL_ALIASES;
+  const spawnConfig = { ...config, upstreamProvider: 'deepseek', modelAliases: aliases };
+  const names = [];
+  for (const name of Object.keys(aliases)) {
+    if (!name || isDeprecatedModel(name)) continue;
+    const alias = resolveModelAlias(name, spawnConfig);
+    if (isDeprecatedModel(alias.upstreamModel)) continue;
+    names.push(name);
+  }
+  return [...new Set(names)];
+}
+
+function enumStringProperty(property, values, description) {
+  const source = isObject(property) ? property : {};
+  const next = { ...source };
+  delete next.const;
+  delete next.oneOf;
+  delete next.anyOf;
+  delete next.allOf;
+  delete next.examples;
+  if (next.default !== undefined && !values.includes(next.default)) delete next.default;
+  next.type = 'string';
+  next.enum = values;
+  next.description = description;
+  return next;
+}
+
+function deepSeekSpawnAgentParameters(parameters, config = {}) {
+  const next = normalizeJsonSchemaObject(parameters);
+  const properties = isObject(next.properties) ? { ...next.properties } : {};
+  const modelAliases = deepSeekGatewayModelAliases(config);
+  properties.model = enumStringProperty(
+    properties.model,
+    modelAliases,
+    'Model for the sub-agent. Omit to inherit.',
+  );
+  properties.reasoning_effort = enumStringProperty(
+    properties.reasoning_effort,
+    CODEX_REASONING_EFFORTS,
+    'Codex reasoning effort for the sub-agent. Omit to inherit.',
+  );
+  return {
+    ...next,
+    properties,
+  };
+}
+
+function deepSeekSpawnAgentDescription() {
+  const description = [
+    'Spawn a Codex-native sub-agent.',
+    'Omit model/reasoning_effort to inherit.',
+    'Valid values are enforced by the schema.',
+  ].filter(Boolean).join(' ');
+  return shortenText(description, DEEPSEEK_TOOL_DESCRIPTION_CHARS);
+}
+
+function isCodexSpawnAgentTool(name) {
+  return name === CODEX_SPAWN_AGENT_TOOL_NAME || name === 'spawn_agent';
+}
+
+function simplifyToolForDeepSeek(tool, config = {}) {
+  if (tool?.type !== 'function' || !isObject(tool.function)) return tool;
+  const fn = tool.function;
+  let parameters = simplifyJsonSchemaDescriptions(fn.parameters);
+  if (isCodexSpawnAgentTool(fn.name)) {
+    parameters = deepSeekSpawnAgentParameters(parameters, config);
+  }
+  const requiredText = requiredParametersText(parameters);
+  const descriptionBudget = Math.max(32, DEEPSEEK_TOOL_DESCRIPTION_CHARS - requiredText.length);
+  const baseDescription = isCodexSpawnAgentTool(fn.name)
+    ? deepSeekSpawnAgentDescription()
+    : shortenText(fn.description, descriptionBudget) || defaultDeepSeekToolDescription(fn.name);
+  const description = shortenText(`${baseDescription}${requiredText}`, DEEPSEEK_TOOL_DESCRIPTION_CHARS);
+  return {
+    ...tool,
+    function: omitUndefined({
+      ...fn,
+      description,
+      parameters,
+    }),
+  };
+}
+
+function hasDeepSeekToolInstructions(messages) {
+  return messages.some((message) => message?.role === 'system' && toText(message.content).includes(DEEPSEEK_TOOL_INSTRUCTIONS_MARKER));
+}
+
+function addDeepSeekToolInstructions(messages, tools) {
+  if (!Array.isArray(tools) || !tools.length || hasDeepSeekToolInstructions(messages)) return messages;
+  if (!messages.length || messages[0]?.role !== 'system') {
+    return [{ role: 'system', content: DEEPSEEK_TOOL_INSTRUCTIONS }, ...messages];
+  }
+  return [
+    {
+      ...messages[0],
+      content: `${toText(messages[0].content)}\n\n${DEEPSEEK_TOOL_INSTRUCTIONS}`,
+    },
+    ...messages.slice(1),
+  ];
+}
+
+function adaptToolsForProvider(tools, provider, config = {}) {
+  if (provider !== 'deepseek' || !Array.isArray(tools)) return tools;
+  return tools.map((tool) => simplifyToolForDeepSeek(tool, config));
+}
+
 function normalizeToolCallArguments(name, argumentsText, toolSchema) {
   if (!argumentsText) return '';
   if (!isObject(toolSchema) || !isObject(toolSchema.properties)) return argumentsText;
@@ -503,9 +921,66 @@ function normalizeToolCallArguments(name, argumentsText, toolSchema) {
   }
 }
 
-function normalizeFunctionCallItemArguments(item, toolSchemas) {
+function normalizeReasoningEffortName(value) {
+  return value == null ? '' : String(value).toLowerCase().replaceAll('_', '-');
+}
+
+function normalizeCodexSpawnAgentArguments(encodedName, argumentsText, config = {}) {
+  if (!isCodexSpawnAgentTool(encodedName) || !argumentsText) return argumentsText;
+  let parsed;
+  try {
+    parsed = JSON.parse(argumentsText);
+  } catch {
+    return argumentsText;
+  }
+  if (!isObject(parsed)) return argumentsText;
+  const next = { ...parsed };
+  let changed = false;
+  const allowedModels = deepSeekGatewayModelAliases(config);
+
+  if (typeof next.model === 'string') {
+    const requestedModel = next.model;
+    if (allowedModels.length && !allowedModels.includes(requestedModel)) {
+      delete next.model;
+      changed = true;
+    }
+  }
+
+  if (typeof next.reasoning_effort === 'string') {
+    const requestedEffort = normalizeReasoningEffortName(next.reasoning_effort);
+    if (!CODEX_REASONING_EFFORTS.includes(requestedEffort)) {
+      delete next.reasoning_effort;
+      changed = true;
+      return JSON.stringify(next);
+    }
+  }
+
+  return changed ? JSON.stringify(next) : argumentsText;
+}
+
+function normalizeFunctionCallItemArguments(item, toolSchemas, config = {}) {
   if (!item || item.type !== 'function_call') return;
-  item.arguments = normalizeToolCallArguments(item.name, item.arguments, toolSchemas?.get(item.name));
+  const encodedName = encodeToolName(item.namespace, item.name);
+  item.arguments = normalizeToolCallArguments(encodedName, item.arguments, toolSchemas?.get(encodedName));
+  item.arguments = normalizeCodexSpawnAgentArguments(encodedName, item.arguments, config);
+}
+
+function sanitizeToolCallsForChatCompletion(toolCalls) {
+  return toolCalls.map((toolCall) => {
+    if (!isObject(toolCall)) return toolCall;
+    const fn = isObject(toolCall.function) ? toolCall.function : {};
+    const { namespace, ...functionFields } = fn;
+    const name = fn.name || toolCall.name || 'tool_call';
+    const toolCallNamespace = toolCall.namespace || namespace || '';
+    return {
+      id: toolCall.id,
+      type: toolCall.type || 'function',
+      function: {
+        ...functionFields,
+        name: encodeToolName(toolCallNamespace, name),
+      },
+    };
+  });
 }
 
 function sanitizeMessageForChatCompletion(message, provider = 'generic') {
@@ -515,7 +990,9 @@ function sanitizeMessageForChatCompletion(message, provider = 'generic') {
     content: contentToChatContent(message.content),
   };
   if (message.name !== undefined) sanitized.name = message.name;
-  if (Array.isArray(message.tool_calls)) sanitized.tool_calls = message.tool_calls;
+  if (Array.isArray(message.tool_calls)) {
+    sanitized.tool_calls = sanitizeToolCallsForChatCompletion(message.tool_calls);
+  }
   if (message.tool_call_id !== undefined) sanitized.tool_call_id = message.tool_call_id;
   if (provider === 'deepseek' && message.role === 'assistant' && typeof message.reasoning_content === 'string') {
     sanitized.reasoning_content = message.reasoning_content;
@@ -543,32 +1020,8 @@ function normalizeOutputTextPart(text, annotations = []) {
   };
 }
 
-function normalizeReasoningSummaryText(text) {
-  const value = String(text ?? '').replace(/\r\n?/g, '\n');
-  if (!value) return '';
-  const plain = value
-    .split('\n')
-    .map((line) => line
-      .replace(/^[ \t]{0,3}(?:`{3,}|~{3,}).*$/, '')
-      .replace(/^[ \t]{0,3}#{1,6}[ \t]+/, '')
-      .replace(/^[ \t]{0,3}>[ \t]?/, '')
-      .replace(/^[ \t]*[-*+][ \t]+(?:\[[ xX]\][ \t]+)?/, '\u2022 ')
-      .replace(/^[ \t]*(\d+)\.[ \t]+/, '$1) ')
-      .replace(/!\[([^\]]*)\]\([^)]+\)/g, '$1')
-      .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
-      .replace(/`([^`]*)`/g, '$1')
-      .replace(/(\*\*|__)([^*_]+)\1/g, '$2')
-      .replace(/(\*|_)([^*_]+)\1/g, '$2')
-      .replace(/[*_`~]/g, '')
-      .replace(/\\([\\`*_{}[\]()#+\-.!>])/g, '$1')
-      .trimEnd())
-    .join('\n');
-  return plain.replace(/^\n+/, '').trimEnd();
-}
-
 function reasoningSummaryText(text) {
-  const summary = normalizeReasoningSummaryText(text);
-  return summary ? `**Reasoning**\n\n${summary}` : '';
+  return reasoningDisplayText(text);
 }
 
 function normalizeSummaryTextPart(text) {
@@ -611,6 +1064,16 @@ function snapshotResponsePart(part) {
 
 function snapshotResponseItem(item) {
   if (!isObject(item)) return item;
+  if (item.type === 'tool_search_call') {
+    return omitUndefined({
+      type: item.type,
+      id: item.id,
+      call_id: item.call_id,
+      status: item.status,
+      execution: item.execution,
+      arguments: isObject(item.arguments) ? { ...item.arguments } : toolSearchArgumentsFromText(item.arguments),
+    });
+  }
   return {
     ...item,
     content: Array.isArray(item.content) ? item.content.map(snapshotResponsePart) : item.content,
@@ -676,6 +1139,7 @@ export function normalizeResponsesRequest(request) {
   const model = request.model || request.model_id || request.upstream_model || '';
   const instructions = normalizeInstructions(request.instructions);
   const responseFormat = request.response_format || request.text?.format;
+  const tools = mergeToolsWithToolSearchOutput(request.tools, request.input ?? request);
   return {
     model,
     messages,
@@ -685,7 +1149,7 @@ export function normalizeResponsesRequest(request) {
     max_tokens: request.max_output_tokens ?? request.max_tokens,
     stop: request.stop,
     stream: Boolean(request.stream),
-    tools: request.tools,
+    tools,
     tool_choice: request.tool_choice,
     parallel_tool_calls: request.parallel_tool_calls,
     presence_penalty: request.presence_penalty,
@@ -710,7 +1174,7 @@ export function toChatCompletionsRequest(normalized, overrides = {}) {
     messages.push({ role: 'system', content: normalized.instructions });
   }
   messages.push(...normalized.messages);
-  const tools = Array.isArray(normalized.tools) ? normalized.tools.map(normalizeTool).filter(Boolean) : undefined;
+  const tools = applyAllowedTools(normalizeTools(normalized.tools), normalized.tool_choice);
   const request = {
     model: overrides.model || normalized.model,
     messages,
@@ -757,16 +1221,14 @@ export function assistantMessageFromResponseOutput(output) {
     id: item.call_id || item.id,
     type: 'function',
     function: {
-      name: item.name,
+      name: encodeToolName(item.namespace, item.name),
       arguments: item.arguments || '',
     },
   }));
   if (toolCalls.length) assistant.tool_calls = toolCalls;
   const reasoningContent = reasoningItems
-    .map((item) => item.content || [])
-    .flat()
-    .filter((part) => part.type === 'reasoning_text')
-    .map((part) => part.text)
+    .map((item) => reasoningTextFromItem(item))
+    .filter(Boolean)
     .join('');
   if (reasoningContent) assistant.reasoning_content = reasoningContent;
   return assistant;
@@ -820,6 +1282,8 @@ export function toProviderChatCompletionsRequest(chatRequest, config = {}) {
   if (provider === 'deepseek') {
     delete request.reasoning_effort;
     delete request.parallel_tool_calls;
+    request.tools = adaptToolsForProvider(request.tools, provider, config);
+    request.messages = addDeepSeekToolInstructions(request.messages, request.tools);
     if (request.user !== undefined) {
       request.user_id = request.user;
       delete request.user;
@@ -949,12 +1413,13 @@ export function createResponseEnvelope({
   });
 }
 
-export function convertChatCompletionToResponses({ completion, model, previousResponseId, normalized, responseId = generateId('resp') }) {
+export function convertChatCompletionToResponses({ completion, model, previousResponseId, normalized, responseId = generateId('resp'), config = {} }) {
   const createdAt = completion.created || Date.now() / 1000;
   const choice = Array.isArray(completion.choices) ? completion.choices[0] : null;
   const message = choice?.message || {};
   const content = chatContentToResponseOutputParts(message.content);
   const toolSchemas = buildToolSchemas(normalized?.tools);
+  const toolNames = buildToolNames(normalized?.tools);
   const output = [];
 
   if (content.length || message.tool_calls?.length) {
@@ -970,27 +1435,20 @@ export function convertChatCompletionToResponses({ completion, model, previousRe
 
   if (Array.isArray(message.tool_calls)) {
     for (const toolCall of message.tool_calls) {
-      const callId = toolCall.id || generateId('call');
-      const item = {
-        type: 'function_call',
-        id: callId,
-        call_id: callId,
-        name: toolCall.function?.name,
-        arguments: toolCall.function?.arguments || '',
-        status: 'completed',
-      };
-      normalizeFunctionCallItemArguments(item, toolSchemas);
+      const item = responseItemFromChatToolCall(toolCall, toolNames);
+      normalizeFunctionCallItemArguments(item, toolSchemas, config);
       output.push(item);
     }
   }
 
   if (message.reasoning_content) {
-    const reasoningText = String(message.reasoning_content);
+    const reasoningText = normalizeReasoningContent(message.reasoning_content);
     output.unshift({
       type: 'reasoning',
       id: generateId('rs'),
       summary: [normalizeSummaryTextPart(reasoningSummaryText(reasoningText))],
-      content: [normalizeReasoningTextPart(reasoningText)],
+      content: [],
+      reasoning_content: reasoningText,
       encrypted_content: null,
       status: 'completed',
     });
@@ -1020,6 +1478,7 @@ export class ResponsesStreamMapper {
     bufferOutputUntilDone = false,
     emitReasoningSummary = true,
     emitReasoningText = false,
+    config = {},
   } = {}) {
     this.responseId = responseId;
     this.model = model;
@@ -1048,6 +1507,8 @@ export class ResponsesStreamMapper {
     this.reasoningItemAdded = false;
     this.streamedReasoningSummaryText = '';
     this.toolSchemas = buildToolSchemas(normalized?.tools);
+    this.toolNames = buildToolNames(normalized?.tools);
+    this.config = config;
   }
 
   nextSequence() {
@@ -1114,7 +1575,7 @@ export class ResponsesStreamMapper {
         type: 'reasoning',
         status: 'in_progress',
         summary: [],
-        content: [normalizeReasoningTextPart('')],
+        content: this.emitReasoningText ? [normalizeReasoningTextPart('')] : [],
         encrypted_content: null,
       };
       this.output.push(this.reasoningItem);
@@ -1133,6 +1594,7 @@ export class ResponsesStreamMapper {
 
   ensureReasoningContentPart(events) {
     if (!this.emitReasoningText || this.reasoningContentAdded || !this.reasoningItem) return;
+    if (!this.reasoningItem.content[0]) this.reasoningItem.content[0] = normalizeReasoningTextPart('');
     this.reasoningContentAdded = true;
     events.push({
       type: 'response.content_part.added',
@@ -1144,6 +1606,19 @@ export class ResponsesStreamMapper {
     });
   }
 
+  syncReasoningItemContent() {
+    if (!this.reasoningItem) return;
+    const reasoningText = normalizeReasoningContent(this.reasoningText);
+    if (this.emitReasoningText) {
+      if (!this.reasoningItem.content[0]) this.reasoningItem.content[0] = normalizeReasoningTextPart('');
+      this.reasoningItem.content[0].text = reasoningText;
+    } else {
+      this.reasoningItem.content = [];
+    }
+    if (reasoningText) this.reasoningItem.reasoning_content = reasoningText;
+    else delete this.reasoningItem.reasoning_content;
+  }
+
   appendReasoningSummaryDelta(events) {
     if (!this.emitReasoningSummary || !this.reasoningItem) return;
     if (!this.reasoningSummaryAdded) {
@@ -1234,7 +1709,7 @@ export class ResponsesStreamMapper {
       const events = [];
       const added = this.ensureReasoningItem();
       if (added) events.push(added);
-      this.reasoningItem.content[0].text = this.reasoningText;
+      this.syncReasoningItemContent();
       this.appendReasoningSummaryDelta(events);
       return events;
     }
@@ -1245,12 +1720,12 @@ export class ResponsesStreamMapper {
           type: 'reasoning',
           status: 'in_progress',
           summary: [],
-          content: [normalizeReasoningTextPart('')],
+          content: this.emitReasoningText ? [normalizeReasoningTextPart('')] : [],
           encrypted_content: null,
         };
         this.output.push(this.reasoningItem);
       }
-      this.reasoningItem.content[0].text = this.reasoningText;
+      this.syncReasoningItemContent();
       return [];
     }
 
@@ -1258,7 +1733,7 @@ export class ResponsesStreamMapper {
     const added = this.ensureReasoningItem();
     if (added) events.push(added);
     this.ensureReasoningContentPart(events);
-    this.reasoningItem.content[0].text = this.reasoningText;
+    this.syncReasoningItemContent();
     this.appendReasoningSummaryDelta(events);
     if (this.emitReasoningText) {
       events.push({
@@ -1279,18 +1754,31 @@ export class ResponsesStreamMapper {
       let item = this.toolItems.get(index);
       if (!item) {
         const callId = toolCall.id || generateId('call');
-        item = {
-          id: callId,
-          type: 'function_call',
-          status: 'in_progress',
-          call_id: callId,
-          name: toolCall.function?.name || '',
-          arguments: '',
-        };
+        item = isCodexToolSearchTool(toolCall.function?.name)
+          ? {
+              id: generateId('tsc'),
+              type: 'tool_search_call',
+              status: 'in_progress',
+              call_id: callId,
+              execution: 'client',
+              arguments: '',
+            }
+          : {
+              id: callId,
+              type: 'function_call',
+              status: 'in_progress',
+              call_id: callId,
+              ...decodedToolName(toolCall.function?.name, this.toolNames),
+              arguments: '',
+            };
         this.toolItems.set(index, item);
         this.output.push(item);
       }
-      if (toolCall.function?.name) item.name = toolCall.function.name;
+      if (isCodexToolSearchTool(toolCall.function?.name)) {
+        item = convertItemToToolSearchCall(item);
+      } else if (toolCall.function?.name && item.type !== 'tool_search_call') {
+        Object.assign(item, decodedToolName(toolCall.function.name, this.toolNames));
+      }
       item.arguments += toolCall.function?.arguments || '';
       return [];
     }
@@ -1303,14 +1791,23 @@ export class ResponsesStreamMapper {
     let item = this.toolItems.get(index);
     if (!item) {
       const callId = toolCall.id || generateId('call');
-      item = {
-        id: callId,
-        type: 'function_call',
-        status: 'in_progress',
-        call_id: callId,
-        name: toolCall.function?.name || '',
-        arguments: '',
-      };
+      item = isCodexToolSearchTool(toolCall.function?.name)
+        ? {
+            id: generateId('tsc'),
+            type: 'tool_search_call',
+            status: 'in_progress',
+            call_id: callId,
+            execution: 'client',
+            arguments: '',
+          }
+        : {
+            id: callId,
+            type: 'function_call',
+            status: 'in_progress',
+            call_id: callId,
+            ...decodedToolName(toolCall.function?.name, this.toolNames),
+            arguments: '',
+          };
       this.toolItems.set(index, item);
       this.output.push(item);
       events.push({
@@ -1320,10 +1817,14 @@ export class ResponsesStreamMapper {
         item: snapshotResponseItem(item),
       });
     }
-    if (toolCall.function?.name) item.name = toolCall.function.name;
+    if (isCodexToolSearchTool(toolCall.function?.name)) {
+      item = convertItemToToolSearchCall(item);
+    } else if (toolCall.function?.name && item.type !== 'tool_search_call') {
+      Object.assign(item, decodedToolName(toolCall.function.name, this.toolNames));
+    }
     const delta = toolCall.function?.arguments || '';
     item.arguments += delta;
-    if (delta) {
+    if (delta && item.type === 'function_call') {
       events.push({
         type: 'response.function_call_arguments.delta',
         sequence_number: this.nextSequence(),
@@ -1347,7 +1848,7 @@ export class ResponsesStreamMapper {
 
       if (this.reasoningItem) {
         this.reasoningItem.status = status;
-        this.reasoningItem.content[0].text = this.reasoningText;
+        this.syncReasoningItemContent();
       }
       if (this.messageItem) {
         this.messageItem.status = status;
@@ -1421,19 +1922,23 @@ export class ResponsesStreamMapper {
 
       for (const item of this.toolItems.values()) {
         item.status = status;
-        item.arguments = normalizeToolCallArguments(item.name, item.arguments, this.toolSchemas.get(item.name));
+        if (item.type === 'tool_search_call') finalizeToolSearchCallItemArguments(item);
+        else normalizeFunctionCallItemArguments(item, this.toolSchemas, this.config);
         const outputIndex = this.output.indexOf(item);
         events.push({
           type: 'response.output_item.added',
           sequence_number: this.nextSequence(),
           output_index: outputIndex,
-          item: snapshotResponseItem({
+          item: snapshotResponseItem(item.type === 'tool_search_call' ? {
+            ...item,
+            status: 'in_progress',
+          } : {
             ...item,
             status: 'in_progress',
             arguments: '',
           }),
         });
-        if (item.arguments) {
+        if (item.type === 'function_call' && item.arguments) {
           events.push({
             type: 'response.function_call_arguments.delta',
             sequence_number: this.nextSequence(),
@@ -1442,13 +1947,15 @@ export class ResponsesStreamMapper {
             delta: item.arguments,
           });
         }
-        events.push({
-          type: 'response.function_call_arguments.done',
-          sequence_number: this.nextSequence(),
-          output_index: outputIndex,
-          item_id: item.id,
-          arguments: item.arguments,
-        });
+        if (item.type === 'function_call') {
+          events.push({
+            type: 'response.function_call_arguments.done',
+            sequence_number: this.nextSequence(),
+            output_index: outputIndex,
+            item_id: item.id,
+            arguments: item.arguments,
+          });
+        }
         events.push({
           type: 'response.output_item.done',
           sequence_number: this.nextSequence(),
@@ -1487,7 +1994,7 @@ export class ResponsesStreamMapper {
         this.reasoningSummaryAdded = true;
         this.reasoningItem.summary.push(normalizeSummaryTextPart(reasoningSummaryText(this.reasoningText)));
       }
-      this.reasoningItem.content[0].text = this.reasoningText;
+      this.syncReasoningItemContent();
       if (this.reasoningItem.summary[0]) {
         this.reasoningItem.summary[0].text = reasoningSummaryText(this.reasoningText);
       }
@@ -1533,14 +2040,17 @@ export class ResponsesStreamMapper {
     events.push(...this.closeReasoningItem(finishReason === 'length' ? 'incomplete' : 'completed'));
     for (const item of this.toolItems.values()) {
       item.status = finishReason === 'length' ? 'incomplete' : 'completed';
-      normalizeFunctionCallItemArguments(item, this.toolSchemas);
-      events.push({
-        type: 'response.function_call_arguments.done',
-        sequence_number: this.nextSequence(),
-        output_index: this.output.indexOf(item),
-        item_id: item.id,
-        arguments: item.arguments,
-      });
+      if (item.type === 'tool_search_call') finalizeToolSearchCallItemArguments(item);
+      else normalizeFunctionCallItemArguments(item, this.toolSchemas, this.config);
+      if (item.type === 'function_call') {
+        events.push({
+          type: 'response.function_call_arguments.done',
+          sequence_number: this.nextSequence(),
+          output_index: this.output.indexOf(item),
+          item_id: item.id,
+          arguments: item.arguments,
+        });
+      }
       events.push({
         type: 'response.output_item.done',
         sequence_number: this.nextSequence(),
@@ -1587,7 +2097,7 @@ export class ResponsesStreamMapper {
           ...this.reasoningItem,
           status: 'in_progress',
           summary: [],
-          content: [normalizeReasoningTextPart('')],
+          content: this.emitReasoningText ? [normalizeReasoningTextPart('')] : [],
         }),
       });
     }
@@ -1640,7 +2150,7 @@ export class ResponsesStreamMapper {
       this.reasoningItem.summary[0].text = summaryText;
     }
     this.reasoningItem.status = status;
-    this.reasoningItem.content[0].text = this.reasoningText;
+    this.syncReasoningItemContent();
     return events;
   }
 
@@ -1648,7 +2158,7 @@ export class ResponsesStreamMapper {
     if (!this.reasoningItem || this.reasoningItemDone) return [];
     this.reasoningItemDone = true;
     this.reasoningItem.status = status;
-    this.reasoningItem.content[0].text = this.reasoningText;
+    this.syncReasoningItemContent();
     const summaryText = reasoningSummaryText(this.reasoningText);
     if (this.emitReasoningSummary && this.reasoningText && !this.reasoningSummaryAdded) {
       this.reasoningSummaryAdded = true;