@opencontextprotocol/agent 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 NALLENSCOTT, LLC
+
+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,198 @@
+# OCP JavaScript Library
+
+Context-aware HTTP client framework for AI agents.
+
+## Installation
+
+```bash
+npm install @opencontextprotocol/agent
+# or with yarn
+yarn add @opencontextprotocol/agent
+```
+
+## Quick Start
+
+```typescript
+import { OCPAgent } from '@opencontextprotocol/agent';
+
+// Create an OCP agent
+const agent = new OCPAgent(
+    'api_explorer',
+    'your-username',
+    'my-project',
+    'Explore GitHub API'
+);
+
+// Register an API from the registry (fast lookup)
+const githubApi = await agent.registerApi('github');
+
+// Or register from OpenAPI specification URL
+// const githubApi = await agent.registerApi(
+//     'github',
+//     'https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json'
+// );
+
+// List available tools
+const tools = agent.listTools('github');
+console.log(`Found ${tools.length} GitHub API tools`);
+
+// Call a tool
+const result = await agent.callTool(
+    'usersGetAuthenticated',
+    undefined,
+    'github'
+);
+console.log(result);
+```
+
+## API Registration & Authentication
+
+The `registerApi()` method supports multiple patterns:
+
+```typescript
+// 1. Registry lookup - fastest, uses community registry
+const githubApi = await agent.registerApi('github');
+
+// 2. Registry lookup with authentication
+const githubApi = await agent.registerApi(
+    'github',
+    undefined,
+    undefined,
+    { 'Authorization': 'token ghp_your_token_here' }
+);
+
+// 3. Registry lookup with base URL override (e.g., GitHub Enterprise)
+const gheApi = await agent.registerApi(
+    'github',
+    undefined,
+    'https://github.company.com/api/v3',
+    { 'Authorization': 'token ghp_enterprise_token' }
+);
+
+// 4. Direct OpenAPI spec URL
+const api = await agent.registerApi(
+    'my-api',
+    'https://api.example.com/openapi.json'
+);
+
+// 5. Direct OpenAPI spec with base URL override and authentication
+const api = await agent.registerApi(
+    'my-api',
+    'https://api.example.com/openapi.json',
+    'https://staging-api.example.com',  // Override for testing
+    { 'X-API-Key': 'your_api_key_here' }
+);
+
+// 6. Local OpenAPI file (JSON or YAML)
+const api = await agent.registerApi(
+    'local-api',
+    'file:///path/to/openapi.yaml',
+    'http://localhost:8000'
+);
+
+// Headers are automatically included in all tool calls
+const result = await agent.callTool('usersGetAuthenticated', undefined, 'github');
+```
+
+## Core Components
+
+- **OCPAgent**: Main agent class with API discovery and tool invocation
+- **AgentContext**: Context management with persistent conversation tracking
+- **OCPHTTPClient**: Context-aware HTTP client wrapper
+- **OCPSchemaDiscovery**: OpenAPI specification parsing and tool extraction
+- **Headers**: OCP context encoding/decoding for HTTP headers
+- **Validation**: JSON schema validation for context objects
+
+## API Reference
+
+### OCPAgent
+
+```typescript
+const agent = new OCPAgent(agentType, user?, workspace?, agentGoal?, registryUrl?, enableCache?);
+await agent.registerApi(name, specUrl?, baseUrl?, headers?);
+agent.listTools(apiName?);
+await agent.callTool(toolName, parameters?, apiName?);
+```
+
+### AgentContext
+
+```typescript
+const context = new AgentContext({ agent_type, user?, workspace? });
+context.addInteraction(action, apiEndpoint?, result?, metadata?);
+context.updateGoal(newGoal, summary?);
+context.toDict();
+```
+
+### HTTP Client
+
+```typescript
+import { OCPHTTPClient, AgentContext } from '@opencontextprotocol/agent';
+
+// Create context
+const context = new AgentContext({
+    agent_type: 'api_client',
+    user: 'username',
+    workspace: 'project'
+});
+
+// Create OCP-aware HTTP client
+const client = new OCPHTTPClient(context, true, 'https://api.example.com');
+
+// Make requests with automatic OCP context headers
+const response = await client.request('GET', '/endpoint');
+```
+
+## Development
+
+```bash
+# Clone repository
+git clone https://github.com/opencontextprotocol/ocp-javascript.git
+cd ocp-javascript
+
+# Install dependencies
+npm install
+
+# Run tests
+npm test
+
+# Run tests with coverage
+npm test -- --coverage
+
+# Build for distribution
+npm run build
+
+# Run specific test file
+npm test context.test.ts
+```
+
+## Project Structure
+
+```
+src/
+├── index.ts             # Public API exports
+├── agent.ts             # OCPAgent class
+├── context.ts           # AgentContext class  
+├── http_client.ts       # HTTP client wrappers
+├── headers.ts           # Header encoding/decoding
+├── schema_discovery.ts  # OpenAPI parsing
+├── registry.ts          # Registry client
+├── validation.ts        # JSON schema validation
+└── errors.ts            # Error classes
+
+tests/
+├── agent.test.ts        # OCPAgent tests
+├── context.test.ts      # AgentContext tests
+├── http_client.test.ts  # HTTP client tests
+├── headers.test.ts      # Header tests
+├── schema_discovery.test.ts # Schema parsing tests
+├── registry.test.ts     # Registry tests
+└── validation.test.ts   # Validation tests
+```
+
+## TypeScript Support
+
+This library is written in TypeScript and includes full type definitions. All exports are fully typed for excellent IDE support and type safety.
+
+## License
+
+MIT License - see LICENSE file.

