@peebles-group/agentlib-js 1.0.1

package/LICENSE.txt

@@ -0,0 +1,8 @@
+Copyright 2025 Peebles Group
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

package/README.md

@@ -0,0 +1,237 @@
+# AgentLib
+
+A lightweight Node.js library for building AI agents with LLM providers and MCP (Model Context Protocol) server integration.
+
+## Installation
+
+```bash
+npm install peebles-agentlib
+```
+
+## Quick Start
+
+1. **Set up API keys**
+   ```bash
+   # Create .env file
+   OPENAI_API_KEY=your_openai_key
+   GEMINI_API_KEY=your_gemini_key
+   ```
+
+2. **Create a new project**
+   ```bash
+   mkdir my-agent-project
+   cd my-agent-project
+   npm init -y
+   npm install peebles-agentlib dotenv
+   ```
+
+## Features
+
+- **Multi-Provider LLM Support**: OpenAI, Gemini
+- **MCP Integration**: Browser automation, filesystem, web search, memory
+- **Tool Calling**: Native function execution with type safety
+- **Structured Output**: Zod schema validation
+- **Agent Orchestration**: Multi-step reasoning with tool use
+
+## Basic Usage
+
+```javascript
+import { Agent } from 'peebles-agentlib';
+import dotenv from 'dotenv';
+dotenv.config();
+
+// Simple agent
+const agent = new Agent('openai', process.env.OPENAI_API_KEY, {
+  model: 'gpt-4o-mini'
+});
+agent.addInput({ role: 'user', content: 'Hello!' });
+const response = await agent.run();
+console.log(response.output_text);
+
+// Agent with MCP servers (auto-installs packages)
+const mcpAgent = new Agent('openai', process.env.OPENAI_API_KEY, { 
+  model: 'gpt-4o-mini', 
+  enableMCP: true 
+});
+
+await mcpAgent.addMCPServer('browser', {
+  type: 'stdio', 
+  command: 'npx',
+  args: ['@playwright/mcp@latest']
+});
+```
+
+## Structured Outputs
+
+AgentLib supports type-safe structured outputs using Zod schemas for reliable JSON responses.
+
+```javascript
+import { Agent } from 'peebles-agentlib';
+import { z } from 'zod';
+import dotenv from 'dotenv';
+dotenv.config();
+
+// Define schema with Zod
+const ResponseSchema = z.object({
+  answer: z.string(),
+  confidence: z.number(),
+  sources: z.array(z.string())
+});
+
+const agent = new Agent('openai', process.env.OPENAI_API_KEY, {
+  model: 'gpt-4o-mini',
+  outputSchema: ResponseSchema  // Pass Zod object directly
+});
+
+agent.addInput({ role: 'user', content: 'What is the capital of France?' });
+const result = await agent.run();
+
+// Access structured data from the result
+const parsedData = result.output_parsed;  // Structured data when schema is used
+const text = result.output_text;          // Raw text response
+```
+
+**Key Points:**
+- **Input/Output Schemas**: Pass Zod objects directly to `inputSchema`/`outputSchema`
+- **Raw Text**: Access via `result.output_text` (when no schema)
+- **Type Safety**: Automatic validation and TypeScript support
+- **Model Support**: Works with `gpt-4o-mini` and `gpt-4o` models
+
+## Examples
+
+The repository includes several development examples that demonstrate different features:
+
+- **`examples/simpleAgent/`** - Basic agent usage with tools
+- **`examples/mcp-example/`** - Full MCP integration demo  
+- **`examples/translatorExample/`** - Multi-agent orchestration
+- **`examples/sqlAgent/`** - Database operations
+- **`examples/schema-example/`** - Structured input/output with Zod schemas
+- **`examples/rag-example/`** - Agentic RAG example with mongodb hybrid search
+
+**Note:** These examples use relative imports for development. In your projects, use the npm package:
+
+```javascript
+// In your project
+import { Agent } from 'peebles-agentlib';
+
+// Instead of (development only)
+import { Agent } from './src/Agent.js';
+```
+
+## API Reference
+
+### Agent Constructor
+```javascript
+const agent = new Agent(provider, apiKey, options);
+```
+
+**Parameters:**
+- `provider` (string): LLM provider name ('openai', 'gemini')
+- `apiKey` (string): API key for the provider
+- `options` (object): Configuration options
+  - `model` (string): LLM model name (default: 'gpt-4o-mini')
+  - `tools` (array): Native function tools
+  - `enableMCP` (boolean): Enable MCP servers
+  - `inputSchema` (Zod object): Input validation schema
+  - `outputSchema` (Zod object): Output validation schema
+
+**Example:**
+```javascript
+import { Agent } from 'peebles-agentlib';
+
+const agent = new Agent('openai', process.env.OPENAI_API_KEY, {
+  model: 'gpt-4o-mini',
+  tools: [],
+  enableMCP: true,
+  inputSchema: zodSchema,
+  outputSchema: zodSchema
+});
+```
+
+### LLM Providers
+- **OpenAI**: `gpt-4o-mini`, `gpt-4o`, `gpt-3.5-turbo`
+- **Gemini**: `gemini-2.5-flash-lite`
+
+Input format follows OpenAI's message structure:
+```javascript
+[{ role: 'user', content: 'Hello' }]
+```
+
+### LLM Result Format
+
+When calling an LLM, the result object has the following structure:
+
+```javascript
+{
+  "id": "resp_67ccd2bed1ec8190b14f964abc0542670bb6a6b452d3795b",
+  "object": "response",
+  "created_at": 1741476542,
+  "status": "completed",
+  "error": null,
+  "incomplete_details": null,
+  "instructions": null,
+  "max_output_tokens": null,
+  "model": "gpt-4.1-2025-04-14",
+  "output": [
+    {
+      "type": "message",
+      "id": "msg_67ccd2bf17f0819081ff3bb2cf6508e60bb6a6b452d3795b",
+      "status": "completed",
+      "role": "assistant",
+      "content": [
+        {
+          "type": "output_text",
+          "text": "In a peaceful grove beneath a silver moon...",
+          "annotations": []
+        }
+      ]
+    },
+    {
+        type: 'function',
+        description: 'Search the web for information',
+        name: 'web_search',
+        parameters: [Object],
+        strict: true
+      }
+  ],
+  "parallel_tool_calls": true,
+  "previous_response_id": null,
+  "reasoning": {
+    "effort": null,
+    "summary": null
+  },
+  "store": true,
+  "temperature": 1.0,
+  "text": {
+    "format": {
+      "type": "text"
+    }
+  },
+  "tool_choice": "auto",
+  "tools": [],
+  "top_p": 1.0,
+  "truncation": "disabled",
+  "usage": {
+    "input_tokens": 36,
+    "input_tokens_details": {
+      "cached_tokens": 0
+    },
+    "output_tokens": 87,
+    "output_tokens_details": {
+      "reasoning_tokens": 0
+    },
+    "total_tokens": 123
+  },
+  "user": null,
+  "metadata": {}
+}
+```
+
+**Key Fields:**
+- `output_text` - The actual response text
+- `output_parsed` - Response ONLY WHEN OUTPUT SCHEMA IS PRESENT
+- `usage` - Token consumption details
+- `model` - The model used for the response
+- `status` - Response status ("completed", "failed", etc.)
+
+

