profclaw 0.0.1-beta.3 → 2.3.0

package/dist/plugins/search/serper.js

@@ -1,135 +0,0 @@
-/**
- * Serper Search Provider
- *
- * Fast and cost-effective Google Search API.
- * https://serper.dev/
- */
-const SERPER_API_URL = 'https://google.serper.dev/search';
-class SerperProvider {
-    metadata = SERPER_DEFINITION.metadata;
-    apiKey;
-    baseUrl;
-    constructor(config) {
-        this.apiKey = config.credentials?.apiKey || '';
-        this.baseUrl = config.credentials?.baseUrl || SERPER_API_URL;
-    }
-    async search(query, options) {
-        if (!this.apiKey) {
-            throw new Error('Serper API key not configured');
-        }
-        const startTime = Date.now();
-        const body = {
-            q: query,
-            num: options?.limit || 10,
-        };
-        if (options?.language)
-            body.hl = options.language;
-        if (options?.region)
-            body.gl = options.region;
-        const response = await fetch(this.baseUrl, {
-            method: 'POST',
-            headers: {
-                'X-API-KEY': this.apiKey,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(body),
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Serper API error: ${response.status} - ${error}`);
-        }
-        const data = await response.json();
-        const searchTime = Date.now() - startTime;
-        const results = (data.organic || []).map((item) => ({
-            title: item.title,
-            url: item.link,
-            snippet: item.snippet || '',
-            date: item.date,
-            source: 'serper',
-            metadata: {
-                position: item.position,
-                sitelinks: item.sitelinks,
-            },
-        }));
-        return {
-            results,
-            query,
-            totalResults: data.searchParameters?.totalResults,
-            searchTime,
-            provider: 'serper',
-        };
-    }
-    async isAvailable() {
-        return !!this.apiKey;
-    }
-    async healthCheck() {
-        if (!this.apiKey) {
-            return {
-                healthy: false,
-                lastCheck: new Date(),
-                errorMessage: 'API key not configured',
-            };
-        }
-        try {
-            const startTime = Date.now();
-            await this.search('test', { limit: 1 });
-            const latency = Date.now() - startTime;
-            return {
-                healthy: true,
-                lastCheck: new Date(),
-                latency,
-            };
-        }
-        catch (error) {
-            return {
-                healthy: false,
-                lastCheck: new Date(),
-                errorMessage: error instanceof Error ? error.message : 'Health check failed',
-            };
-        }
-    }
-}
-// Plugin Definition
-export const SERPER_DEFINITION = {
-    metadata: {
-        id: 'serper',
-        name: 'Serper',
-        description: 'Fast Google Search API - cost-effective at scale',
-        category: 'search',
-        icon: 'search',
-        version: '1.0.0',
-        homepage: 'https://serper.dev',
-        pricing: {
-            type: 'paid',
-            costPer1k: 1.0, // $1 per 1000 queries at starter tier
-            freeQuota: 100, // 100 free queries
-        },
-        rateLimit: {
-            requestsPerSecond: 300,
-        },
-    },
-    settingsSchema: {
-        credentials: [
-            {
-                key: 'apiKey',
-                type: 'password',
-                label: 'API Key',
-                description: 'Your Serper API key from serper.dev',
-                placeholder: 'Enter your Serper API key',
-                required: true,
-            },
-        ],
-        settings: [
-            {
-                key: 'defaultLimit',
-                type: 'number',
-                label: 'Default Results',
-                description: 'Default number of results to return',
-                default: 10,
-                validation: { min: 1, max: 100 },
-            },
-        ],
-    },
-    factory: (config) => new SerperProvider(config),
-};
-//# sourceMappingURL=serper.js.map

package/dist/plugins/search/tavily.d.ts

@@ -1,9 +0,0 @@
-/**
- * Tavily Search Provider
- *
- * AI-optimized search API with safety filtering.
- * https://tavily.com/
- */
-import type { SearchPluginDefinition } from '../types.js';
-export declare const TAVILY_DEFINITION: SearchPluginDefinition;
-//# sourceMappingURL=tavily.d.ts.map

package/dist/plugins/search/tavily.js

@@ -1,146 +0,0 @@
-/**
- * Tavily Search Provider
- *
- * AI-optimized search API with safety filtering.
- * https://tavily.com/
- */
-const TAVILY_API_URL = 'https://api.tavily.com/search';
-class TavilyProvider {
-    metadata = TAVILY_DEFINITION.metadata;
-    apiKey;
-    includeRawContent;
-    constructor(config) {
-        this.apiKey = config.credentials?.apiKey || '';
-        this.includeRawContent = config.settings?.includeRawContent || false;
-    }
-    async search(query, options) {
-        if (!this.apiKey) {
-            throw new Error('Tavily API key not configured');
-        }
-        const startTime = Date.now();
-        const body = {
-            api_key: this.apiKey,
-            query,
-            max_results: options?.limit || 10,
-            include_raw_content: this.includeRawContent,
-            include_images: options?.includeImages || false,
-        };
-        if (options?.includeDomains?.length) {
-            body.include_domains = options.includeDomains;
-        }
-        if (options?.excludeDomains?.length) {
-            body.exclude_domains = options.excludeDomains;
-        }
-        const response = await fetch(TAVILY_API_URL, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(body),
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Tavily API error: ${response.status} - ${error}`);
-        }
-        const data = await response.json();
-        const searchTime = Date.now() - startTime;
-        const results = (data.results || []).map((item) => ({
-            title: item.title,
-            url: item.url,
-            snippet: item.content || '',
-            source: 'tavily',
-            score: item.score,
-            metadata: {
-                rawContent: item.raw_content,
-            },
-        }));
-        return {
-            results,
-            query: data.query,
-            searchTime,
-            provider: 'tavily',
-        };
-    }
-    async isAvailable() {
-        return !!this.apiKey;
-    }
-    async healthCheck() {
-        if (!this.apiKey) {
-            return {
-                healthy: false,
-                lastCheck: new Date(),
-                errorMessage: 'API key not configured',
-            };
-        }
-        try {
-            const startTime = Date.now();
-            await this.search('test', { limit: 1 });
-            const latency = Date.now() - startTime;
-            return {
-                healthy: true,
-                lastCheck: new Date(),
-                latency,
-            };
-        }
-        catch (error) {
-            return {
-                healthy: false,
-                lastCheck: new Date(),
-                errorMessage: error instanceof Error ? error.message : 'Health check failed',
-            };
-        }
-    }
-}
-export const TAVILY_DEFINITION = {
-    metadata: {
-        id: 'tavily',
-        name: 'Tavily',
-        description: 'AI-optimized search with safety filtering - built for agents',
-        category: 'search',
-        icon: 'brain',
-        version: '1.0.0',
-        homepage: 'https://tavily.com',
-        pricing: {
-            type: 'credit-based',
-            costPer1k: 8.0, // ~$0.008 per credit, 1 credit per search
-            freeQuota: 1000,
-        },
-        rateLimit: {
-            requestsPerMinute: 60,
-        },
-    },
-    settingsSchema: {
-        credentials: [
-            {
-                key: 'apiKey',
-                type: 'password',
-                label: 'API Key',
-                description: 'Your Tavily API key',
-                placeholder: 'tvly-...',
-                required: true,
-            },
-        ],
-        settings: [
-            {
-                key: 'includeRawContent',
-                type: 'boolean',
-                label: 'Include Raw Content',
-                description: 'Include full page content in results (uses more credits)',
-                default: false,
-            },
-            {
-                key: 'searchDepth',
-                type: 'select',
-                label: 'Search Depth',
-                description: 'Basic is faster, Advanced is more thorough',
-                default: 'basic',
-                options: [
-                    { value: 'basic', label: 'Basic (1 credit)' },
-                    { value: 'advanced', label: 'Advanced (2 credits)' },
-                ],
-            },
-        ],
-    },
-    factory: (config) => new TavilyProvider(config),
-};
-//# sourceMappingURL=tavily.js.map

package/dist/providers/adapters/anthropic.d.ts

@@ -1,26 +0,0 @@
-/**
- * Anthropic Provider Adapter
- *
- * Claude models via Anthropic API.
- * Supports streaming, vision, and tool use.
- *
- * @see https://docs.anthropic.com/
- */
-import type { ChatCompletionRequest, ChatCompletionResponse, ModelDefinition, ProviderConfig, ProviderHealth, ProviderType } from '../types.js';
-import { BaseProvider } from './base.js';
-export declare class AnthropicProvider extends BaseProvider {
-    readonly type: ProviderType;
-    readonly name = "Anthropic";
-    private static readonly API_VERSION;
-    private static readonly BASE_URL;
-    protected createDefaultConfig(partial: Partial<ProviderConfig>): ProviderConfig;
-    protected getDefaultModels(): ModelDefinition[];
-    healthCheck(): Promise<ProviderHealth>;
-    protected doComplete(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
-    protected doCompleteStream(request: ChatCompletionRequest, onChunk: (chunk: string) => void): Promise<ChatCompletionResponse>;
-}
-/**
- * Create an Anthropic provider instance
- */
-export declare function createAnthropicProvider(config?: Partial<ProviderConfig>): AnthropicProvider;
-//# sourceMappingURL=anthropic.d.ts.map

package/dist/providers/adapters/anthropic.js

@@ -1,306 +0,0 @@
-/**
- * Anthropic Provider Adapter
- *
- * Claude models via Anthropic API.
- * Supports streaming, vision, and tool use.
- *
- * @see https://docs.anthropic.com/
- */
-import { randomUUID } from 'node:crypto';
-import { ANTHROPIC_MODELS } from '../types.js';
-import { BaseProvider } from './base.js';
-import { logger } from '../../utils/logger.js';
-export class AnthropicProvider extends BaseProvider {
-    type = 'anthropic';
-    name = 'Anthropic';
-    static API_VERSION = '2023-06-01';
-    static BASE_URL = 'https://api.anthropic.com/v1';
-    createDefaultConfig(partial) {
-        return {
-            id: 'anthropic',
-            type: 'anthropic',
-            name: 'Anthropic',
-            enabled: true,
-            baseUrl: partial.baseUrl || AnthropicProvider.BASE_URL,
-            apiKey: partial.apiKey || process.env.ANTHROPIC_API_KEY,
-            defaultModel: partial.defaultModel || 'claude-sonnet-4-5',
-            maxConcurrent: partial.maxConcurrent || 5,
-            timeout: partial.timeout || 300000,
-            models: ANTHROPIC_MODELS,
-            ...partial,
-        };
-    }
-    getDefaultModels() {
-        return ANTHROPIC_MODELS;
-    }
-    async healthCheck() {
-        const startTime = Date.now();
-        if (!this.config.apiKey) {
-            return {
-                provider: 'anthropic',
-                healthy: false,
-                latencyMs: Date.now() - startTime,
-                message: 'API key not configured',
-                lastChecked: new Date().toISOString(),
-            };
-        }
-        try {
-            // Anthropic doesn't have a dedicated health endpoint
-            // We'll do a minimal messages call with 1 max token
-            const response = await fetch(`${this.config.baseUrl}/messages`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'x-api-key': this.config.apiKey,
-                    'anthropic-version': AnthropicProvider.API_VERSION,
-                },
-                body: JSON.stringify({
-                    model: this.config.defaultModel || 'claude-sonnet-4-5',
-                    max_tokens: 1,
-                    messages: [{ role: 'user', content: 'Hi' }],
-                }),
-                signal: AbortSignal.timeout(10000),
-            });
-            const latencyMs = Date.now() - startTime;
-            if (!response.ok) {
-                const error = await response.json().catch(() => ({}));
-                return {
-                    provider: 'anthropic',
-                    healthy: false,
-                    latencyMs,
-                    message: error?.error?.message || `API returned ${response.status}`,
-                    lastChecked: new Date().toISOString(),
-                };
-            }
-            return {
-                provider: 'anthropic',
-                healthy: true,
-                latencyMs,
-                message: 'Anthropic API is available',
-                availableModels: ANTHROPIC_MODELS.map((m) => m.id),
-                lastChecked: new Date().toISOString(),
-            };
-        }
-        catch (error) {
-            return {
-                provider: 'anthropic',
-                healthy: false,
-                latencyMs: Date.now() - startTime,
-                message: error instanceof Error ? error.message : 'Connection failed',
-                lastChecked: new Date().toISOString(),
-            };
-        }
-    }
-    async doComplete(request) {
-        if (!this.config.apiKey) {
-            throw new Error('Anthropic API key not configured');
-        }
-        const startTime = Date.now();
-        const model = request.model || this.config.defaultModel || 'claude-sonnet-4-5';
-        // Build Anthropic messages format
-        const messages = [];
-        for (const msg of request.messages) {
-            if (msg.role === 'user' || msg.role === 'assistant') {
-                messages.push({
-                    role: msg.role,
-                    content: msg.content,
-                });
-            }
-        }
-        const requestBody = {
-            model,
-            max_tokens: request.maxTokens || 8192,
-            messages,
-        };
-        if (request.systemPrompt) {
-            requestBody.system = request.systemPrompt;
-        }
-        if (request.temperature !== undefined) {
-            requestBody.temperature = request.temperature;
-        }
-        // Add tools if provided
-        if (request.tools && request.tools.length > 0) {
-            requestBody.tools = request.tools.map((tool) => ({
-                name: tool.name,
-                description: tool.description,
-                input_schema: tool.parameters,
-            }));
-        }
-        logger.debug(`[Anthropic] Calling ${model} with ${messages.length} messages`);
-        const response = await fetch(`${this.config.baseUrl}/messages`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'x-api-key': this.config.apiKey,
-                'anthropic-version': AnthropicProvider.API_VERSION,
-            },
-            body: JSON.stringify(requestBody),
-            signal: AbortSignal.timeout(this.config.timeout),
-        });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({}));
-            throw new Error(`Anthropic API error: ${response.status} - ${error?.error?.message || 'Unknown error'}`);
-        }
-        const result = (await response.json());
-        const duration = Date.now() - startTime;
-        // Extract text content
-        const textContent = result.content
-            .filter((c) => c.type === 'text')
-            .map((c) => c.text)
-            .join('');
-        // Extract tool calls
-        const toolCalls = result.content
-            .filter((c) => c.type === 'tool_use')
-            .map((c) => ({
-            id: c.id || randomUUID(),
-            name: c.name || '',
-            arguments: c.input || {},
-        }));
-        const finishReason = result.stop_reason === 'end_turn'
-            ? 'stop'
-            : result.stop_reason === 'max_tokens'
-                ? 'length'
-                : result.stop_reason === 'tool_use'
-                    ? 'tool_calls'
-                    : 'stop';
-        return {
-            id: result.id,
-            provider: 'anthropic',
-            model: result.model,
-            message: this.createMessage('assistant', textContent),
-            finishReason: finishReason,
-            usage: {
-                promptTokens: result.usage.input_tokens,
-                completionTokens: result.usage.output_tokens,
-                totalTokens: result.usage.input_tokens + result.usage.output_tokens,
-                cost: this.calculateCost(result.usage.input_tokens, result.usage.output_tokens, model),
-            },
-            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-            duration,
-        };
-    }
-    async doCompleteStream(request, onChunk) {
-        if (!this.config.apiKey) {
-            throw new Error('Anthropic API key not configured');
-        }
-        const startTime = Date.now();
-        const model = request.model || this.config.defaultModel || 'claude-sonnet-4-5';
-        const messages = [];
-        for (const msg of request.messages) {
-            if (msg.role === 'user' || msg.role === 'assistant') {
-                messages.push({
-                    role: msg.role,
-                    content: msg.content,
-                });
-            }
-        }
-        const requestBody = {
-            model,
-            max_tokens: request.maxTokens || 8192,
-            messages,
-            stream: true,
-        };
-        if (request.systemPrompt) {
-            requestBody.system = request.systemPrompt;
-        }
-        if (request.temperature !== undefined) {
-            requestBody.temperature = request.temperature;
-        }
-        const response = await fetch(`${this.config.baseUrl}/messages`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'x-api-key': this.config.apiKey,
-                'anthropic-version': AnthropicProvider.API_VERSION,
-            },
-            body: JSON.stringify(requestBody),
-            signal: AbortSignal.timeout(this.config.timeout),
-        });
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({}));
-            throw new Error(`Anthropic API error: ${response.status} - ${error?.error?.message || 'Unknown error'}`);
-        }
-        // Process SSE stream
-        let fullContent = '';
-        let promptTokens = 0;
-        let completionTokens = 0;
-        let messageId = randomUUID();
-        let finishReason = 'stop';
-        const reader = response.body?.getReader();
-        if (!reader) {
-            throw new Error('No response body');
-        }
-        const decoder = new TextDecoder();
-        let buffer = '';
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split('\n');
-            buffer = lines.pop() || '';
-            for (const line of lines) {
-                if (line.startsWith('data: ')) {
-                    const data = line.slice(6);
-                    if (data === '[DONE]')
-                        continue;
-                    try {
-                        const event = JSON.parse(data);
-                        switch (event.type) {
-                            case 'message_start':
-                                if (event.message) {
-                                    messageId = event.message.id;
-                                    promptTokens = event.message.usage?.input_tokens || 0;
-                                }
-                                break;
-                            case 'content_block_delta':
-                                if (event.delta?.text) {
-                                    fullContent += event.delta.text;
-                                    onChunk(event.delta.text);
-                                }
-                                break;
-                            case 'message_delta':
-                                if (event.delta?.stop_reason) {
-                                    finishReason =
-                                        event.delta.stop_reason === 'end_turn'
-                                            ? 'stop'
-                                            : event.delta.stop_reason === 'max_tokens'
-                                                ? 'length'
-                                                : 'stop';
-                                }
-                                if (event.usage) {
-                                    completionTokens = event.usage.output_tokens;
-                                }
-                                break;
-                        }
-                    }
-                    catch {
-                        // Skip invalid JSON
-                    }
-                }
-            }
-        }
-        const duration = Date.now() - startTime;
-        return {
-            id: messageId,
-            provider: 'anthropic',
-            model,
-            message: this.createMessage('assistant', fullContent),
-            finishReason,
-            usage: {
-                promptTokens,
-                completionTokens,
-                totalTokens: promptTokens + completionTokens,
-                cost: this.calculateCost(promptTokens, completionTokens, model),
-            },
-            duration,
-        };
-    }
-}
-/**
- * Create an Anthropic provider instance
- */
-export function createAnthropicProvider(config) {
-    return new AnthropicProvider(config || {});
-}
-//# sourceMappingURL=anthropic.js.map

