@peebles-group/agentlib-js 2.0.0 → 2.1.0

package/index.js

@@ -1,3 +1,6 @@
-export { LLMService } from './src/llmService.js';
+export { LLMService } from './src/LLMService.js';
 export { Agent } from './src/Agent.js';
-export { PromptLoader } from './src/prompt-loader/promptLoader.js';
+export { PromptLoader } from './src/prompt-loader/promptLoader.js';
+export { ToolLoader } from "./src/ToolLoader.js";
+export { startA2AServer } from "./src/a2a/A2AServer.js";
+export { createRemoteAgentTool } from "./src/a2a/RemoteAgentTool.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peebles-group/agentlib-js",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "A minimal JavaScript library implementing concurrent async agents for illustrating multi-agent systems and other agentic design patterns including recursive ones purely through function calling loops.",
   "main": "index.js",
   "type": "module",
@@ -11,12 +11,15 @@
   "author": "Peebles Group",
   "license": "MIT",
   "dependencies": {
+    "@a2a-js/sdk": "^0.3.10",
     "@google/genai": "^1.16.0",
     "@modelcontextprotocol/sdk": "^1.18.2",
-    "openai": "^6.0.0",
+    "express": "^5.2.1",
     "js-yaml": "^4.1.0",
+    "openai": "^6.0.0",
+    "path": "^0.12.7",
     "sqlite3": "^5.1.7",
-    "path": "^0.12.7"
+    "uuid": "^13.0.0"
   },
   "devDependencies": {
     "@peebles-group/agentlib-js": "^2.0.0",
@@ -34,4 +37,4 @@
     "README.md",
     "LICENSE"
   ]
-}
+}

package/src/Agent.js

@@ -1,5 +1,5 @@
-import { defaultModel } from "./config.js";
-import { MCPManager } from "./mcp/MCPManager.js";
+import { defaultOpenaiModel } from "./config.js";
+import { ToolLoader } from "./ToolLoader.js";
 import { PromptLoader } from "./prompt-loader/promptLoader.js";
 import { fileURLToPath } from 'url';
 import path, { dirname } from 'path';
@@ -7,8 +7,6 @@ import path, { dirname } from 'path';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-const promptLoader = await PromptLoader.create(path.join(__dirname, 'prompts', 'agentPrompts.yml'));
-
 /**
  * Represents an LLM-based agent capable of tool calling.
  */