package/dist/src/agent.d.ts

@@ -0,0 +1,112 @@
+/**
+ * OCP Agent - Context-Aware API Discovery and Execution
+ *
+ * Combines OCP's context management with automatic API discovery,
+ * providing intelligent API interactions with zero infrastructure.
+ */
+import { AgentContext } from './context.js';
+import { OCPSchemaDiscovery, OCPAPISpec, OCPTool } from './schema_discovery.js';
+import { OCPHTTPClient, OCPResponse } from './http_client.js';
+import { OCPRegistry } from './registry.js';
+import { OCPStorage } from './storage.js';
+/**
+ * OCP Agent for Context-Aware API Interactions
+ *
+ * Provides:
+ * 1. API Discovery (from OpenAPI specs or community registry)
+ * 2. Tool Invocation (with parameter validation)
+ * 3. Context Management (persistent across calls)
+ * 4. Zero Infrastructure (no servers required)
+ */
+export declare class OCPAgent {
+    context: AgentContext;
+    discovery: OCPSchemaDiscovery;
+    registry: OCPRegistry;
+    knownApis: Map<string, OCPAPISpec>;
+    apiClients: Map<string, OCPHTTPClient>;
+    httpClient: OCPHTTPClient;
+    storage: OCPStorage | null;
+    /**
+     * Initialize OCP Agent with context and schema discovery.
+     *
+     * @param agentType - Type of AI agent (e.g., "ide_coding_assistant")
+     * @param user - User identifier
+     * @param workspace - Current workspace/project
+     * @param agentGoal - Current objective or goal
+     * @param registryUrl - Custom registry URL (uses OCP_REGISTRY_URL env var or default if not provided)
+     * @param enableCache - Enable local API caching and session persistence (default: true)
+     */
+    constructor(agentType?: string, user?: string, workspace?: string, agentGoal?: string, registryUrl?: string, enableCache?: boolean);
+    /**
+     * Register an API for discovery and usage.
+     *
+     * @param name - Human-readable name for the API or registry API name
+     * @param specUrl - URL to OpenAPI specification (optional if using registry lookup)
+     * @param baseUrl - Optional override for API base URL
+     * @param headers - Optional headers for authenticated requests to this API
+     * @returns Discovered API specification with available tools
+     *
+     * @example
+     * // Registry lookup (fast)
+     * await agent.registerApi('github');
+     *
+     * @example
+     * // Direct OpenAPI discovery
+     * await agent.registerApi('my-api', 'https://api.example.com/openapi.json');
+     */
+    registerApi(name: string, specUrl?: string, baseUrl?: string, headers?: Record<string, string>): Promise<OCPAPISpec>;
+    /**
+     * List available tools.
+     *
+     * @param apiName - Optional API name to filter tools
+     * @returns List of available tools
+     */
+    listTools(apiName?: string): OCPTool[];
+    /**
+     * Get specific tool by name.
+     *
+     * @param toolName - Name of the tool to find
+     * @param apiName - Optional API name to search within
+     * @returns Found tool or undefined
+     */
+    getTool(toolName: string, apiName?: string): OCPTool | undefined;
+    /**
+     * Search tools by name or description.
+     *
+     * @param query - Search query
+     * @param apiName - Optional API name to search within
+     * @returns List of matching tools
+     */
+    searchTools(query: string, apiName?: string): OCPTool[];
+    /**
+     * Call a discovered tool with OCP context injection.
+     *
+     * @param toolName - Name of the tool to call
+     * @param parameters - Parameters for the tool call
+     * @param apiName - Optional API name if tool name is ambiguous
+     * @param headers - Optional headers for this specific request (overrides registered headers)
+     * @returns HTTP response from the API call
+     */
+    callTool(toolName: string, parameters?: Record<string, any>, apiName?: string, headers?: Record<string, string>): Promise<OCPResponse>;
+    /**
+     * Validate parameters against tool schema.
+     */
+    private _validateParameters;
+    /**
+     * Build HTTP request from tool and parameters.
+     */
+    private _buildRequest;
+    /**
+     * Get documentation for a specific tool.
+     */
+    getToolDocumentation(toolName: string, apiName?: string): string;
+    /**
+     * Update agent goal and context.
+     */
+    updateGoal(goal: string, summary?: string): void;
+    /**
+     * Normalize API name for case-insensitive matching.
+     */
+    private _normalizeApiName;
+}
+//# sourceMappingURL=agent.d.ts.map

