@krr2020/taskflow-core 0.1.0-beta.3 → 0.1.0-beta.5

package/dist/llm/factory.js

@@ -0,0 +1,102 @@
+/**
+ * LLM Provider Factory
+ * Factory for creating LLM providers and model selectors
+ */
+import { LLMProviderType, } from "./base.js";
+import { ModelSelector } from "./model-selector.js";
+import { AnthropicProvider } from "./providers/anthropic.js";
+import { OllamaProvider } from "./providers/ollama.js";
+import { OpenAICompatibleProvider } from "./providers/openai-compatible.js";
+export { LLMProvider, LLMProviderType } from "./base.js";
+export { ModelSelector } from "./model-selector.js";
+export { AnthropicProvider, OllamaProvider, OpenAICompatibleProvider, } from "./providers/index.js";
+/**
+ * Provider factory namespace
+ * Functions for creating LLM providers and model selectors
+ */
+export const ProviderFactory = {
+    /**
+     * Create a model selector from configuration
+     */
+    createSelector(config) {
+        return new ModelSelector(config);
+    },
+    /**
+     * Create a single provider (backward compatible)
+     */
+    createProvider(type, model, apiKey, baseUrl) {
+        switch (type) {
+            case LLMProviderType.OpenAICompatible: {
+                const config = { model };
+                if (apiKey)
+                    config.apiKey = apiKey;
+                if (baseUrl)
+                    config.baseUrl = baseUrl;
+                return OpenAICompatibleProvider.fromEnv(config);
+            }
+            case LLMProviderType.Anthropic: {
+                const config = { model };
+                if (apiKey)
+                    config.apiKey = apiKey;
+                return AnthropicProvider.fromEnv(config);
+            }
+            case LLMProviderType.Ollama: {
+                const config = { model };
+                if (baseUrl)
+                    config.baseUrl = baseUrl;
+                return OllamaProvider.fromEnv(config);
+            }
+            default:
+                throw new Error(`Unknown provider type: ${type}`);
+        }
+    },
+    /**
+     * Test if a provider is configured and working
+     */
+    async testProvider(provider) {
+        try {
+            if (!provider.isConfigured()) {
+                return { success: false, error: "Provider not configured" };
+            }
+            // Simple test request
+            await provider.generate([
+                {
+                    role: "user",
+                    content: "Hello, please respond with just 'OK'.",
+                },
+            ], { maxTokens: 10 });
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    },
+    /**
+     * Get available providers
+     */
+    getAvailableProviders() {
+        return [
+            LLMProviderType.OpenAICompatible,
+            LLMProviderType.Anthropic,
+            LLMProviderType.Ollama,
+        ];
+    },
+    /**
+     * Get default model for provider
+     */
+    getDefaultModel(providerType) {
+        switch (providerType) {
+            case LLMProviderType.OpenAICompatible:
+                return "gpt-4o-mini";
+            case LLMProviderType.Anthropic:
+                return "claude-3-5-sonnet-20241022";
+            case LLMProviderType.Ollama:
+                return "llama2";
+            default:
+                throw new Error(`Unknown provider type: ${providerType}`);
+        }
+    },
+};

package/dist/llm/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * LLM package exports
+ */
+export * from "./base.js";
+export * from "./factory.js";
+export * from "./model-selector.js";
+export * from "./providers/index.js";

package/dist/llm/index.js

@@ -0,0 +1,7 @@
+/**
+ * LLM package exports
+ */
+export * from "./base.js";
+export * from "./factory.js";
+export * from "./model-selector.js";
+export * from "./providers/index.js";

package/dist/llm/model-selector.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Model Selector
+ * Selects the appropriate model for each phase (planning, execution, analysis)
+ */
+import { type LLMProvider, LLMProviderType, Phase } from "./base.js";
+export interface ModelSelection {
+    planning: LLMProvider;
+    execution: LLMProvider;
+    analysis: LLMProvider;
+}
+export interface AIConfig {
+    enabled: boolean;
+    provider: LLMProviderType;
+    apiKey?: string;
+    models: {
+        default: string;
+        planning?: string;
+        execution?: string;
+        analysis?: string;
+    };
+    planningProvider?: LLMProviderType;
+    planningApiKey?: string;
+    executionProvider?: LLMProviderType;
+    executionApiKey?: string;
+    analysisProvider?: LLMProviderType;
+    analysisApiKey?: string;
+    ollamaBaseUrl?: string;
+    openaiBaseUrl?: string;
+}
+/**
+ * Model Selector class
+ * Manages per-phase model selection and provider instantiation
+ */
+export declare class ModelSelector {
+    private selection;
+    private modelNames;
+    constructor(config: AIConfig);
+    /**
+     * Get the provider for a specific phase
+     */
+    getProvider(phase: Phase): LLMProvider;
+    /**
+     * Get the model name for a specific phase
+     */
+    getModelName(phase: Phase): string;
+    /**
+     * Check if any provider is configured
+     */
+    isConfigured(): boolean;
+    /**
+     * Create provider from configuration
+     */
+    private createProvider;
+    /**
+     * Create model selection from configuration
+     */
+    private createSelection;
+    /**
+     * Get base URL for provider
+     */
+    private getBaseUrlForProvider;
+    /**
+     * Create ModelSelector from minimal config (backward compatible)
+     */
+    static fromSimpleConfig(config: {
+        enabled: boolean;
+        provider: LLMProviderType;
+        apiKey?: string;
+        model?: string;
+    }): ModelSelector;
+}

package/dist/llm/model-selector.js

@@ -0,0 +1,139 @@
+/**
+ * Model Selector
+ * Selects the appropriate model for each phase (planning, execution, analysis)
+ */
+import { LLMProviderType, Phase } from "./base.js";
+import { AnthropicProvider } from "./providers/anthropic.js";
+import { OllamaProvider } from "./providers/ollama.js";
+import { OpenAICompatibleProvider } from "./providers/openai-compatible.js";
+/**
+ * Model Selector class
+ * Manages per-phase model selection and provider instantiation
+ */
+export class ModelSelector {
+    selection;
+    modelNames;
+    constructor(config) {
+        this.selection = this.createSelection(config);
+        this.modelNames = {
+            planning: config.models.planning || config.models.default,
+            execution: config.models.execution || config.models.default,
+            analysis: config.models.analysis || config.models.default,
+        };
+    }
+    /**
+     * Get the provider for a specific phase
+     */
+    getProvider(phase) {
+        switch (phase) {
+            case Phase.Planning:
+                return this.selection.planning;
+            case Phase.Execution:
+                return this.selection.execution;
+            case Phase.Analysis:
+                return this.selection.analysis;
+            default:
+                return this.selection.planning;
+        }
+    }
+    /**
+     * Get the model name for a specific phase
+     */
+    getModelName(phase) {
+        switch (phase) {
+            case Phase.Planning:
+                return this.modelNames.planning;
+            case Phase.Execution:
+                return this.modelNames.execution;
+            case Phase.Analysis:
+                return this.modelNames.analysis;
+            default:
+                return this.modelNames.planning;
+        }
+    }
+    /**
+     * Check if any provider is configured
+     */
+    isConfigured() {
+        return (this.selection.planning.isConfigured() ||
+            this.selection.execution.isConfigured() ||
+            this.selection.analysis.isConfigured());
+    }
+    /**
+     * Create provider from configuration
+     */
+    createProvider(providerType, model, apiKey, baseUrl) {
+        switch (providerType) {
+            case LLMProviderType.OpenAICompatible: {
+                const config = { model };
+                if (apiKey)
+                    config.apiKey = apiKey;
+                if (baseUrl)
+                    config.baseUrl = baseUrl;
+                return OpenAICompatibleProvider.fromEnv(config);
+            }
+            case LLMProviderType.Anthropic: {
+                const config = { model };
+                if (apiKey)
+                    config.apiKey = apiKey;
+                return AnthropicProvider.fromEnv(config);
+            }
+            case LLMProviderType.Ollama: {
+                const config = { model };
+                if (baseUrl)
+                    config.baseUrl = baseUrl;
+                return OllamaProvider.fromEnv(config);
+            }
+            default:
+                throw new Error(`Unknown provider type: ${providerType}`);
+        }
+    }
+    /**
+     * Create model selection from configuration
+     */
+    createSelection(config) {
+        const defaultProvider = this.createProvider(config.provider, config.models.default, config.apiKey, this.getBaseUrlForProvider(config, config.provider));
+        // Planning provider
+        const planningProvider = config.planningProvider
+            ? this.createProvider(config.planningProvider, config.models.planning || config.models.default, config.planningApiKey, this.getBaseUrlForProvider(config, config.planningProvider))
+            : defaultProvider;
+        // Execution provider
+        const executionProvider = config.executionProvider
+            ? this.createProvider(config.executionProvider, config.models.execution || config.models.default, config.executionApiKey, this.getBaseUrlForProvider(config, config.executionProvider))
+            : defaultProvider;
+        // Analysis provider
+        const analysisProvider = config.analysisProvider
+            ? this.createProvider(config.analysisProvider, config.models.analysis || config.models.default, config.analysisApiKey, this.getBaseUrlForProvider(config, config.analysisProvider))
+            : defaultProvider;
+        return {
+            planning: planningProvider,
+            execution: executionProvider,
+            analysis: analysisProvider,
+        };
+    }
+    /**
+     * Get base URL for provider
+     */
+    getBaseUrlForProvider(config, providerType) {
+        if (providerType === LLMProviderType.Ollama) {
+            return config.ollamaBaseUrl;
+        }
+        if (providerType === LLMProviderType.OpenAICompatible) {
+            return config.openaiBaseUrl;
+        }
+        return undefined;
+    }
+    /**
+     * Create ModelSelector from minimal config (backward compatible)
+     */
+    static fromSimpleConfig(config) {
+        return new ModelSelector({
+            enabled: config.enabled,
+            provider: config.provider,
+            apiKey: config.apiKey ?? "",
+            models: {
+                default: config.model || "gpt-4o-mini",
+            },
+        });
+    }
+}

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

@@ -0,0 +1,31 @@
+/**
+ * Anthropic Claude LLM Provider
+ * Supports Claude models via Anthropic API
+ */
+import { type LLMGenerationOptions, type LLMGenerationResult, type LLMMessage, LLMProvider } from "../base.js";
+export interface AnthropicConfig {
+    apiKey: string;
+    model: string;
+    maxTokens?: number;
+}
+export declare class AnthropicProvider extends LLMProvider {
+    private config;
+    private readonly DEFAULT_MAX_TOKENS;
+    constructor(config: AnthropicConfig);
+    /**
+     * Generate text using Anthropic Claude API
+     */
+    generate(messages: LLMMessage[], options?: LLMGenerationOptions): Promise<LLMGenerationResult>;
+    /**
+     * Check if provider is configured
+     */
+    isConfigured(): boolean;
+    /**
+     * Create provider from environment variables
+     */
+    static fromEnv(config: {
+        apiKey?: string;
+        model?: string;
+        maxTokens?: number;
+    }): AnthropicProvider;
+}

package/dist/llm/providers/anthropic.js

@@ -0,0 +1,116 @@
+/**
+ * Anthropic Claude LLM Provider
+ * Supports Claude models via Anthropic API
+ */
+import { LLMProvider, LLMProviderType, } from "../base.js";
+export class AnthropicProvider extends LLMProvider {
+    config;
+    DEFAULT_MAX_TOKENS = 4096;
+    constructor(config) {
+        super(LLMProviderType.Anthropic, config.model);
+        this.config = config;
+        this.config.maxTokens = config.maxTokens || this.DEFAULT_MAX_TOKENS;
+    }
+    /**
+     * Generate text using Anthropic Claude API
+     */
+    async generate(messages, options) {
+        if (!this.isConfigured()) {
+            throw new Error("Anthropic provider is not configured properly");
+        }
+        // Extract system message (Anthropic separates system message)
+        let systemMessage = "";
+        const apiMessages = [];
+        for (const msg of messages) {
+            if (msg.role === "system") {
+                systemMessage = msg.content;
+            }
+            else {
+                apiMessages.push(msg);
+            }
+        }
+        const requestBody = {
+            model: this.config.model,
+            messages: apiMessages,
+            max_tokens: options?.maxTokens || this.config.maxTokens,
+            stream: false,
+        };
+        if (systemMessage) {
+            requestBody.system = systemMessage;
+        }
+        if (options?.temperature !== undefined) {
+            requestBody.temperature = options.temperature;
+        }
+        if (options?.topP !== undefined) {
+            requestBody.top_p = options.topP;
+        }
+        if (options?.topK !== undefined) {
+            requestBody.top_k = options.topK;
+        }
+        const response = await fetch("https://api.anthropic.com/v1/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": this.config.apiKey,
+                "anthropic-version": "2023-06-01",
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Anthropic API error: ${response.status} - ${error}`);
+        }
+        const data = (await response.json());
+        const contentItem = data.content[0];
+        if (!contentItem) {
+            throw new Error("No content returned from Anthropic API");
+        }
+        return {
+            content: contentItem.text,
+            model: data.model,
+            tokensUsed: (data.usage?.input_tokens ?? 0) + (data.usage?.output_tokens ?? 0),
+            finishReason: data.stop_reason,
+        };
+    }
+    /**
+     * Check if provider is configured
+     */
+    isConfigured() {
+        return !!this.config.apiKey;
+    }
+    /**
+     * Create provider from environment variables
+     */
+    static fromEnv(config) {
+        const apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY || "";
+        const model = config.model ||
+            process.env.ANTHROPIC_MODEL ||
+            "claude-3-5-sonnet-20241022";
+        const maxTokensValue = config.maxTokens ||
+            Number.parseInt(process.env.ANTHROPIC_MAX_TOKENS || "4096", 10);
+        if (!apiKey) {
+            console.warn("Warning: Anthropic provider missing API key");
+        }
+        const maxTokens = Number.isNaN(maxTokensValue) ? undefined : maxTokensValue;
+        return new AnthropicProvider({
+            apiKey: expandEnvVar(apiKey),
+            model,
+            maxTokens: maxTokens ?? 4096,
+        });
+    }
+}
+/**
+ * Expand environment variable in string (e.g., "${VAR_NAME}" -> actual value)
+ */
+function expandEnvVar(value) {
+    if (!value) {
+        return value;
+    }
+    const envVarMatch = value.match(/^\$\{([^}]+)\}$/);
+    if (envVarMatch?.[1]) {
+        const envVar = envVarMatch[1];
+        const envValue = process.env[envVar];
+        return envValue ?? value;
+    }
+    return value;
+}

package/dist/llm/providers/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Provider exports
+ */
+export { type AnthropicConfig, AnthropicProvider } from "./anthropic.js";
+export { type OllamaConfig, OllamaProvider } from "./ollama.js";
+export { type OpenAICompatibleConfig, OpenAICompatibleProvider, } from "./openai-compatible.js";

package/dist/llm/providers/index.js

@@ -0,0 +1,6 @@
+/**
+ * Provider exports
+ */
+export { AnthropicProvider } from "./anthropic.js";
+export { OllamaProvider } from "./ollama.js";
+export { OpenAICompatibleProvider, } from "./openai-compatible.js";

package/dist/llm/providers/ollama.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Ollama LLM Provider
+ * Supports local LLM models via Ollama API
+ */
+import { type LLMGenerationOptions, type LLMGenerationResult, type LLMMessage, LLMProvider } from "../base.js";
+export interface OllamaConfig {
+    baseUrl: string;
+    model: string;
+}
+export declare class OllamaProvider extends LLMProvider {
+    private config;
+    constructor(config: OllamaConfig);
+    /**
+     * Generate text using Ollama API
+     */
+    generate(messages: LLMMessage[], options?: LLMGenerationOptions): Promise<LLMGenerationResult>;
+    /**
+     * Check if provider is configured
+     */
+    isConfigured(): boolean;
+    /**
+     * Create provider from environment variables
+     */
+    static fromEnv(config: {
+        baseUrl?: string;
+        model?: string;
+    }): OllamaProvider;
+}

package/dist/llm/providers/ollama.js

@@ -0,0 +1,91 @@
+/**
+ * Ollama LLM Provider
+ * Supports local LLM models via Ollama API
+ */
+import { LLMProvider, LLMProviderType, } from "../base.js";
+export class OllamaProvider extends LLMProvider {
+    config;
+    constructor(config) {
+        super(LLMProviderType.Ollama, config.model);
+        this.config = config;
+    }
+    /**
+     * Generate text using Ollama API
+     */
+    async generate(messages, options) {
+        if (!this.isConfigured()) {
+            throw new Error("Ollama provider is not configured properly");
+        }
+        // Convert messages to Ollama format
+        const prompt = messages
+            .map((msg) => `${msg.role}: ${msg.content}`)
+            .join("\n\n");
+        const requestBody = {
+            model: this.config.model,
+            prompt,
+            stream: false,
+        };
+        if (options?.temperature !== undefined) {
+            requestBody.temperature = options.temperature;
+        }
+        if (options?.topP !== undefined) {
+            requestBody.top_p = options.topP;
+        }
+        if (options?.topK !== undefined) {
+            requestBody.top_k = options.topK;
+        }
+        if (options?.maxTokens) {
+            requestBody.num_predict = options.maxTokens;
+        }
+        const response = await fetch(`${this.config.baseUrl}/api/generate`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Ollama API error: ${response.status} - ${error}`);
+        }
+        const data = (await response.json());
+        return {
+            content: data.response,
+            model: data.model,
+            tokensUsed: data.eval_count,
+            finishReason: data.done ? "stop" : "length",
+        };
+    }
+    /**
+     * Check if provider is configured
+     */
+    isConfigured() {
+        return !!(this.config.baseUrl && this.config.model);
+    }
+    /**
+     * Create provider from environment variables
+     */
+    static fromEnv(config) {
+        const baseUrl = config.baseUrl || process.env.OLLAMA_BASE_URL || "http://localhost:11434";
+        const model = config.model || process.env.OLLAMA_MODEL || "llama2";
+        return new OllamaProvider({
+            baseUrl: expandEnvVar(baseUrl),
+            model: expandEnvVar(model),
+        });
+    }
+}
+/**
+ * Expand environment variable in string (e.g., "${VAR_NAME}" -> actual value)
+ */
+function expandEnvVar(value) {
+    if (!value) {
+        return value;
+    }
+    const envVarMatch = value.match(/^\$\{([^}]+)\}$/);
+    if (envVarMatch?.[1]) {
+        const envVar = envVarMatch[1];
+        const envValue = process.env[envVar];
+        return envValue ?? value;
+    }
+    return value;
+}

package/dist/llm/providers/openai-compatible.d.ts

@@ -0,0 +1,30 @@
+/**
+ * OpenAI-compatible LLM Provider
+ * Supports: OpenAI, Azure OpenAI, Together AI, Groq, DeepSeek, and any OpenAI-compatible API
+ */
+import { type LLMGenerationOptions, type LLMGenerationResult, type LLMMessage, LLMProvider } from "../base.js";
+export interface OpenAICompatibleConfig {
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+}
+export declare class OpenAICompatibleProvider extends LLMProvider {
+    private config;
+    constructor(config: OpenAICompatibleConfig);
+    /**
+     * Generate text using OpenAI-compatible API
+     */
+    generate(messages: LLMMessage[], options?: LLMGenerationOptions): Promise<LLMGenerationResult>;
+    /**
+     * Check if provider is configured
+     */
+    isConfigured(): boolean;
+    /**
+     * Create provider from environment variables
+     */
+    static fromEnv(config: {
+        baseUrl?: string;
+        apiKey?: string;
+        model?: string;
+    }): OpenAICompatibleProvider;
+}