codex-overleaf-link 2.0.0 → 2.1.1

package/native-host/src/anthropicMessagesBridge.js

@@ -0,0 +1,281 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const http = require('node:http');
+const {
+  buildAnthropicRequest,
+  rectifyAnthropicRequestForRetry
+} = require('./anthropicBridgeRequest');
+const {
+  convertAnthropicResponse,
+  streamAnthropicResponse
+} = require('./anthropicBridgeResponse');
+const { writeConvertedResponseAsSse } = require('./chatBridgeResponse');
+const { classifyResponsesRoute } = require('./providerBridgeRoutes');
+const { providerError } = require('./providerProfile');
+const { sanitizeProviderMessage } = require('./providerRedaction');
+
+const MAX_REQUEST_BYTES = 16 * 1024 * 1024;
+const MAX_ERROR_BYTES = 64 * 1024;
+const MAX_HISTORY_ENTRIES = 64;
+
+async function startAnthropicMessagesBridge({ launch, signal } = {}) {
+  if (!launch?.baseUrl) throw providerError('provider_base_url_invalid', 'Anthropic routing requires a provider Base URL.');
+  const clientToken = crypto.randomBytes(32).toString('base64url');
+  const activeRequests = new Set();
+  const history = new Map();
+  const server = http.createServer((req, res) => {
+    handleRequest({ req, res, launch, clientToken, activeRequests, history }).catch(error => {
+      if (res.writableEnded) return;
+      const code = normalizeBridgeErrorCode(error?.code);
+      const message = sanitizeProviderMessage(error?.message, [launch.apiKey]) || 'The Anthropic provider bridge failed.';
+      if (res.headersSent) {
+        res.end(`event: response.failed\ndata: ${JSON.stringify({
+          type: 'response.failed',
+          sequence_number: 999999,
+          response: { status: 'failed', error: { code, message } }
+        })}\n\n`);
+      } else {
+        sendJsonError(res, code === 'provider_connection_timeout' ? 504 : 502, code, message);
+      }
+    });
+  });
+  const timeoutMs = resolveTimeout(launch);
+  server.keepAliveTimeout = 5000;
+  server.requestTimeout = timeoutMs + 5000;
+  await listen(server);
+  const address = server.address();
+  let closed = false;
+  const close = async () => {
+    if (closed) return;
+    closed = true;
+    signal?.removeEventListener('abort', close);
+    for (const controller of activeRequests) controller.abort();
+    activeRequests.clear();
+    history.clear();
+    await closeServer(server);
+  };
+  signal?.addEventListener('abort', close, { once: true });
+  if (signal?.aborted) await close();
+  return { baseUrl: `http://127.0.0.1:${address.port}/v1`, clientToken, close };
+}
+
+async function handleRequest({ req, res, launch, clientToken, activeRequests, history }) {
+  if (!isAuthorized(req, clientToken)) {
+    sendJsonError(res, 401, 'unauthorized', 'Local bridge authorization failed.');
+    return;
+  }
+  const url = new URL(req.url || '/', 'http://127.0.0.1');
+  if (req.method === 'GET' && /\/models\/?$/.test(url.pathname)) {
+    sendJson(res, 200, { object: 'list', data: [{ id: launch.modelId, object: 'model', created: 0, owned_by: launch.providerName || 'anthropic' }] });
+    return;
+  }
+  const responsesRoute = classifyResponsesRoute(req.method, url.pathname);
+  if (!responsesRoute) {
+    sendJsonError(res, 404, 'not_found', 'The local Anthropic bridge only exposes Responses, Responses Compact, and Models endpoints.');
+    return;
+  }
+  const requestBody = await readJsonBody(req);
+  const previous = history.get(String(requestBody.previous_response_id || ''));
+  const translated = buildAnthropicRequest({
+    requestBody,
+    launch,
+    historyMessages: previous?.messages || []
+  });
+  const controller = new AbortController();
+  activeRequests.add(controller);
+  const onClientClose = () => {
+    if (!res.writableEnded) controller.abort();
+  };
+  req.on('aborted', onClientClose);
+  res.on('close', onClientClose);
+  const timeout = setTimeout(() => controller.abort(), resolveTimeout(launch));
+  try {
+    const upstream = await fetchWithRectification(launch, translated.body, controller.signal);
+    if (!upstream.response.ok) {
+      forwardUpstreamError(upstream.response, upstream.errorText, res, launch.apiKey);
+      return;
+    }
+    const context = {
+      launch,
+      requestBody,
+      model: translated.body.model,
+      toolContext: translated.toolContext
+    };
+    const remember = converted => rememberHistory(history, converted.response.id, [
+      ...(upstream.requestBody.messages || translated.messages),
+      { role: 'assistant', content: converted.assistantBlocks }
+    ]);
+    const contentType = String(upstream.response.headers.get('content-type') || '').toLowerCase();
+    if (requestBody.stream !== false) {
+      if (contentType.includes('text/event-stream')) {
+        await streamAnthropicResponse({ upstream: upstream.response, res, context, onComplete: remember });
+      } else {
+        const converted = convertAnthropicResponse(await upstream.response.json(), context);
+        writeConvertedResponseAsSse(res, converted, context, remember);
+      }
+    } else if (contentType.includes('text/event-stream')) {
+      let converted;
+      const sink = { writeHead() {}, write() {}, end() {} };
+      await streamAnthropicResponse({ upstream: upstream.response, res: sink, context, onComplete: value => { converted = value; } });
+      remember(converted);
+      sendJson(res, 200, converted.response);
+    } else {
+      const converted = convertAnthropicResponse(await upstream.response.json(), context);
+      remember(converted);
+      sendJson(res, 200, converted.response);
+    }
+  } catch (error) {
+    if (controller.signal.aborted) throw providerError('provider_connection_timeout', 'The provider request was cancelled or timed out.');
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+    activeRequests.delete(controller);
+    req.removeListener('aborted', onClientClose);
+    res.removeListener('close', onClientClose);
+  }
+}
+
+async function fetchWithRectification(launch, body, signal) {
+  let requestBody = body;
+  let response = await fetch(buildAnthropicMessagesUrl(launch.baseUrl, launch), {
+    method: 'POST',
+    headers: buildAnthropicHeaders(launch),
+    body: JSON.stringify(body),
+    signal
+  });
+  if (response.ok) return { response, errorText: '', requestBody };
+  let errorText = (await response.text()).slice(0, MAX_ERROR_BYTES);
+  if (response.status === 400) {
+    const retryBody = JSON.parse(JSON.stringify(body));
+    if (rectifyAnthropicRequestForRetry(retryBody, errorText)) {
+      requestBody = retryBody;
+      response = await fetch(buildAnthropicMessagesUrl(launch.baseUrl, launch), {
+        method: 'POST',
+        headers: buildAnthropicHeaders(launch),
+        body: JSON.stringify(retryBody),
+        signal
+      });
+      errorText = response.ok ? '' : (await response.text()).slice(0, MAX_ERROR_BYTES);
+    }
+  }
+  return { response, errorText, requestBody };
+}
+
+function buildAnthropicMessagesUrl(baseUrl, launch = {}) {
+  const url = new URL(baseUrl);
+  if (!launch.fullEndpoint && !/\/v1\/messages\/?$/i.test(url.pathname.replace(/\/+$/, ''))) {
+    const path = url.pathname.replace(/\/+$/, '');
+    url.pathname = /\/v1$/i.test(path)
+      ? `${path}/messages`
+      : `${!path || path === '/' ? '' : path}/v1/messages`;
+  }
+  url.hash = '';
+  for (const [key, value] of Object.entries(launch.queryParams || {})) url.searchParams.set(key, value);
+  return url.toString();
+}
+
+function buildAnthropicHeaders(launch = {}) {
+  const headers = {
+    accept: 'application/json, text/event-stream',
+    'content-type': 'application/json',
+    'user-agent': launch.impersonateClaudeCode ? 'claude-cli/2.1.0 (external, cli)' : 'Codex-Overleaf-Link/provider-bridge',
+    'anthropic-version': launch.anthropicVersion || '2023-06-01',
+    ...(launch.customHeaders || {})
+  };
+  if (launch.anthropicBeta) headers['anthropic-beta'] = launch.anthropicBeta;
+  if (launch.impersonateClaudeCode) headers['x-app'] = 'cli';
+  if (!launch.apiKey || launch.authMode === 'none') return headers;
+  if (launch.authMode === 'bearer') headers.authorization = `Bearer ${launch.apiKey}`;
+  else if (launch.authMode === 'api-key') headers['api-key'] = launch.apiKey;
+  else if (launch.authMode === 'custom' && launch.apiKeyHeaderName) headers[launch.apiKeyHeaderName] = launch.apiKey;
+  else headers['x-api-key'] = launch.apiKey;
+  return headers;
+}
+
+function forwardUpstreamError(response, errorText, res, apiKey) {
+  let message = `Provider returned HTTP ${response.status}.`;
+  try {
+    const parsed = JSON.parse(errorText || '{}');
+    message = parsed?.error?.message || parsed?.message || message;
+  } catch (_error) {}
+  sendJsonError(res, response.status, 'provider_upstream_error', sanitizeProviderMessage(message, [apiKey]));
+}
+
+function rememberHistory(history, responseId, messages) {
+  history.delete(responseId);
+  history.set(responseId, { messages });
+  while (history.size > MAX_HISTORY_ENTRIES) history.delete(history.keys().next().value);
+}
+
+function resolveTimeout(launch = {}) {
+  const configured = Math.min(300000, Math.max(5000, Number(launch.requestTimeoutMs) || 30000));
+  const thinking = !['', 'none', 'off', 'disabled'].includes(String(launch.reasoningEffort || '').toLowerCase());
+  return thinking ? Math.max(120000, configured) : configured;
+}
+
+function normalizeBridgeErrorCode(value) {
+  return ['provider_connection_timeout', 'provider_response_invalid', 'provider_request_invalid', 'provider_upstream_error'].includes(value)
+    ? value
+    : 'provider_bridge_failed';
+}
+
+function isAuthorized(req, token) {
+  const value = String(req.headers.authorization || '');
+  const supplied = value.startsWith('Bearer ') ? value.slice(7) : '';
+  const expectedBuffer = Buffer.from(token);
+  const suppliedBuffer = Buffer.from(supplied);
+  return expectedBuffer.length === suppliedBuffer.length && crypto.timingSafeEqual(expectedBuffer, suppliedBuffer);
+}
+
+function readJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let bytes = 0;
+    req.on('data', chunk => {
+      bytes += chunk.length;
+      if (bytes > MAX_REQUEST_BYTES) {
+        reject(providerError('provider_request_too_large', 'Provider request exceeded the local bridge limit.'));
+        req.destroy();
+      } else chunks.push(chunk);
+    });
+    req.on('end', () => {
+      try { resolve(JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}')); }
+      catch (_error) { reject(providerError('provider_request_invalid', 'Codex sent an invalid Responses request.')); }
+    });
+    req.on('error', reject);
+  });
+}
+
+function sendJson(res, status, value) {
+  if (res.writableEnded) return;
+  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+  res.end(JSON.stringify(value));
+}
+
+function sendJsonError(res, status, code, message) {
+  sendJson(res, status, { error: { type: 'provider_error', code, message } });
+}
+
+function listen(server) {
+  return new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      server.removeListener('error', reject);
+      resolve();
+    });
+  });
+}
+
+function closeServer(server) {
+  return new Promise(resolve => {
+    server.close(() => resolve());
+    server.closeAllConnections?.();
+  });
+}
+
+module.exports = {
+  buildAnthropicHeaders,
+  buildAnthropicMessagesUrl,
+  startAnthropicMessagesBridge
+};

