@tianmucreations/jeeves 0.2.1 → 0.3.1

package/dist/agent/errors.js

@@ -1,41 +1,102 @@
-function firstLine(text) {
-    const line = text.split('\n')[0].trim();
-    return line.length > 0 ? line : 'Something went wrong - please ask again.';
+import { directService, serviceNameFor, CUSTOM_SERVICE_ID } from '../providers/direct-services.js';
+import { getCustomService } from '../platform/config.js';
+// The AI service's name as the user knows it, for messages that name it.
+function serviceName(providerId) {
+    if (providerId === 'zai')
+        return 'Z.ai';
+    if (providerId === 'ollama')
+        return 'Ollama';
+    if (providerId === CUSTOM_SERVICE_ID) {
+        const saved = getCustomService();
+        return saved ? serviceNameFor(saved.baseURL) : 'The service';
+    }
+    const direct = providerId ? directService(providerId) : undefined;
+    if (direct)
+        return direct.label;
+    return 'OpenRouter';
+}
+// Turns technical failures into plain English (Phase 9 polish). Nothing technical
+// reaches the screen: unrecognised failures get a plain sentence, and the raw text
+// travels in detail for /verbose.
+// The HTTP status of a failed request. The AI SDK puts it on the error itself, or on
+// lastError once its retries give up; the message text alone often doesn't say it
+// (a bad OpenRouter key reads just "User not found.", measured live).
+export function statusOf(error) {
+    const candidates = [error, error?.lastError];
+    for (const candidate of candidates) {
+        const code = candidate?.statusCode;
+        if (typeof code === 'number')
+            return code;
+    }
+    return null;
 }
-// Turns technical failures into plain English (Phase 9 polish).
-export function plainError(error) {
+export function plainError(error, providerId) {
     const raw = error instanceof Error ? error.message : String(error);
+    const status = statusOf(error);
     const text = raw.toLowerCase();
-    if (text.includes('no openrouter api key')) {
-        return { message: "There's no key yet - type /keys to add one.", kind: 'auth' };
+    const service = serviceName(providerId);
+    const make = (message, kind) => ({ message, kind, detail: raw });
+    if (/^no .*\bkey\b/.test(text)) {
+        return make("There's no key yet - type /keys to add one.", 'auth');
     }
-    if (text.includes('401') || text.includes('unauthorized') || text.includes('invalid api key') || text.includes('not authenticated')) {
-        return { message: "That key wasn't accepted - type /keys to check or replace it.", kind: 'auth' };
+    if (status === 401 ||
+        status === 403 ||
+        text.includes('401') ||
+        text.includes('unauthorized') ||
+        text.includes('invalid api key') ||
+        // Google answers 400 "API key not valid"; OpenAI "Incorrect API key provided";
+        // Anthropic "invalid x-api-key".
+        text.includes('api key not valid') ||
+        text.includes('incorrect api key') ||
+        text.includes('invalid x-api-key') ||
+        text.includes('not authenticated') ||
+        text.includes('authentication failed') ||
+        text.includes('user not found')) {
+        return make(`${service} didn't accept the key - type /keys to check or replace it.`, 'auth');
     }
-    if (text.includes('402') || text.includes('insufficient') || text.includes('out of credit') || text.includes('quota')) {
-        return { message: 'OpenRouter credit ran out - top up at openrouter.ai/credits, then ask again.', kind: 'payment' };
+    // Z.ai's flat plan reports its time window as "Usage limit reached for 5 hour.
+    // Your limit will reset at 2026-09-17 13:03:01" (seen in a real session). The
+    // reset time is repeated exactly as Z.ai gave it - its time zone is not stated.
+    if (text.includes('usage limit')) {
+        const reset = raw.match(/reset at \d{4}-\d{2}-\d{2} (\d{2}:\d{2})/i);
+        const when = reset ? ` Z.ai says it resets at ${reset[1]}.` : '';
+        return {
+            ...make(`Your ${service} plan has used up its allowance for now.${when} Type /model to use a different model meanwhile.`, 'payment'),
+            resetAt: reset ? reset[1] : '',
+        };
     }
-    if (text.includes('429') || text.includes('rate limit') || text.includes('rate_limit') || text.includes('too many requests')) {
-        return { message: 'OpenRouter is asking us to slow down - wait a few seconds and ask again.', kind: 'rate-limit' };
+    if (status === 402 ||
+        text.includes('402') ||
+        text.includes('insufficient') ||
+        text.includes('out of credit') ||
+        text.includes('quota') ||
+        // Anthropic: "Your credit balance is too low to access the Anthropic API".
+        text.includes('credit balance')) {
+        const topUp = service === 'OpenRouter' ? 'top up at openrouter.ai/credits' : `add credit on the ${service} website`;
+        return make(`${service} credit ran out - ${topUp}, then ask again.`, 'payment');
+    }
+    if (status === 429 || text.includes('429') || text.includes('rate limit') || text.includes('rate_limit') || text.includes('too many requests')) {
+        return make(`${service} is asking us to slow down - wait a few seconds and ask again.`, 'rate-limit');
+    }
+    const name = error?.name;
+    if (name === 'TimeoutError' || text.includes('timed out') || text.includes('timeout')) {
+        return make(`${service} stopped responding partway through - please ask again.`, 'network');
     }
     if (text.includes('fetch failed') ||
         text.includes('network') ||
         text.includes('enotfound') ||
         text.includes('econnrefused') ||
+        text.includes('econnreset') ||
         text.includes('etimedout') ||
-        text.includes('timeout') ||
         text.includes('eai_again') ||
         text.includes('socket hang up')) {
-        return { message: 'Lost connection - please ask again in a moment.', kind: 'network' };
+        return make(`Couldn't reach ${service} - check the internet connection and ask again in a moment.`, 'network');
     }
-    if (text.includes('model') && (text.includes('not found') || text.includes('404'))) {
-        return { message: "That model isn't available any more - type /model to pick another.", kind: 'model' };
+    if ((status === 404 || text.includes('404') || text.includes('not found')) && text.includes('model')) {
+        return make("That model isn't available any more - type /model to pick another.", 'model');
     }
     if (text.includes('context') && (text.includes('length') || text.includes('too long'))) {
-        return {
-            message: 'This conversation grew too long for the model - type /model to switch, or /clear to start fresh.',
-            kind: 'context',
-        };
+        return make('This conversation grew too long for the model - type /model to switch, or /clear to start fresh.', 'context');
     }
-    return { message: firstLine(raw), kind: 'other' };
+    return make("Something went wrong with that request and I don't recognise the reason - please ask again. Type /verbose to see the technical details next time.", 'other');
 }

package/dist/agent/expert-chat.js

@@ -0,0 +1,33 @@
+import { generateText } from 'ai';
+import { session } from '../state/session.js';
+import { getOpenRouterKey, serviceKey } from '../providers/index.js';
+import { openrouterChat } from '../tools/web/openrouterChat.js';
+import { isDirectService } from '../providers/direct-services.js';
+import { modelFactory } from '../providers/direct.js';
+import { estimateCost, priceOf } from '../providers/catalogue.js';
+import { reportSpend } from './spending.js';
+export const expertChat = async (model, messages, maxTokens) => {
+    const providerId = session.providerId;
+    if (providerId === 'openrouter') {
+        const key = getOpenRouterKey();
+        if (!key)
+            throw new Error('the expert needs an OpenRouter key');
+        return (await openrouterChat(key, { model, messages, max_tokens: maxTokens })).text;
+    }
+    if (isDirectService(providerId)) {
+        const key = serviceKey(providerId);
+        if (!key)
+            throw new Error('the expert needs a key for this service');
+        const result = await generateText({
+            model: modelFactory(providerId, key)(model),
+            instructions: messages.filter((m) => m.role === 'system').map((m) => m.content).join('\n\n') || undefined,
+            messages: messages.filter((m) => m.role === 'user').map((m) => ({ role: 'user', content: m.content })),
+            // Thinking models spend part of the allowance before answering, so it is larger here.
+            maxOutputTokens: maxTokens * 4,
+            abortSignal: AbortSignal.timeout(120_000),
+        });
+        reportSpend(estimateCost(priceOf(providerId, model), result.usage), true);
+        return result.text.trim();
+    }
+    throw new Error('no expert is available for this service');
+};

package/dist/agent/housekeeping.js

@@ -0,0 +1,55 @@
+// Quiet housekeeping that keeps the conversation small, because every message
+// re-sends the whole conversation. Modelled on Anthropic's published context
+// editing (platform.claude.com/docs/en/build-with-claude/context-editing): old
+// tool results are cleared first - they are the bulk, and a file can simply be
+// read again - keeping the most recent 3, and only when enough is freed to be
+// worth losing the prompt-cache discount for one message. The trigger and minimum
+// are the figures from Anthropic's own worked example (30,000 and 5,000 tokens);
+// their default trigger is 100,000, which is where summarising starts.
+export const CLEAR_TRIGGER_TOKENS = 30_000;
+export const CLEAR_AT_LEAST_TOKENS = 5_000;
+export const KEEP_RECENT_TOOL_RESULTS = 3;
+export const SUMMARY_TRIGGER_TOKENS = 100_000;
+export const CLEARED_PLACEHOLDER = '[Earlier output removed to keep the conversation small. Run the tool again if it is needed.]';
+// The same rough measure used elsewhere in the app: about 4 characters per token.
+export function estimateTokens(value) {
+    return Math.ceil(JSON.stringify(value).length / 4);
+}
+export function clearOldToolResults(messages) {
+    if (estimateTokens(messages) < CLEAR_TRIGGER_TOKENS)
+        return { messages, freedTokens: 0 };
+    const positions = [];
+    messages.forEach((message, messageIndex) => {
+        if (message.role !== 'tool' || !Array.isArray(message.content))
+            return;
+        message.content.forEach((part, partIndex) => {
+            if (part.type === 'tool-result')
+                positions.push({ message: messageIndex, part: partIndex });
+        });
+    });
+    const older = positions.slice(0, Math.max(0, positions.length - KEEP_RECENT_TOOL_RESULTS));
+    let freed = 0;
+    const copy = messages.map((message) => message.role === 'tool' && Array.isArray(message.content) ? { ...message, content: [...message.content] } : message);
+    for (const { message, part } of older) {
+        const content = copy[message].content;
+        const result = content[part];
+        if (result.output?.type === 'text' && result.output.value === CLEARED_PLACEHOLDER)
+            continue;
+        const before = estimateTokens(result.output);
+        const replacement = { type: 'text', value: CLEARED_PLACEHOLDER };
+        freed += before - estimateTokens(replacement);
+        content[part] = { ...result, output: replacement };
+    }
+    if (freed < CLEAR_AT_LEAST_TOKENS)
+        return { messages, freedTokens: 0 };
+    return { messages: copy, freedTokens: freed };
+}
+// Anthropic's structured summary (the five parts of their compaction prompt), so a
+// summary keeps what matters for carrying on with the job.
+export const SUMMARY_INSTRUCTIONS = `Summarise the conversation so far so the work can continue from the summary alone. Use exactly these headings:
+1. Task overview - what the person asked for and what counts as done.
+2. Current state - what has been completed, which files were changed or created.
+3. Important discoveries - facts checked, decisions made, errors met and how they were resolved, approaches that failed.
+4. Next steps - what remains, in order, and anything blocking it.
+5. Context to preserve - the person's preferences, how they like to be addressed, promises made.
+Be specific: keep exact file names, figures, and quoted facts. Reply with only the summary.`;

package/dist/agent/loop.js

@@ -1,12 +1,30 @@
 import { session } from '../state/session.js';
 import { getActiveProvider, refreshCredit } from '../providers/index.js';
 import { getTools } from '../tools/index.js';
-import { buildTurnMessages } from './context.js';
+import { buildTurnMessages, getSystemPrompt, contextLimitFor, summaryDue, summariseHistory } from './context.js';
 import { plainError } from './errors.js';
 import { toggleVerbose } from '../commands/verbose.js';
 import { openModelPicker } from '../commands/model.js';
 import { clearConversation } from '../commands/clear.js';
+import { openAddressPrompt } from '../commands/address.js';
 import { isToolCapable } from '../models/filter.js';
+import { autoCatalogue } from './auto.js';
+import { isAuto, workingModelId, workerModel, expertModel, topModel, AUTO_NOTE, shouldTakeOver, createAskExpertTool, newAutoTurnState, topModelPriceRatio, topModelQuestion, REVIEW_FINISHED_JOBS } from './auto.js';
+import { jobNeedsReview, reviewJob, fixRequest, startReproducing, stopReproducing, UNCHECKED_NOTICE } from './review.js';
+import { requestApproval } from './permissions.js';
+import { clearOldToolResults } from './housekeeping.js';
+import { startJob, endJob, reportStepCost, withinLimits } from './spending.js';
+import { getAddress } from '../platform/config.js';
+import { startTurnCheckpoints, undoLastChange } from '../checkpoints/index.js';
+import { noteSkipRequest } from './research-gate.js';
+import { untrustProject } from './trust.js';
+// Added to the rulebook when the chosen model cannot use tools, so a task request
+// gets a plain answer instead of a pretend attempt.
+export const CHAT_ONLY_NOTE = `
+
+Chat-Only Model
+
+The model currently selected can only chat. For now you have no tools: you cannot read files, write files, list folders, or run commands, whatever the sections above say. If you are asked to do something that needs them, say plainly that the model in use can only chat, and suggest typing /model to choose one that can do tasks. Never pretend to have done it.`;
 const DISCONNECTING = new Set(['auth', 'network', 'payment']);
 export async function runTurn(input) {
     if (input.startsWith('/') && input.length > 1 && !input.startsWith('/ ')) {
@@ -22,6 +40,32 @@ export async function runTurn(input) {
         else if (input === '/verbose') {
             session.addNotice(toggleVerbose());
         }
+        else if (input === '/address') {
+            openAddressPrompt();
+        }
+        else if (input === '/ask') {
+            session.addNotice(untrustProject()
+                ? "I'll ask before every change in this project folder again."
+                : 'I already ask before every change in this project folder.');
+        }
+        else if (input === '/undo') {
+            if (session.status === 'working') {
+                session.addNotice('Undo works between tasks - wait for this one to finish, then type /undo.');
+            }
+            else {
+                try {
+                    const outcome = await undoLastChange();
+                    session.addNotice(outcome.message);
+                    if (outcome.historyNote)
+                        session.pendingContextNote = outcome.historyNote;
+                }
+                catch (error) {
+                    session.addError("Undo didn't work this time - nothing was changed. Please try /undo again.");
+                    if (session.verbose)
+                        session.addNotice(`Technical details: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
         else if (input === '/clear') {
             clearConversation();
         }
@@ -29,24 +73,87 @@ export async function runTurn(input) {
             session.requestExit();
         }
         else {
-            session.addNotice('Unknown command. Try /help.');
+            session.addNotice("I don't know that command - type /help to see them all.");
         }
         return;
     }
     session.addUser(input);
+    // "Skip the research" must come from the person, so it is read from their own words.
+    const skipped = noteSkipRequest(input);
+    if (skipped)
+        session.addNotice(skipped);
+    startTurnCheckpoints(input);
+    startJob();
+    // Nothing is sent once today's limit is reached, unless the person agrees.
+    if (!(await withinLimits())) {
+        endJob();
+        session.addNotice('Stopped - nothing was sent.');
+        return;
+    }
+    // Quiet housekeeping: old tool output is cleared, and a long conversation summarised.
+    const cleared = clearOldToolResults(session.history);
+    if (cleared.freedTokens > 0)
+        session.setHistory(cleared.messages);
+    const modelId = workingModelId(session.model);
+    if (summaryDue(session.estimateContextTokens(), contextLimitFor(modelId, session.models))) {
+        await summariseHistory();
+    }
+    const auto = isAuto(session.model);
+    const autoState = newAutoTurnState();
+    session.setActiveModel(auto ? workerModel() : null);
+    const stop = new AbortController();
+    let countedSteps = 0;
     session.beginTurn();
     session.setStatus('working');
+    const turnStart = session.transcript.length;
     let assistantId = null;
     try {
         const provider = getActiveProvider();
-        const messages = buildTurnMessages(session.history, input);
+        // A note from /undo travels with the next message, so the model knows files changed back.
+        const note_ = session.pendingContextNote;
+        session.pendingContextNote = null;
+        const messages = buildTurnMessages(session.history, note_ ? `${note_}\n\n${input}` : input);
         // Models without tool support get a tool-free chat mode automatically (spec 4.2).
-        const currentModel = session.models.find((model) => model.id === session.model);
-        const tools = !currentModel || isToolCapable(currentModel) ? getTools() : {};
-        const result = await provider.stream({
-            modelId: session.model,
+        const currentModel = session.models.find((model) => model.id === modelId);
+        const toolCapable = !currentModel || isToolCapable(currentModel);
+        const tools = toolCapable ? { ...getTools(), ...(auto ? { askExpert: createAskExpertTool(autoState) } : {}) } : {};
+        const note = !toolCapable ? CHAT_ONLY_NOTE : auto ? AUTO_NOTE.replaceAll('{{ADDRESS}}', getAddress() ?? 'Sir') : '';
+        const streamOptions = {
+            modelId,
             messages,
             tools,
+            instructions: getSystemPrompt() + note,
+            abortSignal: stop.signal,
+            beforeStep: async ({ stepFailures, stepCosts, messages: stepMessages }) => {
+                for (const cost of stepCosts.slice(countedSteps))
+                    reportStepCost(cost);
+                countedSteps = stepCosts.length;
+                if (!(await withinLimits())) {
+                    stop.abort();
+                    return {};
+                }
+                // In Auto mode the expert takes over the rest of a job the worker keeps failing.
+                // If the expert keeps failing too, Jeeves asks before trying the strongest model.
+                let stepModel;
+                const expert = expertModel();
+                const strongest = topModel();
+                if (auto && expert && !autoState.expertTookOver && shouldTakeOver(stepFailures))
+                    autoState.expertTookOver = true;
+                // (The expert can also take over by saying so when consulted.)
+                if (autoState.expertTookOver && autoState.takeoverStep < 0)
+                    autoState.takeoverStep = stepFailures.length;
+                if (auto && strongest && autoState.expertTookOver && !autoState.askedAboutTop && shouldTakeOver(stepFailures.slice(autoState.takeoverStep))) {
+                    autoState.askedAboutTop = true;
+                    session.addNotice(topModelQuestion(getAddress() ?? 'Sir', topModelPriceRatio(autoCatalogue())));
+                    autoState.onTopModel = await requestApproval();
+                }
+                if (auto && autoState.expertTookOver && expert) {
+                    stepModel = autoState.onTopModel && strongest ? strongest : expert;
+                    session.setActiveModel(stepModel);
+                }
+                const tidied = clearOldToolResults(stepMessages);
+                return { modelId: stepModel, messages: tidied.freedTokens > 0 ? tidied.messages : undefined };
+            },
             onToken: (token) => {
                 if (assistantId === null)
                     assistantId = session.startAssistant();
@@ -57,28 +164,83 @@ export async function runTurn(input) {
                     session.appendReasoning(delta);
             },
             onToolCall: () => {
-                // Hide pre-tool chatter so only the final answer stays visible (spec 2.3).
-                if (assistantId !== null)
+                // Hide pre-tool chatter so only the final answer stays visible (spec 2.3). The
+                // entry is removed, not just emptied, so the final answer appears below the
+                // actions it reports on rather than above them.
+                if (assistantId !== null) {
                     session.setAssistantText(assistantId, '');
+                    session.finishAssistant(assistantId);
+                    assistantId = null;
+                }
                 session.closeReasoningEntry();
             },
-        });
+        };
+        let uncheckedNotice = false;
+        let result = await provider.stream(streamOptions);
+        let allMessages = [...messages, ...result.messages];
+        // Auto's double-check, once, when this job changed a program or wrote a document
+        // (where the cheap worker's mistakes were measured - see review.ts).
+        if (auto && REVIEW_FINISHED_JOBS && jobNeedsReview(session.transcript.slice(turnStart)) && !stop.signal.aborted) {
+            for (const cost of (result.stepCosts ?? []).slice(countedSteps))
+                reportStepCost(cost);
+            countedSteps = result.stepCosts?.length ?? countedSteps;
+            const review = await reviewJob(allMessages);
+            if (review.kind === 'unavailable') {
+                uncheckedNotice = true;
+            }
+            else if (review.kind === 'problems') {
+                countedSteps = 0;
+                if (assistantId !== null)
+                    session.setAssistantText(assistantId, '');
+                const fixMessages = [...allMessages, { role: 'user', content: fixRequest(review.problems) }];
+                // Changing files waits until the worker has reproduced a problem.
+                startReproducing();
+                try {
+                    result = await provider.stream({ ...streamOptions, messages: fixMessages });
+                }
+                finally {
+                    stopReproducing();
+                }
+                allMessages = [...fixMessages, ...result.messages];
+            }
+        }
         if (assistantId === null)
             assistantId = session.startAssistant();
         session.setAssistantText(assistantId, result.text);
         session.finishAssistant(assistantId);
-        session.setHistory([...messages, ...result.messages]);
+        if (uncheckedNotice)
+            session.addNotice(UNCHECKED_NOTICE);
+        session.setHistory(allMessages);
         session.setLastReasoning(result.reasoning);
         session.addUsage(result.usage.input, result.usage.output, result.cost, result.usage.cached ?? 0);
         session.setRateLimit(result.rateLimit);
         void refreshCredit();
+        for (const cost of (result.stepCosts ?? []).slice(countedSteps))
+            reportStepCost(cost);
+        session.setPlanResetAt(null);
+        session.setActiveModel(auto ? workerModel() : null);
+        endJob();
         session.setStatus('idle');
     }
     catch (error) {
-        const plain = plainError(error);
+        endJob();
+        session.setActiveModel(auto ? workerModel() : null);
+        if (stop.signal.aborted) {
+            if (assistantId !== null)
+                session.finishAssistant(assistantId);
+            session.addNotice('Stopped, as you asked - nothing more will be spent on this.');
+            session.setStatus('idle');
+            return;
+        }
+        const plain = plainError(error, session.providerId);
         if (assistantId !== null)
             session.finishAssistant(assistantId);
         session.addError(plain.message);
+        if (plain.resetAt !== undefined)
+            session.setPlanResetAt(plain.resetAt);
+        // The technical text stays off screen unless /verbose is on.
+        if (session.verbose && plain.detail)
+            session.addNotice(`Technical details: ${plain.detail}`);
         session.setStatus(DISCONNECTING.has(plain.kind) ? 'disconnected' : 'idle');
     }
 }