@@ -17,6 +15,7 @@ export class Agent {
    * @param {object} llmService - The LLM service used for communication with LLM client.
    * @param {object} [options] - Configuration options for the agent.
    * @param {string} [options.model=defaultModel] - The model identifier to use.
+   * @param {ToolLoader} [options.toolLoader=null] - Optional ToolLoader instance.
    * @param {Array<object>} [options.tools=[]] - Array of native tools available to the agent.
    * @param {zod object|null} [options.inputSchema=null] - Zod schema for validating input messages.
    * @param {zod object|null} [options.outputSchema=null] - Zod schema for expected final output format.
@@ -24,13 +23,12 @@ export class Agent {
    * @param {boolean} [options.redundantToolInfo=true] - Whether to include tool descriptions in the system prompt.
    * @param {object} [options...] - Additional options passed to the LLM service.
    */
-  constructor(llmService, { model = defaultModel, tools = [], inputSchema = null, outputSchema = null, enableMCP = false, redundantToolInfo = true, ...options } = {}) {
+  constructor(llmService, { model = defaultOpenaiModel, toolLoader = null, inputSchema = null, outputSchema = null, enableMCP = false, redundantToolInfo = true, ...options } = {}) {
     this.llmService = llmService;
     this.model = model;
-    this.nativeTools = tools;
+    this.toolLoader = toolLoader || new ToolLoader(enableMCP);
     this.inputSchema = inputSchema;
     this.outputSchema = outputSchema;
-    this.mcpManager = enableMCP ? new MCPManager() : null;
     this.redundantToolInfo = redundantToolInfo;
     this.additionalOptions = options;
     this.input = [];
@@ -40,105 +38,16 @@ export class Agent {
     }
   }
 
-  /**
-   * Adds a new MCP server for remote tool access.
-   * @param {string} serverName - A unique name for the server.
-   * @param {object} config - Configuration details for the MCP server connection.
-   * @returns {Promise<object>} The result of adding the server.
-   * @throws {Error} If MCP is not enabled.
-   */
-  async addMCPServer(serverName, config) {
-    if (!this.mcpManager) {
-      throw new Error("MCP is not enabled for this agent");
-    }
-
-    const result = await this.mcpManager.addServer(serverName, config);
-    if (this.redundantToolInfo) {
-      this.updateSystemPrompt();
-    }
-    return result;
-  }
-
-  /**
-   * Removes an existing MCP server.
-   * @param {string} serverName - The unique name of the server to remove.
-   * @returns {Promise<boolean>} True if the server was successfully removed, false otherwise.
-   */
-  async removeMCPServer(serverName) {
-    if (!this.mcpManager) return false;
-
-    const result = await this.mcpManager.removeServer(serverName);
-    if (result && this.redundantToolInfo) {
-      this.updateSystemPrompt();
-    }
-    return result;
-  }
-
-  /**
-   * Adds a native tool to the agent's array of tools.
-   * @param {object} tool - The tool object.
-   * @param {string} tool.name - The unique name of the tool.
-   * @param {function} tool.func - The function to execute when the tool is called.
-   * @param {string} [tool.description=''] - A description for the LLM on when to use the tool.
-   * @returns {object} The added tool object.
-   * @throws {Error} If the tool is invalid or a name collision occurs.
-   */
-  addTool(tool) {
-    if (!tool || typeof tool !== 'object') {
-      throw new Error('Invalid tool: expected an object');
-    }
-
-    const { name, func } = tool;
-    if (typeof name !== 'string' || name.trim() === '') {
-      throw new Error("Invalid tool: missing valid 'name' (string)");
-    }
-    if (typeof func !== 'function') {
-      throw new Error("Invalid tool: missing 'func' (function)");
-    }
-
-    const nameExistsInNative = this.nativeTools.some(t => t && t.name === name);
-    const nameExistsInMCP = this.mcpManager ? this.mcpManager.getAllTools().some(t => t && t.name === name) : false;
-    if (nameExistsInNative || nameExistsInMCP) {
-      throw new Error(`Tool with name '${name}' already exists`);
-    }
-
-    if (typeof tool.description !== 'string') {
-      tool.description = '';
-    }
-
-    this.nativeTools.push(tool);
-    if (this.redundantToolInfo) {
-      this.updateSystemPrompt();
-    }
-    return tool;
-  }
-
-  /**
-   * Retrieves all available tools, including native and MCP tools.
-   * @returns {Array<object>} An array of all tools.
-   */
-  getAllTools() {
-    const mcpTools = this.mcpManager ? this.mcpManager.getAllTools() : [];
-    return [...this.nativeTools, ...mcpTools];
-  }
-
-  /**
-   * Gets status information about the MCP manager.
-   * @returns {object} Information about the MCP manager, or { enabled: false } if disabled.
-   */
-  getMCPInfo() {
-    return this.mcpManager ? this.mcpManager.getServerInfo() : { enabled: false };
-  }
-
   /**
    * Updates the system prompt with descriptions of all currently available tools.
    */
   updateSystemPrompt() {
-    const allTools = this.getAllTools();
+    const allTools = this.toolLoader.getTools();
     const toolDescriptions = allTools.map(tool => `${tool.name}: ${tool.description}`).join('; ');
     this.input = [{
       role: 'system',
-      content: promptLoader.getPrompt('systemPrompt').format({ toolDescriptions })
+      content: `You are a tool-calling agent. You have access to the following tools: ${toolDescriptions}. 
+      Use these tools to answer the user's questions.`
     }];
   }
 
@@ -159,7 +68,7 @@ export class Agent {
    * @returns {Promise<object>} The final response object from the LLM, including execution details.
    */
   async run() {
-    const allTools = this.getAllTools();
+    const allTools = this.toolLoader.getTools() || [];
     const executed = []
 
     let response = await this.llmService.chat(this.input, {
@@ -174,7 +83,8 @@ export class Agent {
     rawResponse.output.forEach(item => {
       if (item.type === "function_call") {
         const { parsed_arguments, ...rest } = item;
-        const cleanedItem = { ...rest, arguments: JSON.stringify(item.arguments) };
+        const args = typeof item.arguments === 'string' ? item.arguments : JSON.stringify(item.arguments);
+        const cleanedItem = { ...rest, arguments: args };
         this.addInput(cleanedItem);
       } else {
         this.addInput(item);
@@ -190,7 +100,7 @@ export class Agent {
         call.arguments = args
         executed.push(call)
 
-        const tool = allTools.find(t => t.name === call.name);
+        const tool = this.toolLoader.findTool(call.name);
         if (!tool || !tool.func) {
           throw new Error(`Tool ${call.name} not found or missing implementation.`);
         }
@@ -198,12 +108,12 @@ export class Agent {
         const result = await tool.func(args);
 
         this.input.push({
+          ...call,
           type: "function_call_output",
-          call_id: call.call_id,
           output: JSON.stringify(result),
         });
       }
-      
+
       // Step 6: send updated input back to model for final response
       response = await this.llmService.chat(this.input, {
         tools: allTools,
@@ -215,14 +125,4 @@ export class Agent {
     response.executed = executed;
     return response;
   }
-
-  /**
-   * Performs cleanup operations, primarily closing MCP server connections.
-   * @returns {Promise<void>}
-   */
-  async cleanup() {
-    if (this.mcpManager) {
-      await this.mcpManager.cleanup();
-    }
-  }
 }

package/src/ToolLoader.js

@@ -0,0 +1,149 @@
+import { MCPManager } from "./mcp/MCPManager.js";
+
+/**
+ * Manages the lifecycle, storage, and retrieval of the agent's tools.
+ */
+export class ToolLoader {
+    /**
+     * @param {boolean} [enableMCP=false] - Whether to initialize the MCP manager.
+     */
+    constructor(enableMCP = false) {
+        this.nativeTools = new Map();
+        this.mcpManager = enableMCP ? new MCPManager() : null;
+    }
+
+    /**
+     * @returns {Array<Object>} An array of tool objects containing name, description, and schemas.
+     */
+    getTools() {
+        const native = Array.from(this.nativeTools.values());
+        const mcp = this.mcpManager ? this.mcpManager.getAllTools() : [];
+        return [...native, ...mcp];
+    }
+
+    /**
+     * Finds a tool by name, searching Native tools first, then MCP tools.
+     * @param {string} name - The name of the tool to find.
+     * @returns {Object|null} The tool object including the executable function, or null if not found.
+     */
+    findTool(name) {
+        if (this.nativeTools.has(name)) {
+            return this.nativeTools.get(name);
+        }
+        if (this.mcpManager) {
+            return this.mcpManager.getAllTools().find(t => t.name === name);
+        }
+        return null;
+    }
+
+    /**
+     * Registers a new tool.
+     * @param {Object} tool - The tool definition.
+     * @param {string} tool.name - The unique name of the tool.
+     * @param {Function} tool.func - The function to execute when the tool is called.
+     * @param {string} [tool.description] - A description of what the tool does.
+     * @throws {Error} If the tool structure is invalid or the name is a duplicate.
+     */
+    addTool(tool) {
+        this._validateToolStructure(tool);
+
+        if (this._isDuplicate(tool.name)) {
+            throw new Error(`Tool with name '${tool.name}' already exists.`);
+        }
+
+        this.nativeTools.set(tool.name, {
+            description: '',
+            ...tool
+        });
+    }
+
+    /**
+     * Registers multiple tools.
+     * @param {Array<Object>} tools - An array of tool definitions.
+     * @throws {Error} If any tool structure is invalid or if any name is a duplicate.
+     */
+    addTools(tools) {
+        tools.forEach(tool => this.addTool(tool));
+    }
+
+    /**
+     * Adds an MCP server configuration to the manager.
+     * @param {string} serverName - A unique identifier for this MCP server.
+     * @param {Object} config - The configuration object for the MCP server connection.
+     * @returns {Promise<Object>} The result of the connection attempt.
+     * @throws {Error} If MCP is not enabled for this registry.
+     */
+    async addMCPServer(serverName, config) {
+        if (!this.mcpManager) {
+            throw new Error("MCP is disabled.");
+        }
+        return this.mcpManager.addServer(serverName, config);
+    }
+
+    /**
+     * Removes an MCP server and cleans up its resources.
+     * @param {string} serverName - The identifier of the server to remove.
+     * @returns {Promise<boolean>} True if removed successfully, false otherwise.
+     */
+    async removeMCPServer(serverName) {
+        if (!this.mcpManager) return false;
+        return this.mcpManager.removeServer(serverName);
+    }
+
+    /**
+     * Generates a text snippet describing available tools for the System Prompt.
+     * @returns {string} A formatted string describing all tools, or an empty string if no tools exist.
+     */
+    getSystemPromptSnippet() {
+        const tools = this.getTools();
+        if (tools.length === 0) return "";
+
+        const descriptions = tools
+            .map(t => `${t.name}: ${t.description}`)
+            .join('; ');
+
+        return `You are a tool-calling agent. You have access to the following tools: ${descriptions}. Use these tools to answer the user's questions.`;
+    }
+
+    /**
+     * Gets status information about the MCP manager.
+     * @returns {Object} Information about the MCP manager, or { enabled: false } if disabled.
+     */
+    getMCPInfo() {
+        return this.mcpManager ? this.mcpManager.getServerInfo() : { enabled: false };
+    }
+
+    /**
+     * Cleans up resources, specifically closing MCP connections.
+     * @returns {Promise<void>}
+     */
+    async cleanup() {
+        if (this.mcpManager) await this.mcpManager.cleanup();
+    }
+
+    // --- Internals ---
+
+    /**
+     * Validates that a tool object matches the required schema.
+     * @private
+     * @param {Object} tool - The tool to validate.
+     * @throws {Error} If the tool is missing required properties.
+     */
+    _validateToolStructure(tool) {
+        if (!tool || typeof tool !== 'object') throw new Error("Invalid tool object");
+        if (typeof tool.name !== 'string' || !tool.name.trim()) throw new Error("Tool missing name");
+        if (typeof tool.func !== 'function') throw new Error("Tool missing func");
+    }
+
+    /**
+     * Checks if a tool name already exists in either Native or MCP registries.
+     * @private
+     * @param {string} name - The tool name to check.
+     * @returns {boolean} True if the name exists, false otherwise.
+     */
+    _isDuplicate(name) {
+        const existsNative = this.nativeTools.has(name);
+        const existsMCP = this.mcpManager?.getAllTools().some(t => t.name === name);
+        return existsNative || existsMCP;
+    }
+}

package/src/a2a/A2AServer.js

@@ -0,0 +1,84 @@
+
+import express from 'express';
+import {
+    AGENT_CARD_PATH
+} from '@a2a-js/sdk';
+import {
+    DefaultRequestHandler,
+    InMemoryTaskStore,
+} from '@a2a-js/sdk/server';
+import {
+    agentCardHandler,
+    jsonRpcHandler,
+    restHandler,
+    UserBuilder
+} from '@a2a-js/sdk/server/express';
+import { AgentExecutorAdapter } from './AgentExecutorAdapter.js';
+
+/**
+ * Starts an A2A-compliant server for the given agent.
+ * @param {import('../Agent').Agent} agent - The agent to expose.
+ * @param {object} options
+ * @param {number} [options.port=4000] - The port to listen on.
+ * @param {string} [options.name] - Agent name override.
+ * @param {string} [options.baseUrl] - The public URL (e.g., http://localhost:4000).
+ */
+export function startA2AServer(agent, { port = 4000, name, baseUrl = `http://localhost:${port}` } = {}) {
+
+    // 1. Generate Agent Card
+    const tools = agent.toolLoader.getTools();
+
+    // Convert tools to A2A skills
+    const skills = tools.map(tool => ({
+        id: tool.name,
+        name: tool.name,
+        description: tool.description,
+        tags: ['tool']
+    }));
+
+    const agentCard = {
+        name: name || "AgentLib Agent",
+        description: "An agent exposed via agentlib A2A.",
+        protocolVersion: '0.3.0',
+        version: '1.0.0',
+        url: `${baseUrl}/a2a/jsonrpc`,
+        skills: skills,
+        capabilities: {
+            pushNotifications: false,
+        },
+        defaultInputModes: ['text'],
+        defaultOutputModes: ['text'],
+        additionalInterfaces: [
+            { url: `${baseUrl}/a2a/jsonrpc`, transport: 'JSONRPC' },
+            { url: `${baseUrl}/a2a/rest`, transport: 'HTTP+JSON' },
+        ],
+    };
+
+    // 2. Setup Executor and Handlers
+    const executor = new AgentExecutorAdapter(agent);
+    const taskStore = new InMemoryTaskStore();
+    const requestHandler = new DefaultRequestHandler(
+        agentCard,
+        taskStore,
+        executor
+    );
+
+    // 3. Setup Express
+    const app = express();
+
+    // Agent Card Endpoint
+    app.use(`/${AGENT_CARD_PATH}`, agentCardHandler({ agentCardProvider: requestHandler }));
+
+    // Communication Endpoints
+    // Note: Using UserBuilder.noAuthentication for easy testing.
+    app.use('/a2a/jsonrpc', jsonRpcHandler({ requestHandler, userBuilder: UserBuilder.noAuthentication }));
+    app.use('/a2a/rest', restHandler({ requestHandler, userBuilder: UserBuilder.noAuthentication }));
+
+    // Start Server
+    const server = app.listen(port, () => {
+        console.log(`  A2A Server started on ${baseUrl}`);
+        console.log(`   Card: ${baseUrl}/${AGENT_CARD_PATH}`);
+    });
+
+    return server;
+}

package/src/a2a/AgentExecutorAdapter.js

@@ -0,0 +1,109 @@
+import { v4 as uuidv4 } from 'uuid';
+
+/**
+ * Adapts an agentlib Agent to the A2A AgentExecutor interface.
+ * This allows the agent to be run by the A2A server.
+ */
+export class AgentExecutorAdapter {
+    /**
+     * @param {import('../Agent').Agent} agent - The agent to adapt.
+     */
+    constructor(agent) {
+        this.agent = agent;
+        this.cancelledTasks = new Set();
+    }
+
+    /**
+     * Executes the agent logic for a given task.
+     * @param {import('@a2a-js/sdk/server').RequestContext} requestContext
+     * @param {import('@a2a-js/sdk/server').ExecutionEventBus} eventBus
+     */
+    async execute(requestContext, eventBus) {
+        const { taskId, contextId, userMessage, task } = requestContext;
+
+        // Publish initial task state if not already present
+        if (!task) {
+            eventBus.publish({
+                kind: 'task',
+                id: taskId,
+                contextId: contextId,
+                status: { state: 'submitted', timestamp: new Date().toISOString() },
+                history: [userMessage],
+            });
+        }
+
+        // Publish 'working' status
+        eventBus.publish({
+            kind: 'status-update',
+            taskId,
+            contextId,
+            status: { state: 'working', timestamp: new Date().toISOString() },
+            final: false,
+        });
+
+        try {
+            // Extract text content from the A2A message
+            // A2A messages have parts, usually 'text' kind.
+            const textPart = userMessage.parts.find(p => p.kind === 'text');
+            const inputContent = textPart ? textPart.text : JSON.stringify(userMessage.parts);
+
+            // Add to agent's input
+            this.agent.addInput({ role: 'user', content: inputContent });
+
+            // Run the agent
+            const response = await this.agent.run();
+
+            // The response from agentlib is typically { rawResponse, output: [...messages], ... }
+            // We want the final text response.
+            // Depending on the Agent implementation, output might be the full history or just the new messages.
+            // Based on Agent.js, run() returns `response` which has `executed`. 
+            // The last message in `this.agent.input` should be the assistant's response.
+
+            const lastMessage = this.agent.input[this.agent.input.length - 1];
+            let responseText = "No response generated";
+
+            if (lastMessage && lastMessage.role === 'assistant') {
+                responseText = lastMessage.content;
+            } else if (response.rawResponse && response.rawResponse.content) {
+                // Fallback if not added to input yet
+                responseText = response.rawResponse.content;
+            }
+
+            // Publish the response message
+            eventBus.publish({
+                kind: 'message',
+                messageId: uuidv4(),
+                role: 'agent',
+                parts: [{ kind: 'text', text: responseText }],
+                contextId: contextId,
+            });
+
+            // Mark as completed
+            eventBus.publish({
+                kind: 'status-update',
+                taskId,
+                contextId,
+                status: { state: 'completed', timestamp: new Date().toISOString() },
+                final: true,
+            });
+
+        } catch (error) {
+            console.error("Error executing agent:", error);
+            eventBus.publish({
+                kind: 'status-update',
+                taskId,
+                contextId,
+                status: { state: 'failed', timestamp: new Date().toISOString(), details: error.message },
+                final: true,
+            });
+        } finally {
+            eventBus.finished();
+        }
+    }
+
+    async cancelTask(taskId, eventBus) {
+        this.cancelledTasks.add(taskId);
+        // Note: To fully support cancellation, Agent.js would need to check this flag during its execution loop.
+        // For now, this just marks it.
+    }
+}

package/src/a2a/RemoteAgentTool.js

@@ -0,0 +1,71 @@
+import { ClientFactory } from '@a2a-js/sdk/client';
+import { v4 as uuidv4 } from 'uuid';
+
+/**
+ * Creates a tool function that calls a remote A2A agent.
+ * This can be added to a local agent's tool set.
+ * 
+ * @param {string} remoteUrl - The URL of the remote agent (e.g. http://localhost:4000)
+ * @param {string} [toolName='remote_agent'] - The name of the tool to register.
+ * @param {string} [description] - Description for the tool. Use this to tell the agent when to use it.
+ * @returns {object} A tool definition compatible with ToolLoader.
+ */
+export async function createRemoteAgentTool(remoteUrl, toolName = 'remote_agent', description = "Ask a remote agent for help.") {
+    const factory = new ClientFactory();
+    let client;
+
+    try {
+        client = await factory.createFromUrl(remoteUrl);
+    } catch (err) {
+        console.warn(`Failed to connect to remote agent at ${remoteUrl}:`, err.message);
+        // We return the tool anyway, but it might fail at runtime if not fixed.
+    }
+
+    return {
+        name: toolName,
+        type: 'function',
+        description: description,
+        func: async ({ request }) => {
+            if (!client) {
+                // Try connecting again if initially failed
+                client = await factory.createFromUrl(remoteUrl);
+            }
+
+            const sendParams = {
+                message: {
+                    messageId: uuidv4(),
+                    role: 'user',
+                    parts: [{ kind: 'text', text: request }],
+                    kind: 'message',
+                },
+            };
+
+            try {
+                const response = await client.sendMessage(sendParams);
+
+                if (response.kind === 'task') {
+                    // It returned a task object, check artifacts or wait?
+                    // Simple case: just report the status
+                    return `Remote task started: ${response.id} - Status: ${response.status.state}`;
+                } else if (response.kind === 'message') {
+                    // Return the text
+                    return response.parts.map(p => p.text).join('\n');
+                }
+                return "Unknown response type from remote agent.";
+
+            } catch (error) {
+                return `Error communicating with remote agent: ${error.message}`;
+            }
+        },
+        parameters: {
+            type: "object",
+            properties: {
+                request: {
+                    type: "string",
+                    description: "The natural language request to send to the remote agent."
+                }
+            },
+            required: ["request"]
+        }
+    };
+}

package/src/config.js

@@ -1,2 +1,3 @@
 export const defaultProvider = 'openai';
-export const defaultModel = 'gpt-5';
+export const defaultOpenaiModel = 'gpt-5';
+export const defaultGeminiModel = 'gemini-3-pro-preview';

package/src/llmService.js

@@ -18,11 +18,26 @@ export class LLMService {
         return this.providerNamespace.createClient(this.apiKey);
     }
 
-    async chat(input, {inputSchema = null, outputSchema = null, ...options} = {}) {        
-        return this.providerNamespace.chat(this.client, input, {
-            inputSchema, 
-            outputSchema, 
-            ...options
-        });
+    async chat(input, { inputSchema = null, outputSchema = null, maxRetries = 3, initialDelay = 1000, ...options } = {}) {
+        let attempt = 0;
+        let delay = initialDelay;
+
+        while (true) {
+            try {
+                return await this.providerNamespace.chat(this.client, input, {
+                    inputSchema,
+                    outputSchema,
+                    ...options
+                });
+            } catch (error) {
+                attempt++;
+                if (attempt > maxRetries) {
+                    throw error;
+                }
+                console.warn(`LLM call failed (attempt ${attempt}/${maxRetries}). Retrying in ${delay}ms... Error: ${error.message}`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+                delay *= 2; // Exponential backoff
+            }
+        }
     }
 }

package/src/providers/gemini.js

@@ -1,20 +1,132 @@
 import { GoogleGenAI } from "@google/genai";
+import { defaultGeminiModel } from "../config.js";
+import { zodToJsonSchema } from "zod-to-json-schema";
 
 export function createClient(apiKey) {
-    return new GoogleGenAI(apiKey);
+    return new GoogleGenAI({ apiKey });
 }
 
-export async function chat(client, input, { inputSchema, outputSchema, ...options }) {
-    // TODO: Add translation of input to provide 
-    const defaultOptions = { model: 'gemini-2.5-flash-lite' };
-    const finalOptions = { ...defaultOptions, ...options };
+function _convertInput(input) {
+    const contents = [];
+    const systemParts = [];
+    for (const object of input) {
+        if (object.role === 'user') {
+            contents.push({
+                role: "user",
+                parts: [{ text: object.content }]
+            })
+        } else if (object.type === 'function_call') {
+            contents.push({
+                role: "model",
+                parts: [{
+                    functionCall: {
+                        name: object.name,
+                        args: object.args || (typeof object.arguments === 'string' ? JSON.parse(object.arguments) : object.arguments),
+                    },
+                    thoughtSignature: object.thoughtSignature
+                }],
+            })
+        } else if (object.type === 'function_call_output') {
+            contents.push({
+                role: 'user',
+                parts: [{ functionResponse: { name: object.name, response: { result: JSON.parse(object.output) } } }]
+            })
+        } else if (object.role === 'system') {
+            systemParts.push({
+                text: object.content
+            })
+        }
+    }
+    return {
+        contents,
+        systemParts
+    }
+}
+
+function _convertCandidateParts(parts) {
+    const output = [];
+    for (const part of parts) {
+        if (part.functionCall) {
+            output.push({
+                type: "function_call",
+                name: part.functionCall.name,
+                arguments: JSON.stringify(part.functionCall.args),
+                thoughtSignature: part.thoughtSignature
+            })
+        }
+        else {
+            output.push({
+                type: "message",
+                content: {
+                    text: part.text
+                }
+            })
+        }
+    }
+    return output;
+}
 
+function _convertResponse(response, output) {
+    return {
+        output: output,
+        rawResponse: {
+            output: _convertCandidateParts(response.candidates[0].content.parts),
+            model: response.modelVersion,
+            id: response.responseId,
+            usage: response.usageMetadata,
+            originalFormat: response
+        }
+    };
+}
+
+export async function chat(client, input, { inputSchema, outputSchema, tools, ...options }) {
     try {
-        const response = await client.models.generateContent({
-            contents: input,
-            ...finalOptions,
-        });
-        return response;
+        let response, output;
+        const formattedInput = _convertInput(input);
+        const config = {
+            systemInstruction: {
+                parts: formattedInput.systemParts || []
+            },
+            tools: tools ? [{
+                functionDeclarations: tools.map(tool => ({
+                    name: tool.name,
+                    description: tool.description,
+                    parameters: tool.parameters,
+                    func: tool.func
+                }))
+            }] : [],
+            ...options
+        }
+
+        if (outputSchema) {
+            response = await client.models.generateContent({
+                model: defaultGeminiModel,
+                contents: formattedInput.contents,
+                config: {
+                    ...config,
+                    responseMimeType: "application/json",
+                    responseJsonSchema: zodToJsonSchema(outputSchema),
+                }
+            });
+
+            const candidates = response.candidates;
+            const hasFunctionCall = candidates && candidates[0] && candidates[0].content && candidates[0].content.parts.some(p => p.functionCall);
+
+            if (hasFunctionCall) {
+                output = null;
+            } else {
+                const text = response.text ? (typeof response.text === 'function' ? response.text() : response.text) : null;
+                output = text ? outputSchema.parse(JSON.parse(text)) : null;
+            }
+        } else {
+            response = await client.models.generateContent({
+                model: defaultGeminiModel,
+                contents: formattedInput.contents,
+                config: config,
+            });
+            output = response.text ? (typeof response.text === 'function' ? response.text() : response.text) : null;
+        }
+        return _convertResponse(response, output);
     } catch (error) {
         console.error(`Error during Gemini chat completion:`, error);
         throw error;

package/src/providers/openai.js

@@ -1,15 +1,25 @@
 import OpenAI from 'openai';
 import { zodTextFormat } from "openai/helpers/zod";
-import { defaultModel } from "../config.js";
+import { defaultOpenaiModel } from "../config.js";
 
 // Factory function to create client
 export function createClient(apiKey) {
     return new OpenAI({ apiKey });
 }
 
+function _convertInput(input) {
+    return input.map((item) => {
+        if (item.type === 'function_call_output') {
+            return { type: 'function_call_output', call_id: item.call_id, output: JSON.stringify(item.output) };
+        } else {
+            return item;
+        }
+    });
+}
+
 // Now accepts the client as first parameter
 export async function chat(client, input, { inputSchema, outputSchema, ...options }) {
-    const defaultOptions = { model: defaultModel };
+    const defaultOptions = { model: defaultOpenaiModel };
     const finalOptions = { ...defaultOptions, ...options };
 
     if (inputSchema) {
@@ -20,21 +30,21 @@ export async function chat(client, input, { inputSchema, outputSchema, ...option
         let response, output;
         if (outputSchema) {
             response = await client.responses.parse({
-                input: input,
-                text: { 
-                    format: zodTextFormat(outputSchema, "output") 
+                input: _convertInput(input),
+                text: {
+                    format: zodTextFormat(outputSchema, "output")
                 },
                 ...finalOptions,
             });
             output = response.output_parsed;
         } else {
             response = await client.responses.create({
-                input: input,
+                input: _convertInput(input),
                 ...finalOptions,
             });
             output = response.output_text;
         }
-        return {output: output, rawResponse: response};
+        return { output: output, rawResponse: response };
     } catch (error) {
         console.error(`Error during OpenAI chat response creation:`, error);
         throw error;