@germanescobar/anita 0.3.0

package/dist/models/anthropic.js

@@ -0,0 +1,195 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { conversationItemsToMessages } from "../types/conversation.js";
+export class AnthropicProvider {
+    client;
+    model;
+    constructor(model) {
+        this.client = new Anthropic();
+        this.model = model;
+    }
+    async chat(params) {
+        const response = await this.client.messages.create({
+            model: this.model,
+            max_tokens: 16384,
+            system: params.systemPrompt,
+            messages: conversationItemsToMessages(params.conversationItems).map((m) => this.toAnthropicMessage(m)),
+            tools: params.tools.map((t) => this.toAnthropicTool(t)),
+        }, { signal: params.signal });
+        return {
+            stopReason: this.mapStopReason(response.stop_reason),
+            content: response.content.map((block) => this.fromAnthropicBlock(block)),
+            usage: {
+                inputTokens: response.usage.input_tokens,
+                outputTokens: response.usage.output_tokens,
+            },
+        };
+    }
+    async *streamChat(params) {
+        const stream = await this.client.messages.create({
+            model: this.model,
+            max_tokens: 16384,
+            system: params.systemPrompt,
+            messages: conversationItemsToMessages(params.conversationItems).map((m) => this.toAnthropicMessage(m)),
+            tools: params.tools.map((t) => this.toAnthropicTool(t)),
+            stream: true,
+        }, { signal: params.signal });
+        const blocks = new Map();
+        let stopReason = "end_turn";
+        let inputTokens = 0;
+        let outputTokens = 0;
+        for await (const event of stream) {
+            switch (event.type) {
+                case "message_start":
+                    inputTokens = event.message.usage.input_tokens;
+                    outputTokens = event.message.usage.output_tokens;
+                    break;
+                case "message_delta":
+                    stopReason = this.mapStopReason(event.delta.stop_reason);
+                    outputTokens = event.usage.output_tokens;
+                    break;
+                case "content_block_start": {
+                    const block = event.content_block;
+                    if (block.type === "text") {
+                        blocks.set(event.index, { type: "text", text: block.text });
+                    }
+                    else if (block.type === "tool_use") {
+                        blocks.set(event.index, {
+                            type: "tool_use",
+                            id: block.id,
+                            name: block.name,
+                            input: block.input,
+                            inputJson: "",
+                        });
+                        yield {
+                            type: "tool_call_delta",
+                            index: event.index,
+                            id: block.id,
+                            name: block.name,
+                        };
+                    }
+                    break;
+                }
+                case "content_block_delta": {
+                    const block = blocks.get(event.index);
+                    if (event.delta.type === "text_delta" && block?.type === "text") {
+                        block.text += event.delta.text;
+                        yield { type: "assistant_text_delta", text: event.delta.text };
+                    }
+                    else if (event.delta.type === "input_json_delta" &&
+                        block?.type === "tool_use") {
+                        block.inputJson += event.delta.partial_json;
+                        yield {
+                            type: "tool_call_delta",
+                            index: event.index,
+                            id: block.id,
+                            name: block.name,
+                            inputDelta: event.delta.partial_json,
+                        };
+                    }
+                    break;
+                }
+            }
+        }
+        const content = [];
+        for (const [, block] of [...blocks].sort(([left], [right]) => left - right)) {
+            if (block.type === "text") {
+                content.push({ type: "text", text: block.text });
+                continue;
+            }
+            content.push({
+                type: "tool_use",
+                id: block.id,
+                name: block.name,
+                input: this.parseToolInput(block.inputJson, block.input),
+            });
+        }
+        yield {
+            type: "response",
+            response: {
+                stopReason,
+                content,
+                usage: {
+                    inputTokens,
+                    outputTokens,
+                },
+            },
+        };
+    }
+    toAnthropicMessage(msg) {
+        if (typeof msg.content === "string") {
+            return { role: msg.role, content: msg.content };
+        }
+        return {
+            role: msg.role,
+            content: msg.content.map((block) => {
+                switch (block.type) {
+                    case "text":
+                        return { type: "text", text: block.text };
+                    case "image":
+                    case "file":
+                        throw new Error("AnthropicProvider does not support Anita attachment blocks yet.");
+                    case "tool_use":
+                        return {
+                            type: "tool_use",
+                            id: block.id,
+                            name: block.name,
+                            input: block.input,
+                        };
+                    case "tool_result":
+                        return {
+                            type: "tool_result",
+                            tool_use_id: block.toolUseId,
+                            content: block.content,
+                            is_error: block.isError,
+                        };
+                }
+            }),
+        };
+    }
+    toAnthropicTool(tool) {
+        return {
+            name: tool.name,
+            description: tool.description,
+            input_schema: tool.parameters,
+        };
+    }
+    fromAnthropicBlock(block) {
+        switch (block.type) {
+            case "text":
+                return { type: "text", text: block.text };
+            case "tool_use":
+                return {
+                    type: "tool_use",
+                    id: block.id,
+                    name: block.name,
+                    input: block.input,
+                };
+            default:
+                return { type: "text", text: JSON.stringify(block) };
+        }
+    }
+    mapStopReason(stopReason) {
+        switch (stopReason) {
+            case "tool_use":
+                return "tool_use";
+            case "max_tokens":
+                return "max_tokens";
+            default:
+                return "end_turn";
+        }
+    }
+    parseToolInput(inputJson, fallback) {
+        if (!inputJson)
+            return fallback;
+        try {
+            const parsed = JSON.parse(inputJson);
+            return this.isRecord(parsed) ? parsed : fallback;
+        }
+        catch {
+            return fallback;
+        }
+    }
+    isRecord(value) {
+        return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
+}

package/dist/models/openai-responses.d.ts

@@ -0,0 +1,62 @@
+import OpenAI from "openai";
+import type { ChatParams, ModelProvider, ModelStreamEvent } from "./provider.js";
+import type { ModelResponse, StopReason } from "../types/agent.js";
+import { type ConversationItem } from "../types/conversation.js";
+import type { ContentBlock, Message } from "../types/messages.js";
+import type { ToolSchema } from "../types/tools.js";
+/**
+ * Provider that uses the OpenAI Responses API instead of Chat Completions.
+ *
+ * The Responses API uses a conversation-item model where inputs and outputs are
+ * represented as typed items (messages, function calls, function call outputs,
+ * reasoning items).  This provider converts our internal message format into
+ * Responses API input items and converts the response output items back into
+ * our internal ContentBlock format.
+ *
+ * Key differences from Chat Completions:
+ * - The system prompt is passed as `instructions`, not a system message.
+ * - Function calls use `call_id` / `type: "function_call"`.
+ * - Function call outputs use `type: "function_call_output"`.
+ * - Reasoning summaries are explicit output items.
+ * - The overall response has a `status` field instead of `finish_reason`.
+ */
+export declare class OpenAIResponsesProvider implements ModelProvider {
+    private client;
+    private model;
+    constructor(model: string, options?: {
+        apiKey?: string;
+        baseURL?: string;
+    });
+    chat(params: ChatParams): Promise<ModelResponse>;
+    streamChat(params: ChatParams): AsyncIterable<ModelStreamEvent>;
+}
+/**
+ * Convert internal messages into Responses API input items.
+ *
+ * The Responses API accepts an array of input items.  Our internal
+ * representation uses role-based messages with content blocks, so we map:
+ *
+ * - user text → { type: "message", role: "user", content: [...] }
+ * - assistant text → { type: "message", role: "assistant", content: [...] }
+ * - assistant tool_use → { type: "function_call", ... }
+ * - user tool_result → { type: "function_call_output", ... }
+ */
+export declare function messagesToInputItems(messages: Message[]): OpenAI.Responses.ResponseInputItem[];
+export declare function conversationItemsToInputItems(conversationItems: ConversationItem[]): OpenAI.Responses.ResponseInputItem[];
+export declare function toFunctionTool(tool: ToolSchema): OpenAI.Responses.FunctionTool;
+/**
+ * Convert a Responses API response into our internal ModelResponse.
+ *
+ * Output items we handle:
+ * - message → text content blocks
+ * - function_call → tool_use content blocks
+ * - reasoning → reasoning string (summary text)
+ *
+ * We determine the stop reason from the response status:
+ * - completed + has function_calls → tool_use
+ * - completed → end_turn
+ * - incomplete + reason max_tokens → max_tokens
+ * - everything else → error
+ */
+export declare function responseToModelResponse(response: OpenAI.Responses.Response): ModelResponse;
+export declare function mapStopReason(response: OpenAI.Responses.Response, content: ContentBlock[]): StopReason;

package/dist/models/openai-responses.js

@@ -0,0 +1,377 @@
+import OpenAI from "openai";
+/**
+ * Provider that uses the OpenAI Responses API instead of Chat Completions.
+ *
+ * The Responses API uses a conversation-item model where inputs and outputs are
+ * represented as typed items (messages, function calls, function call outputs,
+ * reasoning items).  This provider converts our internal message format into
+ * Responses API input items and converts the response output items back into
+ * our internal ContentBlock format.
+ *
+ * Key differences from Chat Completions:
+ * - The system prompt is passed as `instructions`, not a system message.
+ * - Function calls use `call_id` / `type: "function_call"`.
+ * - Function call outputs use `type: "function_call_output"`.
+ * - Reasoning summaries are explicit output items.
+ * - The overall response has a `status` field instead of `finish_reason`.
+ */
+export class OpenAIResponsesProvider {
+    client;
+    model;
+    constructor(model, options) {
+        this.client = new OpenAI({
+            apiKey: options?.apiKey ?? process.env.OPENAI_API_KEY ?? "not-needed",
+            baseURL: options?.baseURL,
+        });
+        this.model = model;
+    }
+    async chat(params) {
+        const inputItems = conversationItemsToInputItems(params.conversationItems);
+        const tools = params.tools.map(toFunctionTool);
+        const response = await this.client.responses.create({
+            model: this.model,
+            instructions: params.systemPrompt,
+            input: inputItems,
+            tools: tools.length > 0 ? tools : undefined,
+        }, { signal: params.signal });
+        return responseToModelResponse(response);
+    }
+    async *streamChat(params) {
+        const inputItems = conversationItemsToInputItems(params.conversationItems);
+        const tools = params.tools.map(toFunctionTool);
+        const stream = await this.client.responses.create({
+            model: this.model,
+            instructions: params.systemPrompt,
+            input: inputItems,
+            tools: tools.length > 0 ? tools : undefined,
+            stream: true,
+        }, { signal: params.signal });
+        let response;
+        const toolCalls = new Map();
+        for await (const event of stream) {
+            switch (event.type) {
+                case "response.output_text.delta":
+                    yield { type: "assistant_text_delta", text: event.delta };
+                    break;
+                case "response.reasoning_summary_text.delta":
+                    yield { type: "assistant_reasoning_delta", text: event.delta };
+                    break;
+                case "response.reasoning_summary.delta":
+                    if (typeof event.delta === "string") {
+                        yield { type: "assistant_reasoning_delta", text: event.delta };
+                    }
+                    break;
+                case "response.output_item.added":
+                case "response.output_item.done":
+                    if (event.item.type === "function_call") {
+                        const existing = toolCalls.get(event.output_index) ?? {};
+                        existing.id = event.item.call_id;
+                        existing.name = event.item.name;
+                        existing.itemId = event.item.id;
+                        toolCalls.set(event.output_index, existing);
+                        yield {
+                            type: "tool_call_delta",
+                            index: event.output_index,
+                            id: existing.id,
+                            name: existing.name,
+                        };
+                    }
+                    break;
+                case "response.function_call_arguments.delta": {
+                    const existing = toolCalls.get(event.output_index);
+                    yield {
+                        type: "tool_call_delta",
+                        index: event.output_index,
+                        id: existing?.id,
+                        name: existing?.name,
+                        inputDelta: event.delta,
+                    };
+                    break;
+                }
+                case "response.completed":
+                case "response.failed":
+                case "response.incomplete":
+                    response = event.response;
+                    break;
+                case "error":
+                    throw new Error(event.message);
+            }
+        }
+        if (!response) {
+            throw new Error("OpenAI Responses stream completed without a final response.");
+        }
+        yield {
+            type: "response",
+            response: responseToModelResponse(response),
+        };
+    }
+}
+// ─── Input conversion ────────────────────────────────────────────────
+/**
+ * Convert internal messages into Responses API input items.
+ *
+ * The Responses API accepts an array of input items.  Our internal
+ * representation uses role-based messages with content blocks, so we map:
+ *
+ * - user text → { type: "message", role: "user", content: [...] }
+ * - assistant text → { type: "message", role: "assistant", content: [...] }
+ * - assistant tool_use → { type: "function_call", ... }
+ * - user tool_result → { type: "function_call_output", ... }
+ */
+export function messagesToInputItems(messages) {
+    const items = [];
+    for (const msg of messages) {
+        if (typeof msg.content === "string") {
+            items.push({
+                type: "message",
+                role: msg.role,
+                content: msg.content,
+            });
+            continue;
+        }
+        const messageContentBlocks = msg.content.filter((b) => b.type === "text" || b.type === "image" || b.type === "file");
+        const toolUseBlocks = msg.content.filter((b) => b.type === "tool_use");
+        const toolResultBlocks = msg.content.filter((b) => b.type === "tool_result");
+        if (messageContentBlocks.length > 0) {
+            if (msg.role === "assistant") {
+                const textBlocks = messageContentBlocks.filter((b) => b.type === "text");
+                items.push({
+                    type: "message",
+                    role: "assistant",
+                    content: textBlocks.map((b) => ({
+                        type: "output_text",
+                        text: b.text,
+                        annotations: [],
+                    })),
+                });
+            }
+            else {
+                items.push({
+                    type: "message",
+                    role: "user",
+                    content: messageContentBlocks.map(toResponseInputContent),
+                });
+            }
+        }
+        for (const block of toolUseBlocks) {
+            const tu = block;
+            items.push({
+                type: "function_call",
+                call_id: tu.id,
+                name: tu.name,
+                arguments: JSON.stringify(tu.input),
+            });
+        }
+        for (const block of toolResultBlocks) {
+            const tr = block;
+            items.push({
+                type: "function_call_output",
+                call_id: tr.toolUseId,
+                output: tr.content,
+            });
+        }
+    }
+    return items;
+}
+export function conversationItemsToInputItems(conversationItems) {
+    const items = [];
+    for (const item of conversationItems) {
+        switch (item.type) {
+            case "message":
+            case "compaction_summary": {
+                const role = item.type === "message" ? item.role : "user";
+                const content = item.type === "message" ? item.content : item.summary;
+                items.push({
+                    type: "message",
+                    role,
+                    content,
+                });
+                break;
+            }
+            case "attachment":
+                items.push({
+                    type: "message",
+                    role: "user",
+                    content: [toResponseInputContent(item.attachment)],
+                });
+                break;
+            case "reasoning":
+                if (!item.id)
+                    break;
+                items.push({
+                    type: "reasoning",
+                    id: item.id,
+                    summary: item.summary
+                        ? [{ type: "summary_text", text: item.summary }]
+                        : [],
+                    ...(item.encryptedContent
+                        ? { encrypted_content: item.encryptedContent }
+                        : {}),
+                });
+                break;
+            case "function_call":
+                items.push({
+                    type: "function_call",
+                    call_id: item.id,
+                    name: item.name,
+                    arguments: JSON.stringify(item.input),
+                });
+                break;
+            case "function_output":
+                items.push({
+                    type: "function_call_output",
+                    call_id: item.callId,
+                    output: item.content,
+                });
+                break;
+        }
+    }
+    return items;
+}
+export function toFunctionTool(tool) {
+    return {
+        type: "function",
+        name: tool.name,
+        description: tool.description || undefined,
+        parameters: tool.parameters,
+        strict: false,
+    };
+}
+function toResponseInputContent(block) {
+    switch (block.type) {
+        case "text":
+            return { type: "input_text", text: block.text };
+        case "image":
+            return {
+                type: "input_image",
+                image_url: attachmentUrl(block),
+                detail: "auto",
+            };
+        case "file":
+            return {
+                type: "input_file",
+                filename: block.name,
+                ...responseFileSource(block),
+            };
+    }
+}
+function attachmentUrl(block) {
+    if (block.source.type === "url")
+        return block.source.url;
+    return `data:${block.source.mediaType};base64,${block.source.data}`;
+}
+function responseFileSource(block) {
+    if (block.source.type === "url") {
+        return { file_url: block.source.url };
+    }
+    return {
+        file_data: `data:${block.source.mediaType};base64,${block.source.data}`,
+    };
+}
+// ─── Output conversion ────────────────────────────────────────────────
+/**
+ * Convert a Responses API response into our internal ModelResponse.
+ *
+ * Output items we handle:
+ * - message → text content blocks
+ * - function_call → tool_use content blocks
+ * - reasoning → reasoning string (summary text)
+ *
+ * We determine the stop reason from the response status:
+ * - completed + has function_calls → tool_use
+ * - completed → end_turn
+ * - incomplete + reason max_tokens → max_tokens
+ * - everything else → error
+ */
+export function responseToModelResponse(response) {
+    const content = [];
+    let reasoning;
+    const reasoningItems = [];
+    for (const item of response.output) {
+        if (item.type === "message") {
+            const message = item;
+            for (const part of message.content) {
+                if (part.type === "output_text") {
+                    const textPart = part;
+                    content.push({ type: "text", text: textPart.text });
+                }
+                // Skip refusals — we treat them as no content.
+            }
+        }
+        else if (item.type === "function_call") {
+            const fc = item;
+            content.push({
+                type: "tool_use",
+                id: fc.call_id,
+                name: fc.name,
+                input: parseFunctionCallArguments(fc.arguments),
+            });
+        }
+        else if (item.type === "reasoning") {
+            const ri = item;
+            const summaryText = ri.summary
+                .map((s) => s.text)
+                .join("\n")
+                .trim();
+            if (summaryText) {
+                reasoning = summaryText;
+            }
+            reasoningItems.push({
+                type: "reasoning",
+                id: ri.id,
+                summary: summaryText,
+                ...(ri.encrypted_content ? { encryptedContent: ri.encrypted_content } : {}),
+            });
+        }
+        // Skip other output item types (web_search_call, etc.)
+    }
+    const stopReason = mapStopReason(response, content);
+    const usage = response.usage
+        ? {
+            inputTokens: response.usage.input_tokens,
+            outputTokens: response.usage.output_tokens,
+        }
+        : undefined;
+    return {
+        stopReason,
+        content,
+        reasoning,
+        reasoningItems: reasoningItems.length > 0 ? reasoningItems : undefined,
+        usage,
+    };
+}
+export function mapStopReason(response, content) {
+    // If we have tool_use blocks the model wants to call tools.
+    if (content.some((b) => b.type === "tool_use")) {
+        return "tool_use";
+    }
+    switch (response.status) {
+        case "completed":
+            return "end_turn";
+        case "incomplete": {
+            const reason = response.incomplete_details?.reason;
+            if (reason === "max_output_tokens") {
+                return "max_tokens";
+            }
+            return "error";
+        }
+        case "failed":
+            return "error";
+        default:
+            return "error";
+    }
+}
+function parseFunctionCallArguments(inputJson) {
+    if (!inputJson)
+        return {};
+    try {
+        const parsed = JSON.parse(inputJson);
+        return isPlainObject(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function isPlainObject(value) {
+    return (typeof value === "object" && value !== null && !Array.isArray(value));
+}

package/dist/models/openai.d.ts

@@ -0,0 +1,32 @@
+import type { ChatParams, ModelProvider, ModelStreamEvent } from "./provider.js";
+import type { ModelResponse } from "../types/agent.js";
+interface OpenAIProviderOptions {
+    apiKey?: string;
+    baseURL?: string;
+    maxTokens?: number;
+    openRouter?: boolean;
+}
+export declare class OpenAIProvider implements ModelProvider {
+    private client;
+    private model;
+    private maxTokens?;
+    private openRouter;
+    constructor(model: string, options?: OpenAIProviderOptions);
+    chat(params: ChatParams): Promise<ModelResponse>;
+    streamChat(params: ChatParams): AsyncIterable<ModelStreamEvent>;
+    private withOpenRouterSessionId;
+    private mapUsage;
+    private createChatCompletionStream;
+    private toOpenAIMessages;
+    private toOpenAITool;
+    private toOpenAIUserContent;
+    private attachmentUrl;
+    private fromOpenAIMessage;
+    private extractReasoning;
+    private extractReasoningDelta;
+    private mapFinishReason;
+    private parseToolArguments;
+    private isRecord;
+    private isUnsupportedStreamOptionsError;
+}
+export {};