@agentionai/agents 0.3.0-beta

package/dist/agents/google/GeminiAgent.d.ts

@@ -0,0 +1,63 @@
+import { FunctionDeclarationsTool, GenerateContentResult, Schema } from "@google/generative-ai";
+import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
+import { History } from "../../history/History";
+import { GeminiModel } from "../model-types";
+type AgentConfig = BaseAgentConfig & {
+    apiKey: string;
+    model?: GeminiModel;
+    maxTokens?: number;
+    candidateCount?: number;
+    responseMimeType?: string;
+    responseSchema?: Schema;
+};
+/**
+ * Agent for Google Gemini models.
+ *
+ * @example
+ * ```typescript
+ * const agent = new GeminiAgent({
+ *   id: "1",
+ *   name: "Assistant",
+ *   description: "A helpful assistant",
+ *   apiKey: process.env.GOOGLE_API_KEY,
+ * });
+ *
+ * const response = await agent.execute("Hello!");
+ * ```
+ */
+export declare class GeminiAgent extends BaseAgent {
+    private client;
+    private generativeModel;
+    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 getToolDefinitionsForGemini(): FunctionDeclarationsTool | undefined;
+    /**
+     * Convert JSON Schema to Gemini's FunctionDeclarationSchema format
+     */
+    private convertSchemaToGeminiParams;
+    /**
+     * Convert a property schema to Gemini Schema type
+     */
+    private convertPropertyToSchema;
+    /**
+     * Map JSON Schema types to Gemini's SchemaType
+     */
+    private mapJsonSchemaTypeToGemini;
+    protected process(_input: string): Promise<string>;
+    execute(input: string): Promise<string>;
+    protected handleResponse(response: GenerateContentResult): Promise<string>;
+    private handleFunctionCalls;
+    protected parseUsage(input: {
+        promptTokenCount?: number;
+        candidatesTokenCount?: number;
+        totalTokenCount?: number;
+    }): TokenUsage;
+}
+export {};
+//# sourceMappingURL=GeminiAgent.d.ts.map

package/dist/agents/google/GeminiAgent.js

