@vistagenic/vista 0.2.16 → 0.3.2

package/dist/ai/providers/openai.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpenAIModel = createOpenAIModel;
+const tool_1 = require("../tool");
+function formatMessagesForOpenAI(messages, systemPrompt) {
+    const result = [];
+    if (systemPrompt) {
+        result.push({ role: 'system', content: systemPrompt });
+    }
+    for (const msg of messages) {
+        if (msg.role === 'tool') {
+            result.push({
+                role: 'tool',
+                tool_call_id: msg.toolCallId || 'call_default',
+                content: msg.content,
+            });
+        }
+        else if (msg.role === 'assistant' && msg.toolCalls && msg.toolCalls.length > 0) {
+            result.push({
+                role: 'assistant',
+                content: msg.content || null,
+                tool_calls: msg.toolCalls.map((tc) => ({
+                    id: tc.id,
+                    type: 'function',
+                    function: {
+                        name: tc.name,
+                        arguments: typeof tc.arguments === 'string' ? tc.arguments : JSON.stringify(tc.arguments),
+                    },
+                })),
+            });
+        }
+        else {
+            result.push({
+                role: msg.role,
+                content: msg.content,
+            });
+        }
+    }
+    return result;
+}
+function createOpenAIModel(options) {
+    const baseURL = (options.baseURL ||
+        process.env.OPENAI_BASE_URL ||
+        'https://api.openai.com/v1').replace(/\/+$/, '');
+    const apiKey = options.apiKey || process.env.OPENAI_API_KEY || '';
+    const modelName = options.model || 'gpt-4o';
+    return {
+        provider: 'openai',
+        modelName,
+        async generateText(genOptions) {
+            const url = `${baseURL}/chat/completions`;
+            const messages = formatMessagesForOpenAI(genOptions.messages, genOptions.systemPrompt);
+            const body = {
+                model: modelName,
+                messages,
+                temperature: genOptions.temperature ?? options.temperature ?? 0.7,
+            };
+            if (genOptions.maxTokens || options.maxTokens) {
+                body.max_tokens = genOptions.maxTokens || options.maxTokens;
+            }
+            if (genOptions.tools && genOptions.tools.length > 0) {
+                body.tools = genOptions.tools.map(tool_1.formatToolForOpenAI);
+                body.tool_choice = 'auto';
+            }
+            const headers = {
+                'Content-Type': 'application/json',
+                ...(options.headers || {}),
+            };
+            if (apiKey) {
+                headers['Authorization'] = `Bearer ${apiKey}`;
+            }
+            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(`OpenAI API request failed [${res.status}]: ${errText}`);
+            }
+            const data = await res.json();
+            const choice = data.choices?.[0];
+            const message = choice?.message;
+            let toolCalls;
+            if (message?.tool_calls && message.tool_calls.length > 0) {
+                toolCalls = message.tool_calls.map((tc) => {
+                    let parsedArgs = {};
+                    try {
+                        parsedArgs = JSON.parse(tc.function?.arguments || '{}');
+                    }
+                    catch {
+                        parsedArgs = { raw: tc.function?.arguments };
+                    }
+                    return {
+                        id: tc.id,
+                        name: tc.function?.name,
+                        arguments: parsedArgs,
+                    };
+                });
+            }
+            return {
+                text: message?.content || '',
+                toolCalls,
+                finishReason: choice?.finish_reason || 'stop',
+                usage: data.usage
+                    ? {
+                        promptTokens: data.usage.prompt_tokens || 0,
+                        completionTokens: data.usage.completion_tokens || 0,
+                        totalTokens: data.usage.total_tokens || 0,
+                    }
+                    : undefined,
+                raw: data,
+            };
+        },
+        async *streamText(genOptions) {
+            const url = `${baseURL}/chat/completions`;
+            const messages = formatMessagesForOpenAI(genOptions.messages, genOptions.systemPrompt);
+            const body = {
+                model: modelName,
+                messages,
+                temperature: genOptions.temperature ?? options.temperature ?? 0.7,
+                stream: true,
+            };
+            if (genOptions.maxTokens || options.maxTokens) {
+                body.max_tokens = genOptions.maxTokens || options.maxTokens;
+            }
+            if (genOptions.tools && genOptions.tools.length > 0) {
+                body.tools = genOptions.tools.map(tool_1.formatToolForOpenAI);
+                body.tool_choice = 'auto';
+            }
+            const headers = {
+                'Content-Type': 'application/json',
+                ...(options.headers || {}),
+            };
+            if (apiKey) {
+                headers['Authorization'] = `Bearer ${apiKey}`;
+            }
+            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(`OpenAI API 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 || trimmed.startsWith(':'))
+                            continue;
+                        if (trimmed === 'data: [DONE]') {
+                            yield { type: 'done' };
+                            return;
+                        }
+                        if (trimmed.startsWith('data: ')) {
+                            try {
+                                const parsed = JSON.parse(trimmed.slice(6));
+                                const delta = parsed.choices?.[0]?.delta;
+                                if (delta?.content) {
+                                    yield { type: 'text-delta', textDelta: delta.content };
+                                }
+                                if (delta?.tool_calls) {
+                                    for (const tc of delta.tool_calls) {
+                                        let parsedArgs = {};
+                                        try {
+                                            parsedArgs = JSON.parse(tc.function?.arguments || '{}');
+                                        }
+                                        catch {
+                                            parsedArgs = { raw: tc.function?.arguments };
+                                        }
+                                        yield {
+                                            type: 'tool-call',
+                                            toolCall: {
+                                                id: tc.id || `call_${Date.now()}`,
+                                                name: tc.function?.name || '',
+                                                arguments: parsedArgs,
+                                            },
+                                        };
+                                    }
+                                }
+                            }
+                            catch {
+                                // Ignore parse errors on partial chunks
+                            }
+                        }
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+            yield { type: 'done' };
+        },
+    };
+}

package/dist/ai/rag.d.ts

@@ -0,0 +1,35 @@
+import type { ToolDefinition } from './types';
+export interface DocumentEntry<TMetadata = any> {
+    id: string;
+    text: string;
+    vector?: number[];
+    metadata?: TMetadata;
+}
+export interface DocumentMatch<TMetadata = any> {
+    id: string;
+    text: string;
+    score: number;
+    metadata?: TMetadata;
+}
+export declare function cosineSimilarity(a: number[], b: number[]): number;
+export declare class InMemoryVectorStore<TMetadata = any> {
+    private documents;
+    addDocument(doc: DocumentEntry<TMetadata>): void;
+    addDocuments(docs: DocumentEntry<TMetadata>[]): void;
+    search(queryVector: number[], topK?: number): DocumentMatch<TMetadata>[];
+    searchByKeyword(query: string, topK?: number): DocumentMatch<TMetadata>[];
+    clear(): void;
+}
+export interface RetrieverOptions<TMetadata = any> {
+    name?: string;
+    description?: string;
+    store: InMemoryVectorStore<TMetadata>;
+    embed?: (text: string) => Promise<number[]> | number[];
+    topK?: number;
+}
+/**
+ * Creates a knowledge retriever tool that can be provided directly to an AI agent.
+ */
+export declare function createRetrieverTool<TMetadata = any>(options: RetrieverOptions<TMetadata>): ToolDefinition<{
+    query: string;
+}>;

package/dist/ai/rag.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryVectorStore = void 0;
+exports.cosineSimilarity = cosineSimilarity;
+exports.createRetrieverTool = createRetrieverTool;
+const tool_1 = require("./tool");
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length || a.length === 0)
+        return 0;
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+    if (denominator === 0)
+        return 0;
+    return dotProduct / denominator;
+}
+class InMemoryVectorStore {
+    documents = [];
+    addDocument(doc) {
+        this.documents.push(doc);
+    }
+    addDocuments(docs) {
+        this.documents.push(...docs);
+    }
+    search(queryVector, topK = 3) {
+        const scored = [];
+        for (const doc of this.documents) {
+            if (!doc.vector)
+                continue;
+            const score = cosineSimilarity(queryVector, doc.vector);
+            scored.push({
+                id: doc.id,
+                text: doc.text,
+                score,
+                metadata: doc.metadata,
+            });
+        }
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, topK);
+    }
+    searchByKeyword(query, topK = 3) {
+        const lowerQuery = query.toLowerCase();
+        const scored = [];
+        for (const doc of this.documents) {
+            const lowerText = doc.text.toLowerCase();
+            let matchCount = 0;
+            const terms = lowerQuery.split(/\s+/).filter(Boolean);
+            for (const term of terms) {
+                if (lowerText.includes(term))
+                    matchCount++;
+            }
+            if (matchCount > 0) {
+                scored.push({
+                    id: doc.id,
+                    text: doc.text,
+                    score: matchCount / terms.length,
+                    metadata: doc.metadata,
+                });
+            }
+        }
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, topK);
+    }
+    clear() {
+        this.documents = [];
+    }
+}
+exports.InMemoryVectorStore = InMemoryVectorStore;
+/**
+ * Creates a knowledge retriever tool that can be provided directly to an AI agent.
+ */
+function createRetrieverTool(options) {
+    const { name = 'search_knowledge_base', description = 'Search the knowledge base for relevant context, documentation, or domain facts.', store, embed, topK = 3, } = options;
+    return (0, tool_1.tool)({
+        name,
+        description,
+        parameters: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The search query or keyword phrase to find context for',
+                },
+            },
+            required: ['query'],
+        },
+        execute: async ({ query }) => {
+            let matches = [];
+            if (embed) {
+                const queryVector = await embed(query);
+                matches = store.search(queryVector, topK);
+            }
+            else {
+                matches = store.searchByKeyword(query, topK);
+            }
+            return matches.map((m) => ({
+                id: m.id,
+                content: m.text,
+                score: Math.round(m.score * 100) / 100,
+                metadata: m.metadata,
+            }));
+        },
+    });
+}

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

@@ -0,0 +1 @@
+export * from './use-agent';

package/dist/ai/react/index.js

@@ -0,0 +1,17 @@
+"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("./use-agent"), exports);

package/dist/ai/react/react-server.d.ts

@@ -0,0 +1 @@
+export * from './index';

package/dist/ai/react/react-server.js

@@ -0,0 +1,17 @@
+"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("./index"), exports);

package/dist/ai/react/use-agent.d.ts

@@ -0,0 +1,23 @@
+import type { Message } from '../types';
+export interface UseAgentOptions {
+    api?: string;
+    initialMessages?: Message[];
+    sessionId?: string;
+    onResponse?: (response: Response) => void;
+    onFinish?: (message: Message) => void;
+    onError?: (error: Error) => void;
+}
+export interface UseAgentResult {
+    messages: Message[];
+    input: string;
+    setInput: (value: string) => void;
+    handleInputChange: (e: any) => void;
+    handleSubmit: (e?: any, options?: {
+        prompt?: string;
+    }) => Promise<void>;
+    isLoading: boolean;
+    error: Error | null;
+    stop: () => void;
+    reload: () => Promise<void>;
+}
+export declare function useAgent(options?: UseAgentOptions): UseAgentResult;

package/dist/ai/react/use-agent.js

@@ -0,0 +1,138 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAgent = useAgent;
+const react_1 = require("react");
+function useAgent(options = {}) {
+    const { api = '/api/chat', initialMessages = [], sessionId, onResponse, onFinish, onError, } = options;
+    const [messages, setMessages] = (0, react_1.useState)(initialMessages);
+    const [input, setInput] = (0, react_1.useState)('');
+    const [isLoading, setIsLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const abortControllerRef = (0, react_1.useRef)(null);
+    const handleInputChange = (0, react_1.useCallback)((e) => {
+        setInput(e?.target?.value ?? e);
+    }, []);
+    const stop = (0, react_1.useCallback)(() => {
+        if (abortControllerRef.current) {
+            abortControllerRef.current.abort();
+            abortControllerRef.current = null;
+            setIsLoading(false);
+        }
+    }, []);
+    const sendPrompt = (0, react_1.useCallback)(async (promptToSend) => {
+        if (!promptToSend.trim())
+            return;
+        const userMessage = { role: 'user', content: promptToSend };
+        const newMessages = [...messages, userMessage];
+        setMessages(newMessages);
+        setInput('');
+        setIsLoading(true);
+        setError(null);
+        const abortController = new AbortController();
+        abortControllerRef.current = abortController;
+        try {
+            const response = await fetch(api, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    prompt: promptToSend,
+                    messages: newMessages,
+                    sessionId,
+                }),
+                signal: abortController.signal,
+            });
+            onResponse?.(response);
+            if (!response.ok) {
+                const errText = await response.text().catch(() => '');
+                throw new Error(errText || `Request failed with status ${response.status}`);
+            }
+            if (!response.body) {
+                throw new Error('Response body is empty or not streamable');
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            let assistantText = '';
+            // Add empty assistant message that will stream
+            setMessages((prev) => [...prev, { role: 'assistant', content: '' }]);
+            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 chunk = JSON.parse(payload);
+                        if (chunk.type === 'text-delta' && chunk.textDelta) {
+                            assistantText += chunk.textDelta;
+                            setMessages((prev) => {
+                                const updated = [...prev];
+                                const lastIdx = updated.length - 1;
+                                if (lastIdx >= 0 && updated[lastIdx].role === 'assistant') {
+                                    updated[lastIdx] = {
+                                        ...updated[lastIdx],
+                                        content: assistantText,
+                                    };
+                                }
+                                return updated;
+                            });
+                        }
+                        else if (chunk.type === 'error' && chunk.error) {
+                            throw new Error(chunk.error);
+                        }
+                    }
+                    catch {
+                        // Ignore partial JSON chunks
+                    }
+                }
+            }
+            const finalAssistantMessage = {
+                role: 'assistant',
+                content: assistantText,
+            };
+            onFinish?.(finalAssistantMessage);
+        }
+        catch (err) {
+            if (err?.name === 'AbortError')
+                return;
+            const e = err instanceof Error ? err : new Error(String(err));
+            setError(e);
+            onError?.(e);
+        }
+        finally {
+            setIsLoading(false);
+            abortControllerRef.current = null;
+        }
+    }, [api, messages, sessionId, onResponse, onFinish, onError]);
+    const handleSubmit = (0, react_1.useCallback)(async (e, submitOptions) => {
+        e?.preventDefault?.();
+        const promptToSend = submitOptions?.prompt ?? input;
+        await sendPrompt(promptToSend);
+    }, [input, sendPrompt]);
+    const reload = (0, react_1.useCallback)(async () => {
+        const lastUserMessage = [...messages].reverse().find((m) => m.role === 'user');
+        if (lastUserMessage) {
+            await sendPrompt(lastUserMessage.content);
+        }
+    }, [messages, sendPrompt]);
+    return {
+        messages,
+        input,
+        setInput,
+        handleInputChange,
+        handleSubmit,
+        isLoading,
+        error,
+        stop,
+        reload,
+    };
+}

package/dist/ai/stream.d.ts

@@ -0,0 +1,24 @@
+import type { StreamChunk, TokenUsage, ToolCall } from './types';
+export declare class AgentStream implements AsyncIterable<StreamChunk> {
+    private source;
+    constructor(source: AsyncIterable<StreamChunk>);
+    [Symbol.asyncIterator](): AsyncIterator<StreamChunk>;
+    /**
+     * Converts the stream into a Server-Sent Events (SSE) Response.
+     * Format is compatible with UI clients and standard EventSource.
+     */
+    toDataStreamResponse(init?: ResponseInit): Response;
+    /**
+     * Converts the stream into a simple text-only Response stream.
+     */
+    toTextStreamResponse(init?: ResponseInit): Response;
+    /**
+     * Collects all text and events from the stream into a single result.
+     */
+    collect(): Promise<{
+        text: string;
+        toolCalls: ToolCall[];
+        usage?: TokenUsage;
+    }>;
+}
+export declare function createAIStreamResponse(stream: AsyncIterable<StreamChunk> | AgentStream, init?: ResponseInit): Response;