package/index.js

@@ -0,0 +1,2 @@
+export { LLMService } from './src/llmService.js';
+export { Agent } from './src/Agent.js';

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@peebles-group/agentlib-js",
+  "version": "1.0.1",
+  "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",
+  "scripts": {
+    "start": "node index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Peebles Group",
+  "license": "MIT",
+  "dependencies": {
+    "@google/genai": "^1.16.0",
+    "@modelcontextprotocol/sdk": "^1.18.2",
+    "openai": "^6.0.0"
+  },
+  "devDependencies": {
+    "dotenv": "^16.6.1",
+    "js-yaml": "^4.1.0",
+    "mongodb": "^6.20.0",
+    "openai": "^5.16.0",
+    "agentlib-js": "^1.0.0",
+    "playwright": "^1.55.0",
+    "prompt-sync": "^4.2.0",
+    "sqlite": "^5.1.1",
+    "sqlite3": "^5.1.7",
+    "zod": "^3.25.76"
+  },
+  "files": [
+    "index.js",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/Agent.js

@@ -0,0 +1,132 @@
+import { LLMService } from "./llmService.js";
+import { defaultModel } from "./config.js";
+import { MCPManager } from "./mcp/MCPManager.js";
+
+export class Agent {
+  constructor(provider, apiKey, {model = defaultModel, tools = [], inputSchema = null, outputSchema = null, enableMCP = false} = {}) {
+    this.llmService = new LLMService(provider, apiKey);
+    this.model = model;
+    this.nativeTools = tools;
+    this.inputSchema = inputSchema;
+    this.outputSchema = outputSchema;
+    this.mcpManager = enableMCP ? new MCPManager() : null;
+    this.updateSystemPrompt();
+  }
+
+  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);
+    this.updateSystemPrompt();
+    return result;
+  }
+
+  async removeMCPServer(serverName) {
+    if (!this.mcpManager) return false;
+
+    const result = await this.mcpManager.removeServer(serverName);
+    if (result) this.updateSystemPrompt();
+    return result;
+  }
+
+  getAllTools() {
+    const mcpTools = this.mcpManager ? this.mcpManager.getAllTools() : [];
+    return [...this.nativeTools, ...mcpTools];
+  }
+
+  getMCPInfo() {
+    return this.mcpManager ? this.mcpManager.getServerInfo() : { enabled: false };
+  }
+
+  // Mentioning the tools in the system prompt for maximum reliability
+  updateSystemPrompt() {
+    const allTools = this.getAllTools();
+    this.input = [{
+      role: 'system',
+      content: 'You are a tool-calling agent. You have access to the following tools: ' +
+      allTools.map(tool => `${tool.name}: ${tool.description}`).join('; ') +
+      '. Use these tools to answer the user\'s questions.'
+    }];
+  }
+
+  addInput(input) {
+    if (this.inputSchema) {
+      this.inputSchema.parse(input);
+    }
+    this.input.push(input);
+  }
+
+  /**
+   * Run the agent for a single step
+   */
+  async run() {
+    const allTools = this.getAllTools();
+
+    // Step 1: send input to model
+    let response = await this.llmService.chat(this.input, {
+      model: this.model,
+      outputSchema: this.outputSchema,
+      tools: allTools,
+    });
+
+    const { output, rawResponse } = response;
+
+    // Step 2: Clean and add the response to input history
+    // Remove parsed_arguments (if it exists) from function calls before adding to history
+    const cleanedOutput = rawResponse.output.map(item => {
+      if (item.type === "function_call" && item.parsed_arguments) {
+        const { parsed_arguments, ...cleanItem } = item;
+        return cleanItem;
+      }
+      return item;
+    });
+      
+    this.input = this.input.concat(cleanedOutput);
+
+    // Step 3: collect all function calls
+    const functionCalls = rawResponse.output.filter(item => item.type === "function_call");
+
+    if (functionCalls.length > 0) {
+      for (const call of functionCalls) {
+        let args;
+        try {
+          args = JSON.parse(call.arguments);
+        } catch (err) {
+          console.error("Failed to parse function call arguments:", call.arguments);
+          continue;
+        }
+
+        const tool = allTools.find(t => t.name === call.name);
+        if (!tool || !tool.func) {
+          throw new Error(`Tool ${call.name} not found or missing implementation.`);
+        }
+
+        // Step 4: execute the function
+        const result = await tool.func(args);
+
+        // Step 5: append function call output to input
+        this.input.push({
+          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,
+        model: this.model,
+        outputSchema: this.outputSchema,
+      });
+    }
+    return response;
+  }
+
+  async cleanup() {
+    if (this.mcpManager) {
+      await this.mcpManager.cleanup();
+    }
+  }
+}

package/src/config.js

@@ -0,0 +1 @@
+export const defaultModel = 'gpt-4o-mini';

package/src/llmService.js

@@ -0,0 +1,33 @@
+import { validateProviderName } from './providers/registry.js';
+
+export class LLMService {
+    constructor(provider, apiKey) {
+        this.provider = validateProviderName(provider);
+        this.apiKey = apiKey;
+        this.client = null;  
+
+        if (!apiKey) {
+            throw new Error(`API key is required for provider: ${provider}`);
+        }
+    }
+
+    async _getProviderClient() {
+
+        if (!this.client) {
+            const provider = await import(`./providers/${this.provider}.js`);
+            this.client = provider.createClient(this.apiKey);
+        }
+        return this.client;
+    }
+
+    async chat(input, {inputSchema = null, outputSchema = null, ...options} = {}) {
+        const client = await this._getProviderClient();
+        const provider = await import(`./providers/${this.provider}.js`);
+        
+        return provider.chat(client, input, {
+            inputSchema, 
+            outputSchema, 
+            ...options
+        });
+    }
+}

package/src/mcp/MCPClient.js

@@ -0,0 +1,109 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+class MCPClient {
+  constructor() {
+    this.mcp = new Client({ name: "mcp-client-cli", version: "1.0.0" });
+    this.tools = [];
+    this.isConnected = false;
+  }
+
+  async connectToServer(server) {
+    try {
+        switch (server.type) {
+            case "stdio":
+                this.transport = new StdioClientTransport(server);
+                break;
+            case "sse":
+                this.transport = new SSEClientTransport(server.url);
+                break;
+            case "streamableHttp":
+                this.transport = new StreamableHTTPClientTransport(server.url);
+                break;
+            default:
+                throw new Error("Invalid server type");
+        }
+        await this.mcp.connect(this.transport);
+    
+        const toolsResult = await this.mcp.listTools();
+        this.tools = toolsResult.tools.map((tool) => {
+            return {
+            type: "function",
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.inputSchema,
+            func: async (args) => {
+                return await this.executeTool(tool.name, args);
+            }
+            };
+        });
+        this.isConnected = true;
+        console.log(
+            "Connected to MCP server with tools:",
+            this.tools.map(({ name }) => name)
+        );
+        
+        return this.tools;
+    } catch (e) {
+      console.log("Failed to connect to MCP server: ", e);
+      throw e;
+    }
+  }
+
+  async executeTool(toolName, args) {
+    if (!this.isConnected) {
+      throw new Error("MCP client is not connected to a server");
+    }
+
+    const tool = this.tools.find(t => t.name === toolName);
+    if (!tool) {
+      throw new Error(`Tool '${toolName}' not found on MCP server`);
+    }
+
+    try {
+      const result = await this.mcp.callTool({
+        name: toolName,
+        arguments: args,
+      });
+      return result.content;
+    } catch (error) {
+      console.error(`Error executing MCP tool '${toolName}':`, error);
+      throw error;
+    }
+  }
+  
+  getTools() {
+    if (!this.isConnected) {
+      return [];
+    }
+    return this.tools;
+  }
+
+  getToolNames() {
+    return this.tools.map(tool => tool.name);
+  }
+
+  getAvailableTools() {
+    return this.tools.map(tool => tool.name);
+  }
+
+  getAgentTools() {
+    return this.tools;
+  }
+
+  isServerConnected() {
+    return this.isConnected;
+  }
+
+  async disconnect() {
+    if (this.transport && this.isConnected) {
+      await this.transport.close();
+      this.isConnected = false;
+      this.tools = [];
+    }
+  }
+}
+
+export default MCPClient;

package/src/mcp/MCPManager.js

@@ -0,0 +1,240 @@
+import MCPClient from "./MCPClient.js";
+
+export class MCPManager {
+  constructor() {
+    this.clients = new Map(); 
+    this.serverConfigs = new Map(); 
+  }
+
+  async addServer(serverName, serverConfig) {
+    if (this.clients.has(serverName)) {
+      throw new Error(`MCP server '${serverName}' already exists`);
+    }
+
+    try {
+      const client = new MCPClient();
+      const tools = await client.connectToServer(serverConfig);
+      
+      this.clients.set(serverName, client);
+      this.serverConfigs.set(serverName, serverConfig);
+      
+      console.log(`MCPManager: Connected to server '${serverName}' with ${tools.length} tools`);
+      return { serverName, tools, toolCount: tools.length };
+      
+    } catch (error) {
+      console.error(`MCPManager: Failed to connect to server '${serverName}':`, error);
+      throw error;
+    }
+  }
+
+  async removeServer(serverName) {
+    const client = this.clients.get(serverName);
+    if (!client) {
+      console.warn(`MCPManager: Server '${serverName}' not found`);
+      return false;
+    }
+
+    try {
+      await client.disconnect();
+      this.clients.delete(serverName);
+      this.serverConfigs.delete(serverName);
+      console.log(`MCPManager: Disconnected from server '${serverName}'`);
+      return true;
+    } catch (error) {
+      console.error(`MCPManager: Error disconnecting from server '${serverName}':`, error);
+      throw error;
+    }
+  }
+
+  // Get all tools from all connected servers
+  getAllTools() {
+    const allTools = [];
+    
+    for (const [serverName, client] of this.clients) {
+      allTools.push(...client.getTools());
+    }
+    
+    return allTools;
+  }
+
+  // Execute a tool by finding the right server
+  async executeTool(toolName, args) {
+    for (const [serverName, client] of this.clients) {
+      if (client.isServerConnected()) {
+        const availableTools = client.getAvailableTools();
+        if (availableTools.includes(toolName)) {
+          console.log(`MCPManager: Executing '${toolName}' on server '${serverName}'`);
+          return await client.executeTool(toolName, args);
+        }
+      }
+    }
+    
+    throw new Error(`MCPManager: Tool '${toolName}' not found on any connected server`);
+  }
+
+  // Get comprehensive server information
+  getServerInfo() {
+    const info = {
+      totalServers: this.clients.size,
+      connectedServers: 0,
+      totalTools: 0,
+      servers: {}
+    };
+
+    for (const [serverName, client] of this.clients) {
+      const isConnected = client.isServerConnected();
+      const tools = isConnected ? client.getAvailableTools() : [];
+      
+      if (isConnected) {
+        info.connectedServers++;
+        info.totalTools += tools.length;
+      }
+
+      info.servers[serverName] = {
+        connected: isConnected,
+        toolCount: tools.length,
+        tools: tools,
+      };
+    }
+
+    return info;
+  }
+
+  // Health check all servers
+  async healthCheck() {
+    const results = {
+      manager: 'healthy',
+      servers: {}
+    };
+
+    for (const [serverName, client] of this.clients) {
+      try {
+        if (client.isServerConnected()) {
+          // Try to get tools as a health check
+          client.getAvailableTools();
+          results.servers[serverName] = 'healthy';
+        } else {
+          results.servers[serverName] = 'disconnected';
+        }
+      } catch (error) {
+        results.servers[serverName] = 'unhealthy';
+        console.warn(`MCPManager: Health check failed for '${serverName}':`, error.message);
+      }
+    }
+
+    return results;
+  }
+
+  // Reconnect a specific server
+  async reconnectServer(serverName) {
+    const config = this.serverConfigs.get(serverName);
+    if (!config) {
+      throw new Error(`MCPManager: No config found for server '${serverName}'`);
+    }
+
+    // Remove existing connection
+    await this.removeServer(serverName);
+    
+    // Reconnect
+    return await this.addServer(serverName, config);
+  }
+
+  // Reconnect all disconnected servers
+  async reconnectAll() {
+    const results = [];
+    
+    for (const [serverName, client] of this.clients) {
+      if (!client.isServerConnected()) {
+        try {
+          const result = await this.reconnectServer(serverName);
+          results.push({ serverName, status: 'reconnected', ...result });
+        } catch (error) {
+          results.push({ serverName, status: 'failed', error: error.message });
+        }
+      }
+    }
+    
+    return results;
+  }
+
+  // Batch operations
+  async addMultipleServers(serverConfigs) {
+    const results = [];
+    
+    for (const { name, config } of serverConfigs) {
+      try {
+        const result = await this.addServer(name, config);
+        results.push({ ...result, status: 'success' });
+      } catch (error) {
+        results.push({ serverName: name, status: 'failed', error: error.message });
+      }
+    }
+    
+    return results;
+  }
+
+  // Get servers by capability (tools matching a pattern)
+  getServersByTool(toolNamePattern) {
+    const matchingServers = [];
+    const regex = new RegExp(toolNamePattern, 'i');
+    
+    for (const [serverName, client] of this.clients) {
+      if (client.isServerConnected()) {
+        const tools = client.getAvailableTools();
+        const matchingTools = tools.filter(tool => regex.test(tool));
+        
+        if (matchingTools.length > 0) {
+          matchingServers.push({
+            serverName,
+            matchingTools
+          });
+        }
+      }
+    }
+    
+    return matchingServers;
+  }
+
+  // Cleanup all connections
+  async cleanup() {
+    console.log(`MCPManager: Cleaning up ${this.clients.size} connections...`);
+    
+    const disconnectPromises = [];
+    for (const [serverName, client] of this.clients) {
+      disconnectPromises.push(
+        client.disconnect().catch(error => 
+          console.error(`MCPManager: Error disconnecting '${serverName}':`, error)
+        )
+      );
+    }
+    
+    await Promise.allSettled(disconnectPromises);
+    this.clients.clear();
+    this.serverConfigs.clear();
+    
+    console.log('MCPManager: Cleanup completed');
+  }
+
+  // Iterator support for easy looping
+  [Symbol.iterator]() {
+    return this.clients.entries();
+  }
+
+  // Get list of connected server names
+  getConnectedServerNames() {
+    return Array.from(this.clients.keys()).filter(serverName => 
+      this.clients.get(serverName).isServerConnected()
+    );
+  }
+
+  // Get total tool count across all servers
+  getTotalToolCount() {
+    let count = 0;
+    for (const client of this.clients.values()) {
+      if (client.isServerConnected()) {
+        count += client.getAvailableTools().length;
+      }
+    }
+    return count;
+  }
+}

package/src/providers/gemini.js

@@ -0,0 +1,22 @@
+import { GoogleGenAI } from "@google/genai";
+
+export function createClient(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 };
+
+    try {
+        const response = await client.models.generateContent({
+            contents: input,
+            ...finalOptions,
+        });
+        return response;
+    } catch (error) {
+        console.error(`Error during Gemini chat completion:`, error);
+        throw error;
+    }
+}

