mod8-cli 0.2.0

package/dist/providers/generic.js

@@ -0,0 +1,331 @@
+/**
+ * Generic provider client factory.
+ *
+ * Given a ProviderEntry from the store, returns a ProviderClient that calls
+ * the right SDK based on apiType. Three dispatch paths:
+ *
+ *   - anthropic:     @anthropic-ai/sdk (native Messages API)
+ *   - gemini:        @google/generative-ai (native)
+ *   - openai-compat: openai SDK with a custom baseURL — covers OpenAI,
+ *                    DeepSeek, Mistral, Groq, OpenRouter, xAI, Together, …
+ *
+ * The mock provider short-circuits everything when MOD8_MOCK=1.
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import OpenAI from 'openai';
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import { priceFor } from './pricing.js';
+import { resolveConfigured } from '../storage/providers.js';
+import { templateById } from './registry.js';
+import { mockProvider } from './mock.js';
+import { resolveModel } from './modelResolution.js';
+import { debugProviderCall, debugProviderError, debugProviderResponse, } from '../util/debug.js';
+/**
+ * Build a ProviderClient bound to a specific configured provider id.
+ * Throws a friendly error if the provider isn't configured.
+ */
+export async function buildProviderClient(id) {
+    if (process.env.MOD8_MOCK === '1')
+        return mockProvider(id);
+    const entry = await resolveConfigured(id);
+    if (!entry) {
+        const tpl = templateById(id);
+        const label = tpl?.name ?? id;
+        throw new Error(`No ${label} key configured. Run: mod8 keys set ${id}` +
+            (tpl ? '' : `, or mod8 add-provider for custom ones`) +
+            '.');
+    }
+    return clientForEntry(id, entry);
+}
+function clientForEntry(id, entry) {
+    switch (entry.apiType) {
+        case 'anthropic':
+            return anthropicClient(id, entry);
+        case 'openai-compat':
+            return openaiCompatClient(id, entry);
+        case 'gemini':
+            return geminiClient(id, entry);
+    }
+}
+// ---------- Anthropic ----------
+function anthropicClient(id, entry) {
+    const client = new Anthropic({ apiKey: entry.apiKey });
+    return {
+        id,
+        defaultModel: entry.defaultModel,
+        async call(prompt, opts = {}) {
+            const resolved = resolveModel(id, opts.model, entry.defaultModel);
+            const model = resolved.model;
+            debugProviderCall({
+                providerId: id,
+                apiType: 'anthropic',
+                model,
+                modelSource: resolved.source,
+                apiKey: entry.apiKey,
+                promptPreview: prompt,
+            });
+            const start = Date.now();
+            try {
+                const res = await client.messages.create({
+                    model,
+                    max_tokens: opts.maxTokens ?? 1024,
+                    messages: [{ role: 'user', content: prompt }],
+                });
+                const latencyMs = Date.now() - start;
+                const text = res.content
+                    .filter((b) => b.type === 'text')
+                    .map((b) => b.text)
+                    .join('');
+                const inputTokens = res.usage.input_tokens;
+                const outputTokens = res.usage.output_tokens;
+                const actualModel = res.model ?? model;
+                debugProviderResponse(id, actualModel, { input: inputTokens, output: outputTokens, latencyMs });
+                return {
+                    text,
+                    inputTokens,
+                    outputTokens,
+                    costUsd: priceFor(actualModel, inputTokens, outputTokens),
+                    latencyMs,
+                    model: actualModel,
+                };
+            }
+            catch (err) {
+                debugProviderError(id, err);
+                throw err;
+            }
+        },
+        async *stream(prompt, opts = {}) {
+            const resolved = resolveModel(id, opts.model, entry.defaultModel);
+            const model = resolved.model;
+            debugProviderCall({
+                providerId: id,
+                apiType: 'anthropic',
+                model,
+                modelSource: resolved.source,
+                apiKey: entry.apiKey,
+                promptPreview: prompt,
+            });
+            const start = Date.now();
+            try {
+                const ms = client.messages.stream({
+                    model,
+                    max_tokens: opts.maxTokens ?? 1024,
+                    messages: [{ role: 'user', content: prompt }],
+                });
+                for await (const ev of ms) {
+                    if (ev.type === 'content_block_delta' && ev.delta.type === 'text_delta') {
+                        yield { type: 'text', delta: ev.delta.text };
+                    }
+                }
+                const final = await ms.finalMessage();
+                const latencyMs = Date.now() - start;
+                const inputTokens = final.usage.input_tokens;
+                const outputTokens = final.usage.output_tokens;
+                const actualModel = final.model ?? model;
+                debugProviderResponse(id, actualModel, { input: inputTokens, output: outputTokens, latencyMs });
+                yield {
+                    type: 'done',
+                    usage: {
+                        inputTokens,
+                        outputTokens,
+                        latencyMs,
+                        model: actualModel,
+                        costUsd: priceFor(actualModel, inputTokens, outputTokens),
+                    },
+                };
+            }
+            catch (err) {
+                debugProviderError(id, err);
+                throw err;
+            }
+        },
+    };
+}
+// ---------- OpenAI-compatible (OpenAI, DeepSeek, Mistral, Groq, ...) ----------
+function openaiCompatClient(id, entry) {
+    const client = new OpenAI({
+        apiKey: entry.apiKey,
+        baseURL: entry.baseUrl,
+    });
+    return {
+        id,
+        defaultModel: entry.defaultModel,
+        async call(prompt, opts = {}) {
+            const resolved = resolveModel(id, opts.model, entry.defaultModel);
+            const model = resolved.model;
+            debugProviderCall({
+                providerId: id,
+                apiType: 'openai-compat',
+                model,
+                modelSource: resolved.source,
+                baseUrl: entry.baseUrl,
+                apiKey: entry.apiKey,
+                promptPreview: prompt,
+            });
+            const start = Date.now();
+            try {
+                const res = await client.chat.completions.create({
+                    model,
+                    messages: [{ role: 'user', content: prompt }],
+                    max_tokens: opts.maxTokens ?? 1024,
+                });
+                const latencyMs = Date.now() - start;
+                const text = res.choices[0]?.message?.content ?? '';
+                const inputTokens = res.usage?.prompt_tokens ?? 0;
+                const outputTokens = res.usage?.completion_tokens ?? 0;
+                const actualModel = res.model ?? model;
+                debugProviderResponse(id, actualModel, { input: inputTokens, output: outputTokens, latencyMs });
+                return {
+                    text,
+                    inputTokens,
+                    outputTokens,
+                    costUsd: priceFor(actualModel, inputTokens, outputTokens),
+                    latencyMs,
+                    model: actualModel,
+                };
+            }
+            catch (err) {
+                debugProviderError(id, err);
+                throw err;
+            }
+        },
+        async *stream(prompt, opts = {}) {
+            const resolved = resolveModel(id, opts.model, entry.defaultModel);
+            const model = resolved.model;
+            debugProviderCall({
+                providerId: id,
+                apiType: 'openai-compat',
+                model,
+                modelSource: resolved.source,
+                baseUrl: entry.baseUrl,
+                apiKey: entry.apiKey,
+                promptPreview: prompt,
+            });
+            const start = Date.now();
+            try {
+                const stream = await client.chat.completions.create({
+                    model,
+                    messages: [{ role: 'user', content: prompt }],
+                    max_tokens: opts.maxTokens ?? 1024,
+                    stream: true,
+                    stream_options: { include_usage: true },
+                });
+                let inputTokens = 0;
+                let outputTokens = 0;
+                let actualModel = model;
+                for await (const chunk of stream) {
+                    const delta = chunk.choices[0]?.delta?.content;
+                    if (delta)
+                        yield { type: 'text', delta };
+                    if (chunk.usage) {
+                        inputTokens = chunk.usage.prompt_tokens ?? 0;
+                        outputTokens = chunk.usage.completion_tokens ?? 0;
+                    }
+                    if (chunk.model)
+                        actualModel = chunk.model;
+                }
+                const latencyMs = Date.now() - start;
+                debugProviderResponse(id, actualModel, { input: inputTokens, output: outputTokens, latencyMs });
+                yield {
+                    type: 'done',
+                    usage: {
+                        inputTokens,
+                        outputTokens,
+                        latencyMs,
+                        model: actualModel,
+                        costUsd: priceFor(actualModel, inputTokens, outputTokens),
+                    },
+                };
+            }
+            catch (err) {
+                debugProviderError(id, err);
+                throw err;
+            }
+        },
+    };
+}
+// ---------- Gemini ----------
+function geminiClient(id, entry) {
+    const genAI = new GoogleGenerativeAI(entry.apiKey);
+    return {
+        id,
+        defaultModel: entry.defaultModel,
+        async call(prompt, opts = {}) {
+            const resolved = resolveModel(id, opts.model, entry.defaultModel);
+            const modelName = resolved.model;
+            debugProviderCall({
+                providerId: id,
+                apiType: 'gemini',
+                model: modelName,
+                modelSource: resolved.source,
+                apiKey: entry.apiKey,
+                promptPreview: prompt,
+            });
+            const model = genAI.getGenerativeModel({ model: modelName });
+            const start = Date.now();
+            try {
+                const result = await model.generateContent(prompt);
+                const latencyMs = Date.now() - start;
+                const text = result.response.text();
+                const usage = result.response.usageMetadata;
+                const inputTokens = usage?.promptTokenCount ?? 0;
+                const outputTokens = usage?.candidatesTokenCount ?? 0;
+                debugProviderResponse(id, modelName, { input: inputTokens, output: outputTokens, latencyMs });
+                return {
+                    text,
+                    inputTokens,
+                    outputTokens,
+                    costUsd: priceFor(modelName, inputTokens, outputTokens),
+                    latencyMs,
+                    model: modelName,
+                };
+            }
+            catch (err) {
+                debugProviderError(id, err);
+                throw err;
+            }
+        },
+        async *stream(prompt, opts = {}) {
+            const resolved = resolveModel(id, opts.model, entry.defaultModel);
+            const modelName = resolved.model;
+            debugProviderCall({
+                providerId: id,
+                apiType: 'gemini',
+                model: modelName,
+                modelSource: resolved.source,
+                apiKey: entry.apiKey,
+                promptPreview: prompt,
+            });
+            const model = genAI.getGenerativeModel({ model: modelName });
+            const start = Date.now();
+            try {
+                const result = await model.generateContentStream(prompt);
+                for await (const chunk of result.stream) {
+                    const text = chunk.text();
+                    if (text)
+                        yield { type: 'text', delta: text };
+                }
+                const final = await result.response;
+                const usage = final.usageMetadata;
+                const inputTokens = usage?.promptTokenCount ?? 0;
+                const outputTokens = usage?.candidatesTokenCount ?? 0;
+                const latencyMs = Date.now() - start;
+                debugProviderResponse(id, modelName, { input: inputTokens, output: outputTokens, latencyMs });
+                yield {
+                    type: 'done',
+                    usage: {
+                        inputTokens,
+                        outputTokens,
+                        latencyMs,
+                        model: modelName,
+                        costUsd: priceFor(modelName, inputTokens, outputTokens),
+                    },
+                };
+            }
+            catch (err) {
+                debugProviderError(id, err);
+                throw err;
+            }
+        },
+    };
+}

