@vistagenic/vista 0.2.16 → 0.3.2

package/dist/ai/providers/anthropic.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAnthropicModel = createAnthropicModel;
+const tool_1 = require("../tool");
+function formatMessagesForAnthropic(messages) {
+    const result = [];
+    for (const msg of messages) {
+        if (msg.role === 'system') {
+            // System prompt is handled separately in Anthropic
+            continue;
+        }
+        if (msg.role === 'tool') {
+            result.push({
+                role: 'user',
+                content: [
+                    {
+                        type: 'tool_result',
+                        tool_use_id: msg.toolCallId || 'call_default',
+                        content: msg.content,
+                    },
+                ],
+            });
+        }
+        else if (msg.role === 'assistant' && msg.toolCalls && msg.toolCalls.length > 0) {
+            const contentBlocks = [];
+            if (msg.content) {
+                contentBlocks.push({ type: 'text', text: msg.content });
+            }
+            for (const tc of msg.toolCalls) {
+                contentBlocks.push({
+                    type: 'tool_use',
+                    id: tc.id,
+                    name: tc.name,
+                    input: typeof tc.arguments === 'object' ? tc.arguments : JSON.parse(tc.arguments || '{}'),
+                });
+            }
+            result.push({ role: 'assistant', content: contentBlocks });
+        }
+        else {
+            result.push({
+                role: msg.role === 'assistant' ? 'assistant' : 'user',
+                content: msg.content,
+            });
+        }
+    }
+    return result;
+}
+function createAnthropicModel(options) {
+    const baseURL = (options.baseURL ||
+        process.env.ANTHROPIC_BASE_URL ||
+        'https://api.anthropic.com/v1').replace(/\/+$/, '');
+    const apiKey = options.apiKey || process.env.ANTHROPIC_API_KEY || '';
+    const modelName = options.model || 'claude-3-5-sonnet-20241022';
+    return {
+        provider: 'anthropic',
+        modelName,
+        async generateText(genOptions) {
+            const url = `${baseURL}/messages`;
+            const messages = formatMessagesForAnthropic(genOptions.messages);
+            const body = {
+                model: modelName,
+                messages,
+                max_tokens: genOptions.maxTokens || options.maxTokens || 4096,
+                temperature: genOptions.temperature ?? options.temperature ?? 0.7,
+            };
+            if (genOptions.systemPrompt) {
+                body.system = genOptions.systemPrompt;
+            }
+            if (genOptions.tools && genOptions.tools.length > 0) {
+                body.tools = genOptions.tools.map(tool_1.formatToolForAnthropic);
+            }
+            const headers = {
+                'Content-Type': 'application/json',
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01',
+                ...(options.headers || {}),
+            };
+            const res = await fetch(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+                signal: genOptions.abortSignal,
+            });
+            if (!res.ok) {
+                const errText = await res.text().catch(() => '');
+                throw new Error(`Anthropic API request failed [${res.status}]: ${errText}`);
+            }
+            const data = await res.json();
+            let text = '';
+            const toolCalls = [];
+            if (Array.isArray(data.content)) {
+                for (const block of data.content) {
+                    if (block.type === 'text') {
+                        text += block.text;
+                    }
+                    else if (block.type === 'tool_use') {
+                        toolCalls.push({
+                            id: block.id,
+                            name: block.name,
+                            arguments: block.input,
+                        });
+                    }
+                }
+            }
+            return {
+                text,
+                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                finishReason: data.stop_reason || 'stop',
+                usage: data.usage
+                    ? {
+                        promptTokens: data.usage.input_tokens || 0,
+                        completionTokens: data.usage.output_tokens || 0,
+                        totalTokens: (data.usage.input_tokens || 0) + (data.usage.output_tokens || 0),
+                    }
+                    : undefined,
+                raw: data,
+            };
+        },
+        async *streamText(genOptions) {
+            const url = `${baseURL}/messages`;
+            const messages = formatMessagesForAnthropic(genOptions.messages);
+            const body = {
+                model: modelName,
+                messages,
+                max_tokens: genOptions.maxTokens || options.maxTokens || 4096,
+                temperature: genOptions.temperature ?? options.temperature ?? 0.7,
+                stream: true,
+            };
+            if (genOptions.systemPrompt) {
+                body.system = genOptions.systemPrompt;
+            }
+            if (genOptions.tools && genOptions.tools.length > 0) {
+                body.tools = genOptions.tools.map(tool_1.formatToolForAnthropic);
+            }
+            const headers = {
+                'Content-Type': 'application/json',
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01',
+                ...(options.headers || {}),
+            };
+            const res = await fetch(url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+                signal: genOptions.abortSignal,
+            });
+            if (!res.ok) {
+                const errText = await res.text().catch(() => '');
+                throw new Error(`Anthropic stream request failed [${res.status}]: ${errText}`);
+            }
+            if (!res.body) {
+                throw new Error('ReadableStream not supported on fetch response');
+            }
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed.startsWith('data: '))
+                            continue;
+                        const payload = trimmed.slice(6);
+                        if (payload === '[DONE]')
+                            break;
+                        try {
+                            const event = JSON.parse(payload);
+                            if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+                                yield { type: 'text-delta', textDelta: event.delta.text };
+                            }
+                        }
+                        catch {
+                            // Ignore partial JSON parse errors
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            yield { type: 'done' };
+        },
+    };
+}

