agen-vektor 0.1.0

package/dist/providers/anthropic.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicProvider = void 0;
+/**
+ * Anthropic provider — Messages API with tool use and streaming.
+ * https://docs.anthropic.com/en/api/messages
+ */
+const provider_1 = require("./provider");
+const credentials_1 = require("../config/credentials");
+const models_1 = require("../config/models");
+const API_URL = 'https://api.anthropic.com/v1/messages';
+const ANTHROPIC_VERSION = '2023-06-01';
+function toAnthropicMessages(messages) {
+    const out = [];
+    for (const m of messages) {
+        if (m.role === 'system')
+            continue; // system handled separately
+        if (m.role === 'tool') {
+            out.push({
+                role: 'user',
+                content: [
+                    {
+                        type: 'tool_result',
+                        tool_use_id: m.toolCallId,
+                        content: m.content,
+                    },
+                ],
+            });
+            continue;
+        }
+        if (m.toolCalls && m.toolCalls.length > 0) {
+            const content = [];
+            if (m.content)
+                content.push({ type: 'text', text: m.content });
+            for (const tc of m.toolCalls) {
+                content.push({
+                    type: 'tool_use',
+                    id: tc.id,
+                    name: tc.name,
+                    input: safeParse(tc.arguments),
+                });
+            }
+            out.push({ role: 'assistant', content });
+            continue;
+        }
+        out.push({ role: m.role, content: m.content });
+    }
+    return out;
+}
+function toToolDefs(tools) {
+    return tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.parameters,
+    }));
+}
+function safeParse(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return { _raw: s };
+    }
+}
+class AnthropicProvider {
+    id = 'anthropic';
+    name = 'Anthropic';
+    apiKey;
+    constructor(apiKey) {
+        this.apiKey = apiKey !== undefined ? apiKey : (0, credentials_1.getApiKey)('anthropic');
+    }
+    capabilities() {
+        return { streaming: true, tools: true, contextWindow: 200000 };
+    }
+    headers() {
+        return {
+            'Content-Type': 'application/json',
+            'x-api-key': this.apiKey || '',
+            'anthropic-version': ANTHROPIC_VERSION,
+        };
+    }
+    buildBody(params, stream) {
+        const system = params.messages
+            .filter((m) => m.role === 'system')
+            .map((m) => m.content)
+            .join('\n\n');
+        const body = {
+            model: params.model,
+            max_tokens: params.maxTokens || 8192,
+            messages: toAnthropicMessages(params.messages),
+            stream,
+        };
+        if (system)
+            body.system = system;
+        if (params.tools && params.tools.length > 0)
+            body.tools = toToolDefs(params.tools);
+        if (params.temperature !== undefined)
+            body.temperature = params.temperature;
+        return body;
+    }
+    async post(body, signal) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 180_000);
+        const onOuterAbort = () => controller.abort();
+        if (signal) {
+            if (signal.aborted)
+                controller.abort();
+            else
+                signal.addEventListener('abort', onOuterAbort);
+        }
+        try {
+            const res = await fetch(API_URL, {
+                method: 'POST',
+                headers: this.headers(),
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            const text = await res.text();
+            if (!res.ok) {
+                const detail = safeJson(text);
+                const errObj = (detail && detail.error);
+                throw new provider_1.ProviderError(errObj?.message || `HTTP ${res.status}: ${text.slice(0, 300)}`, res.status, res.status >= 500 || res.status === 429);
+            }
+            return safeJson(text) || {};
+        }
+        finally {
+            clearTimeout(timer);
+            if (signal)
+                signal.removeEventListener('abort', onOuterAbort);
+        }
+    }
+    async chat(params) {
+        const data = await this.post(this.buildBody(params, false), params.signal);
+        const content = data.content || [];
+        let text = '';
+        const toolCalls = [];
+        for (const block of content) {
+            if (block.type === 'text')
+                text += String(block.text || '');
+            if (block.type === 'tool_use') {
+                toolCalls.push({
+                    id: String(block.id),
+                    name: String(block.name),
+                    arguments: JSON.stringify(block.input ?? {}),
+                });
+            }
+        }
+        const usage = data.usage;
+        return {
+            content: text,
+            toolCalls,
+            stopReason: String(data.stop_reason || 'end_turn'),
+            usage: usage
+                ? { inputTokens: usage.input_tokens, outputTokens: usage.output_tokens }
+                : undefined,
+            model: String(data.model || params.model),
+        };
+    }
+    async *stream(params) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 180_000);
+        const onOuterAbort = () => controller.abort();
+        if (params.signal) {
+            if (params.signal.aborted)
+                controller.abort();
+            else
+                params.signal.addEventListener('abort', onOuterAbort);
+        }
+        try {
+            const res = await fetch(API_URL, {
+                method: 'POST',
+                headers: this.headers(),
+                body: JSON.stringify(this.buildBody(params, true)),
+                signal: controller.signal,
+            });
+            if (!res.ok || !res.body) {
+                const text = await res.text().catch(() => '');
+                throw new provider_1.ProviderError(`HTTP ${res.status}: ${text.slice(0, 200)}`, res.status, res.status >= 500);
+            }
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            let content = '';
+            const toolCalls = [];
+            let currentTool = null;
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                // Events arrive as pairs: `event: X` then `data: {...}`
+                for (let i = 0; i < lines.length; i++) {
+                    const trimmed = lines[i].trim();
+                    if (!trimmed.startsWith('event:'))
+                        continue;
+                    const evtName = trimmed.slice(6).trim();
+                    const dataLine = lines[i + 1];
+                    if (!dataLine)
+                        continue;
+                    const json = safeJson(dataLine.replace(/^data:\s*/, '').trim());
+                    if (!json)
+                        continue;
+                    const contentBlock = json.content_block;
+                    if (evtName === 'content_block_start' && contentBlock?.type === 'tool_use') {
+                        currentTool = {
+                            id: String(contentBlock.id || ''),
+                            name: String(contentBlock.name || ''),
+                            arguments: '',
+                        };
+                    }
+                    else if (evtName === 'content_block_delta') {
+                        const delta = json.delta;
+                        if (delta?.type === 'text_delta' && typeof delta.text === 'string') {
+                            content += delta.text;
+                            yield { type: 'delta', delta: delta.text };
+                        }
+                        else if (delta?.type === 'input_json_delta' &&
+                            currentTool &&
+                            typeof delta.partial_json === 'string') {
+                            currentTool.arguments += delta.partial_json;
+                        }
+                    }
+                    else if (evtName === 'content_block_stop') {
+                        if (currentTool && currentTool.name) {
+                            toolCalls.push(currentTool);
+                            yield { type: 'tool_call', toolCall: currentTool };
+                        }
+                        currentTool = null;
+                    }
+                    else if (evtName === 'message_stop') {
+                        if (currentTool && currentTool.name) {
+                            toolCalls.push(currentTool);
+                            yield { type: 'tool_call', toolCall: currentTool };
+                        }
+                        currentTool = null;
+                        yield {
+                            type: 'done',
+                            result: {
+                                content,
+                                toolCalls,
+                                stopReason: toolCalls.length > 0 ? 'tool_calls' : 'end_turn',
+                                model: params.model,
+                            },
+                        };
+                        return;
+                    }
+                }
+            }
+            if (currentTool && currentTool.name)
+                toolCalls.push(currentTool);
+            yield {
+                type: 'done',
+                result: { content, toolCalls, stopReason: 'end_turn', model: params.model },
+            };
+        }
+        finally {
+            clearTimeout(timer);
+            if (params.signal)
+                params.signal.removeEventListener('abort', onOuterAbort);
+        }
+    }
+    async models() {
+        return (0, models_1.modelsForProvider)(this.id).map((m) => m.id);
+    }
+}
+exports.AnthropicProvider = AnthropicProvider;
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/providers/custom.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomProvider = void 0;
+const openai_compat_1 = require("./openai-compat");
+/**
+ * Custom provider — any OpenAI-compatible endpoint.
+ * Other protocols are documented but not fully implemented;
+ * the adapter clearly reports its limitation.
+ */
+class CustomProvider extends openai_compat_1.OpenAICompatProvider {
+    protocol;
+    constructor(cfg) {
+        super({
+            id: 'custom',
+            name: cfg.name || 'Custom',
+            baseUrl: cfg.baseUrl,
+            apiKey: cfg.apiKey !== undefined ? cfg.apiKey : null,
+            defaultModel: cfg.model || 'default',
+            contextWindow: 128000,
+        });
+        this.protocol = cfg.protocol;
+    }
+}
+exports.CustomProvider = CustomProvider;

