@agentionai/agents 0.3.0-beta

package/dist/agents/mistral/MistralAgent.js

@@ -0,0 +1,313 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MistralAgent = void 0;
+const mistralai_1 = require("@mistralai/mistralai");
+const BaseAgent_1 = require("../BaseAgent");
+const AgentEvent_1 = require("../AgentEvent");
+const AgentError_1 = require("../errors/AgentError");
+const transformers_1 = require("../../history/transformers");
+const components_1 = require("@mistralai/mistralai/models/components");
+const promises_1 = require("timers/promises");
+const VizReporter_1 = require("../../viz/VizReporter");
+const VizConfig_1 = require("../../viz/VizConfig");
+/**
+ * Agent for Mistral models.
+ *
+ * @example
+ * ```typescript
+ * const agent = new MistralAgent({
+ *   id: "1",
+ *   name: "Assistant",
+ *   description: "A helpful assistant",
+ *   apiKey: process.env.MISTRAL_API_KEY,
+ * });
+ *
+ * const response = await agent.execute("Hello!");
+ * ```
+ */
+class MistralAgent extends BaseAgent_1.BaseAgent {
+    constructor(config, history) {
+        super({ ...config, vendor: "mistral" }, history);
+        /** Count of tool calls in current execution */
+        this.currentToolCallCount = 0;
+        this.client = new mistralai_1.Mistral({
+            apiKey: config.apiKey,
+        });
+        // Merge flat config (deprecated) with nested vendorConfig
+        // Flat config takes precedence for backward compatibility
+        const vendorConfig = config.vendorConfig?.mistral || {};
+        const disableParallelToolUse = config.disableParallelToolUse ??
+            vendorConfig.disableParallelToolUse ??
+            false;
+        const safePrompt = config.safePrompt ?? vendorConfig.safePrompt;
+        const randomSeed = config.randomSeed ?? vendorConfig.randomSeed ?? config.seed;
+        const rateLimitDelay = config.rateLimitDelay ?? vendorConfig.rateLimitDelay ?? 1500;
+        this.config = {
+            model: config.model || "mistral-small-latest",
+            maxTokens: config.maxTokens || 1024,
+            disableParallelToolUse,
+            safePrompt,
+            randomSeed,
+            rateLimitDelay,
+            apiKey: config.apiKey,
+            temperature: config.temperature,
+            topP: config.topP,
+            stopSequences: config.stopSequences,
+        };
+        // Add system message to history (skips if already exists with same content)
+        this.addSystemMessage(this.getSystemMessage());
+    }
+    getToolDefinitions() {
+        return Array.from(this.tools.values()).map((tool) => ({
+            type: components_1.ToolTypes.Function,
+            function: {
+                name: tool.getPrompt().name,
+                description: tool.getPrompt().description,
+                parameters: tool.getPrompt().input_schema,
+            },
+        }));
+    }
+    async process(_input) {
+        return "";
+    }
+    async execute(input) {
+        this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
+        // Reset token usage for this execution
+        this.lastTokenUsage = undefined;
+        this.currentToolCallCount = 0;
+        // Start visualization reporting
+        if (VizConfig_1.vizConfig.isEnabled()) {
+            this.vizEventId = VizReporter_1.vizReporter.agentStart(this.id, this.name, this.config.model, "mistral", input);
+        }
+        if (this.history.transient) {
+            this.history.clear();
+            // Re-add system message after clear
+            this.addSystemMessage(this.getSystemMessage());
+        }
+        this.addTextToHistory("user", input);
+        try {
+            const messages = transformers_1.mistralTransformer.toProvider(this.history.entries);
+            const response = await this.client.chat.complete({
+                model: this.config.model,
+                messages: messages,
+                tools: this.getToolDefinitions(),
+                temperature: this.config.temperature,
+                topP: this.config.topP,
+                maxTokens: this.config.maxTokens,
+                randomSeed: this.config.randomSeed,
+                safePrompt: this.config.safePrompt,
+                stop: this.config.stopSequences,
+            });
+            this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
+            return await this.handleResponse(response);
+        }
+        catch (error) {
+            const err = error;
+            if (err.status) {
+                const apiError = new AgentError_1.ApiError(`Mistral API error: ${err.message || "Unknown error"}`, err.status, error);
+                this.emit(AgentEvent_1.AgentEvent.ERROR, apiError);
+                // Report error to viz
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, "ApiError", apiError.message, err.status === 429);
+                    this.vizEventId = undefined;
+                }
+                throw apiError;
+            }
+            else {
+                const executionError = new AgentError_1.ExecutionError(`Error executing agent: ${error instanceof Error ? error.message : "Unknown error"}`);
+                this.emit(AgentEvent_1.AgentEvent.ERROR, executionError);
+                // Report error to viz
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, "ExecutionError", executionError.message, false);
+                    this.vizEventId = undefined;
+                }
+                throw executionError;
+            }
+        }
+    }
+    async handleResponse(response) {
+        if (!response.choices || response.choices.length === 0) {
+            const error = new AgentError_1.ExecutionError("Empty response from Mistral API");
+            this.emit(AgentEvent_1.AgentEvent.ERROR, error);
+            throw error;
+        }
+        const choice = response.choices[0];
+        const usage = this.parseUsage(response.usage);
+        // Track token usage
+        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 };
+        }
+        if (choice.finishReason === "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);
+            // Report error to viz
+            if (this.vizEventId) {
+                VizReporter_1.vizReporter.agentError(this.vizEventId, "MaxTokensExceededError", error.message, false);
+                this.vizEventId = undefined;
+            }
+            throw error;
+        }
+        const message = choice.message;
+        if (choice.finishReason !== "tool_calls" && !message.toolCalls) {
+            // Regular text response
+            let textContent;
+            if (typeof message.content === "string") {
+                textContent = message.content;
+            }
+            else if (Array.isArray(message.content)) {
+                textContent = message.content
+                    .filter((chunk) => typeof chunk === "string" || chunk.type === "text")
+                    .map((chunk) => typeof chunk === "string" ? chunk : chunk.text)
+                    .join("");
+            }
+            else {
+                const error = new AgentError_1.ExecutionError(`Unexpected response format: ${JSON.stringify(message.content)}`);
+                this.emit(AgentEvent_1.AgentEvent.ERROR, error);
+                throw error;
+            }
+            // Add to history in normalized format
+            const entry = transformers_1.mistralTransformer.fromProviderMessage(message);
+            this.addToHistory(entry);
+            this.emit(AgentEvent_1.AgentEvent.DONE, message, usage);
+            // Report completion to viz
+            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;
+        }
+        else if (choice.finishReason === "tool_calls" || message.toolCalls) {
+            try {
+                this.emit(AgentEvent_1.AgentEvent.TOOL_USE, message.toolCalls);
+                // Add assistant message with tool calls to history (normalized)
+                const assistantEntry = transformers_1.mistralTransformer.fromProviderMessage(message);
+                this.addToHistory(assistantEntry);
+                const toolResults = await this.handleToolCalls(message.toolCalls || []);
+                // Add tool results to history (normalized)
+                for (const result of toolResults) {
+                    const resultEntry = transformers_1.mistralTransformer.toolResultEntry(result.toolCallId, result.name, result.content);
+                    this.addToHistory(resultEntry);
+                }
+                // Rate limiting delay for Mistral
+                await (0, promises_1.setTimeout)(this.config.rateLimitDelay || 1500);
+                // Continue conversation
+                try {
+                    const messages = transformers_1.mistralTransformer.toProvider(this.history.entries);
+                    const newResponse = await this.client.chat.complete({
+                        model: this.config.model,
+                        messages: messages,
+                        tools: this.getToolDefinitions(),
+                        temperature: this.config.temperature,
+                        topP: this.config.topP,
+                        maxTokens: this.config.maxTokens,
+                        randomSeed: this.config.randomSeed,
+                        safePrompt: this.config.safePrompt,
+                        stop: this.config.stopSequences,
+                    });
+                    this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
+                    return this.handleResponse(newResponse);
+                }
+                catch (error) {
+                    const err = error;
+                    if (err.status) {
+                        const apiError = new AgentError_1.ApiError(`Mistral API error during tool response: ${err.message || "Unknown error"}`, err.status, error);
+                        this.emit(AgentEvent_1.AgentEvent.ERROR, apiError);
+                        throw apiError;
+                    }
+                    else {
+                        throw new AgentError_1.ExecutionError(`Error handling tool response: ${error instanceof Error ? error.message : "Unknown error"}`);
+                    }
+                }
+            }
+            catch (error) {
+                if (error instanceof AgentError_1.ToolExecutionError) {
+                    this.emit(AgentEvent_1.AgentEvent.TOOL_ERROR, error);
+                    throw error;
+                }
+                const toolError = new AgentError_1.ExecutionError(`Error during tool execution: ${error instanceof Error ? error.message : "Unknown error"}`);
+                this.emit(AgentEvent_1.AgentEvent.ERROR, toolError);
+                throw toolError;
+            }
+        }
+        const error = new AgentError_1.ExecutionError(`Unexpected finish_reason: ${choice.finishReason}`);
+        this.emit(AgentEvent_1.AgentEvent.ERROR, error);
+        // Report error to viz
+        if (this.vizEventId) {
+            VizReporter_1.vizReporter.agentError(this.vizEventId, "ExecutionError", error.message, false);
+            this.vizEventId = undefined;
+        }
+        throw error;
+    }
+    async handleToolCalls(toolCalls) {
+        if (!toolCalls.length) {
+            throw new AgentError_1.ExecutionError("No tool calls found in response");
+        }
+        // Track tool call count for viz reporting
+        this.currentToolCallCount += toolCalls.length;
+        const toolResults = await Promise.all(toolCalls.map(async (toolCall) => {
+            const toolName = toolCall.function.name;
+            const tool = this.tools.get(toolName);
+            const toolCallId = toolCall.id || "";
+            if (!tool) {
+                const errorMessage = `Tool '${toolName}' not found`;
+                const error = new AgentError_1.ToolExecutionError(errorMessage, toolName, toolCall.function.arguments);
+                if (this.debug) {
+                    console.error(error);
+                }
+                return {
+                    name: toolName,
+                    toolCallId,
+                    content: errorMessage,
+                };
+            }
+            try {
+                let args;
+                if (typeof toolCall.function.arguments === "string") {
+                    args = JSON.parse(toolCall.function.arguments);
+                }
+                else {
+                    args = toolCall.function.arguments;
+                }
+                const result = await tool.execute(this.getId(), this.getName(), args, toolCallId, this.config.model, "mistral");
+                return {
+                    name: toolName,
+                    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 {
+                    name: toolName,
+                    toolCallId,
+                    content: errorMessage,
+                };
+            }
+        }));
+        return toolResults;
+    }
+    parseUsage(input) {
+        return {
+            input_tokens: input.promptTokens ?? 0,
+            output_tokens: input.completionTokens ?? 0,
+            total_tokens: input.totalTokens ?? 0,
+        };
+    }
+}
+exports.MistralAgent = MistralAgent;
+//# sourceMappingURL=MistralAgent.js.map

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

