@galaxy-yearn/codex-deepseek-gateway 0.1.0

package/src/codex-config.js

@@ -0,0 +1,83 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+function unquoteTomlString(value) {
+  const trimmed = String(value || '').trim();
+  if (
+    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+    (trimmed.startsWith("'") && trimmed.endsWith("'"))
+  ) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+
+function stripInlineTomlComment(value) {
+  let quote = '';
+  let escaped = false;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (quote) {
+      if (quote === '"' && char === '\\' && !escaped) {
+        escaped = true;
+        continue;
+      }
+      if (char === quote && !escaped) {
+        quote = '';
+      }
+      escaped = false;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      escaped = false;
+      continue;
+    }
+    if (char === '#' && (index === 0 || /\s/.test(value[index - 1]))) {
+      return value.slice(0, index).trimEnd();
+    }
+  }
+  return value.trimEnd();
+}
+
+function defaultCodexConfigPath(env = process.env) {
+  if (env.CODEX_CONFIG_FILE) return resolve(env.CODEX_CONFIG_FILE);
+  const home = env.CODEX_HOME || join(env.USERPROFILE || env.HOME || '', '.codex');
+  return join(home, 'config.toml');
+}
+
+export function readCodexConfig(env = process.env) {
+  const filePath = defaultCodexConfigPath(env);
+  const result = {
+    modelProvider: '',
+    model: '',
+    modelReasoningEffort: '',
+    modelReasoningSummary: '',
+    modelSupportsReasoningSummaries: '',
+    hideAgentReasoning: '',
+  };
+  if (!filePath || !existsSync(filePath)) return result;
+
+  const text = readFileSync(filePath, 'utf8');
+  let inTopLevel = true;
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    if (line.startsWith('[')) {
+      inTopLevel = false;
+      continue;
+    }
+    if (!inTopLevel) continue;
+    const match = line.match(/^([A-Za-z0-9_.-]+)\s*=\s*(.+)$/);
+    if (!match) continue;
+    const [, key, rawValue] = match;
+    const value = unquoteTomlString(stripInlineTomlComment(rawValue));
+    if (key === 'model_provider') result.modelProvider = value;
+    if (key === 'model') result.model = value;
+    if (key === 'model_reasoning_effort') result.modelReasoningEffort = value;
+    if (key === 'model_reasoning_summary') result.modelReasoningSummary = value;
+    if (key === 'model_supports_reasoning_summaries') result.modelSupportsReasoningSummaries = value;
+    if (key === 'hide_agent_reasoning') result.hideAgentReasoning = value;
+  }
+  return result;
+}

package/src/common.js