package/dist/src/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/agent.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAQ1C;;;;;;;;GAQG;AACH,qBAAa,QAAQ;IACjB,OAAO,EAAE,YAAY,CAAC;IACtB,SAAS,EAAE,kBAAkB,CAAC;IAC9B,QAAQ,EAAE,WAAW,CAAC;IACtB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACnC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACvC,UAAU,EAAE,aAAa,CAAC;IAC1B,OAAO,EAAE,UAAU,GAAG,IAAI,CAAC;IAE3B;;;;;;;;;OASG;gBAEC,SAAS,GAAE,MAA2B,EACtC,IAAI,CAAC,EAAE,MAAM,EACb,SAAS,CAAC,EAAE,MAAM,EAClB,SAAS,CAAC,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,MAAM,EACpB,WAAW,GAAE,OAAc;IAgB/B;;;;;;;;;;;;;;;;OAgBG;IACG,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC;IAqE1H;;;;;OAKG;IACH,SAAS,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,EAAE;IAmBtC;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAYhE;;;;;;OAMG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,EAAE;IAmBvD;;;;;;;;OAQG;IACG,QAAQ,CACV,QAAQ,EAAE,MAAM,EAChB,UAAU,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,EACpC,OAAO,CAAC,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,OAAO,CAAC,WAAW,CAAC;IAyFvB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA8B3B;;OAEG;IACH,OAAO,CAAC,aAAa;IAwDrB;;OAEG;IACH,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM;IAShE;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAIhD;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAG5B"}

package/dist/src/agent.js