package/dist/providers/factory.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_IDS = void 0;
+exports.providerDisplayNames = providerDisplayNames;
+exports.createProvider = createProvider;
+exports.providerRequiresKey = providerRequiresKey;
+const openai_1 = require("./openai");
+const anthropic_1 = require("./anthropic");
+const gemini_1 = require("./gemini");
+const openrouter_1 = require("./openrouter");
+const ollama_1 = require("./ollama");
+const custom_1 = require("./custom");
+const credentials_1 = require("../config/credentials");
+exports.PROVIDER_IDS = ['openai', 'anthropic', 'gemini', 'openrouter', 'ollama', 'custom'];
+function providerDisplayNames() {
+    return [
+        { id: 'openai', name: 'OpenAI' },
+        { id: 'anthropic', name: 'Anthropic' },
+        { id: 'gemini', name: 'Gemini' },
+        { id: 'openrouter', name: 'OpenRouter' },
+        { id: 'ollama', name: 'Ollama' },
+        { id: 'custom', name: 'Custom' },
+    ];
+}
+function createProvider(config) {
+    switch (config.provider) {
+        case 'openai':
+            return new openai_1.OpenAIProvider();
+        case 'anthropic':
+            return new anthropic_1.AnthropicProvider();
+        case 'gemini':
+            return new gemini_1.GeminiProvider();
+        case 'openrouter':
+            return new openrouter_1.OpenRouterProvider();
+        case 'ollama':
+            return new ollama_1.OllamaProvider();
+        case 'custom':
+            return new custom_1.CustomProvider({
+                name: config.customName || 'Custom',
+                baseUrl: config.apiUrl || process.env.VECTOR_API_URL || '',
+                apiKey: (0, credentials_1.getApiKey)('custom'),
+                model: config.model,
+                protocol: config.protocol || 'openai',
+            });
+        default:
+            // Unknown provider id: treat as OpenAI-compatible with the given URL
+            return new custom_1.CustomProvider({
+                name: config.provider,
+                baseUrl: config.apiUrl || process.env.VECTOR_API_URL || '',
+                apiKey: (0, credentials_1.getApiKey)('custom'),
+                model: config.model,
+                protocol: 'openai',
+            });
+    }
+}
+function providerRequiresKey(id) {
+    return id !== 'ollama';
+}

