@agentionai/agents 0.12.0-beta → 0.13.0

package/dist/agents/llamacpp/LlamaCppAgent.js

@@ -0,0 +1,262 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LlamaCppAgent = void 0;
+const openai_1 = __importDefault(require("openai"));
+const BaseAgent_1 = require("../BaseAgent");
+const AgentEvent_1 = require("../AgentEvent");
+const AgentError_1 = require("../errors/AgentError");
+const transformers_1 = require("../../history/transformers");
+const VizReporter_1 = require("../../viz/VizReporter");
+const VizConfig_1 = require("../../viz/VizConfig");
+/**
+ * Agent for locally-hosted models served by a llama.cpp server (`llama-server`),
+ * which exposes an OpenAI-compatible `/v1/chat/completions` API.
+ *
+ * Requires the `openai` package as a peer dependency and a running llama.cpp server.
+ *
+ * @example
+ * ```typescript
+ * const agent = new LlamaCppAgent({
+ *   id: "1",
+ *   name: "Assistant",
+ *   description: "A helpful assistant",
+ *   apiKey: "",
+ *   baseURL: "http://localhost:8080/v1",
+ * });
+ *
+ * const response = await agent.execute("Hello!");
+ * ```
+ *
+ * @example List available models
+ * ```typescript
+ * const models = await agent.listModels();
+ * ```
+ */
+class LlamaCppAgent extends BaseAgent_1.BaseAgent {
+    constructor(config, history) {
+        super({ ...config, vendor: "llamacpp" }, history);
+        /** Count of tool calls in current execution */
+        this.currentToolCallCount = 0;
+        const vendorConfig = config.vendorConfig?.llamacpp || {};
+        const baseURL = config.baseURL ?? vendorConfig.baseURL ?? "http://localhost:8080/v1";
+        this.client = new openai_1.default({
+            apiKey: config.apiKey || "not-needed",
+            baseURL,
+        });
+        this.config = {
+            model: config.model || "default",
+            baseURL,
+            maxTokens: config.maxTokens,
+            temperature: config.temperature,
+            topP: config.topP,
+            stopSequences: config.stopSequences,
+            seed: config.seed,
+            presencePenalty: config.presencePenalty,
+            frequencyPenalty: config.frequencyPenalty,
+            apiKey: config.apiKey,
+        };
+        this.addSystemMessage(this.getSystemMessage());
+    }
+    /**
+     * List the models currently available on the llama.cpp server (via its
+     * OpenAI-compatible `/v1/models` endpoint).
+     */
+    async listModels() {
+        try {
+            const page = await this.client.models.list();
+            return page.data;
+        }
+        catch (error) {
+            throw new AgentError_1.ExecutionError(`Failed to list llama.cpp models: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    getToolDefinitions() {
+        return Array.from(this.tools.values()).map((tool) => {
+            const prompt = tool.getPrompt();
+            return {
+                type: "function",
+                function: {
+                    name: prompt.name,
+                    description: prompt.description,
+                    parameters: prompt.input_schema,
+                },
+            };
+        });
+    }
+    async process(_input) {
+        return "";
+    }
+    async execute(input) {
+        this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
+        this.lastTokenUsage = undefined;
+        this.currentToolCallCount = 0;
+        const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
+        if (VizConfig_1.vizConfig.isEnabled()) {
+            this.vizEventId = VizReporter_1.vizReporter.agentStart(this.id, this.name, this.config.model, "llamacpp", inputPreview);
+        }
+        if (this.history.transient) {
+            this.history.clear();
+            this.addSystemMessage(this.getSystemMessage());
+        }
+        if (typeof input === "string") {
+            this.addTextToHistory("user", input);
+        }
+        else {
+            this.addMessageToHistory("user", input);
+        }
+        this.history.setSessionAnchor();
+        this.history.beginExecution();
+        try {
+            const response = await this.callLlamaCpp();
+            this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
+            return await this.handleResponse(response);
+        }
+        catch (error) {
+            if (error instanceof openai_1.default.APIError) {
+                const apiError = new AgentError_1.ApiError(`llama.cpp API error: ${error.message}`, error.status, error);
+                this.emit(AgentEvent_1.AgentEvent.ERROR, apiError);
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, "ApiError", apiError.message, error.status === 429);
+                    this.vizEventId = undefined;
+                }
+                throw apiError;
+            }
+            if (error instanceof AgentError_1.ExecutionError || error instanceof AgentError_1.ApiError) {
+                this.emit(AgentEvent_1.AgentEvent.ERROR, error);
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, error.constructor.name, error.message, false);
+                    this.vizEventId = undefined;
+                }
+                throw error;
+            }
+            const executionError = new AgentError_1.ExecutionError(`llama.cpp error: ${error instanceof Error ? error.message : "Unknown error"}`);
+            this.emit(AgentEvent_1.AgentEvent.ERROR, executionError);
+            if (this.vizEventId) {
+                VizReporter_1.vizReporter.agentError(this.vizEventId, "ExecutionError", executionError.message, false);
+                this.vizEventId = undefined;
+            }
+            throw executionError;
+        }
+        finally {
+            this.history.endExecution();
+        }
+    }
+    async callLlamaCpp() {
+        const messages = transformers_1.chatCompletionsTransformer.toProvider(this.history.getEntries());
+        const tools = this.tools.size > 0 ? this.getToolDefinitions() : undefined;
+        return this.client.chat.completions.create({
+            model: this.config.model,
+            messages,
+            tools,
+            stream: false,
+            max_tokens: this.config.maxTokens,
+            temperature: this.config.temperature,
+            top_p: this.config.topP,
+            stop: this.config.stopSequences,
+            seed: this.config.seed,
+            presence_penalty: this.config.presencePenalty,
+            frequency_penalty: this.config.frequencyPenalty,
+        });
+    }
+    async handleResponse(response) {
+        const usage = this.parseUsage(response);
+        if (this.lastTokenUsage) {
+            this.lastTokenUsage.input_tokens += usage.input_tokens;
+            this.lastTokenUsage.output_tokens += usage.output_tokens;
+            this.lastTokenUsage.total_tokens += usage.total_tokens;
+        }
+        else {
+            this.lastTokenUsage = { ...usage };
+        }
+        const choice = response.choices[0];
+        const message = choice.message;
+        if (choice.finish_reason === "length") {
+            const error = new AgentError_1.MaxTokensExceededError("Response exceeded maximum token limit", this.config.maxTokens || 1024);
+            this.emit(AgentEvent_1.AgentEvent.MAX_TOKENS_EXCEEDED, error);
+            this.emit(AgentEvent_1.AgentEvent.ERROR, error);
+            if (this.vizEventId) {
+                VizReporter_1.vizReporter.agentError(this.vizEventId, "MaxTokensExceededError", error.message, false);
+                this.vizEventId = undefined;
+            }
+            throw error;
+        }
+        const hasToolCalls = message.tool_calls && message.tool_calls.length > 0;
+        if (!hasToolCalls) {
+            const textContent = message.content || "";
+            const entry = transformers_1.chatCompletionsTransformer.fromProviderMessage(message);
+            this.addToHistory(entry);
+            this.emit(AgentEvent_1.AgentEvent.DONE, message, usage);
+            if (this.vizEventId) {
+                VizReporter_1.vizReporter.agentComplete(this.vizEventId, {
+                    input: this.lastTokenUsage?.input_tokens || 0,
+                    output: this.lastTokenUsage?.output_tokens || 0,
+                    total: this.lastTokenUsage?.total_tokens || 0,
+                }, "end_turn", this.currentToolCallCount > 0, this.currentToolCallCount, textContent);
+                this.vizEventId = undefined;
+            }
+            return textContent;
+        }
+        // Tool calls detected
+        const toolCalls = message.tool_calls;
+        this.emit(AgentEvent_1.AgentEvent.TOOL_USE, toolCalls);
+        this.currentToolCallCount += toolCalls.length;
+        const assistantEntry = transformers_1.chatCompletionsTransformer.fromProviderMessage(message);
+        this.addToHistory(assistantEntry);
+        const toolResults = await this.handleToolCalls(toolCalls);
+        for (const result of toolResults) {
+            const resultEntry = transformers_1.chatCompletionsTransformer.toolResultEntry(result.toolCallId, result.content);
+            this.addToHistory(resultEntry);
+        }
+        // Continue conversation with tool results
+        try {
+            const newResponse = await this.callLlamaCpp();
+            this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
+            return this.handleResponse(newResponse);
+        }
+        catch (error) {
+            const executionError = new AgentError_1.ExecutionError(`llama.cpp error during tool response: ${error instanceof Error ? error.message : "Unknown error"}`);
+            this.emit(AgentEvent_1.AgentEvent.ERROR, executionError);
+            throw executionError;
+        }
+    }
+    async handleToolCalls(toolCalls) {
+        return Promise.all(toolCalls.map(async (toolCall) => {
+            const toolName = toolCall.type === "function" ? toolCall.function.name : "";
+            const tool = this.tools.get(toolName);
+            const toolCallId = toolCall.id;
+            if (toolCall.type !== "function" || !tool) {
+                const errorMessage = `Tool '${toolName}' not found`;
+                const error = new AgentError_1.ToolExecutionError(errorMessage, toolName, toolCall.type === "function" ? toolCall.function.arguments : undefined);
+                this.emit(AgentEvent_1.AgentEvent.TOOL_ERROR, error);
+                return { toolCallId, content: errorMessage };
+            }
+            try {
+                const args = JSON.parse(toolCall.function.arguments || "{}");
+                const result = await tool.execute(this.getId(), this.getName(), args, toolCallId, this.config.model, "llamacpp");
+                return { toolCallId, content: JSON.stringify(result) };
+            }
+            catch (error) {
+                const errorMessage = `Error executing tool '${toolName}': ${error instanceof Error ? error.message : "Unknown error"}`;
+                if (this.debug) {
+                    console.error(errorMessage);
+                }
+                const toolError = new AgentError_1.ToolExecutionError(errorMessage, toolName, toolCall.function.arguments);
+                this.emit(AgentEvent_1.AgentEvent.TOOL_ERROR, toolError);
+                return { toolCallId, content: errorMessage };
+            }
+        }));
+    }
+    parseUsage(response) {
+        const usage = response.usage;
+        return {
+            input_tokens: usage?.prompt_tokens ?? 0,
+            output_tokens: usage?.completion_tokens ?? 0,
+            total_tokens: usage?.total_tokens ?? 0,
+        };
+    }
+}
+exports.LlamaCppAgent = LlamaCppAgent;
+//# sourceMappingURL=LlamaCppAgent.js.map

package/dist/agents/model-types.d.ts

@@ -8,7 +8,7 @@
  * You can also provide any custom string for newer models not yet listed.
  * @see https://docs.anthropic.com/en/docs/about-claude/models
  */
-export type ClaudeModel = "claude-opus-4-5" | "claude-sonnet-4-5" | "claude-haiku-4-5" | (string & Record<never, never>);
+export type ClaudeModel = "claude-opus-4-7" | "claude-opus-4-6" | "claude-sonnet-4-6" | "claude-opus-4-5" | "claude-sonnet-4-5" | "claude-haiku-4-5" | "claude-haiku-4-5-20251001" | (string & Record<never, never>);
 /**
  * Supported Google Gemini models.
  * You can also provide any custom string for newer models not yet listed.
@@ -21,6 +21,19 @@ export type GeminiModel = "gemini-flash-latest" | "gemini-flash-lite-latest" | "
  * @see https://docs.mistral.ai/getting-started/models/
  */
 export type MistralModel = "mistral-large-latest" | "mistral-small-latest" | "ministral-8b-latest" | "ministral-8b-2410" | "ministral-3b-latest" | "ministral-3b-2410" | "codestral-latest" | "codestral-2405" | "mistral-embed" | "mistral-moderation-latest" | "mistral-moderation-2411" | (string & {});
+/**
+ * Popular Ollama models (locally hosted).
+ * You can also provide any custom string for models you have pulled.
+ * @see https://ollama.com/library
+ */
+export type OllamaModel = "llama3.2" | "llama3.2:1b" | "llama3.1" | "llama3.1:70b" | "llama3" | "mistral" | "mistral-nemo" | "mixtral" | "qwen2.5" | "qwen2.5:7b" | "qwen2.5:72b" | "qwen2.5-coder" | "gemma2" | "gemma2:27b" | "phi3" | "phi4" | "deepseek-r1" | "deepseek-r1:7b" | "deepseek-r1:14b" | "deepseek-r1:70b" | "codellama" | (string & {});
+/**
+ * Models served by a local llama.cpp server (`llama-server`).
+ * The model is identified by the GGUF file/alias loaded by the server, so any
+ * string is accepted — the values below are common conventions.
+ * @see https://github.com/ggml-org/llama.cpp/tree/master/tools/server
+ */
+export type LlamaCppModel = "default" | "gpt-oss-20b" | "gpt-oss-120b" | "llama-3.1-8b-instruct" | "llama-3.2-3b-instruct" | "qwen2.5-7b-instruct" | "qwen2.5-coder-7b-instruct" | "mistral-7b-instruct" | "phi-4" | "deepseek-r1-distill-qwen-7b" | (string & {});
 /**
  * Supported OpenAI models.
  * You can also provide any custom string for newer models not yet listed.

package/dist/agents/ollama/OllamaAgent.d.ts

@@ -0,0 +1,91 @@
+import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
+import { History, MessageContent } from "../../history/History";
+import { OllamaModel } from "../model-types";
+type AgentConfig = BaseAgentConfig & {
+    /** Ollama server URL (default: `http://localhost:11434`) */
+    host?: string;
+    model?: OllamaModel;
+    maxTokens?: number;
+    think?: boolean;
+};
+type OllamaToolDefinition = {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: object;
+    };
+};
+/**
+ * Agent for locally-hosted Ollama models.
+ *
+ * Requires the `ollama` package as a peer dependency and Ollama running locally.
+ *
+ * @example
+ * ```typescript
+ * const agent = new OllamaAgent({
+ *   id: "1",
+ *   name: "Assistant",
+ *   description: "A helpful assistant",
+ *   model: "llama3.2",
+ * });
+ *
+ * const response = await agent.execute("Hello!");
+ * ```
+ *
+ * @example With tools
+ * ```typescript
+ * const agent = new OllamaAgent({
+ *   id: "1",
+ *   name: "Assistant",
+ *   description: "A helpful assistant",
+ *   model: "qwen2.5",  // Qwen models have strong tool-use support
+ *   tools: [myTool],
+ * });
+ * ```
+ */
+export declare class OllamaAgent extends BaseAgent {
+    protected config: Partial<AgentConfig>;
+    /** Token usage from the last execution (for metrics tracking) */
+    lastTokenUsage?: TokenUsage;
+    /** Current visualization event ID */
+    private vizEventId?;
+    /** Count of tool calls in current execution */
+    private currentToolCallCount;
+    /** Cached Ollama client instance */
+    private _client;
+    constructor(config: Omit<AgentConfig, "vendor">, history?: History);
+    private getClient;
+    /**
+     * List the models currently available on the Ollama server.
+     */
+    listModels(): Promise<OllamaModelInfo[]>;
+    protected getToolDefinitions(): OllamaToolDefinition[];
+    protected process(_input: string): Promise<string>;
+    execute(input: string | MessageContent[]): Promise<string>;
+    private buildOptions;
+    private callOllama;
+    protected handleResponse(response: unknown): Promise<string>;
+    private handleToolCalls;
+    protected parseUsage(input: unknown): TokenUsage;
+}
+/**
+ * A model available on the Ollama server, as returned by `client.list()`.
+ */
+export type OllamaModelInfo = {
+    name: string;
+    model: string;
+    modified_at: Date;
+    size: number;
+    digest: string;
+    details: {
+        parent_model: string;
+        format: string;
+        family: string;
+        families: string[];
+        parameter_size: string;
+        quantization_level: string;
+    };
+};
+export {};
+//# sourceMappingURL=OllamaAgent.d.ts.map