@@ -0,0 +1,358 @@
+/**
+ * OCP Agent - Context-Aware API Discovery and Execution
+ *
+ * Combines OCP's context management with automatic API discovery,
+ * providing intelligent API interactions with zero infrastructure.
+ */
+import { AgentContext } from './context.js';
+import { OCPSchemaDiscovery } from './schema_discovery.js';
+import { OCPHTTPClient } from './http_client.js';
+import { OCPRegistry } from './registry.js';
+import { OCPStorage } from './storage.js';
+const DEFAULT_AGENT_TYPE = 'ai_agent';
+const DEFAULT_CACHE_MAX_AGE_DAYS = 7;
+const DEFAULT_REQUEST_TIMEOUT = 30000;
+const CACHE_SOURCE_NAME = 'cache';
+const REGISTRY_SOURCE_PREFIX = 'registry';
+/**
+ * OCP Agent for Context-Aware API Interactions
+ *
+ * Provides:
+ * 1. API Discovery (from OpenAPI specs or community registry)
+ * 2. Tool Invocation (with parameter validation)
+ * 3. Context Management (persistent across calls)
+ * 4. Zero Infrastructure (no servers required)
+ */
+export class OCPAgent {
+    /**
+     * Initialize OCP Agent with context and schema discovery.
+     *
+     * @param agentType - Type of AI agent (e.g., "ide_coding_assistant")
+     * @param user - User identifier
+     * @param workspace - Current workspace/project
+     * @param agentGoal - Current objective or goal
+     * @param registryUrl - Custom registry URL (uses OCP_REGISTRY_URL env var or default if not provided)
+     * @param enableCache - Enable local API caching and session persistence (default: true)
+     */
+    constructor(agentType = DEFAULT_AGENT_TYPE, user, workspace, agentGoal, registryUrl, enableCache = true) {
+        this.context = new AgentContext({
+            agent_type: agentType,
+            user,
+            workspace,
+            current_goal: agentGoal
+        });
+        this.discovery = new OCPSchemaDiscovery();
+        this.registry = new OCPRegistry(registryUrl);
+        this.knownApis = new Map();
+        this.apiClients = new Map();
+        this.httpClient = new OCPHTTPClient(this.context);
+        this.storage = enableCache ? new OCPStorage() : null;
+    }
+    /**
+     * Register an API for discovery and usage.
+     *
+     * @param name - Human-readable name for the API or registry API name
+     * @param specUrl - URL to OpenAPI specification (optional if using registry lookup)
+     * @param baseUrl - Optional override for API base URL
+     * @param headers - Optional headers for authenticated requests to this API
+     * @returns Discovered API specification with available tools
+     *
+     * @example
+     * // Registry lookup (fast)
+     * await agent.registerApi('github');
+     *
+     * @example
+     * // Direct OpenAPI discovery
+     * await agent.registerApi('my-api', 'https://api.example.com/openapi.json');
+     */
+    async registerApi(name, specUrl, baseUrl, headers) {
+        // Normalize name for case-insensitive matching
+        name = this._normalizeApiName(name);
+        // Check memory first
+        const existingSpec = this.knownApis.get(name);
+        if (existingSpec) {
+            return existingSpec;
+        }
+        // Check cache if storage enabled (7-day expiration)
+        if (this.storage) {
+            const cachedSpec = await this.storage.getCachedApi(name, DEFAULT_CACHE_MAX_AGE_DAYS);
+            if (cachedSpec) {
+                this.knownApis.set(name, cachedSpec);
+                this.context.addApiSpec(name, CACHE_SOURCE_NAME);
+                return cachedSpec;
+            }
+        }
+        // Lookup chain: Registry or Direct OpenAPI discovery
+        let apiSpec;
+        let source;
+        if (specUrl) {
+            // Direct OpenAPI discovery (existing behavior)
+            apiSpec = await this.discovery.discoverApi(specUrl, baseUrl);
+            source = specUrl;
+        }
+        else {
+            // Registry lookup (new behavior)
+            apiSpec = await this.registry.getApiSpec(name, baseUrl);
+            source = `${REGISTRY_SOURCE_PREFIX}:${name}`;
+        }
+        // Store API spec in memory and set name
+        apiSpec.name = name;
+        this.knownApis.set(name, apiSpec);
+        // Create wrapped client if headers provided
+        if (headers) {
+            const { _wrapApi } = await import('./http_client.js');
+            this.apiClients.set(name, _wrapApi(apiSpec.base_url, this.context, headers));
+        }
+        // Cache to disk if storage enabled
+        if (this.storage) {
+            await this.storage.cacheApi(name, apiSpec, { source });
+        }
+        // Add to context's API specs
+        this.context.addApiSpec(name, source);
+        // Log API registration
+        this.context.addInteraction('api_registered', source, `Discovered ${apiSpec.tools.length} tools`, {
+            api_name: name,
+            api_title: apiSpec.title,
+            tool_count: apiSpec.tools.length,
+            base_url: apiSpec.base_url,
+            source: specUrl ? 'openapi' : 'registry'
+        });
+        return apiSpec;
+    }
+    /**
+     * List available tools.
+     *
+     * @param apiName - Optional API name to filter tools
+     * @returns List of available tools
+     */
+    listTools(apiName) {
+        if (apiName) {
+            apiName = this._normalizeApiName(apiName);
+            const apiSpec = this.knownApis.get(apiName);
+            if (!apiSpec) {
+                throw new Error(`Unknown API: ${apiName}`);
+            }
+            return apiSpec.tools;
+        }
+        // Return tools from all APIs
+        const allTools = [];
+        for (const apiSpec of this.knownApis.values()) {
+            allTools.push(...apiSpec.tools);
+        }
+        return allTools;
+    }
+    /**
+     * Get specific tool by name.
+     *
+     * @param toolName - Name of the tool to find
+     * @param apiName - Optional API name to search within
+     * @returns Found tool or undefined
+     */
+    getTool(toolName, apiName) {
+        const tools = this.listTools(apiName);
+        for (const tool of tools) {
+            if (tool.name === toolName) {
+                return tool;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Search tools by name or description.
+     *
+     * @param query - Search query
+     * @param apiName - Optional API name to search within
+     * @returns List of matching tools
+     */
+    searchTools(query, apiName) {
+        if (apiName) {
+            apiName = this._normalizeApiName(apiName);
+            const apiSpec = this.knownApis.get(apiName);
+            if (!apiSpec) {
+                return [];
+            }
+            return this.discovery.searchTools(apiSpec, query);
+        }
+        // Search across all APIs
+        const matches = [];
+        for (const apiSpec of this.knownApis.values()) {
+            matches.push(...this.discovery.searchTools(apiSpec, query));
+        }
+        return matches;
+    }
+    /**
+     * Call a discovered tool with OCP context injection.
+     *
+     * @param toolName - Name of the tool to call
+     * @param parameters - Parameters for the tool call
+     * @param apiName - Optional API name if tool name is ambiguous
+     * @param headers - Optional headers for this specific request (overrides registered headers)
+     * @returns HTTP response from the API call
+     */
+    async callTool(toolName, parameters = {}, apiName, headers) {
+        // Find the tool
+        const tool = this.getTool(toolName, apiName);
+        if (!tool) {
+            const availableTools = this.listTools(apiName).map(t => t.name);
+            throw new Error(`Tool '${toolName}' not found. Available tools: ${availableTools.join(', ')}`);
+        }
+        // Find the API spec for this tool
+        let apiSpec;
+        for (const spec of this.knownApis.values()) {
+            if (spec.tools.includes(tool)) {
+                apiSpec = spec;
+                break;
+            }
+        }
+        if (!apiSpec) {
+            throw new Error(`Could not find API spec for tool '${toolName}'`);
+        }
+        // Validate parameters
+        const validationErrors = this._validateParameters(tool, parameters);
+        if (validationErrors.length > 0) {
+            throw new Error(`Parameter validation failed: ${validationErrors.join(', ')}`);
+        }
+        // Determine HTTP client to use (priority: call_tool headers > registered headers > default)
+        let client;
+        if (headers) {
+            // Per-call override: create temporary wrapped client
+            const { _wrapApi } = await import('./http_client.js');
+            client = _wrapApi(apiSpec.base_url, this.context, headers);
+        }
+        else if (apiSpec.name && this.apiClients.has(apiSpec.name)) {
+            // Use registered client with headers
+            client = this.apiClients.get(apiSpec.name);
+        }
+        else {
+            // Use default client (no auth)
+            client = this.httpClient;
+        }
+        // Build request
+        const [url, requestParams] = this._buildRequest(apiSpec, tool, parameters);
+        // Log the tool call
+        this.context.addInteraction(`tool_call:${toolName}`, url, 'executing', {
+            tool_name: toolName,
+            parameters,
+            method: tool.method
+        });
+        // Make the request with OCP context enhancement
+        try {
+            const response = await client.request(tool.method, url, requestParams);
+            // Log the result
+            this.context.addInteraction(`tool_response:${toolName}`, url, `${response.status} ${response.statusText}`, {
+                status_code: response.status,
+                success: response.ok,
+                response_size: response.text.length
+            });
+            return response;
+        }
+        catch (error) {
+            // Log the error
+            this.context.addInteraction(`tool_error:${toolName}`, url, `Error: ${error instanceof Error ? error.message : String(error)}`, {
+                error_type: error instanceof Error ? error.constructor.name : 'Unknown',
+                error_message: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    /**
+     * Validate parameters against tool schema.
+     */
+    _validateParameters(tool, parameters) {
+        const errors = [];
+        // Check required parameters
+        for (const [paramName, paramInfo] of Object.entries(tool.parameters)) {
+            if (paramInfo.required && !(paramName in parameters)) {
+                errors.push(`Missing required parameter: ${paramName}`);
+            }
+        }
+        // Check parameter types (basic validation)
+        for (const [paramName, value] of Object.entries(parameters)) {
+            if (paramName in tool.parameters) {
+                const paramInfo = tool.parameters[paramName];
+                const expectedType = paramInfo.type || 'string';
+                // Basic type checking
+                if (expectedType === 'integer' && !Number.isInteger(value)) {
+                    errors.push(`Parameter '${paramName}' should be integer, got ${typeof value}`);
+                }
+                else if (expectedType === 'boolean' && typeof value !== 'boolean') {
+                    errors.push(`Parameter '${paramName}' should be boolean, got ${typeof value}`);
+                }
+                else if (expectedType === 'array' && !Array.isArray(value)) {
+                    errors.push(`Parameter '${paramName}' should be array, got ${typeof value}`);
+                }
+            }
+        }
+        return errors;
+    }
+    /**
+     * Build HTTP request from tool and parameters.
+     */
+    _buildRequest(apiSpec, tool, parameters) {
+        // Start with base URL and path
+        let url = apiSpec.base_url.replace(/\/$/, '') + tool.path;
+        // Separate parameters by location
+        const pathParams = {};
+        const queryParams = {};
+        const bodyParams = {};
+        const headerParams = {};
+        for (const [paramName, value] of Object.entries(parameters)) {
+            if (paramName in tool.parameters) {
+                const location = tool.parameters[paramName].location || 'query';
+                if (location === 'path') {
+                    pathParams[paramName] = value;
+                }
+                else if (location === 'query') {
+                    queryParams[paramName] = value;
+                }
+                else if (location === 'body') {
+                    bodyParams[paramName] = value;
+                }
+                else if (location === 'header') {
+                    headerParams[paramName] = value;
+                }
+            }
+        }
+        // Replace path parameters
+        for (const [paramName, value] of Object.entries(pathParams)) {
+            url = url.replace(`{${paramName}}`, String(value));
+        }
+        // Build request parameters
+        const requestParams = {};
+        if (Object.keys(queryParams).length > 0) {
+            requestParams.params = queryParams;
+        }
+        if (Object.keys(bodyParams).length > 0) {
+            requestParams.json = bodyParams;
+        }
+        if (Object.keys(headerParams).length > 0) {
+            requestParams.headers = headerParams;
+        }
+        // Set timeout
+        requestParams.timeout = 30000;
+        return [url, requestParams];
+    }
+    /**
+     * Get documentation for a specific tool.
+     */
+    getToolDocumentation(toolName, apiName) {
+        const tool = this.getTool(toolName, apiName);
+        if (!tool) {
+            return `Tool '${toolName}' not found`;
+        }
+        return this.discovery.generateToolDocumentation(tool);
+    }
+    /**
+     * Update agent goal and context.
+     */
+    updateGoal(goal, summary) {
+        this.context.updateGoal(goal, summary);
+    }
+    /**
+     * Normalize API name for case-insensitive matching.
+     */
+    _normalizeApiName(name) {
+        return name.toLowerCase().trim();
+    }
+}
+//# sourceMappingURL=agent.js.map