package/dist/providers/gemini.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiProvider = void 0;
+/**
+ * Gemini provider — generateContent API with function calling + streaming.
+ * https://ai.google.dev/api/generate-content
+ */
+const provider_1 = require("./provider");
+const credentials_1 = require("../config/credentials");
+const models_1 = require("../config/models");
+const BASE = 'https://generativelanguage.googleapis.com/v1beta';
+function toGeminiMessages(messages) {
+    const out = [];
+    let pendingToolResults = [];
+    const flush = () => {
+        if (pendingToolResults.length > 0) {
+            out.push({ role: 'user', parts: pendingToolResults });
+            pendingToolResults = [];
+        }
+    };
+    for (const m of messages) {
+        if (m.role === 'system')
+            continue; // handled via system_instruction
+        if (m.role === 'tool') {
+            pendingToolResults.push({
+                functionResponse: {
+                    name: m.name,
+                    response: { result: m.content },
+                },
+            });
+            continue;
+        }
+        flush();
+        const parts = [];
+        if (m.content)
+            parts.push({ text: m.content });
+        if (m.toolCalls && m.toolCalls.length > 0) {
+            parts.push({
+                functionCall: m.toolCalls.map((tc) => ({
+                    name: tc.name,
+                    args: safeParse(tc.arguments),
+                })),
+            });
+        }
+        out.push({ role: m.role === 'assistant' ? 'model' : 'user', parts });
+    }
+    flush();
+    return out;
+}
+function toToolDefs(tools) {
+    return tools.map((t) => ({
+        functionDeclarations: [
+            {
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters,
+            },
+        ],
+    }));
+}
+function safeParse(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return { _raw: s };
+    }
+}
+function extractResult(data) {
+    const candidates = data.candidates || [];
+    const content0 = candidates[0]?.content || {};
+    const parts = content0.parts || [];
+    let content = '';
+    const toolCalls = [];
+    for (const part of parts) {
+        if (typeof part.text === 'string')
+            content += part.text;
+        if (part.functionCall) {
+            const raw = part.functionCall;
+            const fcs = Array.isArray(raw) ? raw : [raw];
+            for (const fc of fcs) {
+                toolCalls.push({
+                    id: `gemini_${Math.random().toString(36).slice(2)}`,
+                    name: String(fc.name || ''),
+                    arguments: JSON.stringify(fc.args ?? {}),
+                });
+            }
+        }
+    }
+    return { content, toolCalls };
+}
+class GeminiProvider {
+    id = 'gemini';
+    name = 'Gemini';
+    apiKey;
+    constructor(apiKey) {
+        this.apiKey = apiKey !== undefined ? apiKey : (0, credentials_1.getApiKey)('gemini');
+    }
+    capabilities() {
+        return { streaming: true, tools: true, contextWindow: 1048576 };
+    }
+    buildBody(params, stream) {
+        const system = params.messages
+            .filter((m) => m.role === 'system')
+            .map((m) => m.content)
+            .join('\n\n');
+        const body = {
+            contents: toGeminiMessages(params.messages),
+        };
+        if (system)
+            body.systemInstruction = { parts: [{ text: system }] };
+        if (params.tools && params.tools.length > 0)
+            body.tools = toToolDefs(params.tools);
+        if (params.temperature !== undefined)
+            body.generationConfig = { temperature: params.temperature };
+        if (stream)
+            body.generationConfig = { ...body.generationConfig, responseModalities: ['TEXT'] };
+        return body;
+    }
+    url(params, stream) {
+        const key = this.apiKey || '';
+        const action = stream ? 'streamGenerateContent' : 'generateContent';
+        const alt = stream ? '&alt=sse' : '';
+        return `${BASE}/models/${params.model}:${action}?key=${encodeURIComponent(key)}${alt}`;
+    }
+    async post(params, stream) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 180_000);
+        const onOuterAbort = () => controller.abort();
+        if (params.signal) {
+            if (params.signal.aborted)
+                controller.abort();
+            else
+                params.signal.addEventListener('abort', onOuterAbort);
+        }
+        const res = await fetch(this.url(params, stream), {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(this.buildBody(params, stream)),
+            signal: controller.signal,
+        });
+        clearTimeout(timer);
+        if (params.signal)
+            params.signal.removeEventListener('abort', onOuterAbort);
+        return { res };
+    }
+    async chat(params) {
+        const { res } = await this.post(params, false);
+        const text = await res.text();
+        if (!res.ok) {
+            throw new provider_1.ProviderError(`Gemini HTTP ${res.status}: ${text.slice(0, 300)}`, res.status, res.status >= 500);
+        }
+        const data = JSON.parse(text);
+        const { content, toolCalls } = extractResult(data);
+        return {
+            content,
+            toolCalls,
+            stopReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
+            model: params.model,
+        };
+    }
+    async *stream(params) {
+        const { res } = await this.post(params, true);
+        if (!res.ok || !res.body) {
+            const text = await res.text().catch(() => '');
+            throw new provider_1.ProviderError(`Gemini HTTP ${res.status}: ${text.slice(0, 200)}`, res.status, res.status >= 500);
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let content = '';
+        const toolCalls = [];
+        for (;;) {
+            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(5).trim();
+                if (!payload)
+                    continue;
+                const json = safeJson(payload);
+                if (!json)
+                    continue;
+                const { content: deltaText, toolCalls: newCalls } = extractResult(json);
+                if (deltaText) {
+                    content += deltaText;
+                    yield { type: 'delta', delta: deltaText };
+                }
+                for (const tc of newCalls) {
+                    toolCalls.push(tc);
+                    yield { type: 'tool_call', toolCall: tc };
+                }
+            }
+        }
+        yield {
+            type: 'done',
+            result: {
+                content,
+                toolCalls,
+                stopReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
+                model: params.model,
+            },
+        };
+    }
+    async models() {
+        return (0, models_1.modelsForProvider)(this.id).map((m) => m.id);
+    }
+}
+exports.GeminiProvider = GeminiProvider;
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}