@aragon-agent/core 0.1.3

package/dist/llm/providers/anthropic.js

@@ -0,0 +1,420 @@
+/**
+ * Anthropic Messages API adapter.
+ *
+ * Converts the universal LLM types to/from Anthropic's wire format and maps
+ * SSE events to the unified StreamEvent protocol.
+ *
+ * Supports:
+ * - Streaming via `POST /v1/messages` with `stream: true`
+ * - Extended thinking (thinking_start / thinking_delta)
+ * - Tool use (content_block_start type=tool_use → tool_call_*)
+ * - Multimodal user messages (text + image)
+ * - Model list via `GET /v1/models`
+ */
+import { THINKING_BUDGET } from '../types.js';
+import { LLMError, classifyHttpError, wrapFetchError } from '../provider.js';
+import { parseSSEStream } from '../stream-utils.js';
+import { consumeStream } from '../stream-utils.js';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const DEFAULT_BASE_URL = 'https://api.anthropic.com';
+const ANTHROPIC_VERSION = '2023-06-01';
+const DEFAULT_MAX_TOKENS = 16384;
+// ---------------------------------------------------------------------------
+// Anthropic provider
+// ---------------------------------------------------------------------------
+export class AnthropicProvider {
+    id = 'anthropic';
+    displayName = 'Anthropic';
+    defaultBaseUrl = DEFAULT_BASE_URL;
+    // -----------------------------------------------------------------------
+    // stream
+    // -----------------------------------------------------------------------
+    async *stream(request) {
+        const baseUrl = (request.baseUrl || this.defaultBaseUrl).replace(/\/+$/, '');
+        const url = `${baseUrl}/v1/messages`;
+        const body = buildRequestBody(request);
+        let response;
+        try {
+            response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': request.apiKey,
+                    'anthropic-version': ANTHROPIC_VERSION,
+                },
+                body: JSON.stringify(body),
+                signal: request.signal,
+            });
+        }
+        catch (err) {
+            yield { type: 'error', error: wrapFetchError(err, this.id) };
+            return;
+        }
+        if (!response.ok) {
+            const text = await response.text().catch(() => '');
+            yield { type: 'error', error: classifyHttpError(response.status, text, this.id) };
+            return;
+        }
+        if (!response.body) {
+            yield { type: 'error', error: new LLMError('Response body is null', this.id, 'network_error', true) };
+            return;
+        }
+        // -- Parse SSE events and map to StreamEvent --
+        const usage = { inputTokens: 0, outputTokens: 0 };
+        const contentBlocks = [];
+        let stopReason;
+        // Accumulator state per content block index
+        const blockAccumulators = new Map();
+        let currentBlockIndex = -1;
+        try {
+            for await (const sse of parseSSEStream(response.body, request.signal)) {
+                // Anthropic uses the `event` field to distinguish event types
+                const eventType = sse.event;
+                if (!eventType || !sse.data)
+                    continue;
+                let data;
+                try {
+                    data = JSON.parse(sse.data);
+                }
+                catch {
+                    continue; // skip malformed JSON
+                }
+                switch (eventType) {
+                    case 'message_start': {
+                        const msg = data.message;
+                        if (msg?.usage) {
+                            const u = msg.usage;
+                            usage.inputTokens = u.input_tokens ?? 0;
+                            usage.cacheReadTokens = u.cache_read_input_tokens;
+                            usage.cacheWriteTokens = u.cache_creation_input_tokens;
+                        }
+                        break;
+                    }
+                    case 'content_block_start': {
+                        currentBlockIndex = data.index ?? currentBlockIndex + 1;
+                        const block = data.content_block;
+                        if (!block)
+                            break;
+                        const blockType = block.type;
+                        if (blockType === 'thinking') {
+                            blockAccumulators.set(currentBlockIndex, { type: 'thinking', text: '' });
+                            yield { type: 'thinking_start' };
+                        }
+                        else if (blockType === 'tool_use') {
+                            const toolCallId = block.id || '';
+                            const toolName = block.name || '';
+                            blockAccumulators.set(currentBlockIndex, {
+                                type: 'tool_use',
+                                toolCallId,
+                                toolName,
+                                argsJson: '',
+                            });
+                            yield { type: 'tool_call_start', toolCallId, toolName };
+                        }
+                        else {
+                            // text or redacted_thinking — treat as text
+                            blockAccumulators.set(currentBlockIndex, { type: 'text', text: '' });
+                        }
+                        break;
+                    }
+                    case 'content_block_delta': {
+                        const idx = data.index ?? currentBlockIndex;
+                        const delta = data.delta;
+                        if (!delta)
+                            break;
+                        const deltaType = delta.type;
+                        const acc = blockAccumulators.get(idx);
+                        if (deltaType === 'text_delta') {
+                            const text = delta.text || '';
+                            if (acc && acc.type === 'text')
+                                acc.text += text;
+                            yield { type: 'text_delta', delta: text };
+                        }
+                        else if (deltaType === 'thinking_delta') {
+                            const thinking = delta.thinking || '';
+                            if (acc && acc.type === 'thinking')
+                                acc.text += thinking;
+                            yield { type: 'thinking_delta', delta: thinking };
+                        }
+                        else if (deltaType === 'input_json_delta') {
+                            const partial = delta.partial_json || '';
+                            if (acc && acc.type === 'tool_use') {
+                                acc.argsJson += partial;
+                                yield { type: 'tool_call_delta', toolCallId: acc.toolCallId, argsDelta: partial };
+                            }
+                        }
+                        break;
+                    }
+                    case 'content_block_stop': {
+                        const idx = data.index ?? currentBlockIndex;
+                        const acc = blockAccumulators.get(idx);
+                        if (!acc)
+                            break;
+                        // Extract signature from content_block_stop for thinking blocks
+                        const stopBlock = data.content_block;
+                        if (acc.type === 'text') {
+                            contentBlocks.push({ type: 'text', text: acc.text });
+                        }
+                        else if (acc.type === 'thinking') {
+                            const signature = stopBlock?.signature ?? acc.signature;
+                            contentBlocks.push({ type: 'thinking', text: acc.text, signature });
+                        }
+                        else if (acc.type === 'tool_use') {
+                            let args = {};
+                            try {
+                                args = acc.argsJson ? JSON.parse(acc.argsJson) : {};
+                            }
+                            catch {
+                                // JSON is malformed — likely truncated due to max_tokens.
+                                // Mark with __parse_error so the executor returns a clear error
+                                // to the LLM instead of a confusing "missing required property" message.
+                                console.warn(`[AnthropicProvider] Malformed tool call JSON for "${acc.toolName}" ` +
+                                    `(stopReason=${stopReason ?? 'unknown'}, ` +
+                                    `argsJson length=${acc.argsJson.length}): ` +
+                                    acc.argsJson.slice(0, 200));
+                                args = { __parse_error: true, __raw: acc.argsJson };
+                            }
+                            contentBlocks.push({
+                                type: 'tool_call',
+                                toolCallId: acc.toolCallId,
+                                toolName: acc.toolName,
+                                args,
+                            });
+                            yield {
+                                type: 'tool_call_end',
+                                toolCallId: acc.toolCallId,
+                                toolName: acc.toolName,
+                                args,
+                            };
+                        }
+                        blockAccumulators.delete(idx);
+                        break;
+                    }
+                    case 'message_delta': {
+                        const delta = data.delta;
+                        if (delta?.stop_reason) {
+                            stopReason = mapStopReason(delta.stop_reason);
+                        }
+                        const u = data.usage;
+                        if (u) {
+                            usage.outputTokens = u.output_tokens ?? usage.outputTokens;
+                        }
+                        break;
+                    }
+                    case 'message_stop': {
+                        const message = {
+                            role: 'assistant',
+                            content: contentBlocks,
+                            usage,
+                            stopReason,
+                        };
+                        yield { type: 'done', message, usage };
+                        return;
+                    }
+                    case 'error': {
+                        const errObj = data.error;
+                        const errMsg = errObj?.message || 'Unknown Anthropic error';
+                        const errType = errObj?.type || '';
+                        // Map Anthropic error types to our classification
+                        const llmErr = /overloaded/i.test(errType)
+                            ? new LLMError(errMsg, this.id, 'overloaded', true)
+                            : /rate/i.test(errType)
+                                ? new LLMError(errMsg, this.id, 'rate_limit', true)
+                                : /auth/i.test(errType)
+                                    ? new LLMError(errMsg, this.id, 'auth_error', false)
+                                    : new LLMError(errMsg, this.id, 'server_error', true);
+                        yield { type: 'error', error: llmErr };
+                        return;
+                    }
+                    default:
+                        // ping, etc. — ignored
+                        break;
+                }
+            }
+            // Stream ended without message_stop — emit done with what we have
+            const message = {
+                role: 'assistant',
+                content: contentBlocks,
+                usage,
+                stopReason,
+            };
+            yield { type: 'done', message, usage };
+        }
+        catch (err) {
+            yield { type: 'error', error: wrapFetchError(err, this.id) };
+        }
+    }
+    // -----------------------------------------------------------------------
+    // complete
+    // -----------------------------------------------------------------------
+    async complete(request) {
+        return consumeStream(this.stream(request));
+    }
+    // -----------------------------------------------------------------------
+    // listModels
+    // -----------------------------------------------------------------------
+    async listModels(apiKey, baseUrl) {
+        const base = (baseUrl || this.defaultBaseUrl).replace(/\/+$/, '');
+        const url = `${base}/v1/models`;
+        try {
+            const res = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'x-api-key': apiKey,
+                    'anthropic-version': ANTHROPIC_VERSION,
+                },
+                signal: AbortSignal.timeout(15_000),
+            });
+            if (!res.ok)
+                return [];
+            const data = await res.json();
+            return (data.data || []).map((m) => ({
+                id: String(m.id || ''),
+                name: String(m.display_name || m.id || ''),
+                provider: this.id,
+                contextWindow: 200_000,
+                maxOutputTokens: 8192,
+                supportsThinking: /claude-(sonnet-4|opus-4)/i.test(String(m.id)),
+                supportsTools: true,
+                supportsImages: true,
+                cost: { input: 0, output: 0 },
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Internal: request body builder
+// ---------------------------------------------------------------------------
+function buildRequestBody(request) {
+    const body = {
+        model: request.model,
+        messages: convertMessages(request.messages),
+        stream: true,
+        max_tokens: request.maxTokens ?? DEFAULT_MAX_TOKENS,
+    };
+    if (request.systemPrompt) {
+        body.system = request.systemPrompt;
+    }
+    if (request.tools && request.tools.length > 0) {
+        body.tools = request.tools.map(convertToolDefinition);
+    }
+    if (request.temperature !== undefined) {
+        body.temperature = request.temperature;
+    }
+    if (request.stopSequences && request.stopSequences.length > 0) {
+        body.stop_sequences = request.stopSequences;
+    }
+    // Extended thinking
+    const thinkingBudget = request.thinkingBudget
+        ?? (request.thinkingLevel ? THINKING_BUDGET[request.thinkingLevel] : 0);
+    if (thinkingBudget > 0) {
+        body.thinking = {
+            type: 'enabled',
+            budget_tokens: thinkingBudget,
+        };
+        // When thinking is enabled, temperature must not be set (Anthropic requirement)
+        delete body.temperature;
+    }
+    return body;
+}
+// ---------------------------------------------------------------------------
+// Internal: message format conversion
+// ---------------------------------------------------------------------------
+function convertMessages(messages) {
+    const result = [];
+    for (const msg of messages) {
+        switch (msg.role) {
+            case 'user':
+                result.push({
+                    role: 'user',
+                    content: typeof msg.content === 'string'
+                        ? msg.content
+                        : convertContentParts(msg.content),
+                });
+                break;
+            case 'assistant':
+                result.push({
+                    role: 'assistant',
+                    content: convertAssistantContent(msg.content),
+                });
+                break;
+            case 'tool_result':
+                result.push({
+                    role: 'user',
+                    content: [
+                        {
+                            type: 'tool_result',
+                            tool_use_id: msg.toolCallId,
+                            content: typeof msg.content === 'string'
+                                ? msg.content
+                                : convertContentParts(msg.content),
+                            is_error: msg.isError || false,
+                        },
+                    ],
+                });
+                break;
+        }
+    }
+    return result;
+}
+function convertContentParts(parts) {
+    return parts.map((part) => {
+        if (part.type === 'text') {
+            return { type: 'text', text: part.text };
+        }
+        // image
+        return {
+            type: 'image',
+            source: {
+                type: 'base64',
+                media_type: part.mediaType,
+                data: part.data,
+            },
+        };
+    });
+}
+function convertAssistantContent(blocks) {
+    return blocks.map((block) => {
+        switch (block.type) {
+            case 'text':
+                return { type: 'text', text: block.text };
+            case 'thinking':
+                return {
+                    type: 'thinking',
+                    thinking: block.text,
+                    ...(block.signature ? { signature: block.signature } : {}),
+                };
+            case 'tool_call':
+                return {
+                    type: 'tool_use',
+                    id: block.toolCallId,
+                    name: block.toolName,
+                    input: block.args,
+                };
+        }
+    });
+}
+function convertToolDefinition(tool) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.parameters,
+    };
+}
+// ---------------------------------------------------------------------------
+// Internal: helpers
+// ---------------------------------------------------------------------------
+function mapStopReason(reason) {
+    switch (reason) {
+        case 'end_turn': return 'end_turn';
+        case 'tool_use': return 'tool_use';
+        case 'max_tokens': return 'max_tokens';
+        case 'stop_sequence': return 'stop_sequence';
+        default: return 'end_turn';
+    }
+}

package/dist/llm/providers/google.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Google Gemini (Generative AI) adapter.
+ *
+ * Uses `POST /v1beta/models/{model}:streamGenerateContent?alt=sse` for
+ * streaming and maps the chunked response into unified StreamEvents.
+ *
+ * Key differences from Anthropic/OpenAI:
+ * - Tool calls (functionCall) arrive as complete objects in a single chunk,
+ *   not incrementally — so we emit tool_call_start + tool_call_end together.
+ * - System instructions use a dedicated `system_instruction` field.
+ * - The API key is passed as a query parameter, not a header.
+ */
+import type { AssistantMessage, ModelInfo, StreamEvent } from '../types.js';
+import type { LLMProvider, LLMRequest } from '../provider.js';
+export declare class GoogleProvider implements LLMProvider {
+    readonly id = "google";
+    readonly displayName = "Google";
+    readonly defaultBaseUrl = "https://generativelanguage.googleapis.com";
+    stream(request: LLMRequest): AsyncIterableIterator<StreamEvent>;
+    complete(request: LLMRequest): Promise<AssistantMessage>;
+    listModels(apiKey: string, baseUrl?: string): Promise<ModelInfo[]>;
+}