@@ -0,0 +1,395 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiAgent = void 0;
+const generative_ai_1 = require("@google/generative-ai");
+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 Google Gemini models.
+ *
+ * @example
+ * ```typescript
+ * const agent = new GeminiAgent({
+ *   id: "1",
+ *   name: "Assistant",
+ *   description: "A helpful assistant",
+ *   apiKey: process.env.GOOGLE_API_KEY,
+ * });
+ *
+ * const response = await agent.execute("Hello!");
+ * ```
+ */
+class GeminiAgent extends BaseAgent_1.BaseAgent {
+    constructor(config, history) {
+        super({ ...config, vendor: "gemini" }, history);
+        /** Count of tool calls in current execution */
+        this.currentToolCallCount = 0;
+        this.client = new generative_ai_1.GoogleGenerativeAI(config.apiKey);
+        // Merge flat config with nested vendorConfig
+        const vendorConfig = config.vendorConfig?.gemini || {};
+        const candidateCount = config.candidateCount ?? vendorConfig.candidateCount;
+        const responseMimeType = config.responseMimeType ?? vendorConfig.responseMimeType;
+        const responseSchema = config.responseSchema ?? vendorConfig.responseSchema;
+        this.config = {
+            model: config.model || "gemini-2.0-flash",
+            maxTokens: config.maxTokens || 1024,
+            apiKey: config.apiKey,
+            temperature: config.temperature,
+            topP: config.topP,
+            topK: config.topK,
+            stopSequences: config.stopSequences,
+            candidateCount,
+            responseMimeType,
+            responseSchema,
+        };
+        // Initialize the model
+        this.generativeModel = this.client.getGenerativeModel({
+            model: this.config.model,
+        });
+        // Add system message to history (skips if already exists with same content)
+        this.addSystemMessage(this.getSystemMessage());
+    }
+    getToolDefinitionsForGemini() {
+        const tools = Array.from(this.tools.values());
+        if (tools.length === 0) {
+            return undefined;
+        }
+        return {
+            functionDeclarations: tools.map((tool) => {
+                const prompt = tool.getPrompt();
+                // Cast to unknown first to avoid type conflicts
+                const schema = prompt.input_schema;
+                return {
+                    name: prompt.name,
+                    description: prompt.description,
+                    parameters: this.convertSchemaToGeminiParams(schema),
+                };
+            }),
+        };
+    }
+    /**
+     * Convert JSON Schema to Gemini's FunctionDeclarationSchema format
+     */
+    convertSchemaToGeminiParams(schema) {
+        const properties = {};
+        if (schema.properties) {
+            const props = schema.properties;
+            for (const [key, value] of Object.entries(props)) {
+                properties[key] = this.convertPropertyToSchema(value);
+            }
+        }
+        return {
+            type: generative_ai_1.SchemaType.OBJECT,
+            properties,
+            description: schema.description,
+            required: schema.required,
+        };
+    }
+    /**
+     * Convert a property schema to Gemini Schema type
+     */
+    convertPropertyToSchema(prop) {
+        const type = prop.type;
+        const description = prop.description;
+        switch (type) {
+            case "string":
+                if (prop.enum) {
+                    return {
+                        type: generative_ai_1.SchemaType.STRING,
+                        format: "enum",
+                        enum: prop.enum,
+                        description,
+                    };
+                }
+                return { type: generative_ai_1.SchemaType.STRING, description };
+            case "number":
+                return { type: generative_ai_1.SchemaType.NUMBER, description };
+            case "integer":
+                return { type: generative_ai_1.SchemaType.INTEGER, description };
+            case "boolean":
+                return { type: generative_ai_1.SchemaType.BOOLEAN, description };
+            case "array":
+                return {
+                    type: generative_ai_1.SchemaType.ARRAY,
+                    items: this.convertPropertyToSchema(prop.items),
+                    description,
+                };
+            case "object":
+                const objProps = {};
+                if (prop.properties) {
+                    const subProps = prop.properties;
+                    for (const [key, value] of Object.entries(subProps)) {
+                        objProps[key] = this.convertPropertyToSchema(value);
+                    }
+                }
+                return {
+                    type: generative_ai_1.SchemaType.OBJECT,
+                    properties: objProps,
+                    description,
+                    required: prop.required,
+                };
+            default:
+                return { type: generative_ai_1.SchemaType.STRING, description };
+        }
+    }
+    /**
+     * Map JSON Schema types to Gemini's SchemaType
+     */
+    mapJsonSchemaTypeToGemini(type) {
+        switch (type) {
+            case "string":
+                return generative_ai_1.SchemaType.STRING;
+            case "number":
+                return generative_ai_1.SchemaType.NUMBER;
+            case "integer":
+                return generative_ai_1.SchemaType.INTEGER;
+            case "boolean":
+                return generative_ai_1.SchemaType.BOOLEAN;
+            case "array":
+                return generative_ai_1.SchemaType.ARRAY;
+            case "object":
+                return generative_ai_1.SchemaType.OBJECT;
+            default:
+                return generative_ai_1.SchemaType.STRING;
+        }
+    }
+    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, "gemini", input);
+        }
+        if (this.history.transient) {
+            this.history.clear();
+            // Re-add system message after clear
+            this.addSystemMessage(this.getSystemMessage());
+        }
+        this.addTextToHistory("user", input);
+        try {
+            const contents = transformers_1.geminiTransformer.toProvider(this.history.entries);
+            const systemMessage = this.history.getSystemMessage();
+            const tools = this.getToolDefinitionsForGemini();
+            const response = await this.generativeModel.generateContent({
+                contents,
+                systemInstruction: systemMessage,
+                tools: tools ? [tools] : undefined,
+                generationConfig: {
+                    maxOutputTokens: this.config.maxTokens,
+                    temperature: this.config.temperature,
+                    topP: this.config.topP,
+                    topK: this.config.topK,
+                    stopSequences: this.config.stopSequences,
+                    candidateCount: this.config.candidateCount,
+                    responseMimeType: this.config.responseMimeType,
+                    responseSchema: this.config.responseSchema,
+                },
+            });
+            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(`Gemini 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) {
+        const result = response.response;
+        // Parse and track usage
+        if (result.usageMetadata) {
+            const usage = this.parseUsage(result.usageMetadata);
+            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 };
+            }
+        }
+        // Check for finish reason
+        const candidate = result.candidates?.[0];
+        if (!candidate) {
+            const error = new AgentError_1.ExecutionError("No candidates in Gemini response");
+            this.emit(AgentEvent_1.AgentEvent.ERROR, error);
+            throw error;
+        }
+        if (candidate.finishReason === "MAX_TOKENS") {
+            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 parts = candidate.content?.parts || [];
+        const functionCalls = parts.filter((part) => "functionCall" in part);
+        // If no function calls, return text response
+        if (functionCalls.length === 0) {
+            const textParts = parts.filter((part) => "text" in part);
+            const textContent = textParts
+                .map((part) => ("text" in part ? part.text : ""))
+                .join("");
+            // Add to history in normalized format
+            const entry = transformers_1.geminiTransformer.fromProviderContent("assistant", parts);
+            this.addToHistory(entry);
+            this.emit(AgentEvent_1.AgentEvent.DONE, result, this.lastTokenUsage);
+            // 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;
+        }
+        // Handle function calls
+        try {
+            this.emit(AgentEvent_1.AgentEvent.TOOL_USE, functionCalls);
+            // Add assistant response with function calls to history (normalized)
+            const assistantEntry = transformers_1.geminiTransformer.fromProviderContent("assistant", parts);
+            this.addToHistory(assistantEntry);
+            const toolResults = await this.handleFunctionCalls(functionCalls);
+            // Add tool results to history (normalized)
+            for (const tr of toolResults) {
+                const resultEntry = transformers_1.geminiTransformer.toolResultEntry(tr.name, tr.response);
+                this.addToHistory(resultEntry);
+            }
+            // Continue conversation
+            try {
+                const newContents = transformers_1.geminiTransformer.toProvider(this.history.entries);
+                const systemMessage = this.history.getSystemMessage();
+                const tools = this.getToolDefinitionsForGemini();
+                const newResponse = await this.generativeModel.generateContent({
+                    contents: newContents,
+                    systemInstruction: systemMessage,
+                    tools: tools ? [tools] : undefined,
+                    generationConfig: {
+                        maxOutputTokens: this.config.maxTokens,
+                        temperature: this.config.temperature,
+                        topP: this.config.topP,
+                        topK: this.config.topK,
+                        stopSequences: this.config.stopSequences,
+                        candidateCount: this.config.candidateCount,
+                        responseMimeType: this.config.responseMimeType,
+                        responseSchema: this.config.responseSchema,
+                    },
+                });
+                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(`Gemini 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);
+            // Report error to viz
+            if (this.vizEventId) {
+                VizReporter_1.vizReporter.agentError(this.vizEventId, "ExecutionError", toolError.message, false);
+                this.vizEventId = undefined;
+            }
+            throw toolError;
+        }
+    }
+    async handleFunctionCalls(functionCalls) {
+        if (!functionCalls.length) {
+            throw new AgentError_1.ExecutionError("No function calls found in response");
+        }
+        // Track tool call count for viz reporting
+        this.currentToolCallCount += functionCalls.length;
+        const results = await Promise.all(functionCalls.map(async (part) => {
+            const fc = part.functionCall;
+            const toolName = fc.name;
+            const tool = this.tools.get(toolName);
+            if (!tool) {
+                const errorMessage = `Tool '${toolName}' not found`;
+                const error = new AgentError_1.ToolExecutionError(errorMessage, toolName, fc.args);
+                if (this.debug) {
+                    console.error(error);
+                }
+                return {
+                    name: toolName,
+                    response: JSON.stringify({ error: errorMessage }),
+                };
+            }
+            try {
+                const args = (fc.args || {});
+                const result = await tool.execute(this.getId(), this.getName(), args, toolName, // Gemini uses function name as ID
+                this.config.model, "gemini");
+                return {
+                    name: toolName,
+                    response: 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, fc.args);
+                this.emit(AgentEvent_1.AgentEvent.TOOL_ERROR, toolError);
+                return {
+                    name: toolName,
+                    response: JSON.stringify({ error: errorMessage }),
+                };
+            }
+        }));
+        return results;
+    }
+    parseUsage(input) {
+        return {
+            input_tokens: input.promptTokenCount || 0,
+            output_tokens: input.candidatesTokenCount || 0,
+            total_tokens: input.totalTokenCount || 0,
+        };
+    }
+}
+exports.GeminiAgent = GeminiAgent;
+//# sourceMappingURL=GeminiAgent.js.map

package/dist/agents/mistral/MistralAgent.d.ts

@@ -0,0 +1,47 @@
+import { BaseAgent, BaseAgentConfig, TokenUsage } from "../BaseAgent";
+import { History } from "../../history/History";
+import { ChatCompletionResponse, Tool, UsageInfo } from "@mistralai/mistralai/models/components";
+import { MistralModel } from "../model-types";
+type AgentConfig = BaseAgentConfig & {
+    apiKey: string;
+    model?: MistralModel;
+    maxTokens?: number;
+    disableParallelToolUse?: boolean;
+    safePrompt?: boolean;
+    randomSeed?: number;
+    rateLimitDelay?: number;
+};
+/**
+ * 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!");
+ * ```
+ */
+export declare class MistralAgent 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: ChatCompletionResponse): Promise<string>;
+    private handleToolCalls;
+    protected parseUsage(input: UsageInfo): TokenUsage;
+}
+export {};
+//# sourceMappingURL=MistralAgent.d.ts.map