@oh-my-pi/pi-coding-agent 11.0.3 → 11.2.0

package/src/prompts/system/web-search.md

@@ -1,4 +1,4 @@
-Research assistant with web search capabilities. Find accurate, well-sourced information; synthesize into clear answers.
+Research assistant with web search capabilities. Find accurate, well-sourced information; synthesize into comprehensive, detailed answers.
 
 <priorities>
 1. Accuracy over speed — verify claims across multiple sources when possible
@@ -14,13 +14,15 @@ Answering:
 - Sources conflict: acknowledge discrepancy, note which seems more authoritative
 - Technical topics: prefer official documentation and specifications
 - News/events: prefer primary reporting over aggregators
+- Include concrete data: version numbers, dates, exact figures, code snippets, and specific examples
 </synthesis>
 
 <format>
-- Concise — omit filler phrases and unnecessary hedging
+- Be thorough — cover the topic in depth with specific evidence, not surface-level summaries
+- Omit filler phrases and unnecessary hedging, but do not sacrifice detail for brevity
 - Include publication dates when recency affects relevance
-- Structure complex answers with clear sections
+- Structure answers with clear sections when covering multiple aspects
 - Cite sources inline using provided search results
 </format>
 
-Answer thoroughly. Get facts right.
+Answer thoroughly and in detail. Get facts right.

package/src/prompts/tools/task.md

@@ -1,212 +1,265 @@
 # Task
 
-Launch agents to handle complex, multi-step tasks autonomously.
+Launch subagents to execute parallel, well-scoped tasks with shared, token-efficient context.
 
-<critical>
-## Context is everything
+Subagents have **zero implicit context** — they see only `context` + `assignment`. Treat every subagent as a senior engineer on day one: technically strong, but unfamiliar with every decision, convention, and file layout you've accumulated.
 
-Subagents fail with vague context. Every task needs:
-1. **Goal** - What this accomplishes (one sentence)
-2. **Constraints** - Hard requirements, banned approaches, naming conventions
-3. **Existing Code** - File paths and function signatures to use as patterns
-4. **API Contract** - If the task produces or consumes an interface, spell it out
-
-Subagents CAN grep parent conversation file for supplementary details, but CANNOT grep for:
+Subagents CAN grep the parent conversation file for supplementary details, but CANNOT grep for:
 - Decisions you made but didn't write down
 - Conventions that exist only in your head
 - Which of 50 possible approaches you want
-  **Rule of thumb:** If you'd answer clarifying question for junior dev, info belongs in context.
-</critical>
+---
+
+## Parameters
+
+### `agent` (required)
+
+Agent type for all tasks in this batch.
+
+### `context` (optional — strongly recommended)
 
-<context-structure>
-## Required context structure
+Shared background prepended verbatim to every task `assignment`. Common info once; reduces token cost.
 
-Use this template. Omit sections only if N/A.
+Use template; omit non-applicable sections.
 
 ````
 ## Goal
-[One sentence: what this task accomplishes]
+One sentence: batch accomplishes together.
+
+## Non-goals
+Explicitly exclude tempting scope — what tasks must not touch/attempt.
 
 ## Constraints
-- [Hard requirements - MUST/MUST NOT style]
-- [API conventions, naming patterns, error handling]
-- [What already exists vs what to create]
+- MUST / MUST NOT rules (naming, error handling, banned approaches)
+- Language/framework version requirements
+- What exists vs what to create
 
-## Existing Code
-Reference files the agent MUST read/use as patterns:
-- `path/to/file.ts` - [what pattern it demonstrates]
-- `path/to/other.rs` - [what to reuse from it]
+## Reference Files
+- `path/to/file.ext` — pattern demo
+- `path/to/other.ext` — reuse or avoid
 
-## API Contract (if applicable)
+## API Contract (if tasks produce/consume shared interface)
 ```language
-// Exact signatures the agent must implement or consume
-fn example(input: Type) -> Result<Output>
+// Exact type definitions, function signatures, interface shapes
 ```
 
