@tianmucreations/jeeves 0.3.0 → 0.3.2

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;
+                }
             }
         }
     }

package/dist/tools/web/zai-search.js

@@ -0,0 +1,79 @@
+import { ZAI_CODING_BASE_URL } from '../../providers/zai.js';
+// Web search on the GLM Coding Plan: Z.ai's Web Search MCP server, included in every
+// plan (docs.z.ai/devpack/mcp/search-mcp-server). Spoken to directly over MCP's HTTP
+// transport: initialize, then call the one tool it lists, "web_search_prime".
+// Measured 18 Sept 2026 with a real plan key: results come back as a JSON string of
+// [{title, link, content, refer}], where link is often only the site's front page and
+// content a ~150-character summary - weaker than OpenRouter's search, so Jeeves is told
+// to say plainly when a fact can't be confirmed from them.
+export const ZAI_SEARCH_URL = 'https://api.z.ai/api/mcp/web_search_prime/mcp';
+async function rpc(key, body, session, signal) {
+    const response = await fetch(ZAI_SEARCH_URL, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${key}`,
+            'Content-Type': 'application/json',
+            Accept: 'application/json, text/event-stream',
+            ...(session ? { 'mcp-session-id': session } : {}),
+        },
+        body: JSON.stringify(body),
+        signal,
+    });
+    const text = await response.text();
+    if (!response.ok)
+        throw new Error(`Z.ai web search returned ${response.status}: ${text.slice(0, 200)}`);
+    // Replies arrive as server-sent events ("data: {...}") or as plain JSON.
+    const line = text.split('\n').find((entry) => entry.startsWith('data:'));
+    const parsed = line ? JSON.parse(line.slice(5)) : text ? JSON.parse(text) : {};
+    return { session: response.headers.get('mcp-session-id') ?? session, body: parsed };
+}
+// The tool's text is a JSON string of the results (sometimes JSON-encoded twice).
+export function parseZaiResults(text) {
+    let value = text;
+    for (let i = 0; i < 2 && typeof value === 'string'; i++) {
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            break;
+        }
+    }
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => item)
+        .filter((item) => typeof item.link === 'string' && item.link)
+        .map((item) => ({ url: String(item.link), title: String(item.title ?? ''), content: String(item.content ?? '') }));
+}
+export async function zaiSearch(key, query, site, timeoutMs = 45_000) {
+    const signal = AbortSignal.timeout(timeoutMs);
+    const init = await rpc(key, { jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'jeeves', version: '1' } } }, undefined, signal);
+    // The server expects to be told initialisation is finished before tool calls.
+    await rpc(key, { jsonrpc: '2.0', method: 'notifications/initialized' }, init.session, signal).catch(() => undefined);
+    const call = await rpc(key, {
+        jsonrpc: '2.0',
+        id: 2,
+        method: 'tools/call',
+        params: { name: 'web_search_prime', arguments: { search_query: query.slice(0, 70), location: 'us', ...(site ? { search_domain_filter: site } : {}) } },
+    }, init.session, signal);
+    if (call.body.error || call.body.result?.isError) {
+        throw new Error(`Z.ai web search: ${call.body.error?.message ?? call.body.result?.content?.[0]?.text ?? 'failed'}`);
+    }
+    return parseZaiResults(call.body.result?.content?.find((part) => part.type === 'text')?.text ?? '');
+}
+// One reading request on the plan: GLM-5.3-Flash on the coding endpoint, thinking off
+// (reading only quotes the page). Returns the reply text.
+export const ZAI_READING_MODEL = 'glm-5.3-flash';
+export async function zaiRead(key, messages, timeoutMs = 60_000) {
+    const response = await fetch(`${ZAI_CODING_BASE_URL}/chat/completions`, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${key}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ model: ZAI_READING_MODEL, messages, max_tokens: 1500, thinking: { type: 'disabled' } }),
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    const text = await response.text();
+    if (!response.ok)
+        throw new Error(`Z.ai returned ${response.status}: ${text.slice(0, 200)}`);
+    const body = JSON.parse(text);
+    return (body.choices?.[0]?.message?.content ?? '').trim();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tianmucreations/jeeves",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Your personal assistant in the terminal: say what you need in plain English and Jeeves does the work carefully - asks first, can undo, watches your spending. Auto mode picks the right AI model for you.",
   "keywords": [
     "ai",
@@ -33,7 +33,7 @@
   "bugs": {
     "url": "https://github.com/tianmucreations/Jeeves/issues"
   },
-  "license": "MIT",
+  "license": "SEE LICENSE IN LICENSE",
   "files": [
     "bin/",
     "dist/",
@@ -71,6 +71,7 @@
     "ink": "^7.1.1",
     "ink-spinner": "^5.0.0",
     "keytar": "^7.9.0",
+    "marked": "^18.0.13",
     "node-notifier": "^10.0.1",
     "react": "^19.3.0",
     "signal-exit": "^3.0.7",