@@ -0,0 +1,30 @@
+/**
+ * Type definitions for supported models across different AI providers.
+ * These types provide autocomplete and type safety when configuring agents.
+ * All types also accept custom string values for new/unlisted models.
+ */
+/**
+ * Supported Claude/Anthropic models.
+ * 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>);
+/**
+ * Supported Google Gemini models.
+ * You can also provide any custom string for newer models not yet listed.
+ * @see https://ai.google.dev/gemini-api/docs/models/gemini
+ */
+export type GeminiModel = "gemini-flash-latest" | "gemini-flash-lite-latest" | "gemini-3.0-pro" | "gemini-3.0-flash" | "gemini-2.5-flash-lite" | "gemini-2.0-flash-exp" | "gemini-2.0-flash" | "gemini-2.0-flash-lite" | (string & {});
+/**
+ * Supported Mistral models.
+ * You can also provide any custom string for newer models not yet listed.
+ * @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 & {});
+/**
+ * Supported OpenAI models.
+ * You can also provide any custom string for newer models not yet listed.
+ * @see https://platform.openai.com/docs/models
+ */
+export type OpenAIModel = "gpt-5.2" | "gpt-5" | "gpt-4.1" | "gpt-5-mini" | "gpt-5-nano" | "gpt-4o" | "gpt-4o-mini" | "gpt-4o-2024-11-20" | "gpt-4o-2024-08-06" | "gpt-4o-2024-05-13" | "gpt-4o-mini-2024-07-18" | "gpt-4-turbo" | "gpt-4-turbo-2024-04-09" | "gpt-4-turbo-preview" | "gpt-4-0125-preview" | "gpt-4-1106-preview" | "gpt-4" | "gpt-4-0613" | "gpt-3.5-turbo" | "gpt-3.5-turbo-0125" | "gpt-3.5-turbo-1106" | "o1" | "o1-preview" | "o1-mini" | "o3-mini" | (string & {});
+//# sourceMappingURL=model-types.d.ts.map