-## Task
-{{description}}
-
-## Files
-{{files}}
+## Acceptance (global)
+- Definition of "done" for batch
+- Note: build/test/lint verification happens AFTER all tasks complete — not inside tasks (see below)
 ````
+**Belongs in `context`**: project goal, non-goals, constraints, conventions, reference paths, shared type definitions, API contracts, global acceptance commands — anything 2+ tasks need.
+**Rule of thumb:** if repeat in 2+ tasks, belongs in `context`.
+**Does NOT belong in `context`**: per-task file lists, one-off requirements (go in `assignment`), structured output format (goes in `schema`).
+
+### `tasks` (required)
+
+Array tasks execute in parallel.
+
+|Field|Required|Purpose|
+|---|---|---|
+|`id`|✓|CamelCase identifier, max 32 chars|
+|`description`|✓|Short one-liner for UI display only — not seen by subagent|
+|`assignment`|✓|Complete per-task instructions. See [Writing an assignment](#writing-an-assignment).|
+|`skills`||Skill names preload. Use only when changes correctness — don’t spam every task.|
 
-### Bad context (agent fails or guesses wrong)
+{{#if isolationEnabled}}
+### `isolated` (optional)
+
+Run in isolated git worktree; returns patches. Use when tasks edit overlapping files or when you want clean per-task diffs.
+{{/if}}
+### `schema` (optional — recommended for structured output)
+
+JTD schema defining expected response structure. Use typed properties. If you care about parsing result, define here — **never describe output format in `context` or `assignment`**.
+---
+
+## Writing an assignment
+
+<critical>## Task scope
+
+`assignment` must contain enough info for agent to act **without asking a clarifying question**.
+**Minimum bar:** assignment under ~8 lines or missing acceptance criteria = too vague. One-liners guaranteed failure.
+
+Use structure every assignment:
 
 ```
-N-API migration. Keep highlight sync. Use JsString. No WASM.
-Task: {{description}} Files: {{files}}
+## Target
+- Files: exact path(s)
+- Symbols/entrypoints: specific functions, types, exports
+- Non-goals: what task must NOT touch (prevents scope creep)
+
+## Change
+- Step-by-step: add/remove/rename/restructure
+- Patterns/APIs to use; reference files if applicable
+
+## Edge Cases / Don't Break
+- Tricky case 1: ...
+- Tricky case 2: ...
+- Existing behavior must survive: ...
+
+## Acceptance (task-local)
+- Expected behavior or observable result
+- DO NOT include project-wide build/test/lint commands (see below)
 ```
 
-### Good context (agent can act confidently)
+`context` carries shared background. `assignment` carries only delta: file-specific instructions, local edge cases, per-task acceptance checks. Never duplicate shared constraints across assignments.
 
-````
-## Goal
-Port grep module from WASM to N-API, matching existing text module patterns.
+### Anti-patterns (ban these)
+**Vague assignments** — agent guesses wrong or stalls:
+- "Refactor this to be cleaner."
+- "Migrate to N-API."
+- "Fix the bug in streaming."
+- "Update all constructors in `src/**/*.ts`."
+**Vague context** — forces agent invent conventions:
+- "Use existing patterns."
+- "Follow conventions."
+- "No WASM."
 
-## Constraints
-- Use `#[napi]` attribute macro on all exports (not `#[napi(js_name = "...")]`)
-- Return `napi::Result<T>` for fallible ops; never panic
-- Use `spawn_blocking` for filesystem ops or >1ms work
-- Accept `JsString` for string params (NOT JsStringUtf8; lifetime issues)
-- Keep all existing function names - TS bindings depend on them
-- No new crate dependencies
-
-## Existing Code
-- `crates/pi-natives/src/text.rs` - reference N-API pattern: see how `visible_width` uses JsString
-- `crates/pi-natives/src/lib.rs` - module registration pattern
-- `crates/pi-natives/Cargo.toml` - available dependencies (ignore, regex already present)
-
-## API Contract
-Current sync API to convert to async:
-```rust
-// BEFORE (sync, blocks event loop)
-#[napi]
-pub fn search(pattern: String, path: String) -> Vec<Match>
-
-// AFTER (async, uses spawn_blocking)
-#[napi]
-pub async fn search(pattern: JsString, path: JsString, env: Env) -> napi::Result<Vec<Match>>
+If tempted to write above, expand using templates.
+**Test/lint commands in parallel tasks** — edit wars:
+Parallel agents share working tree. If two agents run `bun check` or `bun test` concurrently, they see each other's half-finished edits, "fix" phantom errors, loop. **Never tell parallel tasks run project-wide build/test/lint commands.** Each task edits, stops. Caller verifies after all tasks complete.
+**If you can’t specify scope yet**, create **Discovery task** first: enumerate files, find callsites, list candidates. Then fan out with explicit paths.
+
+### Delegate intent, not keystrokes
+
+Your role as tech lead: set direction, define boundaries, call out pitfalls — then get out of way. Don’t read every file, decide every edit, dictate line-by-line. That makes you bottleneck; agent typist.
+**Be specific about:** constraints, naming conventions, API contracts, "don’t break" items, acceptance criteria.
+**Delegate:** code reading, approach selection, exact edit locations, implementation details. Agent has tools, can reason about code.
+
+Micromanaging (you think, agent types):
+```
+assignment: "In src/api/handler.ts, line 47, change `throw err` to `throw new ApiError(err.message, 500)`.
+On line 63, wrap fetch call try/catch return 502 on failure.
+On line 89, add null check before accessing resp.body..."
+```
+
+Delegating (agent thinks within constraints):
+```
+assignment: "## Target\n- Files: src/api/handler.ts\n\n## Change\nImprove error handling: replace raw throws
+with typed ApiError instances, add try/catch around external calls, guard against null responses.\n\n
+## Edge Cases / Don't Break\n- Existing error codes in tests must still match\n
+- Don't change public function signatures"
 ```
 
-## Task
-{{description}}
+First style wastes your time, brittle if code shifts. Second gives agent room to do work.
+</critical>
 
-## Files
-{{files}}
-````
-</context-structure>
+## Example
 
-<parallelization>
-## When to parallelize vs sequence
-**Test:** Can agent B write correct code without seeing A's output?
-- If YES → parallelize
-- If NO → sequence (A completes, then B runs with A's output in context)
+<example type="bad" label="Duplicated context inflates tokens">
+<tasks>
+  <task name="Grep">
+    <description>Port grep module from WASM to N-API...</description>
+    <assignment>Port grep module from WASM to N-API... (same blob repeated)</assignment>
+</task>
+</tasks>
+</example>
 
-### Dependencies that MUST be sequential
+<example type="good" label="Shared rules in context, only deltas in assignment">
+<context>
+## Goal
+Port WASM modules to N-API, matching existing pi-natives conventions.
+
+## Non-goals
+Do not touch TS bindings or downstream consumers — separate phase.
 
-|First|Then|Why|
+## Constraints
+- MUST use `#[napi]` attribute macro on all exports
+- MUST return `napi::Result<T>` for fallible ops; never panic
+- MUST use `spawn_blocking` for filesystem I/O or >1ms work
+...
+
+## Acceptance (global)
+- Caller verifies after all tasks: `cargo test -p pi-natives` and `cargo build -p pi-natives` with no warnings
+- Individual tasks must NOT run these commands themselves
+</context>
+
+<tasks>
+  <task name="PortGrep">
+    <description>Port grep module to N-API</description>
+    <assignment>
+## Target
+- Files: `src/grep.rs`, `src/lib.rs` (registration only)
+- Symbols: search, search_multi, compile_pattern
+
+## Change
+- Implement three N-API exports in grep.rs:
+  - `search(pattern: JsString, path: JsString, env: Env) -> napi::Result<Vec<Match>>`
+...
+
+## Acceptance (task-local)
+- Three functions exported with correct signatures (caller verifies build after all tasks)
+</assignment>
+</task>
+
+  <task name="PortHighlight">
+    <description>Port highlight module to N-API</description>
+    <assignment>
+## Target
+- Files: `src/highlight.rs`, `src/lib.rs` (registration only)
+...
+</assignment>
+</task>
+</tasks>
+</example>
+---
+
+## Task scope
+
+Each task small, well-defined scope — **at most 3–5 files**.
+**Signs task too broad:**
+- File paths use globs (`src/**/*.ts`) instead of explicit names
+- Assignment says "update all" / "migrate everything" / "refactor across"
+- Scope covers entire package or directory tree
+**Fix:** enumerate files first (grep/glob discovery), then fan out one task per file or small cluster.
+---
+
+## Parallelization
+**Test:** Can task B produce correct output without seeing task A's result?
+- **Yes** → parallelize
+- **No** → run sequentially (A completes, then launch B with A output in context)
+
+### Must be sequential
+
+|First|Then|Reason|
 |---|---|---|
-|Create Rust API|Update TS bindings|Bindings need export names and signatures|
-|Define interface/types|Implement consumers|Consumers need contract|
-|Scaffold with signatures|Implement bodies|Implementations need shape|
+|Define types/interfaces|Implement consumers|Consumers need contract|
+|Create API exports|Write bindings/callers|Callers need export names/signatures|
+|Scaffold structure|Implement bodies|Bodies need shape|
 |Core module|Dependent modules|Dependents import from core|
+|Schema/DB migration|Application logic|Logic depends on new schema shape|
 
 ### Safe to parallelize
-- Independent modules not importing each other
+- Independent modules, no cross-imports
 - Tests for already-implemented code
+- Isolated file-scoped refactors
 - Documentation for stable APIs
-- Refactors in isolated file scopes
 
-### Phased execution pattern
+### Phased execution
 
-For layered migrations/refactors:
-**Phase 1 - Foundation (do yourself or single task):**
-Create scaffold, define interfaces, establish API shape. Never fan out until contract known.
-**Phase 2 - Parallel implementation:**
-Fan out to independent tasks consuming same known interface. Include Phase 1 API contract in every task's context.
-**Phase 3 - Integration (do yourself):**
-Wire things together, update build/CI, fix mismatches.
-**Phase 4 - Dependent layer:**
-Fan out again for work consuming Phase 2 outputs.
+Layered work with dependencies:
+**Phase 1 — Foundation** (do yourself or single task): define interfaces, create scaffolds, establish API shape. Never fan out until contract known.
+**Phase 2 — Parallel implementation**: fan out tasks consuming same known interface. Include Phase 1 API contract in `context`.
+**Phase 3 — Integration** (do yourself): wire modules, fix mismatches, verify builds.
+**Phase 4 — Dependent layer**: fan out tasks consuming Phase 2 outputs.
+---
 
-### Example: WASM to N-API migration
-**WRONG** (launched together, will fail):
+## Pre-flight checklist
 
-```
-tasks: [
-  { id: "RustApi", description: "Implement N-API exports" },
-  { id: "TsBindings", description: "Update TS to use N-API" },  // ← needs RustApi output!
-]
-```
-**RIGHT** (phased):
+Before calling tool, verify:
+- [ ] `context` includes shared constraints, references, definition of done
+- [ ] Each `assignment` follows assignment template — not one-liner
+- [ ] Each `assignment` includes edge cases / "don’t break" items
+- [ ] Tasks truly parallel (no hidden dependencies)
+- [ ] Scope small, file paths explicit (no globs)
+- [ ] No task runs project-wide build/test/lint — you do after all tasks complete
+- [ ] `schema` used if you expect information
+---
+
+## Agents
 
-```
-// Phase 1: You create scaffold with signatures in lib.rs
-
-// Phase 2: Fan out Rust implementation
-tasks: [
-  { id: "Grep", description: "Implement grep module", args: { files: "src/grep.rs" } },
-  { id: "Text", description: "Implement text module", args: { files: "src/text.rs" } },
-  // Each task gets the API contract you defined in Phase 1
-]
-
-// Phase 3: You verify Rust compiles, exports are correct
-
-// Phase 4: Fan out TS bindings (now they know what Rust exports)
-tasks: [
-  { id: "GrepBindings", description: "Update grep TS", args: { files: "src/grep/index.ts" } },
-  // Context includes actual export names from Phase 2
-]
-```
-</parallelization>
-
-<parameters>
-- `agent`: Agent type for all tasks
-- `context`: Template with `{{placeholders}}`; **Must follow structure above**.
-- `isolated`: (optional) Run in git worktree, return patches
-- `tasks`: Array of `{id, description, args}`
-  - `id`: CamelCase identifier (max 32 chars)
-  - `description`: What task does (for logging)
-  - `args`: Object with keys matching `{{placeholders}}` in context
-  - `skills`: (optional) Skill names to preload
-- `schema`: JTD schema for response structure (**required**; use typed properties, not `{ "type": "string" }`). **Schema goes in `schema`; never describe output format in `context`.**
-</parameters>
-
-<agents>
 {{#list agents join="\n"}}
 <agent name="{{name}}"{{#if output}} output="structured"{{/if}}>
 <description>{{description}}</description>
 <tools>{{default (join tools ", ") "All tools"}}</tools>
 </agent>
-{{/list}}
-</agents>
-
-<critical>
-## Task granularity
-
-Each task MUST target a small, well-defined scope. A single task should touch at most 3-5 files.
-**Red flags that a task is too broad:**
-- File list uses globs (`src/**/*.ts`) instead of explicit paths
-- Description says "update all" / "migrate all" / "refactor all"
-- Task covers an entire package or directory tree
-- Estimated touch surface is >5 files
-**Fix:** Split into one task per file (or small group of related files). Fan out in parallel.
-
-### Bad (will timeout or produce garbage)
-```
-tasks: [
-  { id: "UpdateAll", description: "Update all constructor calls in src/**/*.ts" }
-]
-```
-
-### Good (focused, parallel)
-```
-tasks: [
-  { id: "UpdateDebug", description: "Update constructors in debug/index.ts", args: { files: "src/debug/index.ts" } },
-  { id: "UpdateAgent", description: "Update constructors in commit/agent.ts", args: { files: "src/commit/agentic/agent.ts" } },
-  { id: "UpdateTodoExample", description: "Update constructors in examples/todo", args: { files: "examples/custom-tools/todo/index.ts" } },
-]
-```
-
-When the set of files isn't known upfront, grep/glob yourself first to enumerate them, then fan out one task per file.
-</critical>
+{{/list}}

package/src/sdk.ts

@@ -1,41 +1,11 @@
-/**
- * SDK for programmatic usage of AgentSession.
- *
- * Provides a factory function and discovery helpers that allow full control
- * over agent configuration, or sensible defaults that match CLI behavior.
- *
- * @example
- * ```typescript
- * // Minimal - everything auto-discovered
- * const session = await createAgentSession();
- *
- * // With custom extensions
- * const session = await createAgentSession({
- *   extensions: [myExtensionFactory],
- * });
- *
- * // Full control
- * const session = await createAgentSession({
- *   model: myModel,
- *   getApiKey: async () => Bun.env.MY_KEY,
- *   toolNames: ["read", "bash", "edit", "write"], // Filter tools
- *   extensions: [],
- *   skills: [],
- *   sessionFile: false,
- * });
- * ```
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
 import { Agent, type AgentEvent, type AgentMessage, type AgentTool, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { type Message, type Model, supportsXhigh } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { $env, logger, postmortem } from "@oh-my-pi/pi-utils";
-import { YAML } from "bun";
 import chalk from "chalk";
 import { loadCapability } from "./capability";
 import { type Rule, ruleCapability } from "./capability/rule";
-import { getAgentDir, getConfigDirPaths } from "./config";
+import { getAgentDbPath, getAgentDir } from "./config";
 import { ModelRegistry } from "./config/model-registry";
 import { formatModelString, parseModelString } from "./config/model-resolver";
 import { loadPromptTemplates as loadPromptTemplatesInternal, type PromptTemplate } from "./config/prompt-templates";
@@ -79,7 +49,6 @@ import { AgentSession } from "./session/agent-session";
 import { AuthStorage } from "./session/auth-storage";
 import { convertToLlm } from "./session/messages";
 import { SessionManager } from "./session/session-manager";
-import { migrateJsonStorage } from "./session/storage-migration";
 import { closeAllConnections } from "./ssh/connection-manager";
 import { unmountAll } from "./ssh/sshfs-mount";
 import {
@@ -94,12 +63,12 @@ import {
 	EditTool,
 	FindTool,
 	GrepTool,
-	getWebSearchTools,
+	getSearchTools,
 	loadSshTool,
 	PythonTool,
 	ReadTool,
 	setPreferredImageProvider,
-	setPreferredWebSearchProvider,
+	setPreferredSearchProvider,
 	type Tool,
 	type ToolSession,
 	WriteTool,
@@ -259,82 +228,14 @@ function getDefaultAgentDir(): string {
  * Reads from primary path first, then falls back to legacy paths (.pi, .claude).
  */
 export async function discoverAuthStorage(agentDir: string = getDefaultAgentDir()): Promise<AuthStorage> {
-	const primaryPath = path.join(agentDir, "auth.json");
-	// Get all auth.json paths (user-level only), excluding the primary
-	const allPaths = getConfigDirPaths("auth.json", { project: false });
-	const fallbackPaths = allPaths.filter(p => p !== primaryPath);
-
-	logger.debug("discoverAuthStorage", { agentDir, primaryPath, allPaths, fallbackPaths });
-
-	// Migrate legacy JSON files (settings.json, auth.json) to SQLite before loading
-	await migrateJsonStorage({
-		agentDir,
-		settingsPath: path.join(agentDir, "settings.json"),
-		authPaths: [primaryPath, ...fallbackPaths],
-	});
+	const dbPath = getAgentDbPath(agentDir);
+	logger.debug("discoverAuthStorage", { agentDir, dbPath });
 
-	const storage = await AuthStorage.create(primaryPath, fallbackPaths);
+	const storage = await AuthStorage.create(dbPath);
 	await storage.reload();
 	return storage;
 }
 
-/**
- * Create a ModelRegistry with fallback support.
- * Prefers models.yml over models.json. Reads from primary path first,
- * then falls back to legacy paths (.pi, .claude).
- */
-export function discoverModels(authStorage: AuthStorage, agentDir: string = getDefaultAgentDir()): ModelRegistry {
-	const yamlPath = path.join(agentDir, "models.yml");
-	const jsonPath = path.join(agentDir, "models.json");
-
-	// Check existence of yaml and json files
-	let yamlExists = fs.existsSync(yamlPath);
-	let jsonExists = fs.existsSync(jsonPath);
-
-	// Migrate models.json to models.yml if yaml doesn't exist but json does
-	if (!yamlExists && jsonExists) {
-		migrateModelsJsonToYaml(jsonPath, yamlPath);
-		yamlExists = fs.existsSync(yamlPath);
-		jsonExists = fs.existsSync(jsonPath);
-	}
-
-	// Prefer models.yml, fall back to models.json
-	const primaryPath = yamlExists ? yamlPath : jsonPath;
-
-	// Get all models config paths (user-level only), excluding the primary
-	const yamlPaths = getConfigDirPaths("models.yml", { project: false });
-	const jsonPaths = getConfigDirPaths("models.json", { project: false });
-	const allPaths = [...yamlPaths, ...jsonPaths];
-	const existenceResults = allPaths.map(p => {
-		return { p, exists: fs.existsSync(p) };
-	});
-	const fallbackPaths = existenceResults.filter(({ p, exists }) => p !== primaryPath && exists).map(({ p }) => p);
-
-	logger.debug("discoverModels", { primaryPath, fallbackPaths });
-	return new ModelRegistry(authStorage, primaryPath, fallbackPaths);
-}
-
-/**
- * Migrate models.json to models.yml.
- * Creates models.yml from models.json and renames the json file to .bak.
- */
-function migrateModelsJsonToYaml(jsonPath: string, yamlPath: string): void {
-	try {
-		const content = fs.readFileSync(jsonPath, "utf-8");
-		const parsed = JSON.parse(content);
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-			logger.warn("migrateModelsJsonToYaml: invalid models.json structure", { path: jsonPath });
-			return;
-		}
-		fs.mkdirSync(path.dirname(yamlPath), { recursive: true });
-		fs.writeFileSync(yamlPath, YAML.stringify(parsed, null, 2));
-		fs.renameSync(jsonPath, `${jsonPath}.bak`);
-		logger.debug("migrateModelsJsonToYaml: migrated models.json to models.yml", { from: jsonPath, to: yamlPath });
-	} catch (error) {
-		logger.warn("migrateModelsJsonToYaml: migration failed", { error: String(error) });
-	}
-}
-
 /**
  * Discover extensions from cwd.
  */
@@ -585,7 +486,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	// Use provided or create AuthStorage and ModelRegistry
 	const authStorage = options.authStorage ?? (await discoverAuthStorage(agentDir));
-	const modelRegistry = options.modelRegistry ?? discoverModels(authStorage, agentDir);
+	const modelRegistry = options.modelRegistry ?? new ModelRegistry(authStorage);
 	time("discoverModels");
 
 	const settingsInstance = options.settingsInstance ?? (await Settings.init({ cwd, agentDir }));
@@ -594,7 +495,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	time("initializeWithSettings");
 
 	// Initialize provider preferences from settings
-	setPreferredWebSearchProvider(settingsInstance.get("providers.webSearch") ?? "auto");
+	setPreferredSearchProvider(settingsInstance.get("providers.webSearch") ?? "auto");
 	setPreferredImageProvider(settingsInstance.get("providers.image") ?? "auto");
 
 	const sessionManager = options.sessionManager ?? SessionManager.create(cwd);
@@ -839,16 +740,16 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	// Add specialized Exa web search tools if EXA_API_KEY is available
 	const exaSettings = settingsInstance.getGroup("exa");
 	if (exaSettings.enabled && exaSettings.enableSearch) {
-		const exaWebSearchTools = await getWebSearchTools({
+		const exaSearchTools = await getSearchTools({
 			enableLinkedin: exaSettings.enableLinkedin as boolean,
 			enableCompany: exaSettings.enableCompany as boolean,
 		});
 		// Filter out the base web_search (already in built-in tools), add specialized Exa tools
-		const specializedTools = exaWebSearchTools.filter(t => t.name !== "web_search");
+		const specializedTools = exaSearchTools.filter(t => t.name !== "web_search");
 		if (specializedTools.length > 0) {
 			customTools.push(...specializedTools);
 		}
-		time("getWebSearchTools");
+		time("getSearchTools");
 	}
 
 	const inlineExtensions: ExtensionFactory[] = options.extensions ? [...options.extensions] : [];