package/dist/ai/providers/base.d.ts

@@ -0,0 +1,7 @@
+import type { LanguageModel, ModelOptions } from '../types';
+export interface ParsedModel {
+    provider: string;
+    modelName: string;
+}
+export declare function parseModelIdentifier(model: string): ParsedModel;
+export declare function resolveModel(model: string | LanguageModel, options?: Partial<ModelOptions>): LanguageModel;

package/dist/ai/providers/base.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseModelIdentifier = parseModelIdentifier;
+exports.resolveModel = resolveModel;
+const openai_1 = require("./openai");
+const anthropic_1 = require("./anthropic");
+const gemini_1 = require("./gemini");
+const mock_1 = require("./mock");
+function parseModelIdentifier(model) {
+    const trimmed = model.trim();
+    const colonIndex = trimmed.indexOf(':');
+    if (colonIndex !== -1) {
+        const provider = trimmed.slice(0, colonIndex).toLowerCase();
+        const modelName = trimmed.slice(colonIndex + 1);
+        return { provider, modelName };
+    }
+    // Heuristic guessing if prefix omitted
+    const lower = trimmed.toLowerCase();
+    if (lower.startsWith('gpt-') || lower.startsWith('o1-') || lower.startsWith('o3-')) {
+        return { provider: 'openai', modelName: trimmed };
+    }
+    if (lower.startsWith('claude-')) {
+        return { provider: 'anthropic', modelName: trimmed };
+    }
+    if (lower.startsWith('gemini-')) {
+        return { provider: 'gemini', modelName: trimmed };
+    }
+    if (lower.startsWith('mock')) {
+        return { provider: 'mock', modelName: trimmed };
+    }
+    if (lower.startsWith('llama-') || lower.startsWith('mixtral-') || lower.startsWith('gemma2-')) {
+        return { provider: 'groq', modelName: trimmed };
+    }
+    // Default fallback
+    return { provider: 'openai', modelName: trimmed };
+}
+function resolveModel(model, options = {}) {
+    if (typeof model === 'object' && model !== null && 'generateText' in model) {
+        return model;
+    }
+    if (typeof model !== 'string') {
+        throw new Error('Model must be a model string or a LanguageModel implementation');
+    }
+    const { provider, modelName } = parseModelIdentifier(model);
+    const modelOptions = {
+        model: modelName,
+        ...options,
+    };
+    switch (provider) {
+        case 'openai':
+            return (0, openai_1.createOpenAIModel)(modelOptions);
+        case 'anthropic':
+            return (0, anthropic_1.createAnthropicModel)(modelOptions);
+        case 'gemini':
+            return (0, gemini_1.createGeminiModel)(modelOptions);
+        case 'ollama':
+            return (0, openai_1.createOpenAIModel)({
+                ...modelOptions,
+                baseURL: options.baseURL || process.env.OLLAMA_BASE_URL || 'http://localhost:11434/v1',
+                apiKey: options.apiKey || 'ollama',
+            });
+        case 'nvidia':
+        case 'nim':
+            return (0, openai_1.createOpenAIModel)({
+                ...modelOptions,
+                baseURL: options.baseURL ||
+                    process.env.NVIDIA_BASE_URL ||
+                    process.env.NIM_BASE_URL ||
+                    'https://integrate.api.nvidia.com/v1',
+                apiKey: options.apiKey || process.env.NVIDIA_API_KEY || process.env.NIM_API_KEY || '',
+            });
+        case 'groq':
+            return (0, openai_1.createOpenAIModel)({
+                ...modelOptions,
+                baseURL: options.baseURL || process.env.GROQ_BASE_URL || 'https://api.groq.com/openai/v1',
+                apiKey: options.apiKey || process.env.GROQ_API_KEY || '',
+            });
+        case 'mock':
+            return (0, mock_1.createMockModel)({
+                modelName,
+            });
+        default:
+            throw new Error(`Unsupported model provider "${provider}". Supported providers: openai, anthropic, gemini, ollama, nvidia, groq, mock.`);
+    }
+}

