@galaxy-yearn/codex-deepseek-gateway 0.1.3 → 0.1.5

package/src/codex-launch.js

@@ -0,0 +1,241 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { clearScreenDown, cursorTo } from 'node:readline';
+import { readCodexConfig } from './codex-config.js';
+
+export const DEFAULT_PROVIDER = 'deepseek-gateway';
+export const REASONING_EFFORTS = ['low', 'medium', 'high', 'xhigh'];
+const SELECTED_ROW = '\x1b[38;5;81m';
+const RESET_STYLE = '\x1b[0m';
+
+function print(message = '') {
+  process.stdout.write(message);
+}
+
+export function defaultCodexHome() {
+  return process.env.CODEX_HOME || join(process.env.USERPROFILE || process.env.HOME || process.cwd(), '.codex');
+}
+
+export function findProjectRoot(start) {
+  let current = resolve(start);
+  while (true) {
+    if (existsSync(join(current, '.git'))) return current;
+    const parent = dirname(current);
+    if (parent === current) return resolve(start);
+    current = parent;
+  }
+}
+
+function readJsonObject(file) {
+  if (!existsSync(file)) return {};
+  const value = JSON.parse(readFileSync(file, 'utf8'));
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+export function gatewayModels(installDir) {
+  return Object.keys(readJsonObject(join(installDir, 'config', 'model-aliases.json'))).sort();
+}
+
+export function createLaunchContext(options) {
+  const codexHome = defaultCodexHome();
+  const models = gatewayModels(options.dir);
+  const codexConfig = readCodexConfig();
+  const configModel = codexConfig.modelProvider === DEFAULT_PROVIDER && models.includes(codexConfig.model) ? codexConfig.model : '';
+  return {
+    all: options.all,
+    codexHome,
+    installDir: options.dir,
+    models,
+    projectRoot: findProjectRoot(process.cwd()),
+    provider: options.provider || DEFAULT_PROVIDER,
+    model: options.model || configModel || models[0] || '',
+    reasoningEffort: options.reasoningEffort || codexConfig.modelReasoningEffort || 'low',
+  };
+}
+
+export function missingModelMessage(context) {
+  return `No gateway models found in ${join(context.installDir, 'config', 'model-aliases.json')}\n`;
+}
+
+function configOverrideArgs(context) {
+  return [
+    '-c',
+    `model_provider=${JSON.stringify(context.provider)}`,
+    '-c',
+    `model=${JSON.stringify(context.model)}`,
+    '-c',
+    `model_reasoning_effort=${JSON.stringify(context.reasoningEffort)}`,
+    '-c',
+    'model_supports_reasoning_summaries=true',
+    '-c',
+    'model_reasoning_summary="auto"',
+  ];
+}
+
+function configOverrideCommandParts(context) {
+  return [
+    '-c',
+    `model_provider=${context.provider}`,
+    '-c',
+    `model=${context.model}`,
+    '-c',
+    `model_reasoning_effort=${context.reasoningEffort}`,
+    '-c',
+    'model_supports_reasoning_summaries=true',
+    '-c',
+    'model_reasoning_summary=auto',
+  ];
+}
+
+export function codexNewArgs(context) {
+  return configOverrideArgs(context);
+}
+
+export function codexResumeArgs(sessionId, context) {
+  return ['resume', sessionId, ...configOverrideArgs(context)];
+}
+
+export function codexNewCommand(context) {
+  return ['codex', ...configOverrideCommandParts(context)].join(' ');
+}
+
+export function codexResumeCommand(sessionId, context) {
+  return ['codex', 'resume', sessionId, ...configOverrideCommandParts(context)].join(' ');
+}
+
+export async function runCodex(args) {
+  const child = spawn('codex', args, {
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+  });
+  process.exitCode = await new Promise((resolveChild) => {
+    child.on('exit', (exitCode) => resolveChild(exitCode ?? 0));
+  });
+}
+
+function rowOffset(header) {
+  return header ? 4 : 2;
+}
+
+function renderRow(state, index) {
+  cursorTo(process.stdout, 0, rowOffset(state.header) + index);
+  const row = `${index === state.selected ? '>' : ' '} ${state.rows[index]}`;
+  const styled = index === state.selected ? `${SELECTED_ROW}${row}${RESET_STYLE}` : row;
+  print(`\x1b[2K${styled}`);
+}
+
+function renderPicker(state) {
+  const { title, rows, selected, header } = state;
+  cursorTo(process.stdout, 0, 0);
+  clearScreenDown(process.stdout);
+  let output = `${title}\n\n`;
+  if (header) output += `  ${header}\n  ${'-'.repeat(header.length)}\n`;
+  for (const [index] of rows.entries()) {
+    const row = `${index === selected ? '>' : ' '} ${rows[index]}`;
+    output += `${index === selected ? `${SELECTED_ROW}${row}${RESET_STYLE}` : row}\n`;
+  }
+  output += '\nUp/Down select  Enter confirm  Left back  Esc quit\n';
+  print(output);
+}
+
+function openPickerScreen() {
+  process.stdout.write('\x1b[?1049h\x1b[?25l');
+}
+
+function closePickerScreen() {
+  process.stdout.write('\x1b[?25h\x1b[?1049l');
+}
+
+export async function pick(title, rows, header = '') {
+  if (!rows.length) return { action: 'back' };
+  let selected = 0;
+  const stdin = process.stdin;
+  const state = { title, rows, selected, header };
+  renderPicker(state);
+
+  return await new Promise((resolvePick) => {
+    const done = (result) => {
+      stdin.off('data', onData);
+      resolvePick(result);
+    };
+    const onData = (chunk) => {
+      const key = chunk.toString('utf8');
+      if (key === '\u0003' || key === '\u001b') return done({ action: 'cancel' });
+      if (key === '\u001b[D') return done({ action: 'back' });
+      if (key === '\r' || key === '\n') return done({ action: 'select', index: selected });
+      const previous = selected;
+      if (key === '\u001b[A') selected = Math.max(0, selected - 1);
+      else if (key === '\u001b[B') selected = Math.min(rows.length - 1, selected + 1);
+      else return;
+      if (selected === previous) return;
+      state.selected = selected;
+      renderRow(state, previous);
+      renderRow(state, selected);
+    };
+    stdin.on('data', onData);
+  });
+}
+
+export async function withPickerScreen(callback) {
+  const stdin = process.stdin;
+  stdin.resume();
+  stdin.setRawMode(true);
+  openPickerScreen();
+  try {
+    return await callback();
+  } finally {
+    stdin.setRawMode(false);
+    stdin.pause();
+    closePickerScreen();
+  }
+}
+
+export async function pickModel(context) {
+  const result = await pick('Choose gateway model', context.models);
+  if (result.action === 'select') context.model = context.models[result.index];
+  return result.action;
+}
+
+export async function pickReasoning(context) {
+  const result = await pick(`Choose Codex reasoning effort for ${context.model}`, REASONING_EFFORTS);
+  if (result.action === 'select') context.reasoningEffort = REASONING_EFFORTS[result.index];
+  return result.action;
+}
+
+export async function chooseLaunchContext(context) {
+  return await withPickerScreen(async () => {
+    let step = 'model';
+    while (true) {
+      if (step === 'model') {
+        const action = await pickModel(context);
+        if (action !== 'select') return false;
+        step = 'reasoning';
+      } else {
+        const action = await pickReasoning(context);
+        if (action === 'cancel') return false;
+        if (action === 'back') step = 'model';
+        else return true;
+      }
+    }
+  });
+}
+
+export async function newConversation(options) {
+  const context = createLaunchContext(options);
+  if (!context.model) {
+    print(missingModelMessage(context));
+    return;
+  }
+  const canPick = process.stdin.isTTY && process.stdout.isTTY;
+  const hasLaunchOverrides = options.provider || options.model || options.reasoningEffort;
+  if (!hasLaunchOverrides && !options.print && canPick) {
+    const selected = await chooseLaunchContext(context);
+    if (!selected) return;
+  }
+  if (options.print || (!hasLaunchOverrides && !canPick)) {
+    print(`${codexNewCommand(context)}\n`);
+    return;
+  }
+  await runCodex(codexNewArgs(context));
+}

package/src/codex-sessions.js

@@ -1,4 +1,3 @@
-import { spawn } from 'node:child_process';
 import {
   closeSync,
   existsSync,
@@ -6,28 +5,34 @@ import {
   readFileSync,
   readdirSync,
   readSync,
+  statSync,
 } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-import { clearLine, clearScreenDown, cursorTo } from 'node:readline';
-import { readCodexConfig } from './codex-config.js';
+import { join, resolve } from 'node:path';
+import {
+  codexNewArgs,
+  codexResumeArgs,
+  codexResumeCommand,
+  createLaunchContext,
+  missingModelMessage,
+  pick,
+  pickModel,
+  pickReasoning,
+  runCodex,
+  withPickerScreen,
+} from './codex-launch.js';
 
-const DEFAULT_PROVIDER = 'deepseek-gateway';
-const REASONING_EFFORTS = ['low', 'medium', 'high', 'xhigh'];
 const TIME_WIDTH = 10;
-const PROVIDER_WIDTH = 18;
+const PROVIDER_WIDTH = 17;
 const ID_WIDTH = 36;
 const TITLE_WIDTH = 16;
 const TABLE_INDENT = '    ';
-const COLUMN_GAP = '    ';
+const COLUMN_GAP = '  ';
+const NEW_SESSION_ROW = '[New conversation]';
 
 function print(message = '') {
   process.stdout.write(message);
 }
 
-function defaultCodexHome() {
-  return process.env.CODEX_HOME || join(process.env.USERPROFILE || process.env.HOME || process.cwd(), '.codex');
-}
-
 function readStart(file, bytes = 256 * 1024) {
   const handle = openSync(file, 'r');
   try {
@@ -56,6 +61,48 @@ function parseJsonLine(line) {
   }
 }
 
+function isSubagentSession(meta) {
+  return meta?.thread_source === 'subagent' || Boolean(meta?.parent_thread_id);
+}
+
+function timestampFromUserMessage(row) {
+  const payload = row?.payload;
+  if (row?.type === 'event_msg' && payload?.type === 'user_message') return row.timestamp || '';
+  if (row?.type === 'response_item' && payload?.type === 'message' && payload.role === 'user') return row.timestamp || '';
+  return '';
+}
+
+function readLastUserMessageTimestamp(file, chunkSize = 256 * 1024) {
+  const handle = openSync(file, 'r');
+  try {
+    let position = statSync(file).size;
+    let suffix = Buffer.alloc(0);
+    while (position > 0) {
+      const length = Math.min(chunkSize, position);
+      position -= length;
+      const buffer = Buffer.alloc(length);
+      const read = readSync(handle, buffer, 0, length, position);
+      let data = buffer.subarray(0, read);
+      if (suffix.length) data = Buffer.concat([data, suffix]);
+
+      let lineEnd = data.length;
+      for (let index = data.length - 1; index >= 0; index -= 1) {
+        if (data[index] !== 10) continue;
+        const row = parseJsonLine(data.subarray(index + 1, lineEnd).toString('utf8').trim());
+        const timestamp = timestampFromUserMessage(row);
+        if (timestamp) return timestamp;
+        lineEnd = index;
+      }
+      suffix = data.subarray(0, lineEnd);
+    }
+
+    const row = parseJsonLine(suffix.toString('utf8').trim());
+    return timestampFromUserMessage(row);
+  } finally {
+    closeSync(handle);
+  }
+}
+
 function readSessionIndex(codexHome) {
   const file = join(codexHome, 'session_index.jsonl');
   const byId = new Map();
@@ -107,16 +154,6 @@ function normalizePath(path) {
   return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
 }
 
-function findProjectRoot(start) {
-  let current = resolve(start);
-  while (true) {
-    if (existsSync(join(current, '.git'))) return current;
-    const parent = dirname(current);
-    if (parent === current) return resolve(start);
-    current = parent;
-  }
-}
-
 function isInsideProject(cwd, projectRoot) {
   if (!cwd) return false;
   const sessionCwd = normalizePath(cwd);
@@ -124,45 +161,21 @@ function isInsideProject(cwd, projectRoot) {
   return sessionCwd === root || sessionCwd.startsWith(`${root}${process.platform === 'win32' ? '\\' : '/'}`);
 }
 
-function readSession(file, indexById) {
+export function readSession(file, indexById) {
   const lines = readStart(file).split(/\r?\n/).filter(Boolean);
   const meta = parseJsonLine(lines[0])?.payload;
   if (!meta?.id) return null;
+  if (isSubagentSession(meta)) return null;
   const index = indexById.get(meta.id) || {};
   return {
     id: meta.id,
     provider: meta.model_provider || '',
     cwd: meta.cwd || '',
-    updatedAt: index.updated_at || meta.timestamp || '',
+    updatedAt: readLastUserMessageTimestamp(file) || index.updated_at || meta.timestamp || '',
     title: index.thread_name || firstUserPreview(lines) || '(untitled)',
   };
 }
 
-function shellQuoteTomlString(key, value) {
-  return `-c ${key}=${value}`;
-}
-
-function resumeCommand(sessionId, context) {
-  return [
-    'codex',
-    'resume',
-    sessionId,
-    shellQuoteTomlString('model_provider', context.provider),
-    shellQuoteTomlString('model', context.model),
-    shellQuoteTomlString('model_reasoning_effort', context.reasoningEffort),
-  ].join(' ');
-}
-
-function readJsonObject(file) {
-  if (!existsSync(file)) return {};
-  const value = JSON.parse(readFileSync(file, 'utf8'));
-  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-}
-
-function gatewayModels(installDir) {
-  return Object.keys(readJsonObject(join(installDir, 'config', 'model-aliases.json'))).sort();
-}
-
 function resolveSessionSelection(selection, sessionsList) {
   if (/^\d+$/.test(selection)) {
     const byIndex = sessionsList[Number(selection) - 1];
@@ -172,29 +185,6 @@ function resolveSessionSelection(selection, sessionsList) {
   return matches.length === 1 ? matches[0] : null;
 }
 
-function resumeArgs(session, context) {
-  return [
-    'resume',
-    session.id,
-    '-c',
-    `model_provider=${JSON.stringify(context.provider)}`,
-    '-c',
-    `model=${JSON.stringify(context.model)}`,
-    '-c',
-    `model_reasoning_effort=${JSON.stringify(context.reasoningEffort)}`,
-  ];
-}
-
-async function runCodexResume(session, context) {
-  const child = spawn('codex', resumeArgs(session, context), {
-    stdio: 'inherit',
-    shell: process.platform === 'win32',
-  });
-  process.exitCode = await new Promise((resolveChild) => {
-    child.on('exit', (exitCode) => resolveChild(exitCode ?? 0));
-  });
-}
-
 function printSessions(sessionsList, options, context) {
   const listed = sessionsList.slice(0, options.limit || 20);
   print(`Codex sessions ${options.all ? `under ${context.codexHome}` : `for project ${context.projectRoot}`}\n`);
@@ -204,11 +194,11 @@ function printSessions(sessionsList, options, context) {
     return;
   }
   print(`${TABLE_INDENT}${sessionHeader()}\n`);
-  print(`${TABLE_INDENT}${'-'.repeat(TIME_WIDTH)}${COLUMN_GAP}${'-'.repeat(PROVIDER_WIDTH)}${COLUMN_GAP}${'-'.repeat(ID_WIDTH)}${COLUMN_GAP}${'-'.repeat(TITLE_WIDTH)}\n`);
+  print(`${TABLE_INDENT}${'-'.repeat(sessionHeader().length)}\n`);
   listed.forEach((session, index) => {
     print(`${String(index + 1).padStart(2, ' ')}  ${sessionRow(session)}\n`);
     if (options.all) print(`    cwd: ${session.cwd || '(unknown cwd)'}\n`);
-    print(`    resume: ${resumeCommand(session.id, context)}\n\n`);
+    print(`    resume: ${codexResumeCommand(session.id, context)}\n\n`);
   });
   if (sessionsList.length > listed.length) print(`Showing ${listed.length} of ${sessionsList.length}. Use --limit ${sessionsList.length} or --all as needed.\n`);
 }
@@ -225,134 +215,47 @@ function sessionRows(sessionsList) {
   return sessionsList.map((session) => sessionRow(session));
 }
 
-function rowOffset(header) {
-  return header ? 4 : 2;
-}
-
-function renderRow(state, index) {
-  cursorTo(process.stdout, 0, rowOffset(state.header) + index);
-  clearLine(process.stdout, 0);
-  print(`${index === state.selected ? '>' : ' '} ${state.rows[index]}`);
-}
-
-function renderPicker(state) {
-  const { title, rows, selected, header } = state;
-  cursorTo(process.stdout, 0, 0);
-  clearScreenDown(process.stdout);
-  let output = `${title}\n\n`;
-  if (header) output += `  ${header}\n  ${'-'.repeat(header.length)}\n`;
-  for (const [index, row] of rows.entries()) output += `${index === selected ? '>' : ' '} ${row}\n`;
-  output += '\n↑/↓ select  Enter confirm  ← back  Esc quit\n';
-  print(output);
-}
-
-function openPickerScreen() {
-  process.stdout.write('\x1b[?1049h\x1b[?25l');
-}
-
-function closePickerScreen() {
-  process.stdout.write('\x1b[?25h\x1b[?1049l');
-}
-
-async function pick(title, rows, header = '') {
-  if (!rows.length) return { action: 'back' };
-  let selected = 0;
-  const stdin = process.stdin;
-  const state = { title, rows, selected, header };
-  renderPicker(state);
-
-  return await new Promise((resolvePick) => {
-    const done = (result) => {
-      stdin.off('data', onData);
-      resolvePick(result);
-    };
-    const onData = (chunk) => {
-      const key = chunk.toString('utf8');
-      if (key === '\u0003' || key === '\u001b') return done({ action: 'cancel' });
-      if (key === '\u001b[D') return done({ action: 'back' });
-      if (key === '\r' || key === '\n') return done({ action: 'select', index: selected });
-      const previous = selected;
-      if (key === '\u001b[A') selected = Math.max(0, selected - 1);
-      else if (key === '\u001b[B') selected = Math.min(rows.length - 1, selected + 1);
-      else return;
-      if (selected === previous) return;
-      state.selected = selected;
-      renderRow(state, previous);
-      renderRow(state, selected);
-    };
-    stdin.on('data', onData);
-  });
-}
-
 async function chooseSessionFlow(allSessions, context, limit) {
-  const models = gatewayModels(context.installDir);
-  const listed = allSessions.slice(0, limit);
-  const header = sessionHeader();
-  if (!listed.length) {
-    print('No matching sessions found.\n');
-    return null;
-  }
-  if (!models.length) {
-    print(`No gateway models found in ${join(context.installDir, 'config', 'model-aliases.json')}\n`);
+  if (!context.models.length) {
+    print(missingModelMessage(context));
     return null;
   }
 
-  const stdin = process.stdin;
-  stdin.resume();
-  stdin.setRawMode(true);
-  openPickerScreen();
-  try {
-    let step = 'model';
+  const listed = allSessions.slice(0, limit);
+  const header = sessionHeader();
+  return await withPickerScreen(async () => {
+    let step = 'session';
     while (true) {
-      if (step === 'model') {
-        const result = await pick('Choose gateway model', models);
-        if (result.action !== 'select') return null;
-        context.model = models[result.index];
+      if (step === 'session') {
+        const rows = [NEW_SESSION_ROW, ...sessionRows(listed)];
+        const result = await pick(`Choose Codex session`, rows, header);
+        if (result.action === 'cancel') return null;
+        if (result.action === 'back') return null;
+        context.selectedSession = result.index === 0 ? { newConversation: true } : listed[result.index - 1];
+        step = 'model';
+      } else if (step === 'model') {
+        const action = await pickModel(context);
+        if (action !== 'select') return null;
         step = 'reasoning';
       } else if (step === 'reasoning') {
-        const result = await pick(`Choose Codex reasoning effort for ${context.model}`, REASONING_EFFORTS);
-        if (result.action === 'cancel') return null;
-        if (result.action === 'back') step = 'model';
-        else {
-          context.reasoningEffort = REASONING_EFFORTS[result.index];
-          step = 'session';
-        }
-      } else {
-        const result = await pick(`Choose Codex session for ${context.provider} / ${context.model} / ${context.reasoningEffort}`, sessionRows(listed), header);
-        if (result.action === 'cancel') return null;
-        if (result.action === 'back') step = 'reasoning';
-        else return listed[result.index];
+        const action = await pickReasoning(context);
+        if (action === 'cancel') return null;
+        if (action === 'back') step = 'model';
+        else return context.selectedSession;
       }
     }
-  } finally {
-    stdin.setRawMode(false);
-    stdin.pause();
-    closePickerScreen();
-  }
+  });
 }
 
 export async function sessions(options) {
-  const codexHome = defaultCodexHome();
-  const sessionsDir = join(codexHome, 'sessions');
-  const indexById = readSessionIndex(codexHome);
-  const projectRoot = findProjectRoot(process.cwd());
-  const codexConfig = readCodexConfig();
-  const models = gatewayModels(options.dir);
-  const configModel = codexConfig.modelProvider === DEFAULT_PROVIDER && models.includes(codexConfig.model) ? codexConfig.model : '';
-  const context = {
-    all: options.all,
-    codexHome,
-    installDir: options.dir,
-    projectRoot,
-    provider: options.provider || DEFAULT_PROVIDER,
-    model: options.model || configModel || models[0] || '',
-    reasoningEffort: options.reasoningEffort || codexConfig.modelReasoningEffort || 'low',
-  };
+  const context = createLaunchContext(options);
+  const sessionsDir = join(context.codexHome, 'sessions');
+  const indexById = readSessionIndex(context.codexHome);
   const seen = new Map();
 
   for (const file of walkJsonl(sessionsDir)) {
     const session = readSession(file, indexById);
-    if (!session || (!options.all && !isInsideProject(session.cwd, projectRoot))) continue;
+    if (!session || (!options.all && !isInsideProject(session.cwd, context.projectRoot))) continue;
     const prior = seen.get(session.id);
     if (!prior || session.updatedAt > prior.updatedAt) seen.set(session.id, session);
   }
@@ -361,7 +264,7 @@ export async function sessions(options) {
   if (options.exec) {
     const session = resolveSessionSelection(options.exec, allSessions);
     if (!session) throw new Error(`Session not found or ambiguous: ${options.exec}`);
-    await runCodexResume(session, context);
+    await runCodex(codexResumeArgs(session.id, context));
     return;
   }
 
@@ -370,6 +273,7 @@ export async function sessions(options) {
     return;
   }
 
-  const session = await chooseSessionFlow(allSessions, context, options.limit || 20);
-  if (session) await runCodexResume(session, context);
+  const selected = await chooseSessionFlow(allSessions, context, options.limit || 20);
+  if (selected?.newConversation) await runCodex(codexNewArgs(context));
+  else if (selected) await runCodex(codexResumeArgs(selected.id, context));
 }

package/src/config.js

@@ -25,7 +25,7 @@ export function loadConfig(env = process.env) {
     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 || 2),
+    tavilyMaxSearchRounds: Number(mergedEnv.TAVILY_MAX_SEARCH_ROUNDS || 10),
     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

@@ -304,12 +304,12 @@ export function formatFirecrawlScrapeResult({ url = '', title = '', summary = ''
     if (links?.length) {
       lines.push('Page links:');
       for (const [index, link] of links.entries()) {
-        lines.push(`[L${index + 1}] ${link.title || link.url}`);
+        lines.push(`Link ${index + 1}: ${link.title || link.url}`);
         lines.push(`URL: ${link.url}`);
       }
     }
   }
-  lines.push('Use this opened page only as source text. Cite it with the source number assigned by the search result when available.');
+  lines.push('Use this opened page only as source text. If it supports the answer, include the page title and URL.');
   const text = lines.filter(Boolean).join('\n');
   const maxChars = Number(config.firecrawlResultMaxChars) || DEFAULT_TOTAL_CHARS;
   if (text.length <= maxChars) return text;