@tianmucreations/jeeves 0.3.1 → 0.3.2

package/dist/providers/openrouter.js

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { streamText, stepCountIs } from 'ai';
 import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { silenceGuard } from './silence.js';
 import { prepareStepFor, stepCost } from './step-control.js';
 // Assumption: the spec's "maxSteps" is called stopWhen/stepCountIs in AI SDK 7 (the installed version); same cap of 25.
 const MAX_TOOL_STEPS = 25;
@@ -38,6 +39,15 @@ export async function fetchCreditInfo(apiKey) {
         return null;
     }
 }
+// A brand-new OpenRouter account has no credit: it connects, but only the free
+// models answer. Said plainly right after connecting, or '' when there is credit
+// (or the balance can't be read - never a guess).
+export async function noCreditNote(apiKey) {
+    const info = await fetchCreditInfo(apiKey);
+    if (!info || info.remaining > 0)
+        return '';
+    return 'Your OpenRouter account has no credit yet. The free models work now - choose one from the Free list. To use the others, add credit at openrouter.ai/credits.';
+}
 // The key's all-time spend in dollars, from GET /api/v1/key (field "usage",
 // confirmed against a live response). Used to work out today's spend in local time.
 export async function fetchKeyUsage(apiKey) {
@@ -67,6 +77,7 @@ export function createOpenRouterProvider(apiKey) {
         id: 'openrouter',
         name: 'OpenRouter',
         async stream({ modelId, messages, tools, instructions, onToken, onReasoning, onToolCall, beforeStep, abortSignal }) {
+            const guard = silenceGuard(abortSignal);
             const result = streamText({
                 instructions,
                 // A stalled request must never wedge the app in the working state forever -
@@ -76,14 +87,16 @@ export function createOpenRouterProvider(apiKey) {
                 // started, and 10 minutes for any single step, which also covers a request that
                 // never starts answering. (A plain number here limits the entire multi-step
                 // job; a 3-minute one killed healthy jobs mid-way in testing.)
-                timeout: { firstChunkMs: 120_000, chunkMs: 90_000, stepMs: 600_000 },
+                // Silence while the model answers is watched by silenceGuard (it pauses while a
+                // command runs or waits for the person); the first piece still has 2 minutes.
+                timeout: { firstChunkMs: 120_000 },
                 // Usage accounting makes OpenRouter report each step's exact cost.
                 model: openrouter.chat(modelId, { usage: { include: true } }),
                 messages,
                 tools,
                 stopWhen: stepCountIs(MAX_TOOL_STEPS),
                 prepareStep: prepareStepFor(beforeStep, (id) => openrouter.chat(id, { usage: { include: true } })),
-                abortSignal,
+                abortSignal: guard.signal,
                 // The library prints every failure to the screen by default, over Jeeves's
                 // window; the failure still arrives below and is explained in plain English.
                 onError: () => { },
@@ -95,6 +108,7 @@ export function createOpenRouterProvider(apiKey) {
             });
             let streamedError = null;
             for await (const part of result.stream) {
+                guard.onPart(part);
                 if (part.type === 'text-delta') {
                     onToken(part.text);
                 }
@@ -108,6 +122,7 @@ export function createOpenRouterProvider(apiKey) {
                     streamedError = part.error;
                 }
             }
+            guard.stop();
             // The real stream error (a rejected key, a missing model) must win over the
             // SDK's generic no-output error, which would otherwise mask the cause.
             if (streamedError !== null) {

package/dist/providers/silence.js

@@ -0,0 +1,39 @@
+// A stalled reply must never leave Jeeves "working" forever - but the time a
+// command runs, or the time the person takes to answer "allow?", is not the model
+// going quiet. The AI SDK's timeout.chunkMs counts both (measured 19 Sept: a 2 s tool
+// tripped a 1 s chunkMs), so any command over 90 s cancelled the whole job and
+// blamed the service. This watchdog counts silence only while no tool is running.
+export const SILENCE_MS = 90_000;
+export function silenceGuard(outer, ms = SILENCE_MS) {
+    const controller = new AbortController();
+    let timer;
+    let toolsRunning = 0;
+    const arm = () => {
+        clearTimeout(timer);
+        if (toolsRunning > 0)
+            return;
+        // Named as the SDK names its own, so the plain-English message stays the same.
+        timer = setTimeout(() => controller.abort(new DOMException(`Chunk timeout of ${ms}ms exceeded`, 'TimeoutError')), ms);
+        // A finished or stopped reply never keeps Jeeves (or a test run) waiting on this timer.
+        timer.unref();
+    };
+    if (outer?.aborted)
+        controller.abort(outer.reason);
+    else
+        outer?.addEventListener('abort', () => controller.abort(outer.reason), { once: true });
+    return {
+        signal: controller.signal,
+        onPart(part) {
+            if (part.type === 'tool-call')
+                toolsRunning += 1;
+            else if (part.type === 'tool-result' || part.type === 'tool-error' || part.type === 'tool-output-denied')
+                toolsRunning = Math.max(0, toolsRunning - 1);
+            arm();
+        },
+        stop() {
+            clearTimeout(timer);
+            if (controller.signal.aborted && !outer?.aborted)
+                throw controller.signal.reason;
+        },
+    };
+}

package/dist/providers/zai.js

@@ -1,11 +1,14 @@
 import { streamText, stepCountIs } from 'ai';
-import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { silenceGuard } from './silence.js';
 import { prepareStepFor } from './step-control.js';
 // The GLM Coding Plan endpoint: OpenAI Chat Completions protocol at
 // https://api.z.ai/api/coding/paas/v4 - NOT the standard /api/paas/v4, which is
-// the pay-per-token API. The OpenRouter client speaks the OpenAI protocol, so it
-// talks to the coding endpoint directly (the same trick the Ollama adapter uses
-// for its OpenAI-compatible endpoint).
+// the pay-per-token API. Connected with @ai-sdk/openai-compatible, as OpenCode does
+// (models.dev "zai-coding-plan"): unlike the OpenRouter client used before, it reads
+// Z.ai's thinking (reasoning_content), so Jeeves can say it is thinking. GLM-5.3
+// thinks for up to half a minute before answering; with the old client that time
+// showed nothing at all (measured 19 Sept: 1,425 thinking tokens, first words at 26 s).
 export const ZAI_CODING_BASE_URL = 'https://api.z.ai/api/coding/paas/v4';
 const MAX_TOOL_STEPS = 25;
 // The GLM Coding Plan is flat-rate, so prices are meaningless per token; the picker
@@ -53,15 +56,12 @@ export const ZAI_MODELS = [
     },
 ];
 export function createZaiProvider(apiKey) {
-    const client = createOpenRouter({
-        apiKey,
-        baseURL: ZAI_CODING_BASE_URL,
-        compatibility: 'compatible',
-    });
+    const client = createOpenAICompatible({ name: 'zai', apiKey, baseURL: ZAI_CODING_BASE_URL, includeUsage: true });
     return {
         id: 'zai',
         name: 'Z.ai',
         async stream({ modelId, messages, tools, instructions, onToken, onReasoning, onToolCall, beforeStep, abortSignal }) {
+            const guard = silenceGuard(abortSignal);
             const result = streamText({
                 instructions,
                 // A stalled request must never wedge the app in the working state forever -
@@ -71,19 +71,22 @@ export function createZaiProvider(apiKey) {
                 // started, and 10 minutes for any single step, which also covers a request that
                 // never starts answering. (A plain number here limits the entire multi-step
                 // job; a 3-minute one killed healthy jobs mid-way in testing.)
-                timeout: { firstChunkMs: 120_000, chunkMs: 90_000, stepMs: 600_000 },
-                model: client.chat(modelId),
+                // Silence while the model answers is watched by silenceGuard (it pauses while a
+                // command runs or waits for the person); the first piece still has 2 minutes.
+                timeout: { firstChunkMs: 120_000 },
+                model: client.chatModel(modelId),
                 messages,
                 tools,
                 stopWhen: stepCountIs(MAX_TOOL_STEPS),
-                prepareStep: prepareStepFor(beforeStep, (id) => client.chat(id)),
-                abortSignal,
+                prepareStep: prepareStepFor(beforeStep, (id) => client.chatModel(id)),
+                abortSignal: guard.signal,
                 // The library prints every failure to the screen by default, over Jeeves's
                 // window; the failure still arrives below and is explained in plain English.
                 onError: () => { },
             });
             let streamedError = null;
             for await (const part of result.stream) {
+                guard.onPart(part);
                 if (part.type === 'text-delta') {
                     onToken(part.text);
                 }
@@ -97,6 +100,7 @@ export function createZaiProvider(apiKey) {
                     streamedError = part.error;
                 }
             }
+            guard.stop();
             // The real stream error (a rejected key, a missing model) must win over the
             // SDK's generic no-output error, which would otherwise mask the cause.
             if (streamedError !== null) {

package/dist/state/session.js

@@ -44,6 +44,9 @@ class SessionStore {
     tidying = false;
     // A short note for the info bar while something quick runs, like 'backing up…'.
     busyNote = null;
+    // When the model began thinking privately before writing (ms), or null. Thinking
+    // can last half a minute, so the screen says so instead of showing nothing.
+    thinkingSince = null;
     // Something the model must be told with the next message (for example, that /undo ran).
     pendingContextNote = null;
     // The daily spending limit in dollars, and any extra allowance granted today.
@@ -58,6 +61,15 @@ class SessionStore {
     // The furthest the transcript can scroll up (contentHeight - viewportHeight),
     // reported by the Transcript from its live measurements.
     transcriptScrollMax = Number.POSITIVE_INFINITY;
+    // Text selected with the mouse in the conversation (Claude Code's in-app selection):
+    // line and character positions within the drawn lines, so it stays on its words
+    // while the view scrolls. null when nothing is selected.
+    selection = null;
+    // What the conversation area shows, published by the Transcript each time it draws,
+    // so a mouse position can be turned into a line and character.
+    // Set by the typing box: puts the cursor at a clicked screen position.
+    inputClick = null;
+    transcriptView = null;
     // What is being typed in the input box (the window sizes the box to fit it).
     inputText = '';
     // Messages sent while Jeeves was busy, in order; each is sent when he finishes.
@@ -222,9 +234,11 @@ class SessionStore {
         this.wizardActive = true;
         this.emit();
     }
-    endWizard() {
+    // skipped: the person chose "not now" - straight to the conversation, not a second
+    // list of services (audit 19 Sept).
+    endWizard(skipped = false) {
         this.wizardActive = false;
-        const shouldOpenModelPicker = this.wizardFromLaunch;
+        const shouldOpenModelPicker = this.wizardFromLaunch && !skipped;
         this.wizardFromLaunch = false;
         this.emit();
         if (shouldOpenModelPicker) {
@@ -233,6 +247,19 @@ class SessionStore {
     }
     launchComplete() {
         this.launchStage = 'ready';
+        this.switchingFolder = false;
+        this.emit();
+    }
+    // /folder: the folder list again, from inside a conversation (owner, 19 Sept: from
+    // "Just chat" there was no way into a folder). Between tasks only, like /model.
+    switchingFolder = false;
+    openFolderPicker() {
+        if (this.status === 'working' || this.approvalPending) {
+            this.addNotice('The folder can be changed between tasks.');
+            return;
+        }
+        this.switchingFolder = true;
+        this.launchStage = 'project';
         this.emit();
     }
     // The address question runs before the project picker on first launch only;
@@ -293,6 +320,12 @@ class SessionStore {
         this.transcriptScrollUp = next;
         this.emit();
     }
+    setSelection(selection) {
+        if (selection === null && this.selection === null)
+            return;
+        this.selection = selection;
+        this.emit();
+    }
     setTranscriptScrollMax(max) {
         this.transcriptScrollMax = Math.max(0, max);
         if (this.transcriptScrollUp > this.transcriptScrollMax) {
@@ -350,6 +383,12 @@ class SessionStore {
         this.activeModel = model;
         this.emit();
     }
+    setThinking(on) {
+        if (on === (this.thinkingSince !== null))
+            return;
+        this.thinkingSince = on ? Date.now() : null;
+        this.emit();
+    }
     setBusyNote(note) {
         if (this.busyNote === note)
             return;

package/dist/tools/index.js

@@ -5,7 +5,7 @@ import { readFileSchema, runReadFile } from './readFile.js';
 import { writeFileSchema, runWriteFile } from './writeFile.js';
 import { listDirSchema, runListDir } from './listDir.js';
 import { runBashSchema, runRunBash } from './runBash.js';
-import { webSearchSchema, runWebSearch, readWebPageSchema, runReadWebPage } from './web/research.js';
+import { webSearchSchema, runWebSearch, readWebPageSchema, runReadWebPage, researchService, borrowedSearchNeedsAsking, borrowedSearchQuestion } from './web/research.js';
 import { ensureCheckpoint, isOutsideProject, commandMayReachOutside } from '../checkpoints/index.js';
 import { resolveFromCwd } from '../platform/paths.js';
 import { isProjectTrusted } from '../agent/trust.js';
@@ -41,6 +41,10 @@ export function plainToolFailure(error) {
         return 'that folder is not empty';
     if (text.includes('no space left'))
         return 'the disk is full';
+    // Say how long it was allowed ("didn't finish in 2 minutes"), not just "took too long".
+    const limit = /didn't finish in ([0-9]+ (?:minutes?|seconds))/.exec(raw)?.[1];
+    if (limit)
+        return `still running after ${limit}, so it was stopped`;
     if (text.includes('timed out') || text.includes('etimedout') || text.includes('stopped after') || text.includes("didn't finish"))
         return 'took too long';
     if (text.includes('binary file'))
@@ -49,6 +53,12 @@ export function plainToolFailure(error) {
         return 'needs an OpenRouter key (type /keys)';
     if (text.includes('web search is not available'))
         return 'web search is not available right now';
+    if (text.includes("web search isn't available with"))
+        return "web search isn't available with this service yet";
+    if (text.includes('was not allowed in this conversation'))
+        return 'not allowed';
+    if (text.includes('needs your z.ai key'))
+        return 'needs your Z.ai key (type /keys)';
     if (text.includes("couldn't open"))
         return "that website wouldn't open";
     if (text.includes('not a valid web address') || text.includes('only web pages'))
@@ -59,6 +69,10 @@ export function plainToolFailure(error) {
     // and explains it in plain English.
     return 'something unexpected went wrong';
 }
+function researchLabel() {
+    const service = researchService();
+    return service === 'zai' ? ' (Z.ai plan)' : service === 'borrowed' ? ' (via OpenRouter)' : '';
+}
 function clip(text, max) {
     return text.length > max ? text.slice(0, max - 1) + '…' : text;
 }
@@ -155,10 +169,13 @@ export const TOOLS = {
         name: 'webSearch',
         description: 'Search the web. Returns titles, addresses and short snippets - a list of where to look, not checked facts.',
         schema: webSearchSchema,
-        permission: false,
+        // On a service with no search of its own, a search borrows OpenRouter (about a cent
+        // each) only after a yes, asked once per conversation - never "always allowed".
+        permission: () => borrowedSearchNeedsAsking(),
+        warning: () => (borrowedSearchNeedsAsking() ? borrowedSearchQuestion() : null),
         summarize: (input) => clip(input.query, 60),
-        // On another service, searches still go through OpenRouter (about a cent each), so say so.
-        label: (input) => `Searched ${clip(input.query, 50)}${session.providerId === 'openrouter' ? '' : ' (via OpenRouter)'}`,
+        // Every search line says which service it went through.
+        label: (input) => `Searched ${clip(input.query, 50)}${researchLabel()}`,
         run: runWebSearch,
     }),
     readWebPage: defineTool({
@@ -167,7 +184,7 @@ export const TOOLS = {
         schema: readWebPageSchema,
         permission: false,
         summarize: (input) => clip(input.url, 60),
-        label: (input) => `Read ${clip(input.url.replace(/^https?:\/\//, ''), 50)}${session.providerId === 'openrouter' ? '' : ' (via OpenRouter)'}`,
+        label: (input) => `Read ${clip(input.url.replace(/^https?:\/\//, ''), 50)}${researchService() === 'zai' ? ' (Z.ai plan)' : ''}`,
         run: runReadWebPage,
     }),
     runBash: defineTool({

package/dist/tools/runBash.js

@@ -2,8 +2,17 @@ import { execa } from 'execa';
 import { z } from 'zod';
 import { getShell } from '../platform/shell.js';
 import { stripQuotes } from '../agent/permissions.js';
+// Claude Code's limits (utils/timeouts.ts): 2 minutes unless the model asks for
+// more, 10 minutes at most. Jeeves had 60 seconds, which cut off every large
+// download or install (owner's screenshot, 19 Sept).
+export const DEFAULT_COMMAND_MS = 120_000;
+export const MAX_COMMAND_MS = 600_000;
 export const runBashSchema = z.object({
     command: z.string().describe('The shell command to run'),
+    timeout: z
+        .number()
+        .optional()
+        .describe(`How long the command may run, in milliseconds - up to ${MAX_COMMAND_MS} (10 minutes). Without it: ${DEFAULT_COMMAND_MS} (2 minutes). Ask for more for downloads, installs and builds.`),
 });
 // Every running command is registered so the exit paths (Ctrl+C, /exit, kill
 // signals) can terminate them immediately - the UI must never be left waiting on
@@ -33,28 +42,31 @@ function interactiveCommandIn(command) {
     }
     return null;
 }
-// A hard ceiling per command: anything still running after this is killed and
-// reported to the model, which continues the conversation.
-const COMMAND_TIMEOUT_MS = 60_000;
+export function describeLimit(ms) {
+    return ms % 60_000 === 0 ? `${ms / 60_000} minute${ms === 60_000 ? '' : 's'}` : `${Math.round(ms / 1000)} seconds`;
+}
 export async function runRunBash(input) {
     const refusal = interactiveCommandIn(input.command);
     if (refusal !== null) {
         throw new Error(`${refusal} needs an interactive terminal, which this tool does not provide - it was not run. Use a non-interactive alternative (for example cat or grep) instead.`);
     }
+    // A hard ceiling per command: anything still running after this is killed and
+    // reported to the model, which continues the conversation.
+    const limit = Math.min(Math.max(input.timeout ?? DEFAULT_COMMAND_MS, 1_000), MAX_COMMAND_MS);
     const shell = getShell();
     const child = execa(shell.program, [shell.flag, input.command], {
         reject: false,
         // stdin is /dev/null: a command that reads input gets an immediate end-of-file
         // instead of sitting forever waiting for keystrokes that will never come.
         stdin: 'ignore',
-        timeout: COMMAND_TIMEOUT_MS,
+        timeout: limit,
         forceKillAfterDelay: 2_000,
     });
     running.add(child);
     try {
         const result = await child;
         if (result.timedOut === true) {
-            throw new Error(`that command didn't finish in ${COMMAND_TIMEOUT_MS / 1000} seconds - it may be waiting for input. It was stopped.`);
+            throw new Error(`that command didn't finish in ${describeLimit(limit)} - it may be waiting for input, or need longer (up to 10 minutes can be asked for). It was stopped.`);
         }
         const parts = [`$ ${input.command}`, `exit code: ${result.exitCode ?? 'unknown'}`];
         if (result.stdout)

package/dist/tools/web/research.js

@@ -1,10 +1,21 @@
 import { z } from 'zod';
 import { session } from '../../state/session.js';
-import { getOpenRouterKey } from '../../providers/index.js';
+import { getOpenRouterKey, getZaiKey, PROVIDER_ROWS } from '../../providers/index.js';
+import { zaiSearch, zaiRead } from './zai-search.js';
+import { expertChat } from '../../agent/expert-chat.js';
+import { isDirectService } from '../../providers/direct-services.js';
 import { htmlToText } from './htmlToText.js';
 import { openrouterChat, OpenRouterRequestError } from './openrouterChat.js';
-import { workingModelId, workerModel } from '../../agent/auto.js';
+import { workingModelId, workerModel, hasAuto } from '../../agent/auto.js';
 import { recordPageOpened, recordSearchResults, recordWebUnavailable } from '../../agent/research-gate.js';
+// The service chosen is the service used (owner's rule, 18 Sept): "if someone has a plan
+// and selects plan then the plan should be the thing being used". So:
+// - OpenRouter: search and reading on OpenRouter, as below;
+// - Z.ai's GLM Coding Plan: search with the plan's own Web Search service and reading
+//   with GLM-5.3-Flash on the plan - never OpenRouter, even when a key is saved;
+// - any other service: reading with that service; search has no equivalent there yet,
+//   so it borrows OpenRouter only after the person says yes (once per conversation),
+//   and without an OpenRouter key says plainly that search isn't available.
 // Web research, built only on OpenRouter's standard (non-beta) features, with
 // automatic fallbacks so no single service leaving creates a hole:
 // - search: OpenRouter's web search plugin, rotating Exa -> Parallel -> Perplexity
@@ -29,7 +40,7 @@ export const PROVEN_READING_MODELS = ['deepseek/deepseek-v4-flash-0731', 'openai
 // Reading models in the order tried: the cheap one first, then Jeeves's own model
 // when that is also an OpenRouter model, then the proven ones.
 export function readingModels() {
-    // Research always runs through OpenRouter, so it uses OpenRouter's Auto worker.
+    // Used only for research on OpenRouter, so it is OpenRouter's Auto worker.
     const models = [workerModel('openrouter')];
     const current = workingModelId(session.model);
     if (session.providerId === 'openrouter' && current && !models.includes(current))
@@ -49,7 +60,60 @@ export function reasoningIsMandatory(error) {
 function isAccountProblem(error) {
     return error instanceof OpenRouterRequestError && (error.status === 401 || error.status === 402);
 }
+// Which service web research runs on for the service in use.
+export function researchService(providerId = session.providerId) {
+    if (providerId === 'openrouter')
+        return 'openrouter';
+    if (providerId === 'zai')
+        return 'zai';
+    return 'borrowed';
+}
+export function serviceLabel(providerId = session.providerId) {
+    return PROVIDER_ROWS.find((row) => row.id === providerId)?.label ?? 'this service';
+}
+// Whether the person agreed, in this conversation, to searches using their OpenRouter
+// account while another service is in use. /clear forgets it.
+let borrowAgreed = false;
+export function agreeToBorrowedSearch() {
+    borrowAgreed = true;
+}
+export function resetBorrowedSearch() {
+    borrowAgreed = false;
+}
+// Asked before a search on OpenRouter while another service is in use.
+export function borrowedSearchNeedsAsking() {
+    return researchService() === 'borrowed' && getOpenRouterKey() !== null && !borrowAgreed;
+}
+export function borrowedSearchQuestion() {
+    return `Web search isn't available with ${serviceLabel()} yet, so this search would use your OpenRouter account (about a cent each). Allow searches through OpenRouter for this conversation? (y/n)`;
+}
+async function searchOnPlan(query, site) {
+    const key = getZaiKey();
+    if (!key) {
+        recordWebUnavailable();
+        throw new Error('Web search on the Z.ai plan needs your Z.ai key - type /keys to add it.');
+    }
+    try {
+        const results = await zaiSearch(key, query, site);
+        recordSearchResults(results.map((result) => result.url));
+        return results;
+    }
+    catch (error) {
+        recordWebUnavailable();
+        throw new Error(`Web search is not available right now on the Z.ai plan (${error instanceof Error ? error.message : String(error)}).`);
+    }
+}
 export async function searchWeb(query, site) {
+    const service = researchService();
+    if (service === 'zai')
+        return searchOnPlan(query, site);
+    if (service === 'borrowed' && !getOpenRouterKey()) {
+        recordWebUnavailable();
+        throw new Error(`Web search isn't available with ${serviceLabel()} yet.`);
+    }
+    if (service === 'borrowed' && !borrowAgreed) {
+        throw new Error('Web search through OpenRouter was not allowed in this conversation.');
+    }
     const key = getOpenRouterKey();
     if (!key) {
         recordWebUnavailable();
@@ -97,12 +161,18 @@ export function formatSearchResults(query, results) {
         const snippet = result.content.replace(/\s+/g, ' ').trim().slice(0, SNIPPET_CHARS);
         return `${index + 1}. ${result.title || result.url}\n   ${result.url}${snippet ? `\n   ${snippet}` : ''}`;
     });
-    return `${lines.join('\n')}\n\nThese are search snippets, not checked facts. Open the most official page with readWebPage before stating anything as fact.`;
+    const planNote = researchService() === 'zai'
+        ? ' These results often point to a site\'s front page with a short summary: open the page, and if the exact fact is not there, say plainly that it could not be confirmed.'
+        : '';
+    return `${lines.join('\n')}\n\nThese are search snippets, not checked facts. Open the most official page with readWebPage before stating anything as fact.${planNote}`;
 }
 export const webSearchSchema = z.object({
     query: z.string().min(1).describe('What to search the web for'),
 });
 export async function runWebSearch(input) {
+    // Only reached after the person said yes when the search is borrowed from OpenRouter.
+    if (researchService() === 'borrowed' && getOpenRouterKey())
+        agreeToBorrowedSearch();
     return formatSearchResults(input.query, await searchWeb(input.query));
 }
 export const readWebPageSchema = z.object({
@@ -156,6 +226,7 @@ export async function runReadWebPage(input) {
     let sourceNote = `Source: ${url.href}`;
     if (pageText === null) {
         // The site refused or needs a browser: fall back to search excerpts from that site.
+        // (Not tried when the search would be borrowed from OpenRouter without a yes.)
         const results = await searchWeb(input.question, url.hostname).catch(() => []);
         if (results.length === 0)
             throw new Error(`Couldn't open ${url.hostname} - the site refused or needs a browser.`);
@@ -164,25 +235,52 @@ export async function runReadWebPage(input) {
         sourceNote = `Source: search excerpts from ${url.hostname} (the page itself could not be opened)`;
     }
     const page = pageText.slice(0, MAX_PAGE_CHARS);
-    const key = getOpenRouterKey();
-    if (key) {
-        for (const model of readingModels()) {
+    const messages = [
+        { role: 'system', content: READING_INSTRUCTIONS },
+        { role: 'user', content: `Question: ${input.question}\nPage: ${url.href}\n\n<page>\n${page}\n</page>` },
+    ];
+    const service = researchService();
+    if (service === 'zai') {
+        // On the plan: GLM-5.3-Flash reads the page, included in the plan.
+        const key = getZaiKey();
+        if (key) {
             try {
-                const reply = await openrouterChat(key, {
-                    model,
-                    messages: [
-                        { role: 'system', content: READING_INSTRUCTIONS },
-                        { role: 'user', content: `Question: ${input.question}\nPage: ${url.href}\n\n<page>\n${page}\n</page>` },
-                    ],
-                    max_tokens: 1500,
-                    reasoning: { effort: 'low' },
-                });
-                if (reply.text)
-                    return `${reply.text}\n\n${sourceNote}`;
+                const text = await zaiRead(key, messages);
+                if (text)
+                    return `${text}\n\n${sourceNote}`;
             }
-            catch (error) {
-                if (isAccountProblem(error))
-                    throw error;
+            catch {
+                // Falls through to the page text below.
+            }
+        }
+    }
+    else if (service === 'borrowed') {
+        // Reading uses the service in use (a direct company); others get the page text.
+        if (isDirectService(session.providerId)) {
+            try {
+                const model = hasAuto(session.providerId) ? workerModel() : workingModelId(session.model);
+                const text = await expertChat(model, messages, 1500);
+                if (text)
+                    return `${text}\n\n${sourceNote}`;
+            }
+            catch {
+                // Falls through to the page text below.
+            }
+        }
+    }
+    else {
+        const key = getOpenRouterKey();
+        if (key) {
+            for (const model of readingModels()) {
+                try {
+                    const reply = await openrouterChat(key, { model, messages, max_tokens: 1500, reasoning: { effort: 'low' } });
+                    if (reply.text)
+                        return `${reply.text}\n\n${sourceNote}`;
+                }
+                catch (error) {
+                    if (isAccountProblem(error))
+                        throw error;
+                }
             }
         }
     }