@tianmucreations/jeeves 0.2.1 → 0.3.0

package/dist/providers/catalogue.js

@@ -0,0 +1,293 @@
+import { DIRECT_SERVICES, directService } from './direct-services.js';
+import { getDirectCatalogue, setDirectCatalogue } from '../platform/config.js';
+import { MODELS_SNAPSHOT } from './models-snapshot.js';
+// Model lists and prices for the direct connections.
+// - What each model can do and costs comes from models.dev (MIT licence), the open
+//   catalogue OpenCode uses; refreshed daily, saved between launches, and a copy is
+//   built into Jeeves so a first launch without internet still has prices.
+// - Which models a key can actually use comes live from the company itself, so a
+//   retired model or one the key has no access to is never offered.
+export const MODELS_DEV_URL = 'https://models.dev/api.json';
+const DAY_MS = 24 * 60 * 60 * 1000;
+// Jeeves's rulebook and tools alone take several thousand tokens; smaller models can't work.
+const MIN_CONTEXT = 32_000;
+function num(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+// Keeps only what Jeeves needs from the full models.dev file (about 5 MB, 200+ services).
+export function trimCatalogue(body) {
+    const out = {};
+    if (typeof body !== 'object' || body === null)
+        return out;
+    for (const service of DIRECT_SERVICES) {
+        const entry = body[service.id];
+        if (!entry || typeof entry.models !== 'object' || entry.models === null)
+            continue;
+        const models = [];
+        for (const raw of Object.values(entry.models)) {
+            if (typeof raw !== 'object' || raw === null)
+                continue;
+            const m = raw;
+            const output = m.modalities?.output;
+            const input = m.modalities?.input;
+            const context = num(m.limit?.context) ?? 0;
+            if (typeof m.id !== 'string' || m.tool_call !== true || m.status === 'deprecated')
+                continue;
+            if (!Array.isArray(output) || output.length !== 1 || output[0] !== 'text')
+                continue;
+            if (!Array.isArray(input) || !input.includes('text'))
+                continue;
+            if (context < MIN_CONTEXT)
+                continue;
+            const inputPrice = num(m.cost?.input);
+            const outputPrice = num(m.cost?.output);
+            models.push({
+                id: m.id,
+                name: typeof m.name === 'string' && m.name ? m.name : m.id,
+                released: typeof m.release_date === 'string' ? m.release_date : '',
+                context,
+                ...(inputPrice !== undefined && outputPrice !== undefined
+                    ? {
+                        cost: {
+                            input: inputPrice,
+                            output: outputPrice,
+                            ...(num(m.cost?.cache_read) !== undefined ? { cacheRead: num(m.cost.cache_read) } : {}),
+                            ...(num(m.cost?.cache_write) !== undefined ? { cacheWrite: num(m.cost.cache_write) } : {}),
+                        },
+                    }
+                    : {}),
+            });
+        }
+        out[service.id] = models;
+    }
+    return out;
+}
+let loaded = null;
+// The catalogue: today's saved copy, else a fresh download, else the last saved copy,
+// else the copy built into Jeeves. Never fails.
+export async function loadCatalogue(now = Date.now()) {
+    if (loaded)
+        return loaded;
+    const saved = getDirectCatalogue();
+    if (saved && now - saved.fetchedAt < DAY_MS) {
+        loaded = saved.catalogue;
+        return loaded;
+    }
+    try {
+        const response = await fetch(MODELS_DEV_URL, { signal: AbortSignal.timeout(20_000) });
+        if (!response.ok)
+            throw new Error(`models.dev returned ${response.status}`);
+        const trimmed = trimCatalogue(await response.json());
+        if (Object.keys(trimmed).length === 0)
+            throw new Error('models.dev returned no models');
+        setDirectCatalogue(trimmed, now);
+        loaded = trimmed;
+    }
+    catch {
+        loaded = saved?.catalogue ?? MODELS_SNAPSHOT;
+    }
+    return loaded;
+}
+// For tests.
+export function resetCatalogue() {
+    loaded = null;
+}
+// The price list of one model, once the catalogue has loaded (for cost estimates).
+export function priceOf(serviceId, modelId) {
+    const service = directService(serviceId);
+    if (!service)
+        return undefined;
+    const models = (loaded ?? MODELS_SNAPSHOT)[service.id] ?? [];
+    return models.find((model) => model.id === modelId)?.cost;
+}
+// What a step cost by the company's price list, in dollars. An estimate: a model with
+// dearer rates above some length (models.dev "tiers") is charged at its base rate.
+export function estimateCost(price, usage) {
+    if (!price)
+        return 0;
+    const input = usage.inputTokens ?? 0;
+    const cacheRead = usage.inputTokenDetails?.cacheReadTokens ?? 0;
+    const cacheWrite = usage.inputTokenDetails?.cacheWriteTokens ?? 0;
+    const fresh = usage.inputTokenDetails?.noCacheTokens ?? Math.max(0, input - cacheRead - cacheWrite);
+    const dollars = fresh * price.input +
+        cacheRead * (price.cacheRead ?? price.input) +
+        cacheWrite * (price.cacheWrite ?? price.input) +
+        (usage.outputTokens ?? 0) * price.output;
+    return dollars / 1_000_000;
+}
+export function toModelInfo(serviceId, model) {
+    return {
+        id: model.id,
+        name: model.name,
+        contextLength: model.context,
+        // Per token, the unit the picker's price column uses for OpenRouter.
+        promptPrice: model.cost ? model.cost.input / 1_000_000 : 0,
+        completionPrice: model.cost ? model.cost.output / 1_000_000 : 0,
+        supportedParameters: ['tools'],
+        provider: serviceId,
+        ...(model.cost ? {} : { priceLabel: 'price not listed' }),
+    };
+}
+// Each company's own model list, which also proves the key works. Free to call.
+export function modelListRequest(serviceId, key) {
+    const bearer = { Authorization: `Bearer ${key}` };
+    switch (serviceId) {
+        case 'anthropic':
+            return { url: 'https://api.anthropic.com/v1/models?limit=1000', headers: { 'x-api-key': key, 'anthropic-version': '2023-06-01' } };
+        case 'openai':
+            return { url: 'https://api.openai.com/v1/models', headers: bearer };
+        case 'google':
+            return { url: 'https://generativelanguage.googleapis.com/v1beta/models?pageSize=1000', headers: { 'x-goog-api-key': key } };
+        case 'xai':
+            return { url: 'https://api.x.ai/v1/models', headers: bearer };
+        case 'mistral':
+            return { url: 'https://api.mistral.ai/v1/models', headers: bearer };
+        case 'groq':
+            return { url: 'https://api.groq.com/openai/v1/models', headers: bearer };
+    }
+}
+// Model ids from a list reply: {data:[{id}]} for most, {models:[{name:"models/x"}]} for Google.
+export function idsFromList(body) {
+    const ids = new Set();
+    if (typeof body !== 'object' || body === null)
+        return ids;
+    const record = body;
+    for (const item of Array.isArray(record.data) ? record.data : []) {
+        const id = item?.id;
+        if (typeof id === 'string')
+            ids.add(id);
+    }
+    for (const item of Array.isArray(record.models) ? record.models : []) {
+        const name = item?.name;
+        if (typeof name === 'string')
+            ids.add(name.replace(/^models\//, ''));
+    }
+    return ids;
+}
+// A refused key: 401/403 from most; Google says 400 "API key not valid" (measured 18 Sept).
+export function isRejection(status, text) {
+    return status === 401 || status === 403 || (status === 400 && /api key/i.test(text));
+}
+export async function checkKey(serviceId, key) {
+    const request = modelListRequest(serviceId, key);
+    try {
+        const response = await fetch(request.url, { headers: request.headers, signal: AbortSignal.timeout(15_000) });
+        const text = await response.text();
+        if (isRejection(response.status, text))
+            return { ok: false, reason: 'rejected' };
+        if (!response.ok)
+            return { ok: false, reason: 'unreachable' };
+        return { ok: true, ids: idsFromList(JSON.parse(text)) };
+    }
+    catch {
+        return { ok: false, reason: 'unreachable' };
+    }
+}
+// The picker's list for one company: newest first, its everyday model at the top.
+// Limited to what the key can use when the company answered; the whole catalogue
+// list otherwise (a model the key can't use then fails with a plain message).
+export function directModelList(serviceId, catalogue, available) {
+    const service = directService(serviceId);
+    const all = catalogue[serviceId] ?? [];
+    const usable = available && available.size > 0 ? all.filter((model) => available.has(model.id)) : all;
+    const sorted = [...usable].sort((a, b) => b.released.localeCompare(a.released));
+    const everyday = service?.defaults.find((id) => sorted.some((model) => model.id === id));
+    const ordered = everyday ? [sorted.find((model) => model.id === everyday), ...sorted.filter((model) => model.id !== everyday)] : sorted;
+    return ordered.map((model) => toModelInfo(serviceId, model));
+}
+const liveLists = new Map();
+// Loads one company's models for the picker, asking the company which the key can use
+// (remembered for this session).
+export async function loadDirectModels(serviceId, key) {
+    const catalogue = await loadCatalogue();
+    let available = liveLists.get(serviceId) ?? null;
+    if (!available) {
+        const check = await checkKey(serviceId, key);
+        if (check.ok) {
+            available = check.ids;
+            liveLists.set(serviceId, available);
+        }
+    }
+    const models = directModelList(serviceId, catalogue, available);
+    rememberModels(models);
+    return models;
+}
+// Forget a company's live list when its key changes.
+export function forgetLiveList(serviceId) {
+    liveLists.delete(serviceId);
+}
+// The company's everyday model, for when a key is first added.
+export async function everydayModel(serviceId, key) {
+    const models = await loadDirectModels(serviceId, key);
+    return models[0]?.id ?? directService(serviceId)?.defaults[0] ?? null;
+}
+// Models seen this session from direct and compatible services, so the rest of Jeeves
+// can look up a model's memory size without knowing where it came from.
+const seen = new Map();
+export function rememberModels(models) {
+    for (const model of models)
+        seen.set(`${model.provider}:${model.id}`, model);
+}
+export function seenModels(serviceId) {
+    return [...seen.values()].filter((model) => model.provider === serviceId);
+}
+export function findSeenModel(serviceId, modelId) {
+    return seen.get(`${serviceId}:${modelId}`);
+}
+// The "any compatible service": the address as pasted, tidied - https:// added when
+// missing, and a pasted request address (…/chat/completions) cut back to its base.
+export function tidyAddress(raw) {
+    let address = raw.trim().replace(/\/+$/, '');
+    if (!/^https?:\/\//i.test(address))
+        address = `https://${address}`;
+    return address.replace(/\/chat\/completions$/i, '').replace(/\/models$/i, '');
+}
+// Asks a compatible service for its models. Tries the address as given, then with
+// /v1 added (most services live there). Returns the working address and its models,
+// and whether that proved the key: some services (OpenRouter, measured 18 Sept) show
+// their model list to anyone, so a wrong key would pass unnoticed.
+export async function checkCustomService(raw, key) {
+    const base = tidyAddress(raw);
+    const candidates = /\/v\d+$/.test(base) ? [base] : [base, `${base}/v1`];
+    let rejected = false;
+    for (const baseURL of candidates) {
+        try {
+            const response = await fetch(`${baseURL}/models`, {
+                headers: { Authorization: `Bearer ${key}` },
+                signal: AbortSignal.timeout(15_000),
+            });
+            const text = await response.text();
+            if (isRejection(response.status, text)) {
+                rejected = true;
+                continue;
+            }
+            if (!response.ok)
+                continue;
+            const ids = [...idsFromList(JSON.parse(text))].sort();
+            if (ids.length === 0)
+                continue;
+            const models = ids.map((id) => customModelInfo(id));
+            rememberModels(models);
+            const open = await fetch(`${baseURL}/models`, { signal: AbortSignal.timeout(15_000) }).then((reply) => reply.ok, () => false);
+            return { ok: true, baseURL, models, keyChecked: !open };
+        }
+        catch {
+            // Try the next form of the address.
+        }
+    }
+    return { ok: false, reason: rejected ? 'rejected' : 'unreachable' };
+}
+// A compatible service says nothing about prices or tools. Assumption: it can use
+// tools (a model that can't will say so when asked to do a task).
+export function customModelInfo(id) {
+    return {
+        id,
+        name: id,
+        contextLength: 0,
+        promptPrice: 0,
+        completionPrice: 0,
+        supportedParameters: ['tools'],
+        provider: 'custom',
+        priceLabel: 'price not listed',
+    };
+}

package/dist/providers/direct-services.js

@@ -0,0 +1,65 @@
+// The model makers Jeeves connects to directly, each with the user's own key.
+// A module with no imports, so the catalogue, key screens and picker can all use it.
+//
+// Approach copied from OpenCode (anomalyco/opencode, packages/opencode/src/provider):
+// the official AI SDK package for each company, and prices and abilities from the
+// open models.dev catalogue (MIT licence), which OpenCode also uses.
+export const DIRECT_SERVICES = [
+    {
+        id: 'anthropic',
+        label: 'Anthropic',
+        keyPage: 'console.anthropic.com/settings/keys',
+        defaults: ['claude-sonnet-5', 'claude-sonnet-4-6', 'claude-sonnet-4-5'],
+    },
+    {
+        id: 'openai',
+        label: 'OpenAI',
+        keyPage: 'platform.openai.com/api-keys',
+        defaults: ['gpt-5.6-terra', 'gpt-5.5', 'gpt-5.4'],
+    },
+    {
+        id: 'google',
+        label: 'Google',
+        keyPage: 'aistudio.google.com/apikey',
+        defaults: ['gemini-3.8-flash', 'gemini-flash-latest', 'gemini-3.5-flash'],
+    },
+    {
+        id: 'xai',
+        label: 'xAI (Grok)',
+        keyPage: 'console.x.ai',
+        defaults: ['grok-4.6', 'grok-4.5', 'grok-4.3'],
+    },
+    {
+        id: 'mistral',
+        label: 'Mistral',
+        keyPage: 'console.mistral.ai/api-keys',
+        defaults: ['mistral-medium-latest', 'mistral-large-latest', 'mistral-small-latest'],
+    },
+    {
+        id: 'groq',
+        label: 'Groq',
+        keyPage: 'console.groq.com/keys',
+        defaults: ['openai/gpt-oss-120b', 'qwen/qwen3.8-27b', 'llama-3.3-70b-versatile'],
+    },
+];
+// "Any compatible service": an address and a key the person pastes in.
+export const CUSTOM_SERVICE_ID = 'custom';
+export function directService(id) {
+    return DIRECT_SERVICES.find((service) => service.id === id);
+}
+export function isDirectService(id) {
+    return directService(id) !== undefined;
+}
+// Services whose cost Jeeves works out from a price list (not reported by the service).
+export function isEstimatedCostService(id) {
+    return isDirectService(id) || id === CUSTOM_SERVICE_ID;
+}
+// The name a compatible service is known by: its web address without "api." or "www.".
+export function serviceNameFor(baseURL) {
+    try {
+        return new URL(baseURL).hostname.replace(/^(api|www)\./, '');
+    }
+    catch {
+        return 'your service';
+    }
+}

package/dist/providers/direct.js

@@ -0,0 +1,145 @@
+import { streamText, stepCountIs } from 'ai';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createGoogle } from '@ai-sdk/google';
+import { createXai } from '@ai-sdk/xai';
+import { createMistral } from '@ai-sdk/mistral';
+import { createGroq } from '@ai-sdk/groq';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import { prepareStepFor } from './step-control.js';
+import { directService, serviceNameFor, CUSTOM_SERVICE_ID } from './direct-services.js';
+import { estimateCost, priceOf } from './catalogue.js';
+const MAX_TOOL_STEPS = 25;
+// Each company's official AI SDK package, at its default model type (OpenCode does the same).
+export function modelFactory(serviceId, apiKey) {
+    switch (serviceId) {
+        case 'anthropic': {
+            const client = createAnthropic({ apiKey });
+            return (id) => client.languageModel(id);
+        }
+        case 'openai': {
+            const client = createOpenAI({ apiKey });
+            return (id) => client.languageModel(id);
+        }
+        case 'google': {
+            const client = createGoogle({ apiKey });
+            return (id) => client.languageModel(id);
+        }
+        case 'xai': {
+            const client = createXai({ apiKey });
+            return (id) => client.languageModel(id);
+        }
+        case 'mistral': {
+            const client = createMistral({ apiKey });
+            return (id) => client.languageModel(id);
+        }
+        case 'groq': {
+            const client = createGroq({ apiKey });
+            return (id) => client.languageModel(id);
+        }
+    }
+}
+const ANTHROPIC_CACHE = { anthropic: { cacheControl: { type: 'ephemeral' } } };
+// Anthropic only reuses the unchanged start of a conversation (at a tenth of the
+// price) when told where it ends. As OpenCode does: mark the rulebook and the last
+// two messages. Anthropic allows four marks, so marks on older messages are removed,
+// and the stored conversation is never changed (copies are marked).
+export function markForCaching(messages) {
+    const firstMarked = messages.length - 2;
+    return messages.map((message, index) => {
+        const options = message.providerOptions;
+        if (index >= firstMarked) {
+            return { ...message, providerOptions: { ...options, anthropic: { ...options?.anthropic, ...ANTHROPIC_CACHE.anthropic } } };
+        }
+        if (!options?.anthropic?.cacheControl)
+            return message;
+        const { cacheControl, ...keep } = options.anthropic;
+        void cacheControl;
+        const { anthropic, ...others } = options;
+        void anthropic;
+        return { ...message, providerOptions: Object.keys(keep).length > 0 ? { ...others, anthropic: keep } : others };
+    });
+}
+function streamWith(id, name, modelFor, costOf, caching) {
+    return {
+        id,
+        name,
+        async stream({ modelId, messages, tools, instructions, onToken, onReasoning, onToolCall, beforeStep, abortSignal }) {
+            const stepCostOf = (step) => costOf(step.model?.modelId ?? modelId, step.usage ?? {});
+            const prepare = prepareStepFor(beforeStep, modelFor, stepCostOf);
+            const system = caching && instructions ? { role: 'system', content: instructions, providerOptions: ANTHROPIC_CACHE } : instructions;
+            const result = streamText({
+                instructions: system,
+                // The same limits on silence as the other services (see openrouter.ts).
+                timeout: { firstChunkMs: 120_000, chunkMs: 90_000, stepMs: 600_000 },
+                model: modelFor(modelId),
+                messages: caching ? markForCaching(messages) : messages,
+                tools,
+                stopWhen: stepCountIs(MAX_TOOL_STEPS),
+                // The marks move to the newest messages at every step of a job.
+                prepareStep: prepare || caching
+                    ? async (step) => {
+                        const control = prepare ? await prepare(step) : {};
+                        if (!caching)
+                            return control;
+                        return { ...control, messages: markForCaching(control.messages ?? step.messages) };
+                    }
+                    : undefined,
+                abortSignal,
+                // 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) {
+                if (part.type === 'text-delta') {
+                    onToken(part.text);
+                }
+                else if (part.type === 'reasoning-delta') {
+                    onReasoning(part.text);
+                }
+                else if (part.type === 'tool-call') {
+                    onToolCall({ id: part.toolCallId, name: part.toolName });
+                }
+                else if (part.type === 'error') {
+                    streamedError = part.error;
+                }
+            }
+            // 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) {
+                throw streamedError instanceof Error ? streamedError : new Error(String(streamedError));
+            }
+            const text = await result.text;
+            const finalStep = await result.finalStep;
+            const responseMessages = await result.responseMessages;
+            const usage = await result.usage;
+            const steps = await result.steps;
+            return {
+                text,
+                reasoning: finalStep.reasoningText ?? '',
+                messages: responseMessages,
+                usage: {
+                    input: usage.inputTokens ?? 0,
+                    output: usage.outputTokens ?? 0,
+                    total: usage.totalTokens ?? 0,
+                    cached: usage.inputTokenDetails?.cacheReadTokens ?? 0,
+                },
+                cost: 0,
+                rateLimit: null,
+                // Worked out from the price list: these services don't report a cost.
+                stepCosts: steps.map(stepCostOf),
+            };
+        },
+    };
+}
+export function createDirectProvider(serviceId, apiKey) {
+    const service = directService(serviceId);
+    return streamWith(serviceId, service.label, modelFactory(serviceId, apiKey), (modelId, usage) => estimateCost(priceOf(serviceId, modelId), usage), serviceId === 'anthropic');
+}
+// The "any compatible service": most AI services accept the OpenAI request format at
+// an address ending in /v1. Its prices are unknown, so its cost can't be estimated.
+export function createCustomProvider(baseURL, apiKey) {
+    const client = createOpenAICompatible({ name: 'custom', baseURL, apiKey, includeUsage: true });
+    return streamWith(CUSTOM_SERVICE_ID, serviceNameFor(baseURL), (id) => client.chatModel(id), () => 0, false);
+}