profclaw 0.0.1-beta.1

package/dist/providers/adapters/ollama.js

@@ -0,0 +1,292 @@
+/**
+ * Ollama Provider Adapter
+ *
+ * Local LLM inference via Ollama.
+ * Supports model auto-discovery and streaming.
+ *
+ * @see https://ollama.ai/
+ */
+import { randomUUID } from 'node:crypto';
+import { BaseProvider } from './base.js';
+import { logger } from '../../utils/logger.js';
+export class OllamaProvider extends BaseProvider {
+    type = 'ollama';
+    name = 'Ollama';
+    discoveredModels = [];
+    createDefaultConfig(partial) {
+        return {
+            id: 'ollama',
+            type: 'ollama',
+            name: 'Ollama',
+            enabled: true,
+            baseUrl: partial.baseUrl || process.env.OLLAMA_BASE_URL || 'http://localhost:11434',
+            defaultModel: partial.defaultModel || process.env.OLLAMA_MODEL || 'llama3.2',
+            maxConcurrent: partial.maxConcurrent || 3,
+            timeout: partial.timeout || 300000,
+            models: [],
+            ...partial,
+        };
+    }
+    getDefaultModels() {
+        // Default models that are commonly available
+        return [
+            {
+                id: 'llama3.2',
+                name: 'Llama 3.2',
+                provider: 'ollama',
+                capabilities: ['text', 'code'],
+                contextWindow: 128000,
+                maxOutputTokens: 8192,
+                supportsStreaming: true,
+                supportsVision: false,
+                cost: { inputPerMillion: 0, outputPerMillion: 0 },
+                isDefault: true,
+            },
+            {
+                id: 'deepseek-r1:7b',
+                name: 'DeepSeek R1 7B',
+                provider: 'ollama',
+                capabilities: ['text', 'code', 'reasoning'],
+                contextWindow: 128000,
+                maxOutputTokens: 8192,
+                supportsStreaming: true,
+                supportsVision: false,
+                cost: { inputPerMillion: 0, outputPerMillion: 0 },
+                isDefault: false,
+            },
+            {
+                id: 'qwen2.5:14b',
+                name: 'Qwen 2.5 14B',
+                provider: 'ollama',
+                capabilities: ['text', 'code'],
+                contextWindow: 128000,
+                maxOutputTokens: 8192,
+                supportsStreaming: true,
+                supportsVision: false,
+                cost: { inputPerMillion: 0, outputPerMillion: 0 },
+                isDefault: false,
+            },
+        ];
+    }
+    /**
+     * Discover models from local Ollama instance
+     */
+    async discoverModels() {
+        try {
+            const response = await fetch(`${this.config.baseUrl}/api/tags`, {
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!response.ok) {
+                logger.warn(`[Ollama] Failed to discover models: ${response.status}`);
+                return [];
+            }
+            const data = (await response.json());
+            if (!data.models || data.models.length === 0) {
+                return [];
+            }
+            this.discoveredModels = data.models.map((model) => {
+                const modelId = model.name;
+                const isReasoning = modelId.toLowerCase().includes('r1') ||
+                    modelId.toLowerCase().includes('reasoning') ||
+                    modelId.toLowerCase().includes('deepseek');
+                const isVision = modelId.toLowerCase().includes('vision') ||
+                    modelId.toLowerCase().includes('llava');
+                return {
+                    id: modelId,
+                    name: model.details?.family
+                        ? `${model.details.family} ${model.details.parameter_size || ''}`
+                        : modelId,
+                    provider: 'ollama',
+                    capabilities: isReasoning
+                        ? ['text', 'code', 'reasoning']
+                        : isVision
+                            ? ['text', 'vision']
+                            : ['text', 'code'],
+                    contextWindow: 128000,
+                    maxOutputTokens: 8192,
+                    supportsStreaming: true,
+                    supportsVision: isVision,
+                    cost: { inputPerMillion: 0, outputPerMillion: 0 }, // Free!
+                    isDefault: false,
+                };
+            });
+            logger.info(`[Ollama] Discovered ${this.discoveredModels.length} models`);
+            return this.discoveredModels;
+        }
+        catch (error) {
+            logger.warn(`[Ollama] Model discovery failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return [];
+        }
+    }
+    async listModels() {
+        // Try to discover models first
+        const discovered = await this.discoverModels();
+        if (discovered.length > 0) {
+            this.models = discovered;
+            return this.models;
+        }
+        // Fall back to defaults
+        this.models = this.getDefaultModels();
+        return this.models;
+    }
+    async healthCheck() {
+        const startTime = Date.now();
+        try {
+            const response = await fetch(`${this.config.baseUrl}/api/tags`, {
+                signal: AbortSignal.timeout(5000),
+            });
+            const latencyMs = Date.now() - startTime;
+            if (!response.ok) {
+                return {
+                    provider: 'ollama',
+                    healthy: false,
+                    latencyMs,
+                    message: `Ollama API returned ${response.status}`,
+                    lastChecked: new Date().toISOString(),
+                };
+            }
+            const data = (await response.json());
+            const modelNames = data.models?.map((m) => m.name) || [];
+            // Check if default model is available
+            const defaultModel = this.config.defaultModel || 'llama3.2';
+            const modelAvailable = modelNames.some((name) => name === defaultModel || name.startsWith(`${defaultModel}:`));
+            return {
+                provider: 'ollama',
+                healthy: true,
+                latencyMs,
+                message: modelAvailable
+                    ? `Ollama running with ${modelNames.length} models`
+                    : `Model '${defaultModel}' not found`,
+                availableModels: modelNames,
+                lastChecked: new Date().toISOString(),
+            };
+        }
+        catch (error) {
+            return {
+                provider: 'ollama',
+                healthy: false,
+                latencyMs: Date.now() - startTime,
+                message: error instanceof Error ? error.message : 'Connection failed',
+                lastChecked: new Date().toISOString(),
+            };
+        }
+    }
+    async doComplete(request) {
+        const startTime = Date.now();
+        const model = request.model || this.config.defaultModel || 'llama3.2';
+        const messages = this.formatMessages(request.messages, request.systemPrompt);
+        const response = await fetch(`${this.config.baseUrl}/api/chat`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model,
+                messages,
+                stream: false,
+                options: {
+                    temperature: request.temperature || 0.7,
+                    num_predict: request.maxTokens || 4096,
+                },
+            }),
+            signal: AbortSignal.timeout(this.config.timeout),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Ollama API error: ${response.status} - ${errorText}`);
+        }
+        const result = (await response.json());
+        const duration = Date.now() - startTime;
+        const promptTokens = result.prompt_eval_count || 0;
+        const completionTokens = result.eval_count || 0;
+        return {
+            id: randomUUID(),
+            provider: 'ollama',
+            model,
+            message: this.createMessage('assistant', result.message?.content || ''),
+            finishReason: 'stop',
+            usage: {
+                promptTokens,
+                completionTokens,
+                totalTokens: promptTokens + completionTokens,
+                cost: 0, // Free!
+            },
+            duration,
+        };
+    }
+    async doCompleteStream(request, onChunk) {
+        const startTime = Date.now();
+        const model = request.model || this.config.defaultModel || 'llama3.2';
+        const messages = this.formatMessages(request.messages, request.systemPrompt);
+        const response = await fetch(`${this.config.baseUrl}/api/chat`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model,
+                messages,
+                stream: true,
+                options: {
+                    temperature: request.temperature || 0.7,
+                    num_predict: request.maxTokens || 4096,
+                },
+            }),
+            signal: AbortSignal.timeout(this.config.timeout),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Ollama API error: ${response.status} - ${errorText}`);
+        }
+        // Process streaming response
+        let fullContent = '';
+        let promptTokens = 0;
+        let completionTokens = 0;
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new Error('No response body');
+        }
+        const decoder = new TextDecoder();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            const chunk = decoder.decode(value, { stream: true });
+            const lines = chunk.split('\n').filter((line) => line.trim());
+            for (const line of lines) {
+                try {
+                    const data = JSON.parse(line);
+                    if (data.message?.content) {
+                        fullContent += data.message.content;
+                        onChunk(data.message.content);
+                    }
+                    if (data.done) {
+                        promptTokens = data.prompt_eval_count || 0;
+                        completionTokens = data.eval_count || 0;
+                    }
+                }
+                catch {
+                    // Skip invalid JSON
+                }
+            }
+        }
+        const duration = Date.now() - startTime;
+        return {
+            id: randomUUID(),
+            provider: 'ollama',
+            model,
+            message: this.createMessage('assistant', fullContent),
+            finishReason: 'stop',
+            usage: {
+                promptTokens,
+                completionTokens,
+                totalTokens: promptTokens + completionTokens,
+                cost: 0,
+            },
+            duration,
+        };
+    }
+}
+/**
+ * Create an Ollama provider instance
+ */
+export function createOllamaProvider(config) {
+    return new OllamaProvider(config || {});
+}
+//# sourceMappingURL=ollama.js.map

package/dist/providers/ai-sdk.d.ts

@@ -0,0 +1,178 @@
+/**
+ * profClaw AI Provider System
+ *
+ * Built on Vercel AI SDK for production-ready multi-provider support.
+ * Supports: Anthropic, OpenAI, Google, Ollama, and more.
+ *
+ * @see https://sdk.vercel.ai/docs
+ */
+import { type LanguageModel } from 'ai';
+import { z } from 'zod';
+import { ProviderType, PROVIDER_STATUS, type ProviderConfig, type ProviderStatus, type ModelInfo, type ChatMessage, type ChatRequest, type ChatResponse } from './core/types.js';
+import { MODEL_ALIASES, MODEL_CATALOG } from './core/models.js';
+export { ProviderType, PROVIDER_STATUS, MODEL_ALIASES, MODEL_CATALOG, };
+export type { ProviderConfig, ProviderStatus, ModelInfo, ChatMessage, ChatRequest, ChatResponse, };
+declare class AIProviderManager {
+    private providers;
+    private configs;
+    private defaultProvider;
+    constructor();
+    private initFromEnv;
+    configure(type: ProviderType, config: ProviderConfig): void;
+    /** Map hyphenated provider types to camelCase keys for the providers record */
+    private providerKey;
+    /**
+     * Lazily import and instantiate the SDK for a provider on first use.
+     * Each SDK is ~15MB; this avoids loading all of them at startup.
+     */
+    private ensureProvider;
+    setDefaultProvider(type: ProviderType): void;
+    getDefaultProvider(): ProviderType;
+    /**
+     * Auto-select the best configured provider as default.
+     * Prioritizes cloud providers (that support tools) over Ollama.
+     */
+    autoSelectDefaultProvider(): void;
+    isConfigured(type: ProviderType): boolean;
+    getConfiguredProviders(): ProviderType[];
+    /**
+     * Load saved provider configurations from storage
+     * Call this after storage is initialized
+     */
+    loadSavedConfigs(loader: () => Promise<Array<{
+        type: string;
+        apiKey?: string;
+        baseUrl?: string;
+        resourceName?: string;
+        deploymentName?: string;
+        apiVersion?: string;
+        defaultModel?: string;
+        enabled?: boolean;
+    }>>): Promise<number>;
+    resolveModel(modelOrAlias: string): {
+        provider: ProviderType;
+        model: string;
+    };
+    getModel(provider: ProviderType, modelId: string): Promise<LanguageModel>;
+    getModelInfo(modelId: string): ModelInfo | undefined;
+    getModelsForProvider(provider: ProviderType): ModelInfo[];
+    getAllModels(): ModelInfo[];
+    chat(request: ChatRequest): Promise<ChatResponse>;
+    private static readonly CHUNK_BATCH_SIZE;
+    private static readonly CHUNK_BATCH_TIME_MS;
+    chatStream(request: ChatRequest, onChunk: (chunk: string) => void): Promise<ChatResponse>;
+    /**
+     * Chat with tool calling support
+     * Handles tool detection and execution manually for better control
+     */
+    chatWithTools(request: ChatWithToolsRequest): Promise<ChatWithToolsResponse>;
+    /**
+     * Check if a model supports native tool calling
+     */
+    modelSupportsTools(modelOrAlias?: string): {
+        supported: boolean;
+        model: string;
+        provider: ProviderType;
+        recommendation?: string;
+    };
+    /**
+     * Chat with native tool calling using Vercel AI SDK
+     * This uses the native tool() function for proper multi-step execution
+     *
+     * NOTE: If the model doesn't support native tool calling, tools will be
+     * skipped and a warning will be included in the response.
+     */
+    chatWithNativeTools(request: ChatWithNativeToolsRequest): Promise<ChatWithNativeToolsResponse>;
+    /**
+     * Stream chat with native tool calling
+     */
+    streamWithNativeTools(request: ChatWithNativeToolsRequest, onChunk: (chunk: string) => void, onToolCall?: (toolName: string, args: unknown) => void, onToolResult?: (toolName: string, result: unknown) => void): Promise<ChatWithNativeToolsResponse>;
+    healthCheck(provider?: ProviderType): Promise<{
+        provider: ProviderType;
+        healthy: boolean;
+        message: string;
+        latencyMs?: number;
+    }[]>;
+}
+export declare const aiProvider: AIProviderManager;
+/**
+ * Quick chat function
+ */
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: z.ZodType<unknown>;
+}
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface ChatWithToolsResponse extends ChatResponse {
+    toolCalls?: ToolCall[];
+    toolResults?: Array<{
+        toolCallId: string;
+        toolName: string;
+        result: unknown;
+    }>;
+}
+export interface ChatWithToolsRequest extends ChatRequest {
+    tools?: ToolDefinition[];
+    executeTools?: (toolName: string, args: unknown) => Promise<unknown>;
+    maxToolRoundtrips?: number;
+}
+export interface NativeToolDefinition {
+    name: string;
+    description: string;
+    parameters: z.ZodType<unknown>;
+}
+export interface NativeToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface NativeToolResult {
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    approvalRequired?: boolean;
+    approvalId?: string;
+}
+export interface ToolExecutionResult {
+    result: unknown;
+    /** Human-readable markdown output for UI display (not sent to AI model) */
+    output?: string;
+    approvalRequired?: boolean;
+    approvalId?: string;
+}
+export interface ChatWithNativeToolsRequest extends ChatRequest {
+    tools?: NativeToolDefinition[];
+    onToolCall?: (toolName: string, args: unknown, toolCallId: string) => Promise<ToolExecutionResult>;
+    maxToolRoundtrips?: number;
+}
+export interface ChatWithNativeToolsResponse extends ChatResponse {
+    toolCalls?: NativeToolCall[];
+    toolResults?: NativeToolResult[];
+    pendingApprovals?: NativeToolResult[];
+    steps?: number;
+    toolSupport?: {
+        requested: boolean;
+        supported: boolean;
+        used: boolean;
+        recommendation?: string;
+    };
+}
+export declare function chat(prompt: string, options?: {
+    model?: string;
+    systemPrompt?: string;
+    temperature?: number;
+}): Promise<string>;
+/**
+ * Stream chat function
+ */
+export declare function chatStream(prompt: string, onChunk: (chunk: string) => void, options?: {
+    model?: string;
+    systemPrompt?: string;
+    temperature?: number;
+}): Promise<string>;
+//# sourceMappingURL=ai-sdk.d.ts.map