package/dist/providers/adapters/base.d.ts

@@ -1,53 +0,0 @@
-/**
- * Base Provider Adapter
- *
- * Abstract base class for AI provider implementations.
- * Handles common functionality like configuration and model management.
- */
-import type { AIProvider, ChatCompletionRequest, ChatCompletionResponse, ChatMessage, ModelDefinition, ProviderConfig, ProviderHealth, ProviderType } from '../types.js';
-export declare abstract class BaseProvider implements AIProvider {
-    abstract readonly type: ProviderType;
-    abstract readonly name: string;
-    protected config: ProviderConfig;
-    protected models: ModelDefinition[];
-    constructor(config: Partial<ProviderConfig>);
-    /**
-     * Create default configuration for this provider
-     */
-    protected abstract createDefaultConfig(partial: Partial<ProviderConfig>): ProviderConfig;
-    /**
-     * Get default models for this provider
-     */
-    protected abstract getDefaultModels(): ModelDefinition[];
-    /**
-     * Make the actual API call for completion
-     */
-    protected abstract doComplete(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
-    /**
-     * Make the actual API call for streaming completion
-     */
-    protected abstract doCompleteStream(request: ChatCompletionRequest, onChunk: (chunk: string) => void): Promise<ChatCompletionResponse>;
-    configure(config: Partial<ProviderConfig>): void;
-    getConfig(): ProviderConfig;
-    abstract healthCheck(): Promise<ProviderHealth>;
-    listModels(): Promise<ModelDefinition[]>;
-    getModel(modelId: string): ModelDefinition | undefined;
-    complete(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
-    completeStream(request: ChatCompletionRequest, onChunk: (chunk: string) => void): Promise<ChatCompletionResponse>;
-    /**
-     * Create a chat message
-     */
-    protected createMessage(role: ChatMessage['role'], content: string, options?: Partial<ChatMessage>): ChatMessage;
-    /**
-     * Convert messages to provider-specific format
-     */
-    protected formatMessages(messages: ChatMessage[], systemPrompt?: string): Array<{
-        role: string;
-        content: string;
-    }>;
-    /**
-     * Calculate cost from token usage
-     */
-    protected calculateCost(promptTokens: number, completionTokens: number, modelId?: string): number;
-}
-//# sourceMappingURL=base.d.ts.map