@tianmucreations/jeeves 0.2.0

package/dist/providers/ollama.js

@@ -0,0 +1,103 @@
+import { streamText, stepCountIs } from 'ai';
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+const OLLAMA_BASE_URL = 'http://localhost:11434/v1';
+const MAX_TOOL_STEPS = 25;
+// Ollama exposes an OpenAI-compatible endpoint, so the OpenRouter client speaks to it directly.
+export function createOllamaProvider() {
+    const client = createOpenRouter({
+        apiKey: 'ollama',
+        baseURL: OLLAMA_BASE_URL,
+        compatibility: 'compatible',
+    });
+    return {
+        id: 'ollama',
+        name: 'Ollama',
+        async stream({ modelId, messages, tools, onToken, onReasoning, onToolCall }) {
+            const result = streamText({
+                model: client.chat(modelId),
+                messages,
+                tools,
+                stopWhen: stepCountIs(MAX_TOOL_STEPS),
+            });
+            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;
+                }
+            }
+            const text = await result.text;
+            if (!text && streamedError !== null) {
+                throw streamedError instanceof Error ? streamedError : new Error(String(streamedError));
+            }
+            const finalStep = await result.finalStep;
+            const responseMessages = await result.responseMessages;
+            const usage = await result.usage;
+            return {
+                text,
+                reasoning: finalStep.reasoningText ?? '',
+                messages: responseMessages,
+                usage: {
+                    input: usage.inputTokens ?? 0,
+                    output: usage.outputTokens ?? 0,
+                    total: usage.totalTokens ?? 0,
+                    cached: 0,
+                },
+                cost: 0,
+                rateLimit: null,
+            };
+        },
+    };
+}
+// Maps the local Ollama model list (/api/tags) into picker rows.
+export function mapOllamaTags(body) {
+    if (typeof body !== 'object' || body === null)
+        return [];
+    const models = body.models;
+    if (!Array.isArray(models))
+        return [];
+    const out = [];
+    for (const raw of models) {
+        if (typeof raw !== 'object' || raw === null)
+            continue;
+        const entry = raw;
+        const name = typeof entry.name === 'string' ? entry.name : '';
+        if (!name)
+            continue;
+        const info = (typeof entry.model_info === 'object' && entry.model_info !== null ? entry.model_info : {});
+        out.push({
+            id: name,
+            name,
+            contextLength: typeof info.context_length === 'number' ? info.context_length : 0,
+            promptPrice: 0,
+            completionPrice: 0,
+            // Assumption: current Ollama models handle tools through the OpenAI-compatible endpoint.
+            supportedParameters: ['tools'],
+            provider: 'ollama',
+        });
+    }
+    return out;
+}
+export async function listLocalOllamaModels() {
+    const response = await fetch('http://localhost:11434/api/tags', { signal: AbortSignal.timeout(1500) });
+    if (!response.ok)
+        throw new Error('local Ollama did not respond');
+    return mapOllamaTags(await response.json());
+}
+export async function isOllamaOnline() {
+    try {
+        const response = await fetch('http://localhost:11434/api/tags', { signal: AbortSignal.timeout(1200) });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/providers/openrouter.js

@@ -0,0 +1,109 @@
+import { randomUUID } from 'node:crypto';
+import { streamText, stepCountIs } from 'ai';
+import { createOpenRouter } from '@openrouter/ai-sdk-provider';
+// 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;
+// Sticky routing: one id per conversation, sent with every request. OpenRouter uses
+// it directly as the routing key, pinning the conversation to one provider endpoint
+// so the repeated context hits that endpoint's prompt cache (cache reads bill at
+// roughly 0.1-0.5x the fresh-input price). /clear rotates it for a fresh conversation.
+let stickySessionId = randomUUID();
+export function resetStickySession() {
+    stickySessionId = randomUUID();
+}
+export function getStickySessionId() {
+    return stickySessionId;
+}
+// Reads the account's credit position from OpenRouter; returns null when unavailable.
+export async function fetchCreditInfo(apiKey) {
+    try {
+        const response = await fetch('https://openrouter.ai/api/v1/credits', {
+            headers: { Authorization: `Bearer ${apiKey}` },
+        });
+        if (!response.ok)
+            return null;
+        const body = (await response.json());
+        const data = body.data;
+        if (!data || typeof data.total_credits !== 'number' || typeof data.total_usage !== 'number') {
+            return null;
+        }
+        return {
+            used: data.total_usage,
+            limit: data.total_credits,
+            remaining: data.total_credits - data.total_usage,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function headerNumber(headers, name) {
+    const raw = headers?.[name];
+    if (raw === undefined)
+        return null;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+export function createOpenRouterProvider(apiKey) {
+    const openrouter = createOpenRouter({ apiKey });
+    return {
+        id: 'openrouter',
+        name: 'OpenRouter',
+        async stream({ modelId, messages, tools, onToken, onReasoning, onToolCall }) {
+            const result = streamText({
+                model: openrouter.chat(modelId),
+                messages,
+                tools,
+                stopWhen: stepCountIs(MAX_TOOL_STEPS),
+                providerOptions: {
+                    openrouter: {
+                        session_id: stickySessionId,
+                    },
+                },
+            });
+            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;
+                }
+            }
+            const text = await result.text;
+            if (!text && streamedError !== null) {
+                throw streamedError instanceof Error ? streamedError : new Error(String(streamedError));
+            }
+            const finalStep = await result.finalStep;
+            const reasoning = finalStep.reasoningText ?? '';
+            const responseMessages = await result.responseMessages;
+            const usage = await result.usage;
+            const headers = finalStep.response.headers;
+            const limit = headerNumber(headers, 'x-ratelimit-limit');
+            const remaining = headerNumber(headers, 'x-ratelimit-remaining');
+            const reset = headerNumber(headers, 'x-ratelimit-reset');
+            const rateLimit = limit !== null || remaining !== null
+                ? { limit: limit ?? 0, remaining: remaining ?? 0, reset: reset ?? 0 }
+                : null;
+            return {
+                text,
+                reasoning,
+                messages: responseMessages,
+                usage: {
+                    input: usage.inputTokens ?? 0,
+                    output: usage.outputTokens ?? 0,
+                    total: usage.totalTokens ?? 0,
+                    cached: usage.inputTokenDetails?.cacheReadTokens ?? 0,
+                },
+                cost: 0,
+                rateLimit,
+            };
+        },
+    };
+}

package/dist/providers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/providers/zai.js

@@ -0,0 +1,104 @@
+import { streamText, stepCountIs } from 'ai';
+import { createAnthropic } from '@ai-sdk/anthropic';
+// Z.ai's coding endpoint speaks the Anthropic Messages protocol, so the official
+// Anthropic adapter talks to it directly. The base URL must include /v1 because
+// the appends /messages to it.
+const ZAI_BASE_URL = 'https://api.z.ai/api/anthropic/v1';
+const MAX_TOOL_STEPS = 25;
+// The GLM Coding Plan is flat-rate, so prices are meaningless per token; the picker
+// shows "included" instead of a dollar figure (spec: no misleading numbers).
+export const ZAI_MODELS = [
+    {
+        id: 'glm-5.3',
+        name: 'GLM-5.3',
+        contextLength: 200_000,
+        promptPrice: 0,
+        completionPrice: 0,
+        supportedParameters: ['tools'],
+        provider: 'zai',
+        priceLabel: 'included',
+    },
+    {
+        id: 'glm-5.3-flash',
+        name: 'GLM-5.3-Flash',
+        contextLength: 200_000,
+        promptPrice: 0,
+        completionPrice: 0,
+        supportedParameters: ['tools'],
+        provider: 'zai',
+        priceLabel: 'included',
+    },
+    {
+        id: 'glm-5.2',
+        name: 'GLM-5.2',
+        contextLength: 1_000_000,
+        promptPrice: 0,
+        completionPrice: 0,
+        supportedParameters: ['tools'],
+        provider: 'zai',
+        priceLabel: 'included',
+    },
+    {
+        id: 'glm-4.6',
+        name: 'GLM-4.6',
+        contextLength: 200_000,
+        promptPrice: 0,
+        completionPrice: 0,
+        supportedParameters: ['tools'],
+        provider: 'zai',
+        priceLabel: 'included',
+    },
+];
+export function createZaiProvider(apiKey) {
+    const client = createAnthropic({
+        apiKey,
+        baseURL: ZAI_BASE_URL,
+    });
+    return {
+        id: 'zai',
+        name: 'Z.ai',
+        async stream({ modelId, messages, tools, onToken, onReasoning, onToolCall }) {
+            const result = streamText({
+                model: client(modelId),
+                messages,
+                tools,
+                stopWhen: stepCountIs(MAX_TOOL_STEPS),
+            });
+            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;
+                }
+            }
+            const text = await result.text;
+            if (!text && streamedError !== null) {
+                throw streamedError instanceof Error ? streamedError : new Error(String(streamedError));
+            }
+            const finalStep = await result.finalStep;
+            const responseMessages = await result.responseMessages;
+            const usage = await result.usage;
+            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,
+            };
+        },
+    };
+}

package/dist/state/session.js

@@ -0,0 +1,315 @@
+import { useSyncExternalStore } from 'react';
+// Assumption: z-ai/glm-5.3's context length; the Phase 6 model registry replaces this constant.
+export const DEFAULT_CONTEXT_TOKENS = 1_310_720;
+class SessionStore {
+    model = 'z-ai/glm-5.3';
+    providerId = 'openrouter';
+    providerName = 'OpenRouter';
+    status = 'idle';
+    approvalPending = false;
+    verbose = false;
+    showLastReasoning = false;
+    pickerOpen = false;
+    keysOpen = false;
+    wizardActive = false;
+    helpOpen = false;
+    exitRequested = false;
+    launchStage = 'project';
+    wizardFromLaunch = false;
+    recentProjects = [];
+    models = [];
+    modelsNote = '';
+    favorites = [];
+    recents = [];
+    tokensIn = 0;
+    tokensOut = 0;
+    tokensCached = 0;
+    cost = 0;
+    footerExpanded = null;
+    hiddenMetrics = [];
+    creditUsed = null;
+    creditRemaining = null;
+    creditLimit = null;
+    creditIsAccount = false;
+    spend = 0;
+    rateLimit = null;
+    transcript = [];
+    history = [];
+    lastReasoning = '';
+    // Lines the transcript view is scrolled up from the bottom; 0 means "follow the newest".
+    transcriptScrollUp = 0;
+    turnEvents = [];
+    creditBaselineUsed = null;
+    nextId = 1;
+    version = 0;
+    reasoningEntryId = null;
+    listeners = new Set();
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    };
+    getSnapshot = () => this.version;
+    emit() {
+        this.version += 1;
+        for (const listener of this.listeners)
+            listener();
+    }
+    setStatus(status) {
+        this.status = status;
+        this.emit();
+    }
+    setActiveApproval() {
+        this.approvalPending = true;
+        this.status = 'awaiting-approval';
+        this.emit();
+    }
+    clearActiveApproval() {
+        this.approvalPending = false;
+        this.status = 'working';
+        this.emit();
+    }
+    setVerbose(value) {
+        this.verbose = value;
+        this.emit();
+    }
+    toggleShowLastReasoning() {
+        this.showLastReasoning = !this.showLastReasoning;
+        this.emit();
+    }
+    addUser(text) {
+        this.transcript = [...this.transcript, { id: this.nextId++, kind: 'user', text }];
+        this.emit();
+    }
+    addNotice(text) {
+        this.transcript = [...this.transcript, { id: this.nextId++, kind: 'notice', text }];
+        this.emit();
+    }
+    addError(text) {
+        this.transcript = [...this.transcript, { id: this.nextId++, kind: 'error', text }];
+        this.emit();
+    }
+    startAssistant() {
+        const id = this.nextId++;
+        this.transcript = [...this.transcript, { id, kind: 'assistant', text: '' }];
+        this.emit();
+        return id;
+    }
+    appendToken(id, token) {
+        this.transcript = this.transcript.map((entry) => entry.id === id && entry.kind === 'assistant' ? { ...entry, text: entry.text + token } : entry);
+        this.emit();
+    }
+    setAssistantText(id, text) {
+        this.transcript = this.transcript.map((entry) => entry.id === id && entry.kind === 'assistant' ? { ...entry, text } : entry);
+        this.emit();
+    }
+    finishAssistant(id) {
+        this.transcript = this.transcript.filter((entry) => !(entry.id === id && entry.kind === 'assistant' && entry.text === ''));
+        this.emit();
+    }
+    beginTurn() {
+        this.reasoningEntryId = null;
+    }
+    // Reasoning only renders while verbose is on; each model step gets its own block.
+    appendReasoning(delta) {
+        if (this.reasoningEntryId === null) {
+            const id = this.nextId++;
+            this.transcript = [...this.transcript, { id, kind: 'reasoning', text: '' }];
+            this.reasoningEntryId = id;
+        }
+        const target = this.reasoningEntryId;
+        this.transcript = this.transcript.map((entry) => entry.id === target && entry.kind === 'reasoning' ? { ...entry, text: entry.text + delta } : entry);
+        this.emit();
+    }
+    closeReasoningEntry() {
+        this.reasoningEntryId = null;
+    }
+    addToolLine(tool, summary, state) {
+        const id = this.nextId++;
+        this.transcript = [...this.transcript, { id, kind: 'tool', data: { tool, summary, state, label: '' } }];
+        this.emit();
+        return id;
+    }
+    updateToolLine(id, patch) {
+        this.transcript = this.transcript.map((entry) => entry.kind === 'tool' && entry.id === id ? { ...entry, data: { ...entry.data, ...patch } } : entry);
+        this.emit();
+    }
+    setModel(model) {
+        this.model = model;
+        this.emit();
+    }
+    setProvider(providerId) {
+        this.providerId = providerId;
+        this.emit();
+    }
+    setModels(models, note) {
+        this.models = models;
+        this.modelsNote = note;
+        this.emit();
+    }
+    setFavorites(models) {
+        this.favorites = models;
+        this.emit();
+    }
+    setRecents(models) {
+        this.recents = models.slice(0, 10);
+        this.emit();
+    }
+    openPicker() {
+        if (this.status === 'working' || this.approvalPending) {
+            this.addNotice('The model picker opens between tasks.');
+            return;
+        }
+        this.pickerOpen = true;
+        this.emit();
+    }
+    closePicker() {
+        this.pickerOpen = false;
+        this.emit();
+    }
+    openKeys() {
+        if (this.status === 'working' || this.approvalPending) {
+            this.addNotice('The key screens open between tasks.');
+            return;
+        }
+        this.keysOpen = true;
+        this.emit();
+    }
+    closeKeys() {
+        this.keysOpen = false;
+        this.emit();
+    }
+    startWizard(fromLaunch = false) {
+        this.wizardFromLaunch = fromLaunch;
+        this.wizardActive = true;
+        this.emit();
+    }
+    endWizard() {
+        this.wizardActive = false;
+        const shouldOpenModelPicker = this.wizardFromLaunch;
+        this.wizardFromLaunch = false;
+        this.emit();
+        if (shouldOpenModelPicker) {
+            this.openPicker();
+        }
+    }
+    launchComplete() {
+        this.launchStage = 'ready';
+        this.emit();
+    }
+    setRecentProjects(projects) {
+        this.recentProjects = projects.slice(0, 10);
+        this.emit();
+    }
+    openHelp() {
+        this.helpOpen = true;
+        this.emit();
+    }
+    closeHelp() {
+        this.helpOpen = false;
+        this.emit();
+    }
+    requestExit() {
+        this.exitRequested = true;
+        this.emit();
+    }
+    clearTranscript() {
+        this.transcript = [];
+        this.transcriptScrollUp = 0;
+        this.emit();
+    }
+    // Internal scrolling for the alternate-screen era: the terminal's own scrollback is
+    // unavailable there, so the transcript region scrolls itself. Positive deltas go up
+    // (older); the count is clamped to zero so the view can never sink past the newest.
+    scrollTranscript(delta) {
+        if (delta === 0)
+            return;
+        const next = Math.max(0, this.transcriptScrollUp + delta);
+        if (next === this.transcriptScrollUp)
+            return;
+        this.transcriptScrollUp = next;
+        this.emit();
+    }
+    followTranscript() {
+        if (this.transcriptScrollUp === 0)
+            return;
+        this.transcriptScrollUp = 0;
+        this.emit();
+    }
+    setHistory(messages) {
+        this.history = messages;
+    }
+    setLastReasoning(text) {
+        this.lastReasoning = text;
+    }
+    addUsage(input, output, cost, cached = 0) {
+        this.tokensIn += input;
+        this.tokensOut += output;
+        this.tokensCached += cached;
+        this.cost += cost;
+        this.turnEvents.push({ t: Date.now(), tokens: input + output });
+        const cutoff = Date.now() - 60_000;
+        this.turnEvents = this.turnEvents.filter((event) => event.t >= cutoff);
+        this.emit();
+    }
+    // Share of input tokens served from the provider's prompt cache - the at-a-glance
+    // "is the money-saving working" number for the footer.
+    cacheHitRate() {
+        if (this.tokensIn <= 0)
+            return null;
+        return Math.min(1, this.tokensCached / this.tokensIn);
+    }
+    tokensPerMinute() {
+        const cutoff = Date.now() - 60_000;
+        return this.turnEvents.filter((event) => event.t >= cutoff).reduce((sum, event) => sum + event.tokens, 0);
+    }
+    setHiddenMetrics(metrics) {
+        this.hiddenMetrics = metrics;
+        this.emit();
+    }
+    // Tab is an optional zoom-in: it expands one metric into a wide bar, cycling
+    // through them and wrapping back to the always-visible compact view.
+    tabFooter() {
+        const all = ['session', 'context', 'cache', 'today', 'credit', 'speed'];
+        const visible = all.filter((metric) => !this.hiddenMetrics.includes(metric));
+        if (visible.length === 0) {
+            this.footerExpanded = null;
+            this.emit();
+            return;
+        }
+        if (this.footerExpanded === null) {
+            this.footerExpanded = visible[0];
+        }
+        else {
+            const index = visible.indexOf(this.footerExpanded);
+            this.footerExpanded = visible[index + 1] ?? null;
+        }
+        this.emit();
+    }
+    escapeFooter() {
+        this.footerExpanded = null;
+        this.emit();
+    }
+    setCredit(used, limit, remaining, accountWide) {
+        if (this.creditBaselineUsed === null)
+            this.creditBaselineUsed = used;
+        this.spend = Math.max(0, used - this.creditBaselineUsed);
+        this.creditUsed = used;
+        this.creditLimit = limit;
+        this.creditRemaining = remaining;
+        this.creditIsAccount = accountWide;
+        this.emit();
+    }
+    setRateLimit(info) {
+        this.rateLimit = info;
+        this.emit();
+    }
+    // Assumption: roughly four characters per token is accurate enough for the context meter.
+    estimateContextTokens() {
+        return Math.ceil(JSON.stringify(this.history).length / 4);
+    }
+}
+export const session = new SessionStore();
+export function useSession() {
+    useSyncExternalStore(session.subscribe, session.getSnapshot);
+    return session;
+}