@@ -0,0 +1,141 @@
+import { randomUUID } from 'node:crypto';
+
+export function isObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+export function generateId(prefix) {
+  return `${prefix}_${randomUUID().replaceAll('-', '')}`;
+}
+
+export function normalizeRole(role, provider = 'generic') {
+  if (role === 'developer') return 'system';
+  return role || 'user';
+}
+
+export function toText(content) {
+  if (content == null) return '';
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === 'string') return part;
+        if (!isObject(part)) return '';
+        if (part.type === 'input_text' || part.type === 'output_text' || part.type === 'text') {
+          return String(part.text ?? part.content ?? '');
+        }
+        if (typeof part.text === 'string') return part.text;
+        if (part.type === 'message') return toText(part.content);
+        return '';
+      })
+      .filter(Boolean)
+      .join('');
+  }
+  if (isObject(content)) {
+    if (content.type === 'message') return toText(content.content);
+    if (content.type === 'input_text' || content.type === 'output_text' || content.type === 'text') {
+      return String(content.text ?? content.content ?? '');
+    }
+    if (typeof content.text === 'string') return content.text;
+  }
+  return '';
+}
+
+export function parseBoolean(value, defaultValue = false) {
+  if (value == null || value === '') return defaultValue;
+  if (typeof value === 'boolean') return value;
+  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 defaultValue;
+}
+
+export function parseList(value) {
+  if (Array.isArray(value)) return value.map((item) => String(item).trim()).filter(Boolean);
+  if (value == null || value === '') return [];
+  return String(value)
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+export function mapDeepSeekReasoningEffort(effort) {
+  if (!effort) return undefined;
+  const normalized = String(effort).toLowerCase().replaceAll('_', '-');
+  if (normalized === 'low') return undefined;
+  if (normalized === 'none' || normalized === 'disabled' || normalized === 'off') return undefined;
+  if (normalized === 'xhigh' || normalized === 'max') return 'max';
+  if (normalized === 'medium' || normalized === 'high') return 'high';
+  return normalized;
+}
+
+export function joinUrl(baseUrl, path) {
+  const base = String(baseUrl || '').replace(/\/+$/, '');
+  const suffix = String(path || '').startsWith('/') ? String(path || '') : `/${String(path || '')}`;
+  return `${base}${suffix}`;
+}
+
+export class SseParser {
+  constructor() {
+    this.decoder = new TextDecoder();
+    this.buffer = '';
+  }
+
+  push(chunk) {
+    this.buffer += this.decoder.decode(chunk, { stream: true });
+    this.buffer = this.buffer.replace(/\r\n/g, '\n');
+    return this.drain(false);
+  }
+
+  end() {
+    this.buffer += this.decoder.decode();
+    this.buffer = this.buffer.replace(/\r\n/g, '\n');
+    return this.drain(true);
+  }
+
+  drain(flush) {
+    const events = [];
+    while (true) {
+      const boundary = this.buffer.indexOf('\n\n');
+      if (boundary < 0) break;
+      const frame = this.buffer.slice(0, boundary);
+      this.buffer = this.buffer.slice(boundary + 2);
+      const parsed = this.parseFrame(frame);
+      if (parsed) events.push(parsed);
+    }
+    if (flush && this.buffer.trim()) {
+      const parsed = this.parseFrame(this.buffer);
+      if (parsed) events.push(parsed);
+      this.buffer = '';
+    }
+    return events;
+  }
+
+  parseFrame(frame) {
+    const lines = String(frame).replace(/\r\n/g, '\n').split('\n');
+    let event = 'message';
+    const dataLines = [];
+    for (const line of lines) {
+      if (!line) continue;
+      if (line.startsWith('event:')) {
+        event = line.slice(6).trim();
+        continue;
+      }
+      if (line.startsWith('data:')) {
+        dataLines.push(line.slice(5).replace(/^\s/, ''));
+      }
+    }
+    if (dataLines.length === 0) return null;
+    const data = dataLines.join('\n');
+    if (data === '[DONE]') return { done: true };
+    return { event, data };
+  }
+}
+
+export function safeJsonParse(text) {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch (error) {
+    return { ok: false, error };
+  }
+}

package/src/config.js

@@ -0,0 +1,31 @@
+import { loadModelAliases } from './model-map.js';
+import { mergeLocalConfig } from './local-config.js';
+import { parseBoolean, parseList } from './common.js';
+import { readCodexConfig } from './codex-config.js';
+
+export function loadConfig(env = process.env) {
+  const mergedEnv = mergeLocalConfig(env);
+  const codexConfig = readCodexConfig(mergedEnv);
+  return {
+    port: Number(mergedEnv.PORT || 3000),
+    host: mergedEnv.HOST || '127.0.0.1',
+    upstreamBaseUrl: mergedEnv.UPSTREAM_BASE_URL || 'https://api.deepseek.com',
+    upstreamApiKey: mergedEnv.UPSTREAM_API_KEY || mergedEnv.DEEPSEEK_API_KEY || '',
+    upstreamModel: mergedEnv.UPSTREAM_MODEL || '',
+    upstreamProvider: mergedEnv.UPSTREAM_PROVIDER || 'deepseek',
+    upstreamTimeoutMs: Number(mergedEnv.UPSTREAM_TIMEOUT_MS || 120000),
+    upstreamModels: parseList(mergedEnv.UPSTREAM_MODELS || mergedEnv.MODELS),
+    fetchUpstreamModels: parseBoolean(mergedEnv.FETCH_UPSTREAM_MODELS, false),
+    modelsTimeoutMs: Number(mergedEnv.MODELS_TIMEOUT_MS || 5000),
+    modelsCacheMs: Number(mergedEnv.MODELS_CACHE_MS || 60000),
+    proxyApiKey: mergedEnv.PROXY_API_KEY || '',
+    debugPayload: parseBoolean(mergedEnv.DEBUG_PAYLOAD || mergedEnv.DEBUG_DEEPSEEK_PAYLOAD, false),
+    codexModelProvider: codexConfig.modelProvider,
+    codexModel: codexConfig.model,
+    codexReasoningEffort: mergedEnv.CODEX_REASONING_EFFORT || mergedEnv.MODEL_REASONING_EFFORT || codexConfig.modelReasoningEffort,
+    codexReasoningSummary: codexConfig.modelReasoningSummary,
+    codexModelSupportsReasoningSummaries: codexConfig.modelSupportsReasoningSummaries,
+    codexHideAgentReasoning: codexConfig.hideAgentReasoning,
+    modelAliases: loadModelAliases(mergedEnv),
+  };
+}

package/src/local-config.js

@@ -0,0 +1,51 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { isObject, safeJsonParse } from './common.js';
+
+const PROJECT_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+function normalizeEnvName(key) {
+  return String(key)
+    .replace(/[A-Z]/g, (letter) => `_${letter}`)
+    .replace(/[-.\s]+/g, '_')
+    .replace(/^_+/, '')
+    .toUpperCase();
+}
+
+function flattenConfig(value, prefix = '') {
+  const entries = {};
+  if (!isObject(value)) return entries;
+  for (const [key, child] of Object.entries(value)) {
+    const childKey = prefix ? `${prefix}_${normalizeEnvName(key)}` : normalizeEnvName(key);
+    if (isObject(child)) {
+      Object.assign(entries, flattenConfig(child, childKey));
+    } else if (child !== undefined && child !== null) {
+      entries[childKey] = String(child);
+    }
+  }
+  return entries;
+}
+
+export function readLocalConfigFile(path = resolve(PROJECT_ROOT, 'config', 'gateway.local.json')) {
+  if (!path || !existsSync(path)) return {};
+  const parsed = safeJsonParse(readFileSync(path, 'utf8'));
+  if (!parsed.ok || !isObject(parsed.value)) {
+    throw new Error(`${path} must contain a JSON object`);
+  }
+  return flattenConfig(parsed.value);
+}
+
+export function mergeLocalConfig(env = process.env, cwd = PROJECT_ROOT) {
+  const configPath = env.GATEWAY_CONFIG_FILE
+    ? resolve(cwd, env.GATEWAY_CONFIG_FILE)
+    : resolve(cwd, 'config', 'gateway.local.json');
+  const fileConfig = readLocalConfigFile(configPath);
+  if (fileConfig.UPSTREAM_API_KEY === 'sk-REPLACE_ME') {
+    delete fileConfig.UPSTREAM_API_KEY;
+  }
+  return {
+    ...fileConfig,
+    ...env,
+  };
+}

package/src/model-map.js

@@ -0,0 +1,152 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { isObject, mapDeepSeekReasoningEffort } from './common.js';
+
+const DEEPSEEK_V4_MODELS = ['deepseek-v4-flash', 'deepseek-v4-pro'];
+const DEPRECATED_MODEL_PATTERN = /^deepseek-(?:chat|reasoner)$/;
+
+function deepseekV4Aliases() {
+  const aliases = {};
+  for (const model of DEEPSEEK_V4_MODELS) {
+    aliases[model] = { model, thinking: 'auto' };
+  }
+  return aliases;
+}
+
+export const DEFAULT_MODEL_ALIASES = deepseekV4Aliases();
+
+function parseJsonObject(value, source) {
+  if (!value) return {};
+  const parsed = JSON.parse(value);
+  if (!isObject(parsed)) {
+    throw new Error(`${source} must be a JSON object`);
+  }
+  return parsed;
+}
+
+function readJsonFile(filePath) {
+  if (!filePath || !existsSync(filePath)) return {};
+  return parseJsonObject(readFileSync(filePath, 'utf8'), filePath);
+}
+
+export function loadModelAliases(env = process.env, cwd = process.cwd()) {
+  const defaultFile = resolve(cwd, 'config', 'model-aliases.json');
+  const filePath = env.MODEL_ALIASES_FILE ? resolve(cwd, env.MODEL_ALIASES_FILE) : defaultFile;
+  const fileAliases = readJsonFile(filePath);
+  const envAliases = parseJsonObject(env.MODEL_ALIASES_JSON, 'MODEL_ALIASES_JSON');
+  return {
+    ...DEFAULT_MODEL_ALIASES,
+    ...fileAliases,
+    ...envAliases,
+  };
+}
+
+function normalizeThinking(value) {
+  if (value === true) return 'enabled';
+  if (value === false) return 'disabled';
+  if (value == null) return 'auto';
+  const normalized = String(value).toLowerCase().replaceAll('_', '-');
+  if (normalized === 'on' || normalized === 'true' || normalized === 'yes') return 'enabled';
+  if (normalized === 'off' || normalized === 'false' || normalized === 'no') return 'disabled';
+  if (normalized === 'non-thinking' || normalized === 'no-thinking') return 'disabled';
+  if (normalized === 'thinking') return 'enabled';
+  return normalized;
+}
+
+function normalizeAlias(alias, aliasName) {
+  if (typeof alias === 'string') return { alias: aliasName, upstreamModel: alias, thinking: 'auto', extraBody: {} };
+  if (!isObject(alias)) return null;
+  return {
+    alias: aliasName,
+    upstreamModel: alias.upstreamModel || alias.upstream_model || alias.model || aliasName,
+    thinking: normalizeThinking(alias.thinking ?? alias.thinking_mode ?? alias.thinkingMode),
+    reasoningEffort: alias.reasoning_effort ?? alias.reasoningEffort ?? alias.effort,
+    extraBody: isObject(alias.extra_body) ? alias.extra_body : isObject(alias.extraBody) ? alias.extraBody : {},
+  };
+}
+
+export function resolveModelAlias(requestedModel, config = {}) {
+  const model = requestedModel || config.upstreamModel || '';
+  const aliases = isObject(config.modelAliases) ? config.modelAliases : {};
+  const alias = normalizeAlias(aliases[model], model);
+  if (alias) return alias;
+  return {
+    alias: model,
+    upstreamModel: config.upstreamModel || model,
+    thinking: 'auto',
+    reasoningEffort: undefined,
+    extraBody: {},
+  };
+}
+
+function effortDisablesThinking(effort) {
+  if (effort == null) return false;
+  const normalized = String(effort).toLowerCase().replaceAll('_', '-');
+  return normalized === 'low' || normalized === 'none' || normalized === 'disabled' || normalized === 'off' || normalized === 'false';
+}
+
+export function deepseekReasoningPayload({ alias, reasoning } = {}) {
+  const requestEffort = isObject(reasoning) ? reasoning.effort : undefined;
+  const aliasThinking = normalizeThinking(alias?.thinking);
+  const aliasEffort = alias?.reasoningEffort;
+
+  if (aliasThinking === 'disabled' || (aliasThinking === 'auto' && effortDisablesThinking(requestEffort))) {
+    return { thinking: { type: 'disabled' } };
+  }
+
+  const payload = {};
+  const effort = aliasEffort ?? (effortDisablesThinking(requestEffort) ? undefined : requestEffort);
+  if (aliasThinking === 'enabled' || effort) {
+    payload.thinking = { type: 'enabled' };
+  }
+  if (effort) {
+    const reasoningEffort = mapDeepSeekReasoningEffort(effort);
+    if (reasoningEffort) payload.reasoning_effort = reasoningEffort;
+  }
+  return payload;
+}
+
+export function listModels(config = {}) {
+  const aliases = isObject(config.modelAliases) ? config.modelAliases : {};
+  const configuredModels = Array.isArray(config.upstreamModels) ? config.upstreamModels : [];
+  return [...new Set([...Object.keys(aliases), ...configuredModels])]
+    .filter((id) => id && !isDeprecatedModel(id))
+    .sort()
+    .map((id) => ({
+      id,
+      object: 'model',
+      created: 0,
+      owned_by: config.upstreamProvider || 'gateway',
+    }));
+}
+
+export function isDeprecatedModel(model) {
+  return DEPRECATED_MODEL_PATTERN.test(String(model || '').trim());
+}
+
+export function normalizeModelList(payload, config = {}) {
+  const source = Array.isArray(payload?.data) ? payload.data : Array.isArray(payload) ? payload : [];
+  return source
+    .map((item) => {
+      if (typeof item === 'string') return { id: item, object: 'model', created: 0 };
+      if (!isObject(item) || !item.id) return null;
+      return {
+        ...item,
+        object: item.object || 'model',
+        owned_by: item.owned_by || config.upstreamProvider || 'gateway',
+      };
+    })
+    .filter((item) => item?.id && !isDeprecatedModel(item.id));
+}
+
+export function mergeModelLists(...lists) {
+  const byId = new Map();
+  for (const list of lists) {
+    for (const model of Array.isArray(list) ? list : []) {
+      if (model?.id && !isDeprecatedModel(model.id) && !byId.has(model.id)) {
+        byId.set(model.id, model);
+      }
+    }
+  }
+  return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+}