package/dist/providers/genericChat.js

@@ -0,0 +1,265 @@
+/**
+ * Generic multi-turn streaming chat — used by the chat REPL.
+ *
+ * Same dispatch as generic.ts but for the multi-message API surface
+ * (system prompt + messages array, with cancellation via AbortSignal).
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import OpenAI from 'openai';
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import { priceFor } from './pricing.js';
+import { resolveConfigured } from '../storage/providers.js';
+import { templateById } from './registry.js';
+import { resolveModel } from './modelResolution.js';
+import { debugProviderCall, debugProviderError, } from '../util/debug.js';
+import { readAuth, effectiveProxyUrl } from '../storage/auth.js';
+import { toProxyProviderId } from './proxy.js';
+export async function* streamProviderChat(opts) {
+    // Proxy short-circuit: when logged in via mod8 login, all four built-in
+    // providers route through the hosted proxy.  Custom OpenAI-compat ids
+    // still hit local providers.json below.
+    if (process.env.MOD8_MOCK !== '1') {
+        const auth = await readAuth();
+        if (auth) {
+            const proxyId = toProxyProviderId(opts.providerId);
+            if (proxyId) {
+                yield* streamProxyChat(auth, proxyId, opts);
+                return;
+            }
+        }
+    }
+    const entry = await resolveConfigured(opts.providerId);
+    if (!entry) {
+        const tpl = templateById(opts.providerId);
+        const label = tpl?.name ?? opts.providerId;
+        throw new Error(`No ${label} key configured. Run: mod8 keys set ${opts.providerId}` +
+            (tpl ? '' : `, or mod8 add-provider for custom ones`) +
+            '.');
+    }
+    const resolved = resolveModel(opts.providerId, opts.model, entry.defaultModel);
+    const model = resolved.model;
+    // Preview the most recent user turn (chat REPL prompts are conversation
+    // history, not a single user message — first ~200 chars is enough).
+    const lastUser = [...opts.messages].reverse().find((m) => m.role === 'user');
+    debugProviderCall({
+        providerId: opts.providerId,
+        apiType: entry.apiType,
+        model,
+        modelSource: resolved.source,
+        baseUrl: entry.baseUrl,
+        apiKey: entry.apiKey,
+        promptPreview: lastUser?.content ?? '',
+    });
+    try {
+        switch (entry.apiType) {
+            case 'anthropic':
+                yield* streamAnthropic(entry, model, opts);
+                return;
+            case 'openai-compat':
+                yield* streamOpenAICompat(entry, model, opts);
+                return;
+            case 'gemini':
+                yield* streamGemini(entry, model, opts);
+                return;
+        }
+    }
+    catch (err) {
+        debugProviderError(opts.providerId, err);
+        throw err;
+    }
+}
+async function* streamAnthropic(entry, model, opts) {
+    const client = new Anthropic({ apiKey: entry.apiKey });
+    const start = Date.now();
+    const ms = client.messages.stream({
+        model,
+        max_tokens: opts.maxTokens ?? 4096,
+        system: opts.system,
+        messages: opts.messages,
+    }, { signal: opts.signal });
+    for await (const event of ms) {
+        if (event.type === 'content_block_delta' &&
+            event.delta.type === 'text_delta') {
+            yield { type: 'text', delta: event.delta.text };
+        }
+    }
+    const final = await ms.finalMessage();
+    const latencyMs = Date.now() - start;
+    const inputTokens = final.usage.input_tokens;
+    const outputTokens = final.usage.output_tokens;
+    const actualModel = final.model ?? model;
+    yield {
+        type: 'done',
+        usage: {
+            inputTokens,
+            outputTokens,
+            latencyMs,
+            model: actualModel,
+            costUsd: priceFor(actualModel, inputTokens, outputTokens),
+        },
+    };
+}
+async function* streamOpenAICompat(entry, model, opts) {
+    const client = new OpenAI({
+        apiKey: entry.apiKey,
+        baseURL: entry.baseUrl,
+    });
+    const start = Date.now();
+    const messages = [
+        { role: 'system', content: opts.system },
+        ...opts.messages,
+    ];
+    const stream = await client.chat.completions.create({
+        model,
+        messages,
+        max_tokens: opts.maxTokens ?? 4096,
+        stream: true,
+        stream_options: { include_usage: true },
+    }, { signal: opts.signal });
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let actualModel = model;
+    for await (const chunk of stream) {
+        const delta = chunk.choices[0]?.delta?.content;
+        if (delta)
+            yield { type: 'text', delta };
+        if (chunk.usage) {
+            inputTokens = chunk.usage.prompt_tokens ?? 0;
+            outputTokens = chunk.usage.completion_tokens ?? 0;
+        }
+        if (chunk.model)
+            actualModel = chunk.model;
+    }
+    const latencyMs = Date.now() - start;
+    yield {
+        type: 'done',
+        usage: {
+            inputTokens,
+            outputTokens,
+            latencyMs,
+            model: actualModel,
+            costUsd: priceFor(actualModel, inputTokens, outputTokens),
+        },
+    };
+}
+async function* streamProxyChat(auth, providerId, opts) {
+    // Default models match makeProxyClient for parity.
+    const defaultByProvider = {
+        anthropic: 'claude-sonnet-4-6',
+        openai: 'gpt-4o',
+        google: 'gemini-2.5-flash',
+        deepseek: 'deepseek-chat',
+    };
+    const resolved = resolveModel(opts.providerId, opts.model, defaultByProvider[providerId]);
+    const model = resolved.model;
+    const proxyUrl = effectiveProxyUrl(auth);
+    const start = Date.now();
+    const resp = await fetch(`${proxyUrl}/v1/chat`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${auth.mod8Key}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            provider: providerId,
+            model,
+            system: opts.system,
+            messages: opts.messages,
+            ...(opts.maxTokens !== undefined ? { maxTokens: opts.maxTokens } : {}),
+        }),
+        signal: opts.signal,
+    });
+    if (!resp.ok) {
+        const detail = await resp.text().catch(() => '');
+        throw new Error(`mod8 proxy: ${resp.status} ${resp.statusText}${detail ? ` — ${detail.slice(0, 200)}` : ''}`);
+    }
+    if (!resp.body)
+        throw new Error('mod8 proxy: empty response body');
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = '';
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let chargedMicros = 0;
+    let sawDone = false;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buf += decoder.decode(value, { stream: true });
+        let idx;
+        while ((idx = buf.indexOf('\n\n')) >= 0) {
+            const chunk = buf.slice(0, idx);
+            buf = buf.slice(idx + 2);
+            for (const line of chunk.split('\n')) {
+                if (!line.startsWith('data: '))
+                    continue;
+                try {
+                    const ev = JSON.parse(line.slice(6));
+                    if (ev.type === 'text')
+                        yield { type: 'text', delta: ev.delta };
+                    else if (ev.type === 'done') {
+                        inputTokens = ev.tokensIn;
+                        outputTokens = ev.tokensOut;
+                        chargedMicros = ev.chargedMicros;
+                        sawDone = true;
+                    }
+                    else if (ev.type === 'error') {
+                        throw new Error(`mod8 proxy: ${ev.error}`);
+                    }
+                }
+                catch {
+                    // ignore parse errors on non-JSON lines
+                }
+            }
+        }
+    }
+    if (!sawDone)
+        throw new Error('mod8 proxy: stream ended without a done event');
+    yield {
+        type: 'done',
+        usage: {
+            inputTokens,
+            outputTokens,
+            latencyMs: Date.now() - start,
+            model,
+            costUsd: chargedMicros / 1_000_000,
+        },
+    };
+}
+async function* streamGemini(entry, model, opts) {
+    const genAI = new GoogleGenerativeAI(entry.apiKey);
+    const m = genAI.getGenerativeModel({ model, systemInstruction: opts.system });
+    // Gemini takes a history array + a final user message; reshape.
+    const history = opts.messages.slice(0, -1).map((msg) => ({
+        role: msg.role === 'assistant' ? 'model' : 'user',
+        parts: [{ text: msg.content }],
+    }));
+    const last = opts.messages[opts.messages.length - 1];
+    const userText = last && last.role === 'user' ? last.content : '';
+    const chat = m.startChat({ history });
+    const start = Date.now();
+    const result = await chat.sendMessageStream(userText);
+    for await (const chunk of result.stream) {
+        const text = chunk.text();
+        if (text)
+            yield { type: 'text', delta: text };
+        if (opts.signal?.aborted)
+            throw new Error('aborted');
+    }
+    const final = await result.response;
+    const usage = final.usageMetadata;
+    const inputTokens = usage?.promptTokenCount ?? 0;
+    const outputTokens = usage?.candidatesTokenCount ?? 0;
+    const latencyMs = Date.now() - start;
+    yield {
+        type: 'done',
+        usage: {
+            inputTokens,
+            outputTokens,
+            latencyMs,
+            model,
+            costUsd: priceFor(model, inputTokens, outputTokens),
+        },
+    };
+}

package/dist/providers/google.js

@@ -0,0 +1,63 @@
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import { getKey } from '../storage/keys.js';
+import { priceFor } from './pricing.js';
+const DEFAULT_MODEL = 'gemini-2.0-flash';
+async function buildClient() {
+    // Google ecosystem uses both names; honour either.
+    const apiKey = process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY ?? (await getKey('google'));
+    if (!apiKey) {
+        throw new Error('No Google key configured. Run: mod8 keys set google, or set GOOGLE_API_KEY (or GEMINI_API_KEY).');
+    }
+    return new GoogleGenerativeAI(apiKey);
+}
+export const googleProvider = {
+    id: 'google',
+    defaultModel: DEFAULT_MODEL,
+    async call(prompt, opts = {}) {
+        const genAI = await buildClient();
+        const modelName = opts.model ?? process.env.MOD8_GOOGLE_MODEL ?? DEFAULT_MODEL;
+        const model = genAI.getGenerativeModel({ model: modelName });
+        const start = Date.now();
+        const result = await model.generateContent(prompt);
+        const latencyMs = Date.now() - start;
+        const text = result.response.text();
+        const usage = result.response.usageMetadata;
+        const inputTokens = usage?.promptTokenCount ?? 0;
+        const outputTokens = usage?.candidatesTokenCount ?? 0;
+        return {
+            text,
+            inputTokens,
+            outputTokens,
+            costUsd: priceFor(modelName, inputTokens, outputTokens),
+            latencyMs,
+            model: modelName,
+        };
+    },
+    async *stream(prompt, opts = {}) {
+        const genAI = await buildClient();
+        const modelName = opts.model ?? process.env.MOD8_GOOGLE_MODEL ?? DEFAULT_MODEL;
+        const model = genAI.getGenerativeModel({ model: modelName });
+        const start = Date.now();
+        const result = await model.generateContentStream(prompt);
+        for await (const chunk of result.stream) {
+            const text = chunk.text();
+            if (text)
+                yield { type: 'text', delta: text };
+        }
+        const final = await result.response;
+        const usage = final.usageMetadata;
+        const inputTokens = usage?.promptTokenCount ?? 0;
+        const outputTokens = usage?.candidatesTokenCount ?? 0;
+        const latencyMs = Date.now() - start;
+        yield {
+            type: 'done',
+            usage: {
+                inputTokens,
+                outputTokens,
+                latencyMs,
+                model: modelName,
+                costUsd: priceFor(modelName, inputTokens, outputTokens),
+            },
+        };
+    },
+};