package/dist/ai/providers/gemini.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageModel, ModelOptions } from '../types';
+export declare function createGeminiModel(options: ModelOptions): LanguageModel;

package/dist/ai/providers/gemini.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGeminiModel = createGeminiModel;
+const tool_1 = require("../tool");
+function formatMessagesForGemini(messages) {
+    const contents = [];
+    for (const msg of messages) {
+        if (msg.role === 'system')
+            continue;
+        if (msg.role === 'tool') {
+            contents.push({
+                role: 'user',
+                parts: [
+                    {
+                        functionResponse: {
+                            name: msg.name || 'tool_response',
+                            response: { content: msg.content },
+                        },
+                    },
+                ],
+            });
+        }
+        else if (msg.role === 'assistant' && msg.toolCalls && msg.toolCalls.length > 0) {
+            const parts = [];
+            if (msg.content) {
+                parts.push({ text: msg.content });
+            }
+            for (const tc of msg.toolCalls) {
+                parts.push({
+                    functionCall: {
+                        name: tc.name,
+                        args: typeof tc.arguments === 'object' ? tc.arguments : JSON.parse(tc.arguments || '{}'),
+                    },
+                });
+            }
+            contents.push({ role: 'model', parts });
+        }
+        else {
+            contents.push({
+                role: msg.role === 'assistant' ? 'model' : 'user',
+                parts: [{ text: msg.content }],
+            });
+        }
+    }
+    return contents;
+}
+function createGeminiModel(options) {
+    const baseURL = (options.baseURL ||
+        process.env.GEMINI_BASE_URL ||
+        'https://generativelanguage.googleapis.com/v1beta').replace(/\/+$/, '');
+    const apiKey = options.apiKey || process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY || '';
+    const modelName = options.model || 'gemini-1.5-flash';
+    return {
+        provider: 'gemini',
+        modelName,
+        async generateText(genOptions) {
+            const url = `${baseURL}/models/${modelName}:generateContent?key=${apiKey}`;
+            const contents = formatMessagesForGemini(genOptions.messages);
+            const body = {
+                contents,
+                generationConfig: {
+                    temperature: genOptions.temperature ?? options.temperature ?? 0.7,
+                },
+            };
+            if (genOptions.systemPrompt) {
+                body.systemInstruction = {
+                    parts: [{ text: genOptions.systemPrompt }],
+                };
+            }
+            if (genOptions.maxTokens || options.maxTokens) {
+                body.generationConfig.maxOutputTokens = genOptions.maxTokens || options.maxTokens;
+            }
+            if (genOptions.tools && genOptions.tools.length > 0) {
+                body.tools = [
+                    {
+                        functionDeclarations: genOptions.tools.map(tool_1.formatToolForGemini),
+                    },
+                ];
+            }
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(body),
+                signal: genOptions.abortSignal,
+            });
+            if (!res.ok) {
+                const errText = await res.text().catch(() => '');
+                throw new Error(`Gemini API request failed [${res.status}]: ${errText}`);
+            }
+            const data = await res.json();
+            const candidate = data.candidates?.[0];
+            const parts = candidate?.content?.parts || [];
+            let text = '';
+            const toolCalls = [];
+            for (const part of parts) {
+                if (part.text) {
+                    text += part.text;
+                }
+                else if (part.functionCall) {
+                    toolCalls.push({
+                        id: `call_${Date.now()}_${toolCalls.length}`,
+                        name: part.functionCall.name,
+                        arguments: part.functionCall.args || {},
+                    });
+                }
+            }
+            const usageMetadata = data.usageMetadata;
+            return {
+                text,
+                toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+                finishReason: candidate?.finishReason || 'stop',
+                usage: usageMetadata
+                    ? {
+                        promptTokens: usageMetadata.promptTokenCount || 0,
+                        completionTokens: usageMetadata.candidatesTokenCount || 0,
+                        totalTokens: usageMetadata.totalTokenCount || 0,
+                    }
+                    : undefined,
+                raw: data,
+            };
+        },
+        async *streamText(genOptions) {
+            const url = `${baseURL}/models/${modelName}:streamGenerateContent?alt=sse&key=${apiKey}`;
+            const contents = formatMessagesForGemini(genOptions.messages);
+            const body = {
+                contents,
+                generationConfig: {
+                    temperature: genOptions.temperature ?? options.temperature ?? 0.7,
+                },
+            };
+            if (genOptions.systemPrompt) {
+                body.systemInstruction = {
+                    parts: [{ text: genOptions.systemPrompt }],
+                };
+            }
+            if (genOptions.tools && genOptions.tools.length > 0) {
+                body.tools = [
+                    {
+                        functionDeclarations: genOptions.tools.map(tool_1.formatToolForGemini),
+                    },
+                ];
+            }
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(body),
+                signal: genOptions.abortSignal,
+            });
+            if (!res.ok) {
+                const errText = await res.text().catch(() => '');
+                throw new Error(`Gemini stream request failed [${res.status}]: ${errText}`);
+            }
+            if (!res.body) {
+                throw new Error('ReadableStream not supported on fetch response');
+            }
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed.startsWith('data: '))
+                            continue;
+                        const payload = trimmed.slice(6);
+                        try {
+                            const data = JSON.parse(payload);
+                            const candidate = data.candidates?.[0];
+                            const parts = candidate?.content?.parts || [];
+                            for (const part of parts) {
+                                if (part.text) {
+                                    yield { type: 'text-delta', textDelta: part.text };
+                                }
+                            }
+                        }
+                        catch {
+                            // Ignore partial JSON parse errors
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            yield { type: 'done' };
+        },
+    };
+}