package/native-host/src/chatBridgeRequest.js

@@ -0,0 +1,274 @@
+'use strict';
+
+const crypto = require('node:crypto');
+
+const {
+  applyReasoningControl,
+  requiresReasoningContentReplay,
+  resolveReasoningMaxOutputTokens,
+  supportsToolChoice
+} = require('./providerReasoning');
+
+function buildChatRequest({ requestBody = {}, launch = {}, historyMessages = [] } = {}) {
+  const messages = cloneMessages(historyMessages);
+  const instructions = normalizeText(requestBody.instructions);
+  if (instructions && !messages.some(message => message.role === 'system')) {
+    messages.unshift({ role: 'system', content: instructions });
+  }
+  const model = normalizeText(requestBody.model) || launch.modelId;
+  const replayReasoning = requiresReasoningContentReplay(launch, model);
+  const { tools, toolKinds } = translateTools(requestBody.tools);
+  appendResponsesInput(messages, requestBody.input, { replayReasoning, toolKinds });
+  const body = {
+    ...(launch.bodyOverrides || {}),
+    model,
+    messages,
+    stream: requestBody.stream !== false && launch.upstreamResponseMode !== 'buffered'
+  };
+  if (body.stream && launch.supportsStreamOptions) {
+    body.stream_options = { include_usage: true };
+  }
+  if (tools.length) {
+    body.tools = tools;
+  }
+  const toolChoice = translateToolChoice(requestBody.tool_choice, toolKinds);
+  if (toolChoice && supportsToolChoice(launch, model)) body.tool_choice = toolChoice;
+  copyNumber(requestBody, body, 'temperature');
+  copyNumber(requestBody, body, 'top_p');
+  const maxOutputTokens = resolveReasoningMaxOutputTokens(
+    requestBody.max_output_tokens ?? launch.maxOutputTokens,
+    requestBody,
+    launch,
+    model
+  );
+  if (Number.isFinite(Number(maxOutputTokens))) {
+    body.max_tokens = Math.max(1, Math.floor(Number(maxOutputTokens)));
+  }
+  if (launch.supportsParallelToolCalls && typeof requestBody.parallel_tool_calls === 'boolean') {
+    body.parallel_tool_calls = requestBody.parallel_tool_calls;
+  }
+  applyReasoningControl(body, requestBody, launch);
+  return { body, messages, toolKinds };
+}
+
+function appendResponsesInput(messages, input, { replayReasoning = false, toolKinds = new Map() } = {}) {
+  if (typeof input === 'string') {
+    if (input) messages.push({ role: 'user', content: input });
+    return;
+  }
+  if (!Array.isArray(input)) return;
+  let pendingToolCalls = [];
+  let pendingReasoning = '';
+  const flushToolCalls = () => {
+    if (!pendingToolCalls.length) return;
+    const assistant = {
+      role: 'assistant',
+      content: replayReasoning ? '' : null,
+      tool_calls: pendingToolCalls
+    };
+    if (replayReasoning) assistant.reasoning_content = pendingReasoning || ' ';
+    messages.push(assistant);
+    pendingToolCalls = [];
+    pendingReasoning = '';
+  };
+  for (const item of input) {
+    if (!item || typeof item !== 'object') continue;
+    if (item.type === 'reasoning') {
+      flushToolCalls();
+      pendingReasoning = extractReasoningText(item);
+      continue;
+    }
+    if (item.type === 'function_call' || item.type === 'custom_tool_call' || item.type === 'tool_search_call') {
+      pendingToolCalls.push(toChatToolCall(item, toolKinds));
+      continue;
+    }
+    flushToolCalls();
+    if (item.type === 'function_call_output' || item.type === 'custom_tool_call_output' || item.type === 'computer_call_output' || item.type === 'tool_search_output') {
+      messages.push({
+        role: 'tool',
+        tool_call_id: normalizeText(item.call_id) || normalizeText(item.id),
+        content: normalizeToolOutput(item.output)
+      });
+      continue;
+    }
+    if (item.type === 'message' || item.role) {
+      const role = normalizeRole(item.role);
+      const content = translateMessageContent(item.content);
+      if (content !== '' && content !== null) {
+        const message = { role, content };
+        if (role === 'assistant' && replayReasoning && pendingReasoning) {
+          message.reasoning_content = pendingReasoning;
+        }
+        messages.push(message);
+      }
+      pendingReasoning = '';
+    }
+  }
+  flushToolCalls();
+}
+
+function extractReasoningText(item) {
+  const direct = normalizeText(item.reasoning_content || item.reasoning || item.content);
+  if (direct) return direct;
+  return (Array.isArray(item.summary) ? item.summary : [])
+    .map(part => normalizeText(part?.text || part?.content))
+    .filter(Boolean)
+    .join('\n');
+}
+
+function toChatToolCall(item, toolKinds) {
+  const spec = findToolSpec(toolKinds, item);
+  const isCustom = item.type === 'custom_tool_call' || spec?.kind === 'custom';
+  const rawArguments = isCustom
+    ? JSON.stringify({ input: normalizeText(item.input) })
+    : normalizeArguments(item.arguments);
+  return {
+    id: normalizeText(item.call_id) || normalizeText(item.id),
+    type: 'function',
+    function: {
+      name: spec?.chatName || normalizeText(item.name),
+      arguments: rawArguments
+    }
+  };
+}
+
+function translateMessageContent(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return normalizeToolOutput(content);
+  const parts = [];
+  let hasStructuredPart = false;
+  for (const part of content) {
+    if (!part || typeof part !== 'object') continue;
+    if (part.type === 'input_text' || part.type === 'output_text' || part.type === 'text') {
+      parts.push({ type: 'text', text: normalizeText(part.text) });
+    } else if (part.type === 'input_image' || part.type === 'image_url') {
+      const url = normalizeText(part.image_url?.url || part.image_url || part.url);
+      if (url) {
+        hasStructuredPart = true;
+        parts.push({ type: 'image_url', image_url: { url } });
+      }
+    }
+  }
+  if (!parts.length) return '';
+  if (!hasStructuredPart) return parts.map(part => part.text).join('');
+  return parts;
+}
+
+function translateTools(values) {
+  const tools = [];
+  const toolKinds = new Map();
+  for (const value of Array.isArray(values) ? values : []) {
+    if (value?.type === 'namespace' && Array.isArray(value.tools)) {
+      for (const child of value.tools) {
+        addTool(tools, toolKinds, child, normalizeText(value.name));
+      }
+      continue;
+    }
+    addTool(tools, toolKinds, value, '');
+  }
+  return { tools, toolKinds };
+}
+
+function addTool(tools, toolKinds, value, namespace) {
+    const originalName = normalizeText(value?.name || value?.function?.name)
+      || (value?.type === 'tool_search' ? 'tool_search' : '');
+    if (!originalName) return;
+    const kind = value.type === 'custom'
+      ? 'custom'
+      : value.type === 'tool_search'
+        ? 'tool_search'
+        : 'function';
+    const chatName = uniqueChatToolName(namespace, originalName, toolKinds);
+    const spec = { kind, name: originalName, namespace, chatName };
+    toolKinds.set(chatName, spec);
+    tools.push({
+      type: 'function',
+      function: {
+        name: chatName,
+        description: normalizeText(value.description || value.function?.description),
+        parameters: kind === 'custom'
+          ? {
+              type: 'object',
+              properties: { input: { type: 'string' } },
+              required: ['input'],
+              additionalProperties: false
+            }
+          : kind === 'tool_search'
+            ? {
+                type: 'object',
+                properties: { query: { type: 'string' } },
+                required: ['query'],
+                additionalProperties: false
+              }
+            : normalizeParameters(value.parameters || value.function?.parameters)
+      }
+    });
+}
+
+function translateToolChoice(value, toolKinds) {
+  if (value === 'auto' || value === 'required' || value === 'none') return value;
+  const name = normalizeText(value?.name || value?.function?.name);
+  const spec = name ? findToolSpec(toolKinds, { name, namespace: value?.namespace }) : null;
+  return name ? { type: 'function', function: { name: spec?.chatName || name } } : '';
+}
+
+function findToolSpec(toolKinds, item) {
+  const name = normalizeText(item?.name || item?.function?.name);
+  const namespace = normalizeText(item?.namespace);
+  for (const spec of toolKinds?.values?.() || []) {
+    if (typeof spec === 'object' && spec.name === name && (!namespace || spec.namespace === namespace)) {
+      return spec;
+    }
+  }
+  return null;
+}
+
+function uniqueChatToolName(namespace, name, toolKinds) {
+  const raw = [namespace, name].filter(Boolean).join('__').replace(/[^A-Za-z0-9_-]/g, '_');
+  const base = raw.length <= 64
+    ? raw
+    : `${raw.slice(0, 51)}_${crypto.createHash('sha256').update(raw).digest('hex').slice(0, 12)}`;
+  if (!toolKinds.has(base)) return base;
+  const suffix = crypto.createHash('sha256').update(`${namespace}\0${name}`).digest('hex').slice(0, 8);
+  return `${base.slice(0, 55)}_${suffix}`;
+}
+
+function normalizeParameters(value) {
+  return value && typeof value === 'object'
+    ? value
+    : { type: 'object', properties: {}, additionalProperties: true };
+}
+
+function normalizeArguments(value) {
+  if (typeof value === 'string') return value;
+  if (value === undefined || value === null) return '{}';
+  try { return JSON.stringify(value); } catch (_error) { return '{}'; }
+}
+
+function normalizeToolOutput(value) {
+  if (typeof value === 'string') return value;
+  if (value === undefined || value === null) return '';
+  try { return JSON.stringify(value); } catch (_error) { return String(value); }
+}
+
+function normalizeRole(value) {
+  const role = normalizeText(value).toLowerCase();
+  if (role === 'assistant' || role === 'tool' || role === 'system') return role;
+  if (role === 'developer') return 'system';
+  return 'user';
+}
+
+function cloneMessages(messages) {
+  try { return JSON.parse(JSON.stringify(Array.isArray(messages) ? messages : [])); } catch (_error) { return []; }
+}
+
+function copyNumber(source, target, key) {
+  const value = Number(source?.[key]);
+  if (Number.isFinite(value)) target[key] = value;
+}
+
+function normalizeText(value) {
+  return typeof value === 'string' ? value : '';
+}
+
+module.exports = { buildChatRequest };