package/src/providers/openai.js

@@ -0,0 +1,42 @@
+import OpenAI from 'openai';
+import { zodTextFormat } from "openai/helpers/zod";
+import { defaultModel } from "../config.js";
+
+// Factory function to create client
+export function createClient(apiKey) {
+    return new OpenAI({ apiKey });
+}
+
+// Now accepts the client as first parameter
+export async function chat(client, input, { inputSchema, outputSchema, ...options }) {
+    const defaultOptions = { model: defaultModel };
+    const finalOptions = { ...defaultOptions, ...options };
+
+    if (inputSchema) {
+        input = inputSchema.parse(input);
+    }
+
+    try {
+        let response, output;
+        if (outputSchema) {
+            response = await client.responses.parse({
+                input: input,
+                text: { 
+                    format: zodTextFormat(outputSchema, "output") 
+                },
+                ...finalOptions,
+            });
+            output = response.output_parsed;
+        } else {
+            response = await client.responses.create({
+                input: input,
+                ...finalOptions,
+            });
+            output = response.output_text;
+        }
+        return {output: output, rawResponse: response};
+    } catch (error) {
+        console.error(`Error during OpenAI chat completion:`, error);
+        throw error;
+    }
+}

package/src/providers/registry.js

@@ -0,0 +1,19 @@
+const ALLOWED_PROVIDERS = Object.freeze(['openai', 'gemini']);
+
+export function getAllowedProviders() {
+    return [...ALLOWED_PROVIDERS];
+}
+
+export function validateProviderName(providerName) {
+    if (typeof providerName !== 'string') {
+        throw new TypeError('Provider name must be a string.');
+    }
+
+    const normalizedName = providerName.trim().toLowerCase();
+
+    if (!ALLOWED_PROVIDERS.includes(normalizedName)) {
+        throw new Error(`Unsupported provider. Allowed providers: ${ALLOWED_PROVIDERS.join(', ')}`);
+    }
+
+    return normalizedName;
+}