package/dist/ai/providers/index.d.ts

@@ -0,0 +1,5 @@
+export * from './base';
+export * from './openai';
+export * from './anthropic';
+export * from './gemini';
+export * from './mock';

package/dist/ai/providers/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base"), exports);
+__exportStar(require("./openai"), exports);
+__exportStar(require("./anthropic"), exports);
+__exportStar(require("./gemini"), exports);
+__exportStar(require("./mock"), exports);

package/dist/ai/providers/mock.d.ts

@@ -0,0 +1,8 @@
+import type { LanguageModel, ToolCall } from '../types';
+export interface MockModelOptions {
+    modelName?: string;
+    defaultResponse?: string;
+    cannedResponses?: string[];
+    toolCalls?: ToolCall[];
+}
+export declare function createMockModel(options?: MockModelOptions): LanguageModel;

package/dist/ai/providers/mock.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockModel = createMockModel;
+function createMockModel(options = {}) {
+    const modelName = options.modelName || 'mock-model';
+    let responseIndex = 0;
+    return {
+        provider: 'mock',
+        modelName,
+        async generateText(genOptions) {
+            // Check if last user message asks for a tool or if simulated tool calls provided
+            const lastMsg = genOptions.messages[genOptions.messages.length - 1];
+            const content = lastMsg ? lastMsg.content : '';
+            // If simulated tool calls exist and haven't been provided in options yet
+            if (options.toolCalls && options.toolCalls.length > 0 && !lastMsg?.toolCallId) {
+                return {
+                    text: '',
+                    toolCalls: options.toolCalls,
+                    usage: { promptTokens: 10, completionTokens: 10, totalTokens: 20 },
+                    finishReason: 'tool-calls',
+                };
+            }
+            // Check if user content triggers tool simulation for tests
+            if (genOptions.tools && genOptions.tools.length > 0 && content.includes('CALL_TOOL:')) {
+                const match = content.match(/CALL_TOOL:([a-zA-Z0-9_-]+)\((.*?)\)/);
+                if (match) {
+                    const toolName = match[1];
+                    let args = {};
+                    try {
+                        args = JSON.parse(match[2] || '{}');
+                    }
+                    catch {
+                        args = { query: match[2] };
+                    }
+                    return {
+                        text: '',
+                        toolCalls: [{ id: `call_${Date.now()}`, name: toolName, arguments: args }],
+                        usage: { promptTokens: 15, completionTokens: 10, totalTokens: 25 },
+                        finishReason: 'tool-calls',
+                    };
+                }
+            }
+            let text = options.defaultResponse || `Mock response for: "${content.slice(0, 30)}"`;
+            if (options.cannedResponses && options.cannedResponses.length > 0) {
+                text = options.cannedResponses[responseIndex % options.cannedResponses.length];
+                responseIndex++;
+            }
+            return {
+                text,
+                usage: {
+                    promptTokens: Math.max(1, content.length / 4),
+                    completionTokens: Math.max(1, text.length / 4),
+                    totalTokens: Math.max(2, (content.length + text.length) / 4),
+                },
+                finishReason: 'stop',
+            };
+        },
+        async *streamText(genOptions) {
+            const result = await this.generateText(genOptions);
+            if (result.toolCalls && result.toolCalls.length > 0) {
+                for (const call of result.toolCalls) {
+                    yield { type: 'tool-call', toolCall: call };
+                }
+                return;
+            }
+            const words = result.text.split(' ');
+            for (let i = 0; i < words.length; i++) {
+                const chunk = (i === 0 ? '' : ' ') + words[i];
+                yield { type: 'text-delta', textDelta: chunk };
+            }
+            yield {
+                type: 'done',
+                usage: result.usage,
+            };
+        },
+    };
+}

package/dist/ai/providers/openai.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageModel, ModelOptions } from '../types';
+export declare function createOpenAIModel(options: ModelOptions): LanguageModel;