package/dist/agents/model-types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Type definitions for supported models across different AI providers.
+ * These types provide autocomplete and type safety when configuring agents.
+ * All types also accept custom string values for new/unlisted models.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=model-types.js.map

package/dist/agents/openai/OpenAiAgent.d.ts

@@ -0,0 +1,48 @@
+import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
+import { History } from "../../history/History";
+import { Tool, Response, ResponseUsage } from "openai/resources/responses/responses";
+import { OpenAIModel } from "../model-types";
+type AgentConfig = BaseAgentConfig & {
+    apiKey: string;
+    model?: OpenAIModel;
+    maxTokens?: number;
+    disableParallelToolUse?: boolean;
+    /** Disable extended thinking/reasoning for models that support it (like gpt-5-nano) */
+    disableReasoning?: boolean;
+    reasoningEffort?: "low" | "medium" | "high";
+    user?: string;
+};
+/**
+ * Agent for OpenAI models using the Responses API.
+ *
+ * @example
+ * ```typescript
+ * const agent = new OpenAiAgent({
+ *   id: "1",
+ *   name: "Assistant",
+ *   description: "A helpful assistant",
+ *   apiKey: process.env.OPENAI_API_KEY,
+ * });
+ *
+ * const response = await agent.execute("Hello!");
+ * ```
+ */
+export declare class OpenAiAgent extends BaseAgent {
+    private client;
+    protected config: Partial<AgentConfig>;
+    /** Token usage from the last execution (for metrics tracking) */
+    lastTokenUsage?: TokenUsage;
+    /** Current visualization event ID for tracking */
+    private vizEventId?;
+    /** Count of tool calls in current execution */
+    private currentToolCallCount;
+    constructor(config: Omit<AgentConfig, "vendor">, history?: History);
+    protected getToolDefinitions(): Tool[];
+    protected process(_input: string): Promise<string>;
+    execute(input: string): Promise<string>;
+    protected handleResponse(response: Response): Promise<string>;
+    private handleToolUse;
+    protected parseUsage(input: ResponseUsage): TokenUsage;
+}
+export {};
+//# sourceMappingURL=OpenAiAgent.d.ts.map