@compilr-dev/agents 0.0.1 → 0.1.0

package/dist/agent.d.ts

@@ -449,6 +449,21 @@ export interface RunOptions {
      * Event handler for this run (in addition to config handler)
      */
     onEvent?: AgentEventHandler;
+    /**
+     * Filter tools for this run.
+     * - If provided, only these tool names will be available
+     * - Reduces token usage by not sending unused tool definitions
+     * - Tools must be registered with the agent
+     *
+     * @example
+     * ```typescript
+     * // Only allow file and search tools for this request
+     * await agent.run(message, {
+     *   toolFilter: ['read_file', 'write_file', 'grep', 'glob'],
+     * });
+     * ```
+     */
+    toolFilter?: string[];
 }
 /**
  * Agent run result
@@ -1033,6 +1048,11 @@ export declare class Agent {
      * Get the current conversation history
      */
     getHistory(): Message[];
+    /**
+     * Set the conversation history (for manual compaction/restoration)
+     * Also updates the context manager's token count if configured.
+     */
+    setHistory(messages: Message[]): Promise<this>;
     /**
      * Get the context manager (if configured)
      */

package/dist/agent.js

@@ -684,6 +684,17 @@ export class Agent {
     getHistory() {
         return [...this.conversationHistory];
     }
+    /**
+     * Set the conversation history (for manual compaction/restoration)
+     * Also updates the context manager's token count if configured.
+     */
+    async setHistory(messages) {
+        this.conversationHistory = [...messages];
+        if (this.contextManager) {
+            await this.contextManager.updateTokenCount(messages);
+        }
+        return this;
+    }
     /**
      * Get the context manager (if configured)
      */
@@ -1290,6 +1301,11 @@ export class Agent {
             }
             // Get tool definitions
             let tools = this.toolRegistry.getDefinitions();
+            // Apply tool filter if specified (reduces token usage)
+            if (options?.toolFilter && options.toolFilter.length > 0) {
+                const filterSet = new Set(options.toolFilter);
+                tools = tools.filter((tool) => filterSet.has(tool.name));
+            }
             // Run beforeLLM hooks (can modify messages and tools)
             if (this.hooksManager) {
                 const llmHookResult = await this.hooksManager.runBeforeLLM({

package/dist/index.d.ts

@@ -9,6 +9,14 @@ export type { LLMProvider, Message, MessageRole, ContentBlock, ContentBlockType,
 export { MockProvider, createMockProvider } from './providers/index.js';
 export { ClaudeProvider, createClaudeProvider } from './providers/index.js';
 export type { ClaudeProviderConfig } from './providers/index.js';
+export { OllamaProvider, createOllamaProvider } from './providers/index.js';
+export type { OllamaProviderConfig } from './providers/index.js';
+export { OpenAIProvider, createOpenAIProvider } from './providers/index.js';
+export type { OpenAIProviderConfig } from './providers/index.js';
+export { GeminiProvider, createGeminiProvider } from './providers/index.js';
+export type { GeminiProviderConfig } from './providers/index.js';
+export { OpenAICompatibleProvider } from './providers/index.js';
+export type { OpenAICompatibleConfig } from './providers/index.js';
 export type { Tool, ToolHandler, ToolRegistry, ToolInputSchema, ToolExecutionResult, ToolRegistryOptions, DefineToolOptions, ReadFileInput, WriteFileInput, BashInput, BashResult, FifoDetectionResult, GrepInput, GlobInput, EditInput, TodoWriteInput, TodoReadInput, TodoItem, TodoStatus, TodoContextCleanupOptions, TaskInput, TaskResult, AgentTypeConfig, TaskToolOptions, ContextMode, ThoroughnessLevel, SubAgentEventInfo, } from './tools/index.js';
 export { defineTool, createSuccessResult, createErrorResult, wrapToolExecute, DefaultToolRegistry, createToolRegistry, } from './tools/index.js';
 export { readFileTool, createReadFileTool, writeFileTool, createWriteFileTool, bashTool, createBashTool, execStream, detectFifoUsage, bashOutputTool, createBashOutputTool, killShellTool, createKillShellTool, ShellManager, getDefaultShellManager, setDefaultShellManager, grepTool, createGrepTool, globTool, createGlobTool, editTool, createEditTool, todoWriteTool, todoReadTool, createTodoTools, TodoStore, resetDefaultTodoStore, getDefaultTodoStore, createIsolatedTodoStore, cleanupTodoContextMessages, getTodoContextStats, webFetchTool, createWebFetchTool, createTaskTool, defaultAgentTypes, builtinTools, allBuiltinTools, } from './tools/index.js';

package/dist/index.js

@@ -8,6 +8,10 @@ export { Agent } from './agent.js';
 // Providers
 export { MockProvider, createMockProvider } from './providers/index.js';
 export { ClaudeProvider, createClaudeProvider } from './providers/index.js';
+export { OllamaProvider, createOllamaProvider } from './providers/index.js';
+export { OpenAIProvider, createOpenAIProvider } from './providers/index.js';
+export { GeminiProvider, createGeminiProvider } from './providers/index.js';
+export { OpenAICompatibleProvider } from './providers/index.js';
 // Tool utilities
 export { defineTool, createSuccessResult, createErrorResult, wrapToolExecute, DefaultToolRegistry, createToolRegistry, } from './tools/index.js';
 // Built-in tools

package/dist/providers/gemini.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Google Gemini LLM Provider
+ *
+ * Implements LLMProvider interface for Google Gemini models using
+ * the OpenAI-compatible endpoint for maximum compatibility.
+ *
+ * @example
+ * ```typescript
+ * const provider = createGeminiProvider({
+ *   model: 'gemini-2.0-flash',
+ *   apiKey: process.env.GOOGLE_AI_API_KEY
+ * });
+ * ```
+ *
+ * @remarks
+ * - Requires valid Google AI API key
+ * - Uses OpenAI-compatible endpoint for streaming and tool calling
+ * - Default model is gemini-2.0-flash
+ * - Extended thinking is not supported (Claude-specific feature)
+ */
+import type { ChatOptions } from './types.js';
+import { ProviderError } from '../errors.js';
+import { OpenAICompatibleProvider } from './openai-compatible.js';
+/**
+ * Configuration for GeminiProvider
+ */
+export interface GeminiProviderConfig {
+    /** Google AI API key (falls back to GOOGLE_AI_API_KEY or GEMINI_API_KEY env var) */
+    apiKey?: string;
+    /** Base URL for Gemini API (default: https://generativelanguage.googleapis.com/v1beta/openai) */
+    baseUrl?: string;
+    /** Default model to use (default: gemini-2.0-flash) */
+    model?: string;
+    /** Default max tokens (default: 4096) */
+    maxTokens?: number;
+    /** Request timeout in milliseconds (default: 120000) */
+    timeout?: number;
+}
+/**
+ * Google Gemini LLM Provider
+ *
+ * Provides streaming chat completion using Google's Gemini models
+ * via the OpenAI-compatible API endpoint.
+ * Supports gemini-2.0-flash, gemini-1.5-flash, gemini-1.5-pro, and others.
+ */
+export declare class GeminiProvider extends OpenAICompatibleProvider {
+    readonly name = "gemini";
+    private readonly apiKey;
+    constructor(config?: GeminiProviderConfig);
+    /**
+     * Gemini authentication with Bearer token
+     */
+    protected getAuthHeaders(): Record<string, string>;
+    /**
+     * Gemini's OpenAI-compatible endpoint path
+     */
+    protected getEndpointPath(): string;
+    /**
+     * Gemini uses standard body format (no provider-specific extensions needed)
+     */
+    protected buildProviderSpecificBody(_options?: ChatOptions): Record<string, unknown>;
+    /**
+     * Map HTTP errors with Gemini-specific messages
+     */
+    protected mapHttpError(status: number, body: string, _model: string): ProviderError;
+    /**
+     * Map connection errors with Gemini-specific messages
+     */
+    protected mapConnectionError(_error: Error): ProviderError;
+}
+/**
+ * Create a Gemini provider instance
+ *
+ * @example
+ * ```typescript
+ * // Using environment variable (GOOGLE_AI_API_KEY or GEMINI_API_KEY)
+ * const provider = createGeminiProvider();
+ *
+ * // With explicit API key
+ * const provider = createGeminiProvider({ apiKey: 'AI...' });
+ *
+ * // With custom model
+ * const provider = createGeminiProvider({ model: 'gemini-1.5-pro' });
+ *
+ * // Available models:
+ * // - gemini-2.0-flash (default, fast)
+ * // - gemini-1.5-flash (faster, cheaper)
+ * // - gemini-1.5-pro (more capable)
+ * ```
+ */
+export declare function createGeminiProvider(config?: GeminiProviderConfig): GeminiProvider;

package/dist/providers/gemini.js

@@ -0,0 +1,140 @@
+/**
+ * Google Gemini LLM Provider
+ *
+ * Implements LLMProvider interface for Google Gemini models using
+ * the OpenAI-compatible endpoint for maximum compatibility.
+ *
+ * @example
+ * ```typescript
+ * const provider = createGeminiProvider({
+ *   model: 'gemini-2.0-flash',
+ *   apiKey: process.env.GOOGLE_AI_API_KEY
+ * });
+ * ```
+ *
+ * @remarks
+ * - Requires valid Google AI API key
+ * - Uses OpenAI-compatible endpoint for streaming and tool calling
+ * - Default model is gemini-2.0-flash
+ * - Extended thinking is not supported (Claude-specific feature)
+ */
+import { ProviderError } from '../errors.js';
+import { OpenAICompatibleProvider } from './openai-compatible.js';
+// Default configuration
+const DEFAULT_MODEL = 'gemini-2.0-flash';
+const DEFAULT_BASE_URL = 'https://generativelanguage.googleapis.com/v1beta/openai';
+/**
+ * Google Gemini LLM Provider
+ *
+ * Provides streaming chat completion using Google's Gemini models
+ * via the OpenAI-compatible API endpoint.
+ * Supports gemini-2.0-flash, gemini-1.5-flash, gemini-1.5-pro, and others.
+ */
+export class GeminiProvider extends OpenAICompatibleProvider {
+    name = 'gemini';
+    apiKey;
+    constructor(config = {}) {
+        const apiKey = config.apiKey ??
+            process.env.GOOGLE_AI_API_KEY ??
+            process.env.GEMINI_API_KEY;
+        if (!apiKey) {
+            throw new ProviderError('Gemini API key not found. Set GOOGLE_AI_API_KEY or GEMINI_API_KEY environment variable, or pass apiKey in config.', 'gemini');
+        }
+        const baseConfig = {
+            baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+            model: config.model ?? DEFAULT_MODEL,
+            maxTokens: config.maxTokens,
+            timeout: config.timeout,
+        };
+        super(baseConfig);
+        this.apiKey = apiKey;
+    }
+    /**
+     * Gemini authentication with Bearer token
+     */
+    getAuthHeaders() {
+        return {
+            Authorization: `Bearer ${this.apiKey}`,
+        };
+    }
+    /**
+     * Gemini's OpenAI-compatible endpoint path
+     */
+    getEndpointPath() {
+        return '/chat/completions';
+    }
+    /**
+     * Gemini uses standard body format (no provider-specific extensions needed)
+     */
+    buildProviderSpecificBody(_options) {
+        return {};
+    }
+    /**
+     * Map HTTP errors with Gemini-specific messages
+     */
+    mapHttpError(status, body, _model) {
+        let message = `Gemini error (${String(status)})`;
+        try {
+            const parsed = JSON.parse(body);
+            // Gemini sometimes wraps errors in an array
+            if (Array.isArray(parsed)) {
+                const first = parsed[0];
+                if (first?.error?.message) {
+                    message = first.error.message;
+                }
+            }
+            else if (parsed.error?.message) {
+                message = parsed.error.message;
+            }
+        }
+        catch {
+            // If body isn't JSON, show it directly (truncated)
+            message = body ? body.slice(0, 500) : message;
+        }
+        switch (status) {
+            case 400:
+                return new ProviderError(`Invalid request to Gemini API: ${message}`, 'gemini', 400);
+            case 401:
+                return new ProviderError('Invalid Gemini API key. Check your GOOGLE_AI_API_KEY or GEMINI_API_KEY.', 'gemini', 401);
+            case 403:
+                return new ProviderError('Access denied to Gemini API. Check your API key permissions.', 'gemini', 403);
+            case 429:
+                return new ProviderError('Gemini rate limit exceeded. Please wait and try again.', 'gemini', 429);
+            case 500:
+            case 502:
+            case 503:
+                return new ProviderError('Gemini service temporarily unavailable. Please try again later.', 'gemini', status);
+            default:
+                return new ProviderError(message, 'gemini', status);
+        }
+    }
+    /**
+     * Map connection errors with Gemini-specific messages
+     */
+    mapConnectionError(_error) {
+        return new ProviderError('Failed to connect to Gemini API. Check your internet connection.', 'gemini');
+    }
+}
+/**
+ * Create a Gemini provider instance
+ *
+ * @example
+ * ```typescript
+ * // Using environment variable (GOOGLE_AI_API_KEY or GEMINI_API_KEY)
+ * const provider = createGeminiProvider();
+ *
+ * // With explicit API key
+ * const provider = createGeminiProvider({ apiKey: 'AI...' });
+ *
+ * // With custom model
+ * const provider = createGeminiProvider({ model: 'gemini-1.5-pro' });
+ *
+ * // Available models:
+ * // - gemini-2.0-flash (default, fast)
+ * // - gemini-1.5-flash (faster, cheaper)
+ * // - gemini-1.5-pro (more capable)
+ * ```
+ */
+export function createGeminiProvider(config = {}) {
+    return new GeminiProvider(config);
+}

package/dist/providers/index.d.ts

@@ -6,3 +6,11 @@ export { MockProvider, createMockProvider } from './mock.js';
 export type { MockProviderConfig, MockResponse, MockToolCall } from './mock.js';
 export { ClaudeProvider, createClaudeProvider } from './claude.js';
 export type { ClaudeProviderConfig } from './claude.js';
+export { OllamaProvider, createOllamaProvider } from './ollama.js';
+export type { OllamaProviderConfig } from './ollama.js';
+export { OpenAICompatibleProvider } from './openai-compatible.js';
+export type { OpenAICompatibleConfig, OpenAIMessage, OpenAIToolCall, OpenAITool, OpenAIStreamChunk, } from './openai-compatible.js';
+export { OpenAIProvider, createOpenAIProvider } from './openai.js';
+export type { OpenAIProviderConfig } from './openai.js';
+export { GeminiProvider, createGeminiProvider } from './gemini.js';
+export type { GeminiProviderConfig } from './gemini.js';

package/dist/providers/index.js

@@ -6,6 +6,10 @@ export * from './types.js';
 export { MockProvider, createMockProvider } from './mock.js';
 // Provider implementations
 export { ClaudeProvider, createClaudeProvider } from './claude.js';
-// Future providers
-// export { OpenAIProvider } from './openai.js';
-// export { GeminiProvider } from './gemini.js';
+export { OllamaProvider, createOllamaProvider } from './ollama.js';
+// Base class for OpenAI-compatible providers
+export { OpenAICompatibleProvider } from './openai-compatible.js';
+// OpenAI provider
+export { OpenAIProvider, createOpenAIProvider } from './openai.js';
+// Gemini provider
+export { GeminiProvider, createGeminiProvider } from './gemini.js';

package/dist/providers/ollama.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Ollama LLM Provider
+ *
+ * Implements LLMProvider interface for local Ollama models.
+ * Extends OpenAICompatibleProvider for shared functionality.
+ *
+ * @example
+ * ```typescript
+ * const provider = createOllamaProvider({
+ *   model: 'llama3.1',
+ *   baseUrl: 'http://localhost:11434'
+ * });
+ * ```
+ *
+ * @remarks
+ * - Requires Ollama to be running locally
+ * - Default model is llama3.1 (supports tool calling)
+ * - Extended thinking is not supported (Claude-specific feature)
+ */
+import type { ChatOptions } from './types.js';
+import { ProviderError } from '../errors.js';
+import { OpenAICompatibleProvider } from './openai-compatible.js';
+/**
+ * Configuration for OllamaProvider
+ */
+export interface OllamaProviderConfig {
+    /** Base URL for Ollama server (default: http://localhost:11434) */
+    baseUrl?: string;
+    /** Default model to use (default: llama3.1) */
+    model?: string;
+    /** Default max tokens (default: 4096) */
+    maxTokens?: number;
+    /** Request timeout in milliseconds (default: 120000) */
+    timeout?: number;
+    /** Keep alive duration for model in memory (default: '5m') */
+    keepAlive?: string;
+}
+/**
+ * Ollama LLM Provider
+ *
+ * Provides streaming chat completion using local Ollama models.
+ * Supports tool calling with compatible models (llama3.1, mistral, etc.)
+ */
+export declare class OllamaProvider extends OpenAICompatibleProvider {
+    readonly name = "ollama";
+    private readonly keepAlive;
+    constructor(config?: OllamaProviderConfig);
+    /**
+     * Ollama has no authentication by default
+     */
+    protected getAuthHeaders(): Record<string, string>;
+    /**
+     * Ollama's OpenAI-compatible endpoint
+     */
+    protected getEndpointPath(): string;
+    /**
+     * Add Ollama-specific request options
+     */
+    protected buildProviderSpecificBody(options?: ChatOptions): Record<string, unknown>;
+    /**
+     * Map HTTP errors with Ollama-specific messages
+     */
+    protected mapHttpError(status: number, body: string, model: string): ProviderError;
+    /**
+     * Map connection errors with Ollama-specific messages
+     */
+    protected mapConnectionError(_error: Error): ProviderError;
+}
+/**
+ * Create an Ollama provider instance
+ *
+ * @example
+ * ```typescript
+ * // Default configuration (llama3.1 on localhost:11434)
+ * const provider = createOllamaProvider();
+ *
+ * // Custom model
+ * const provider = createOllamaProvider({ model: 'mistral' });
+ *
+ * // Custom server
+ * const provider = createOllamaProvider({
+ *   baseUrl: 'http://192.168.1.100:11434',
+ *   model: 'llama3.1:70b'
+ * });
+ * ```
+ */
+export declare function createOllamaProvider(config?: OllamaProviderConfig): OllamaProvider;

package/dist/providers/ollama.js

@@ -0,0 +1,133 @@
+/**
+ * Ollama LLM Provider
+ *
+ * Implements LLMProvider interface for local Ollama models.
+ * Extends OpenAICompatibleProvider for shared functionality.
+ *
+ * @example
+ * ```typescript
+ * const provider = createOllamaProvider({
+ *   model: 'llama3.1',
+ *   baseUrl: 'http://localhost:11434'
+ * });
+ * ```
+ *
+ * @remarks
+ * - Requires Ollama to be running locally
+ * - Default model is llama3.1 (supports tool calling)
+ * - Extended thinking is not supported (Claude-specific feature)
+ */
+import { ProviderError } from '../errors.js';
+import { OpenAICompatibleProvider } from './openai-compatible.js';
+// Default configuration
+const DEFAULT_MODEL = 'llama3.1';
+const DEFAULT_BASE_URL = 'http://localhost:11434';
+/**
+ * Ollama LLM Provider
+ *
+ * Provides streaming chat completion using local Ollama models.
+ * Supports tool calling with compatible models (llama3.1, mistral, etc.)
+ */
+export class OllamaProvider extends OpenAICompatibleProvider {
+    name = 'ollama';
+    keepAlive;
+    constructor(config = {}) {
+        const baseConfig = {
+            baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+            model: config.model ?? DEFAULT_MODEL,
+            maxTokens: config.maxTokens,
+            timeout: config.timeout,
+        };
+        super(baseConfig);
+        this.keepAlive = config.keepAlive ?? '5m';
+    }
+    /**
+     * Ollama has no authentication by default
+     */
+    getAuthHeaders() {
+        return {};
+    }
+    /**
+     * Ollama's OpenAI-compatible endpoint
+     */
+    getEndpointPath() {
+        return '/v1/chat/completions';
+    }
+    /**
+     * Add Ollama-specific request options
+     */
+    buildProviderSpecificBody(options) {
+        const body = {
+            keep_alive: this.keepAlive,
+        };
+        // Ollama uses 'options' wrapper for model parameters
+        const modelOptions = {};
+        if (options?.maxTokens !== undefined) {
+            modelOptions.num_predict = options.maxTokens;
+        }
+        if (options?.temperature !== undefined) {
+            modelOptions.temperature = options.temperature;
+        }
+        if (Object.keys(modelOptions).length > 0) {
+            body.options = modelOptions;
+        }
+        return body;
+    }
+    /**
+     * Map HTTP errors with Ollama-specific messages
+     */
+    mapHttpError(status, body, model) {
+        let message = `Ollama error (${String(status)})`;
+        try {
+            const parsed = JSON.parse(body);
+            if (typeof parsed.error === 'string') {
+                message = parsed.error;
+            }
+            else if (parsed.error?.message) {
+                message = parsed.error.message;
+            }
+        }
+        catch {
+            message = body || message;
+        }
+        switch (status) {
+            case 404:
+                return new ProviderError(`Model "${model}" not found. Run: ollama pull ${model}`, 'ollama', 404);
+            case 429:
+                return new ProviderError('Rate limited', 'ollama', 429);
+            case 500:
+            case 502:
+            case 503:
+                return new ProviderError(message, 'ollama', status);
+            default:
+                return new ProviderError(message, 'ollama', status);
+        }
+    }
+    /**
+     * Map connection errors with Ollama-specific messages
+     */
+    mapConnectionError(_error) {
+        return new ProviderError(`Failed to connect to Ollama at ${this.baseUrl}. Is Ollama running? Try: ollama serve`, 'ollama');
+    }
+}
+/**
+ * Create an Ollama provider instance
+ *
+ * @example
+ * ```typescript
+ * // Default configuration (llama3.1 on localhost:11434)
+ * const provider = createOllamaProvider();
+ *
+ * // Custom model
+ * const provider = createOllamaProvider({ model: 'mistral' });
+ *
+ * // Custom server
+ * const provider = createOllamaProvider({
+ *   baseUrl: 'http://192.168.1.100:11434',
+ *   model: 'llama3.1:70b'
+ * });
+ * ```
+ */
+export function createOllamaProvider(config = {}) {
+    return new OllamaProvider(config);
+}