@galaxy-yearn/codex-deepseek-gateway 0.1.7 → 0.2.1

package/src/codex-sessions.js

@@ -21,12 +21,16 @@ import {
   withPickerScreen,
 } from './codex-launch.js';
 
-const TIME_WIDTH = 10;
+const TIME_WIDTH = 11;
 const PROVIDER_WIDTH = 17;
-const ID_WIDTH = 36;
-const TITLE_WIDTH = 16;
+const TITLE_WIDTH = 32;
 const TABLE_INDENT = '    ';
 const COLUMN_GAP = '  ';
+const MUTED_TEXT = '\x1b[90m';
+const RESET_STYLE = '\x1b[0m';
+const GRAPHEME_SEGMENTER = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+const EXTENDED_PICTOGRAPHIC = /\p{Extended_Pictographic}/u;
+const MARK = /\p{Mark}/u;
 export const DEFAULT_SESSION_LIMIT = 15;
 
 function print(message = '') {
@@ -136,12 +140,60 @@ function firstUserPreview(lines) {
   return '';
 }
 
+function isWideCodePoint(codePoint) {
+  return codePoint >= 0x1100 && (
+    codePoint <= 0x115f
+    || codePoint === 0x2329
+    || codePoint === 0x232a
+    || (codePoint >= 0x2e80 && codePoint <= 0x303e)
+    || (codePoint >= 0x3040 && codePoint <= 0xa4cf)
+    || (codePoint >= 0xac00 && codePoint <= 0xd7a3)
+    || (codePoint >= 0xf900 && codePoint <= 0xfaff)
+    || (codePoint >= 0xfe10 && codePoint <= 0xfe19)
+    || (codePoint >= 0xfe30 && codePoint <= 0xfe6f)
+    || (codePoint >= 0xff00 && codePoint <= 0xff60)
+    || (codePoint >= 0xffe0 && codePoint <= 0xffe6)
+    || (codePoint >= 0x1b000 && codePoint <= 0x1b2ff)
+    || (codePoint >= 0x1f1e6 && codePoint <= 0x1f1ff)
+    || (codePoint >= 0x1f200 && codePoint <= 0x1f251)
+    || (codePoint >= 0x20000 && codePoint <= 0x3fffd)
+  );
+}
+
+function graphemeWidth(grapheme) {
+  const characters = [...grapheme];
+  const visible = characters.filter((character) => {
+    const codePoint = character.codePointAt(0);
+    return codePoint !== 0x200d && codePoint !== 0xfe0e && codePoint !== 0xfe0f && !MARK.test(character);
+  });
+  if (!visible.length) return 0;
+  return characters.some((character) => isWideCodePoint(character.codePointAt(0)) || EXTENDED_PICTOGRAPHIC.test(character)) ? 2 : 1;
+}
+
+function displayWidth(text) {
+  let width = 0;
+  for (const { segment } of GRAPHEME_SEGMENTER.segment(String(text))) width += graphemeWidth(segment);
+  return width;
+}
+
 function truncate(text, max) {
-  return text.length > max ? `${text.slice(0, max - 1)}...` : text;
+  const value = String(text);
+  if (displayWidth(value) <= max) return value;
+  const contentWidth = max - 3;
+  let result = '';
+  let width = 0;
+  for (const { segment } of GRAPHEME_SEGMENTER.segment(value)) {
+    const nextWidth = graphemeWidth(segment);
+    if (width + nextWidth > contentWidth) break;
+    result += segment;
+    width += nextWidth;
+  }
+  return `${result}...`;
 }
 
 function pad(text, width) {
-  return truncate(String(text || ''), width).padEnd(width, ' ');
+  const value = truncate(String(text || ''), width);
+  return `${value}${' '.repeat(width - displayWidth(value))}`;
 }
 
 function formatTime(value) {
@@ -190,11 +242,14 @@ function printSessions(sessionsList, options, context) {
   print(`Codex sessions ${options.all ? `under ${context.codexHome}` : `for project ${context.projectRoot}`}\n`);
   print(`Target: ${context.provider} / ${context.model} / ${context.reasoningEffort}\n\n`);
   if (!listed.length) {
-    print('No matching sessions found.\n');
+    print('  No matching sessions found.\n');
     return;
   }
-  print(`${TABLE_INDENT}${sessionHeader()}\n`);
-  print(`${TABLE_INDENT}${'-'.repeat(sessionHeader().length)}\n`);
+  const header = sessionHeader();
+  const divider = '─'.repeat(displayWidth(header));
+  const styledDivider = process.stdout.isTTY ? `${MUTED_TEXT}${divider}${RESET_STYLE}` : divider;
+  print(`${TABLE_INDENT}${header}\n`);
+  print(`${TABLE_INDENT}${styledDivider}\n`);
   listed.forEach((session, index) => {
     print(`${String(index + 1).padStart(2, ' ')}  ${sessionRow(session)}\n`);
     if (options.all) print(`    cwd: ${session.cwd || '(unknown cwd)'}\n`);
@@ -204,11 +259,11 @@ function printSessions(sessionsList, options, context) {
 }
 
 function sessionHeader() {
-  return `${pad('Date', TIME_WIDTH)}${COLUMN_GAP}${pad('Provider', PROVIDER_WIDTH)}${COLUMN_GAP}${pad('Session ID', ID_WIDTH)}${COLUMN_GAP}Title`;
+  return `${pad('Date', TIME_WIDTH)}${COLUMN_GAP}${pad('Provider', PROVIDER_WIDTH)}${COLUMN_GAP}${pad('Title', TITLE_WIDTH)}`;
 }
 
 function sessionRow(session) {
-  return `${pad(formatTime(session.updatedAt), TIME_WIDTH)}${COLUMN_GAP}${pad(session.provider || '(unknown)', PROVIDER_WIDTH)}${COLUMN_GAP}${session.id}${COLUMN_GAP}${truncate(session.title, TITLE_WIDTH)}`;
+  return `${pad(formatTime(session.updatedAt), TIME_WIDTH)}${COLUMN_GAP}${pad(session.provider || '(unknown)', PROVIDER_WIDTH)}${COLUMN_GAP}${pad(session.title, TITLE_WIDTH)}`;
 }
 
 function sessionRows(sessionsList) {
@@ -238,7 +293,7 @@ async function chooseSessionFlow(allSessions, context, limit) {
           {
             windowSize,
             emptyMessage: 'No matching sessions found.',
-            shortcuts: [{ key: 'n', action: 'new', label: 'N new' }],
+            shortcuts: [{ key: 'n', displayKey: 'N', action: 'new', label: 'new' }],
           },
         );
         if (result.action === 'cancel') return null;
@@ -247,8 +302,9 @@ async function chooseSessionFlow(allSessions, context, limit) {
         step = 'model';
       } else if (step === 'model') {
         const action = await pickModel(context);
-        if (action !== 'select') return null;
-        step = 'reasoning';
+        if (action === 'cancel') return null;
+        if (action === 'back') step = 'session';
+        else step = 'reasoning';
       } else if (step === 'reasoning') {
         const action = await pickReasoning(context);
         if (action === 'cancel') return null;

package/src/common.js

@@ -9,7 +9,7 @@ export function generateId(prefix) {
 }
 
 export function normalizeRole(role, provider = 'generic') {
-  if (role === 'developer') return 'system';
+  if (provider === 'deepseek' && role === 'developer') return 'system';
   return role || 'user';
 }
 
@@ -63,10 +63,10 @@ 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 === 'none' || normalized === 'disabled' || normalized === 'off' || normalized === 'false') return undefined;
   if (normalized === 'xhigh' || normalized === 'max') return 'max';
   if (normalized === 'medium' || normalized === 'high') return 'high';
-  return normalized;
+  return undefined;
 }
 
 export function joinUrl(baseUrl, path) {
@@ -139,3 +139,18 @@ export function safeJsonParse(text) {
     return { ok: false, error };
   }
 }
+
+export function parseJsonObject(value, { source = 'JSON value', throwOnInvalid = false } = {}) {
+  if (isObject(value)) return value;
+  if (!value || typeof value !== 'string') {
+    if (throwOnInvalid && value) throw new Error(`${source} must be a JSON object`);
+    return {};
+  }
+  const parsed = safeJsonParse(value);
+  if (parsed.ok && isObject(parsed.value)) return parsed.value;
+  if (throwOnInvalid) {
+    if (parsed.ok) throw new Error(`${source} must be a JSON object`);
+    throw parsed.error;
+  }
+  return {};
+}

package/src/config.js

@@ -1,3 +1,4 @@
+import { dirname, resolve } from 'node:path';
 import { loadModelAliases } from './model-map.js';
 import { mergeLocalConfig, readLocalConfigFile, resolveLocalConfigPath } from './local-config.js';
 import { parseBoolean, parseList } from './common.js';
@@ -5,8 +6,10 @@ import { readCodexConfig } from './codex-config.js';
 import { normalizePromptLanguage } from './prompt-language.js';
 
 export function loadConfig(env = process.env) {
+  const localConfigPath = resolveLocalConfigPath(env);
+  const stateDir = resolve(dirname(localConfigPath), '..', 'state');
   const mergedEnv = mergeLocalConfig(env);
-  const localConfig = readLocalConfigFile(resolveLocalConfigPath(env));
+  const localConfig = readLocalConfigFile(localConfigPath);
   const codexConfig = readCodexConfig(mergedEnv);
   return {
     port: Number(mergedEnv.PORT || 3000),
@@ -16,18 +19,26 @@ export function loadConfig(env = process.env) {
     upstreamModel: mergedEnv.UPSTREAM_MODEL || '',
     upstreamProvider: mergedEnv.UPSTREAM_PROVIDER || 'deepseek',
     upstreamTimeoutMs: Number(mergedEnv.UPSTREAM_TIMEOUT_MS || 120000),
+    upstreamMaxTokens: Number(mergedEnv.UPSTREAM_MAX_TOKENS || mergedEnv.DEEPSEEK_MAX_TOKENS || 0),
     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),
+    debugPayloadLogPath: mergedEnv.DEBUG_PAYLOAD_LOG_PATH || 'gateway.debug.log',
+    reasoningCacheEnabled: parseBoolean(mergedEnv.REASONING_CACHE_ENABLED, true),
+    reasoningCachePath: mergedEnv.REASONING_CACHE_PATH || resolve(stateDir, 'reasoning-cache.jsonl'),
+    reasoningCacheMaxMessages: Number(mergedEnv.REASONING_CACHE_MAX_MESSAGES || 1000),
+    reasoningCacheMaxBytes: Number(mergedEnv.REASONING_CACHE_MAX_BYTES || 0),
+    legacyReasoningCachePath: resolve(stateDir, 'sessions.json'),
+    debugPayloadLogMaxBytes: Number(mergedEnv.DEBUG_PAYLOAD_LOG_MAX_BYTES || 0),
     tavilyWebSearchEnabled: parseBoolean(mergedEnv.TAVILY_WEB_SEARCH_ENABLED ?? mergedEnv.ENABLE_TAVILY_WEB_SEARCH, false),
     tavilyApiKey: mergedEnv.TAVILY_API_KEY || '',
     tavilyBaseUrl: mergedEnv.TAVILY_BASE_URL || 'https://api.tavily.com',
     tavilySearchDepth: mergedEnv.TAVILY_SEARCH_DEPTH || 'basic',
     tavilyMaxResults: Number(mergedEnv.TAVILY_MAX_RESULTS || 5),
-    tavilyMaxSearchRounds: Number(mergedEnv.TAVILY_MAX_SEARCH_ROUNDS || 10),
+    tavilyMaxSearchRounds: Number(mergedEnv.TAVILY_MAX_SEARCH_ROUNDS || 20),
     tavilyTimeoutMs: Number(mergedEnv.TAVILY_TIMEOUT_MS || 15000),
     tavilySnippetChars: Number(mergedEnv.TAVILY_SNIPPET_CHARS || 650),
     tavilyResultMaxChars: Number(mergedEnv.TAVILY_RESULT_MAX_CHARS || 6000),

package/src/firecrawl.js

@@ -1,4 +1,5 @@
-import { isObject, joinUrl, safeJsonParse } from './common.js';
+import { isIP } from 'node:net';
+import { isObject, joinUrl, parseBoolean, safeJsonParse } from './common.js';
 
 const DEFAULT_TOTAL_CHARS = 12000;
 const DEFAULT_PAGE_CHARS = 5000;
@@ -26,15 +27,6 @@ function clampInteger(value, min, max, fallback) {
   return Math.min(max, Math.max(min, Math.trunc(number)));
 }
 
-function booleanValue(value, fallback) {
-  if (typeof value === 'boolean') return value;
-  if (value == null || value === '') return fallback;
-  const normalized = String(value).trim().toLowerCase();
-  if (['1', 'true', 'yes', 'on'].includes(normalized)) return true;
-  if (['0', 'false', 'no', 'off'].includes(normalized)) return false;
-  return fallback;
-}
-
 function cleanText(value, maxChars = DEFAULT_PAGE_CHARS) {
   if (value == null) return '';
   const text = String(value)
@@ -79,16 +71,20 @@ function isPrivateIpv4(hostname) {
   return PRIVATE_IPV4_RANGES.some(([start, end]) => number >= start && number <= end);
 }
 
+function isPrivateIpv6(hostname) {
+  const host = normalizedHostname(hostname);
+  if (isIP(host) !== 6) return false;
+  return host === '::1' || host === '0:0:0:0:0:0:0:1' || host.startsWith('fe80:') || host.startsWith('fc') || host.startsWith('fd');
+}
+
 function isBlockedHostname(hostname, config = {}) {
   const host = normalizedHostname(hostname);
   if (!host) return true;
-  const allowLocal = booleanValue(config.firecrawlAllowPrivateUrls, false);
+  const allowLocal = parseBoolean(config.firecrawlAllowPrivateUrls, false);
   if (allowLocal) return false;
   if (host === 'localhost' || host.endsWith('.localhost')) return true;
   if (host === 'metadata.google.internal') return true;
-  if (host === '::1' || host === '0:0:0:0:0:0:0:1') return true;
-  if (host.startsWith('fe80:') || host.startsWith('fc') || host.startsWith('fd')) return true;
-  return isPrivateIpv4(host);
+  return isPrivateIpv4(host) || isPrivateIpv6(host);
 }
 
 export function normalizeFirecrawlUrl(value, config = {}) {
@@ -127,10 +123,10 @@ function normalizeFormats(args = {}, config = {}) {
     .map((format) => format.toLowerCase())
     .filter((format) => ['markdown', 'links', 'summary', 'changeTracking'].includes(format));
   if (!formats.includes('markdown')) formats.unshift('markdown');
-  if (booleanValue(args.include_links ?? args.includeLinks ?? config.firecrawlIncludeLinks, true) && !formats.includes('links')) {
+  if (parseBoolean(args.include_links ?? args.includeLinks ?? config.firecrawlIncludeLinks, true) && !formats.includes('links')) {
     formats.push('links');
   }
-  if (booleanValue(args.include_summary ?? args.includeSummary ?? config.firecrawlIncludeSummary, false) && !formats.includes('summary')) {
+  if (parseBoolean(args.include_summary ?? args.includeSummary ?? config.firecrawlIncludeSummary, false) && !formats.includes('summary')) {
     formats.push('summary');
   }
   return [...new Set(formats)];
@@ -163,14 +159,14 @@ export function buildFirecrawlScrapeRequest(args = {}, config = {}) {
   const body = {
     url: normalizedUrl.url,
     formats: normalizeFormats(source, config),
-    onlyMainContent: booleanValue(source.only_main_content ?? source.onlyMainContent ?? config.firecrawlOnlyMainContent, true),
-    removeBase64Images: booleanValue(source.remove_base64_images ?? source.removeBase64Images ?? config.firecrawlRemoveBase64Images, true),
+    onlyMainContent: parseBoolean(source.only_main_content ?? source.onlyMainContent ?? config.firecrawlOnlyMainContent, true),
+    removeBase64Images: parseBoolean(source.remove_base64_images ?? source.removeBase64Images ?? config.firecrawlRemoveBase64Images, true),
     waitFor: clampInteger(source.wait_for ?? source.waitFor ?? config.firecrawlWaitForMs, 0, 10000, 0),
     timeout: clampInteger(source.timeout ?? config.firecrawlTimeoutMs, 1000, 120000, 30000),
   };
   if (!body.waitFor) delete body.waitFor;
   const mobile = source.mobile ?? config.firecrawlMobile;
-  if (mobile !== undefined && mobile !== '') body.mobile = booleanValue(mobile, false);
+  if (mobile !== undefined && mobile !== '') body.mobile = parseBoolean(mobile, false);
 
   return {
     ok: true,

package/src/model-map.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { isObject, mapDeepSeekReasoningEffort } from './common.js';
+import { isObject, mapDeepSeekReasoningEffort, parseJsonObject } from './common.js';
 
 const DEEPSEEK_V4_MODELS = ['deepseek-v4-flash', 'deepseek-v4-pro'];
 const DEPRECATED_MODEL_PATTERN = /^deepseek-(?:chat|reasoner)$/;
@@ -15,25 +15,16 @@ function deepseekV4Aliases() {
 
 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);
+  return parseJsonObject(readFileSync(filePath, 'utf8'), { source: filePath, throwOnInvalid: true });
 }
 
 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');
+  const envAliases = parseJsonObject(env.MODEL_ALIASES_JSON, { source: 'MODEL_ALIASES_JSON', throwOnInvalid: true });
   return {
     ...DEFAULT_MODEL_ALIASES,
     ...fileAliases,
@@ -94,15 +85,10 @@ export function deepseekReasoningPayload({ alias, reasoning } = {}) {
     return { thinking: { type: 'disabled' } };
   }
 
-  const payload = {};
+  const payload = { thinking: { type: 'enabled' } };
   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;
-  }
+  const reasoningEffort = mapDeepSeekReasoningEffort(effort);
+  if (reasoningEffort) payload.reasoning_effort = reasoningEffort;
   return payload;
 }