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

package/README.md

@@ -1,59 +1,49 @@
 # Codex DeepSeek Gateway
 
-A small local gateway for using DeepSeek models from Codex.
+A lightweight local gateway for using DeepSeek models in Codex.
 
-Codex keeps sending OpenAI `Responses API` requests to a local endpoint. The gateway converts those requests to DeepSeek-compatible `Chat Completions`, calls DeepSeek, then converts the result back to Responses JSON or streaming `response.*` events.
+Codex keeps using the OpenAI `Responses API` wire format. The gateway translates requests to DeepSeek-compatible `Chat Completions`, calls DeepSeek, then translates the result back to Responses JSON or `response.*` SSE events.
 
-NPM package: [@galaxy-yearn/codex-deepseek-gateway](https://www.npmjs.com/package/@galaxy-yearn/codex-deepseek-gateway)
-
-The runtime uses only the Node.js standard library. It installs under `~/.codex/deepseek-gateway`, runs as a detached background process, and does not edit your existing Codex config.
-
-Use this when you want Codex to stay on its normal Responses API path while the actual model is DeepSeek, including DeepSeek thinking output, function calls, local session resume help, and optional web search emulation through Tavily and Firecrawl.
+Package: [@galaxy-yearn/codex-deepseek-gateway](https://www.npmjs.com/package/@galaxy-yearn/codex-deepseek-gateway)
 
 ## Requirements
 
-- Node.js 20 or newer
+- Node.js 22 or newer
 - A DeepSeek API key
-- Codex configured from `~/.codex/config.toml`
+- Codex CLI
 
 ## Install
 
-Run:
-
 ```sh
-npx @galaxy-yearn/codex-deepseek-gateway install
-```
-
-This copies the runtime to:
-
-```text
-~/.codex/deepseek-gateway
+npm install -g @galaxy-yearn/codex-deepseek-gateway
+codex-deepseek-gateway --version
+codex-deepseek-gateway install
 ```
 
-It creates two local config files:
+The runtime is copied to `~/.codex/deepseek-gateway`. Put your DeepSeek API key in:
 
 ```text
 ~/.codex/deepseek-gateway/config/gateway.local.json
-~/.codex/deepseek-gateway/config/model-aliases.json
 ```
 
-Put your DeepSeek API key in `gateway.local.json`:
-
 ```json
-"upstreamApiKey": "sk-..."
+{
+  "upstreamApiKey": "sk-..."
+}
 ```
 
-`model-aliases.json` controls the gateway-facing model IDs exposed on `GET /v1/models` and used by the `new` and `sessions` pickers. Edit it only if you want to add or rename model aliases.
-
-If the key is already configured, `install` also starts the gateway. If this is your first install, add the key and then run:
+`install` preserves an existing `gateway.local.json`. If this is your first install, add the key and start the gateway:
 
 ```sh
-npx @galaxy-yearn/codex-deepseek-gateway start
+codex-deepseek-gateway start
+codex-deepseek-gateway status
 ```
 
-## Configure Codex
+`status` should show `"reachable": true`.
+
+## Codex Config
 
-Edit `~/.codex/config.toml`:
+Add this provider to `~/.codex/config.toml`:
 
 ```toml
 model_provider = "deepseek-gateway"
@@ -68,225 +58,122 @@ base_url = "http://127.0.0.1:3000/v1"
 wire_api = "responses"
 ```
 
-Use `deepseek-v4-pro` instead of `deepseek-v4-flash` if you want the pro model.
-
-Restart Codex after changing `config.toml`.
+Use `deepseek-v4-pro` if you want the pro model. Restart Codex after editing `config.toml`.
 
-## Start And Verify
+## Usage
 
-Start, stop, and inspect the local background process:
+Start a new Codex conversation with gateway overrides:
 
 ```sh
-npx @galaxy-yearn/codex-deepseek-gateway start
-npx @galaxy-yearn/codex-deepseek-gateway stop
-npx @galaxy-yearn/codex-deepseek-gateway status
+codex-deepseek-gateway new
 ```
 
-`status` should show `"reachable": true`.
-
-Run `doctor` to check the active Codex config and the DeepSeek request shape the gateway will send:
+Resume a Codex session from the current project:
 
 ```sh
-npx @galaxy-yearn/codex-deepseek-gateway doctor
-```
-
-Important fields:
-
-- `codexConfigUsingGateway` should be `true`
-- `codexModel` should be your gateway model, for example `deepseek-v4-pro`
-- `codexReasoningEffort` should match `model_reasoning_effort`
-- `deepseekThinking` shows the DeepSeek `thinking` payload
-- `deepseekReasoningEffort` shows the DeepSeek effort sent upstream
-- `reasoningDisplayMode` shows whether reasoning is shown as `summary`, `hidden`, or `disabled`
-- `tavilyWebSearchReady` and `firecrawlWebFetchReady` show whether optional web search backends are usable
-
-Avoid running Codex through a proxy while using the local gateway. Some proxy clients intercept `http://127.0.0.1:3000` and can break local gateway requests.
-
-## Models
-
-The installed `config/model-aliases.json` starts with:
-
-```json
-{
-  "deepseek-v4-flash": {
-    "model": "deepseek-v4-flash",
-    "thinking": "auto"
-  },
-  "deepseek-v4-pro": {
-    "model": "deepseek-v4-pro",
-    "thinking": "auto"
-  }
-}
-```
-
-The gateway serves these aliases directly on `GET /v1/models`. If you also want to merge DeepSeek's upstream `/models` list, set this in `gateway.local.json`:
-
-```json
-"fetchUpstreamModels": true
-```
-
-Whether Codex TUI `/model` shows custom provider models depends on the Codex client build. `config.toml`, `new`, and `sessions` remain the reliable ways to choose a model.
-
-## Reasoning
-
-Codex reasoning effort maps to DeepSeek V4 thinking mode:
-
-| Codex `model_reasoning_effort` | DeepSeek request |
-| --- | --- |
-| `low` | `thinking.type = disabled` |
-| `medium` | `thinking.type = enabled`, `reasoning_effort = high` |
-| `high` | `thinking.type = enabled`, `reasoning_effort = high` |
-| `xhigh` | `thinking.type = enabled`, `reasoning_effort = max` |
-
-`model_supports_reasoning_summaries = true` and `model_reasoning_summary = "auto"` tell Codex to use its normal thinking UI path. When DeepSeek returns `reasoning_content`, the gateway keeps the raw text as `reasoning_text` and mirrors it into `summary_text` with a `Reasoning` heading for Codex TUI compatibility.
-
-When thinking is enabled, the gateway intentionally buffers visible assistant text and tool-call output until the upstream response completes, then emits reasoning first. This improves thinking order in Codex at the cost of higher first-token latency.
-
-## Web Search
-
-Web search is off by default. To let Codex's native `web_search` or `web_search_preview` tool work while DeepSeek is active, configure the optional backends in `gateway.local.json`.
-
-Tavily provides search results:
-
-```json
-"tavilyApiKey": "tvly-...",
-"tavilyWebSearchEnabled": true
-```
-
-Firecrawl provides opened-page reading and focused page lookup:
-
-```json
-"firecrawlApiKey": "fc-...",
-"firecrawlWebFetchEnabled": true,
-"firecrawlAutoScrapeTopResults": 3
+codex-deepseek-gateway sessions
 ```
 
-Codex does not need MCP, a different tool name, or prompt changes. The gateway converts Codex web search requests into internal Chat Completions tools:
-
-- `tavily_search` searches the web and returns citation-ready snippets.
-- `firecrawl_open_page` reads a specific public page.
-- `firecrawl_find_in_page` reads a page with a focused query.
-
-DeepSeek receives compact text context containing the search query, sources, snippets, and optional opened-page excerpts. Codex receives Responses-compatible `web_search_call` items, final assistant messages, and URL citation annotations when the final text cites a matching source marker.
-
-The web payload is intentionally text-focused. Tavily is called with `include_raw_content: false`; Firecrawl defaults to main content, removes base64 images, rejects local/private URLs, and truncates page text before it reaches the model.
-
-## New Conversations
-
-Start a new Codex conversation with a temporary gateway model override:
+Useful non-interactive forms:
 
 ```sh
-npx @galaxy-yearn/codex-deepseek-gateway new
+codex-deepseek-gateway new --model deepseek-v4-flash --reasoning-effort low
+codex-deepseek-gateway new --print
+codex-deepseek-gateway sessions --print
+codex-deepseek-gateway sessions --all
+codex-deepseek-gateway sessions --exec <id-or-row>
 ```
 
-The command first lets you choose a model from `~/.codex/deepseek-gateway/config/model-aliases.json`, then choose Codex reasoning effort, then runs:
+`new` chooses a model, then Codex reasoning effort. `sessions` chooses a session first, then model and reasoning effort. Both launch Codex with:
 
 ```sh
-codex -c model_provider=deepseek-gateway -c model=<model> -c model_reasoning_effort=<effort>
+codex -c model_provider=deepseek-gateway -c model=<model> -c model_reasoning_effort=<effort> -c model_supports_reasoning_summaries=true -c model_reasoning_summary=auto
 ```
 
-This does not edit `~/.codex/config.toml`; the `model_providers.deepseek-gateway` provider entry still needs to exist there.
+Model aliases are read from:
 
-You can skip the picker:
-
-```sh
-npx @galaxy-yearn/codex-deepseek-gateway new --model deepseek-v4-flash --reasoning-effort low
+```text
+~/.codex/deepseek-gateway/config/model-aliases.json
 ```
 
-Print the generated launch command instead of running Codex:
+## Commands
 
 ```sh
-npx @galaxy-yearn/codex-deepseek-gateway new --print
+codex-deepseek-gateway install
+codex-deepseek-gateway start
+codex-deepseek-gateway stop
+codex-deepseek-gateway status
+codex-deepseek-gateway doctor
+codex-deepseek-gateway new
+codex-deepseek-gateway sessions
+codex-deepseek-gateway uninstall
 ```
 
-## Sessions
-
-Open a cross-provider session picker from a project:
+`doctor` checks the active Codex config, DeepSeek request shape, reasoning mode, and optional web-search backend readiness.
 
-```sh
-npx @galaxy-yearn/codex-deepseek-gateway sessions
-```
-
-The picker is read-only. It scans Codex local transcript files, lists sessions for the current project across providers, then runs:
+To remove the local runtime and then uninstall the global package:
 
 ```sh
-codex resume <session-id> -c model_provider=deepseek-gateway -c model=<model> -c model_reasoning_effort=<effort>
+codex-deepseek-gateway uninstall
+npm uninstall -g @galaxy-yearn/codex-deepseek-gateway
 ```
 
-Flow:
-
-- choose a model from `~/.codex/deepseek-gateway/config/model-aliases.json`
-- choose Codex reasoning effort
-- choose `[New conversation]` or the session to resume
-- use `↑/↓` to select, `Enter` to confirm, `←` to go back, and `Esc` to quit
-
-Print copyable resume commands instead of opening the picker:
-
-```sh
-npx @galaxy-yearn/codex-deepseek-gateway sessions --print
-```
+## Reasoning
 
-Include sessions outside the current project:
+Codex effort maps to DeepSeek V4 thinking mode:
 
-```sh
-npx @galaxy-yearn/codex-deepseek-gateway sessions --all
-```
+| Codex effort | DeepSeek request |
+| --- | --- |
+| `low` | `thinking.type = disabled` |
+| `medium` | `thinking.type = enabled`, `reasoning_effort = high` |
+| `high` | `thinking.type = enabled`, `reasoning_effort = high` |
+| `xhigh` | `thinking.type = enabled`, `reasoning_effort = max` |
 
-Resume a matching session directly by row number or unique session id prefix:
+When DeepSeek returns `reasoning_content`, the gateway preserves the raw text for DeepSeek history and sends a display-only Markdown-cleaned copy through Codex's reasoning summary UI. The raw reasoning is not duplicated into visible message content.
 
-```sh
-npx @galaxy-yearn/codex-deepseek-gateway sessions --exec <id-or-row>
-```
+## Web Search
 
-Limit how many session rows are shown or offered in the picker:
+Web search is optional and off by default. Configure Tavily for search:
 
-```sh
-npx @galaxy-yearn/codex-deepseek-gateway sessions --limit 50
+```json
+{
+  "tavilyApiKey": "tvly-...",
+  "tavilyWebSearchEnabled": true
+}
 ```
 
-The command does not edit session files, change provider ownership, or change Codex's native resume picker filters. It only helps you find the hidden session id and resume it with explicit config overrides.
+Configure Firecrawl if you also want opened-page reading:
 
-## Commands
-
-```sh
-npx @galaxy-yearn/codex-deepseek-gateway install
-npx @galaxy-yearn/codex-deepseek-gateway start
-npx @galaxy-yearn/codex-deepseek-gateway stop
-npx @galaxy-yearn/codex-deepseek-gateway status
-npx @galaxy-yearn/codex-deepseek-gateway doctor
-npx @galaxy-yearn/codex-deepseek-gateway new
-npx @galaxy-yearn/codex-deepseek-gateway sessions
-npx @galaxy-yearn/codex-deepseek-gateway uninstall
+```json
+{
+  "firecrawlApiKey": "fc-...",
+  "firecrawlWebFetchEnabled": true
+}
 ```
 
-`start` launches a headless background Node.js process. `stop` stops it. `uninstall` stops the gateway and removes `~/.codex/deepseek-gateway`, but it does not edit `~/.codex/config.toml`.
+Codex can keep requesting `web_search` / `web_search_preview`. The gateway exposes compact internal web tools to DeepSeek, executes Tavily/Firecrawl calls itself, feeds tool results back to the model, and returns Codex-compatible `web_search_call` items. `TAVILY_MAX_SEARCH_ROUNDS` defaults to `10` and is only a runaway/cost guardrail; when reached, the gateway disables web tools for one final-answer turn.
 
-If `start` returns without visible output on your terminal, run `status`; `"reachable": true` is the source of truth.
+Final answers should include useful source titles and URLs directly.
 
-## What Works
+## 0.1.5 Updates
 
-- Codex `POST /v1/responses`
-- streaming and non-streaming responses
-- text input and output
-- image, file, and audio content parts when DeepSeek accepts the corresponding Chat Completions shape
-- function tools and tool-call history
-- DeepSeek thinking mode and `reasoning_content`
-- lightweight local `previous_response_id` / `conversation` history while the gateway process is running
-- `GET /v1/models` with local model aliases and optional upstream discovery
-- optional Tavily/Firecrawl-backed `web_search` emulation
-- new-conversation launcher with per-run Codex config overrides
-- read-only cross-provider session picker
+- Global CLI usage: install once with `npm install -g`, then run `codex-deepseek-gateway ...` from any directory.
+- `install` preserves `gateway.local.json`; runtime defaults stay in code.
+- `new` and `sessions` launch Codex with reasoning-summary config overrides.
+- `sessions` first chooses the session, hides subagent transcripts, and sorts by the latest user-message date.
+- DeepSeek-facing tool descriptions are compact; namespaced Codex local tools, including multi-agent tools, pass back to Codex with namespace preserved.
+- Web search uses a model-driven loop: internal Tavily/Firecrawl tools run in the gateway, local Codex tools pass through to Codex, and final-answer turns no longer end as empty completions.
+- Reasoning display now uses Codex summary events only, with display-only Markdown cleanup to avoid duplicate or truncated thinking text.
 
 ## Limits
 
-Chat Completions is not a full Responses API replacement. Some Responses features have no equivalent upstream field.
+Chat Completions is not a full Responses API replacement.
 
-- Hosted tools such as file search, computer use, image generation, and code interpreter are represented as function-tool shims unless Codex executes matching tools locally. Web search is the only hosted tool the gateway can emulate directly.
-- Tavily and Firecrawl web emulation is text-focused. It does not expose raw HTML, screenshots, browser actions, crawl/map jobs, cookies, private network access, or provider-specific payloads through Codex `web_search`.
-- URL citations are returned in the Responses metadata path. Whether they appear as clickable links in the terminal depends on the Codex client build and how it renders custom-provider citation annotations.
+- Hosted tools without a local Codex executor are represented as function shims. Web search is the only hosted tool the gateway emulates directly.
+- Tavily/Firecrawl web emulation is text-focused; it does not provide browser control, screenshots, raw HTML, cookies, crawl jobs, or private-network access.
 - OpenAI `file_id` values are passed through; the gateway cannot fetch private OpenAI-hosted files.
-- In-memory conversation history is lost when the gateway restarts.
-- The gateway exposes model aliases on `/v1/models`, including aliases from `config/model-aliases.json`. Whether Codex TUI `/model` actually shows custom provider models depends on the Codex build. `config.toml`, `new`, and `sessions` remain the reliable ways to choose a model.
+- In-memory `previous_response_id` / `conversation` history is lost when the gateway process restarts.
+- The gateway exposes model aliases on `/v1/models`; whether Codex TUI `/model` shows them depends on the Codex build. `config.toml`, `new`, and `sessions` are the reliable model-selection paths.
 
 ## License
 

package/bin/codex-deepseek-gateway.js

@@ -39,6 +39,7 @@ Usage:
   codex-deepseek-gateway uninstall
 
 Options:
+  -v, --version   Print package version
   --dir <path>     Install directory, defaults to ~/.codex/deepseek-gateway
   --no-edit        Do not open the local config file after install
   --all            With sessions, include sessions outside the current project
@@ -58,7 +59,9 @@ function parseArgs(argv) {
   const rest = [];
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
-    if (arg === '--dir' || arg === '-d' || arg === '-InstallDir') {
+    if (arg === '--version' || arg === '-v') {
+      options.version = true;
+    } else if (arg === '--dir' || arg === '-d' || arg === '-InstallDir') {
       const value = argv[index + 1];
       if (!value) throw new Error(`${arg} requires a path`);
       options.dir = resolve(value);
@@ -253,6 +256,10 @@ async function install(options) {
 }
 
 async function start(options) {
+  if (!existsSync(options.dir)) {
+    throw new Error(`Missing runtime at ${options.dir}. Run install first.`);
+  }
+  copyRuntime(options.dir);
   if (!existsSync(serverPath(options.dir))) {
     throw new Error(`Missing runtime at ${options.dir}. Run install first.`);
   }
@@ -400,6 +407,10 @@ async function uninstall(options) {
 
 async function main() {
   const { command, options } = parseArgs(process.argv.slice(2));
+  if (options.version) {
+    print(`${packageJson.version}\n`);
+    return;
+  }
   if (!command || command === '-h' || command === '--help' || command === 'help') {
     usage();
     return;

package/config/gateway.example.json

@@ -1,23 +1,7 @@
 {
-  "port": 3000,
-  "host": "127.0.0.1",
-  "upstreamProvider": "deepseek",
-  "upstreamBaseUrl": "https://api.deepseek.com",
   "upstreamApiKey": "sk-REPLACE_ME",
-  "upstreamTimeoutMs": 120000,
   "tavilyApiKey": "",
   "tavilyWebSearchEnabled": false,
-  "tavilySearchDepth": "basic",
-  "tavilyMaxResults": 5,
-  "tavilyMaxSearchRounds": 2,
-  "tavilyTimeoutMs": 15000,
   "firecrawlApiKey": "",
-  "firecrawlWebFetchEnabled": false,
-  "firecrawlAutoScrapeTopResults": 3,
-  "firecrawlPageMaxChars": 5000,
-  "firecrawlTimeoutMs": 30000,
-  "fetchUpstreamModels": false,
-  "modelsTimeoutMs": 5000,
-  "modelsCacheMs": 60000,
-  "debugPayload": false
+  "firecrawlWebFetchEnabled": false
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galaxy-yearn/codex-deepseek-gateway",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Local OpenAI Codex Responses API gateway for DeepSeek Chat Completions.",
   "type": "module",
   "main": "src/server.js",
@@ -19,7 +19,7 @@
     "test": "node --test"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "keywords": [
     "codex",

package/src/codex-launch.js

@@ -66,6 +66,10 @@ function configOverrideArgs(context) {
     `model=${JSON.stringify(context.model)}`,
     '-c',
     `model_reasoning_effort=${JSON.stringify(context.reasoningEffort)}`,
+    '-c',
+    'model_supports_reasoning_summaries=true',
+    '-c',
+    'model_reasoning_summary="auto"',
   ];
 }
 
@@ -77,6 +81,10 @@ function configOverrideCommandParts(context) {
     `model=${context.model}`,
     '-c',
     `model_reasoning_effort=${context.reasoningEffort}`,
+    '-c',
+    'model_supports_reasoning_summaries=true',
+    '-c',
+    'model_reasoning_summary=auto',
   ];
 }
 
@@ -127,7 +135,7 @@ function renderPicker(state) {
     const row = `${index === selected ? '>' : ' '} ${rows[index]}`;
     output += `${index === selected ? `${SELECTED_ROW}${row}${RESET_STYLE}` : row}\n`;
   }
-  output += '\n↑/↓ select  Enter confirm  ← back  Esc quit\n';
+  output += '\nUp/Down select  Enter confirm  Left back  Esc quit\n';
   print(output);
 }
 

package/src/codex-sessions.js

@@ -5,6 +5,7 @@ import {
   readFileSync,
   readdirSync,
   readSync,
+  statSync,
 } from 'node:fs';
 import { join, resolve } from 'node:path';
 import {
@@ -60,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();
@@ -118,16 +161,17 @@ 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)',
   };
 }
@@ -180,9 +224,16 @@ async function chooseSessionFlow(allSessions, context, limit) {
   const listed = allSessions.slice(0, limit);
   const header = sessionHeader();
   return await withPickerScreen(async () => {
-    let step = 'model';
+    let step = 'session';
     while (true) {
-      if (step === 'model') {
+      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';
@@ -190,14 +241,7 @@ async function chooseSessionFlow(allSessions, context, limit) {
         const action = await pickReasoning(context);
         if (action === 'cancel') return null;
         if (action === 'back') step = 'model';
-        else step = 'session';
-      } else {
-        const rows = [NEW_SESSION_ROW, ...sessionRows(listed)];
-        const result = await pick(`Choose Codex session for ${context.provider} / ${context.model} / ${context.reasoningEffort}`, rows, header);
-        if (result.action === 'cancel') return null;
-        if (result.action === 'back') step = 'reasoning';
-        else if (result.index === 0) return { newConversation: true };
-        else return listed[result.index - 1];
+        else return context.selectedSession;
       }
     }
   });

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;