toolpack-cli 0.1.0-SNAPSHOT

package/dist/context/ToolpackContext.d.ts

@@ -0,0 +1,55 @@
+import { ReactNode } from 'react';
+import { Toolpack, ModeConfig, ToolLogEvent, WorkflowProgress } from 'toolpack-sdk';
+/**
+ * Clean React Context wrapper for the Toolpack SDK.
+ * Manages SDK-related state only: modes, models, and the toolpack instance.
+ * Application state (conversations, history) is handled by ConversationContext.
+ */
+export interface ModelCategory {
+    provider: string;
+    displayName: string;
+    models: {
+        label: string;
+        value: string;
+        capabilities: any;
+    }[];
+}
+interface ToolpackContextType {
+    toolpack: Toolpack | null;
+    activeMode: ModeConfig | null;
+    modes: ModeConfig[];
+    activeModel: string;
+    activeModelCapabilities: {
+        toolCalling?: boolean;
+        vision?: boolean;
+        embeddings?: boolean;
+    } | null;
+    models: {
+        label: string;
+        value: string;
+        provider?: string;
+    }[];
+    modelCategories: ModelCategory[];
+    loadingModels: boolean;
+    setMode: (modeName: string) => void;
+    setModel: (model: {
+        value: string;
+        provider?: string;
+        capabilities?: any;
+    }) => void;
+    cycleMode: () => void;
+    workflowProgress: WorkflowProgress | null;
+    clearWorkflowProgress: () => void;
+    toolHistory: ToolLogEvent[];
+    clearToolHistory: () => void;
+    toolsUnsupportedWarning: string | null;
+    clearToolsUnsupportedWarning: () => void;
+    setToolsUnsupportedWarning: (msg: string) => void;
+    configSource: 'local' | 'global' | 'base' | 'default';
+    activeConfigPath: string | null;
+}
+export declare function ToolpackProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useToolpack(): ToolpackContextType;
+export {};

package/dist/context/ToolpackContext.js

@@ -0,0 +1,221 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState, useCallback, } from 'react';
+import { Toolpack, createMode, loadRuntimeConfig, getRuntimeConfigStatus, } from 'toolpack-sdk';
+import { XAIAdapter } from '../custom-providers/XAIAdapter.js';
+import { skillToolsProject } from '../custom-tools/skill-tools/index.js';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+const ToolpackContext = createContext(undefined);
+export function ToolpackProvider({ children }) {
+    const [toolpack, setToolpack] = useState(null);
+    const [activeMode, setActiveMode] = useState(null);
+    const [modes, setModes] = useState([]);
+    const [activeModel, setActiveModel] = useState('gpt-4.1');
+    const [workflowProgress, setWorkflowProgress] = useState(null);
+    const [toolHistory, setToolHistory] = useState([]);
+    const [models, setModels] = useState([]);
+    const [modelCategories, setModelCategories] = useState([]);
+    const [loadingModels, setLoadingModels] = useState(true);
+    const [activeModelCapabilities, setActiveModelCapabilities] = useState(null);
+    const [toolsUnsupportedWarning, setToolsUnsupportedWarning] = useState(null);
+    const [configSource, setConfigSource] = useState('default');
+    const [activeConfigPath, setActiveConfigPath] = useState(null);
+    useEffect(() => {
+        async function init() {
+            // Get config status
+            const configStatus = getRuntimeConfigStatus();
+            setConfigSource(configStatus.configSource);
+            setActiveConfigPath(configStatus.activeConfigPath);
+            // Load merged runtime configuration
+            const runtimeConfig = loadRuntimeConfig();
+            // To pass the merged config to Toolpack.init (which expects a file),
+            // we create a temporary file with the merged contents.
+            const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'toolpack-cli-'));
+            const tempConfigPath = path.join(tempDir, 'toolpack.config.json');
+            fs.writeFileSync(tempConfigPath, JSON.stringify(runtimeConfig, null, 4));
+            // Define a sample custom mode for demonstration
+            const simpleChat = createMode({
+                name: 'simpleChat',
+                displayName: 'Simple Chat',
+                systemPrompt: 'You are a helpful assistant. Provide clear and concise responses.',
+                blockAllTools: true,
+            });
+            const instance = await Toolpack.init({
+                defaultMode: 'agent',
+                configPath: tempConfigPath, // Use our merged temp config
+                providers: {
+                    openai: {},
+                    anthropic: {},
+                    gemini: {},
+                    ollama: {},
+                },
+                defaultProvider: 'openai',
+                tools: true,
+                customModes: [simpleChat],
+                customProviders: [new XAIAdapter()],
+                customTools: [skillToolsProject],
+                modeOverrides: {
+                    agent: {
+                        // Override the agent mode system prompt to include skill search and read
+                        systemPrompt: [
+                            'You are an autonomous AI agent with full access to all available tools.',
+                            'You must use the tools provided to accomplish tasks end-to-end proactively.',
+                            'If you require a capability that is not listed in your current tools, ALWAYS use `tool.search` to find it before improvising or giving up.',
+                            'Before considering a tool to call, make sure that is the right tool for the job as per the users prompt.',
+                            'You also have access to `skill.search` and `skill.read` tools to find reusable instructions if needed.',
+                            'Verify your actions and check for success or failure states.',
+                            'Explain your actions briefly as you go.',
+                        ].join('\n'),
+                        // Override tool search configuration
+                        toolSearch: {
+                            alwaysLoadedTools: [
+                            // Empty array - AI must search for all tools
+                            // Or specify specific tools you always want available:
+                            // 'tool.search',
+                            // 'fs.read_file',
+                            ],
+                        },
+                    },
+                },
+            });
+            // Cleanup temp file
+            try {
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            }
+            catch (e) {
+                // Ignore cleanup errors
+            }
+            // Set up tool log event listener for history
+            const client = instance.getClient();
+            if (client) {
+                client.on('tool:log', (event) => {
+                    setToolHistory(prev => [...prev, event]);
+                });
+            }
+            // Set up workflow progress event listener
+            const executor = instance.getWorkflowExecutor();
+            if (executor) {
+                executor.on('workflow:progress', (progress) => {
+                    setWorkflowProgress(progress);
+                });
+                executor.on('workflow:completed', () => {
+                    // Don't null out — let the 'completed' progress state persist
+                    // so the UI can show "Workflow completed." text.
+                    // It gets cleared when the next request starts.
+                });
+                executor.on('workflow:failed', () => {
+                    // Don't null out — let the 'failed' progress state persist.
+                    // It gets cleared when the next request starts.
+                });
+            }
+            setToolpack(instance);
+            setActiveMode(instance.getMode() || null);
+            setModes(instance.getModes() || []);
+            // Fetch dynamic models list
+            setLoadingModels(true);
+            try {
+                const providersInfo = await instance.listProviders();
+                const categories = providersInfo
+                    .map(p => ({
+                    provider: p.name,
+                    displayName: p.displayName || p.name,
+                    models: p.models.map((m) => ({
+                        label: m.displayName,
+                        value: m.id,
+                        capabilities: m.capabilities,
+                    })),
+                }))
+                    .filter(c => c.models.length > 0);
+                setModelCategories(categories);
+                // Also set flat list for backward compatibility of setModel
+                const flatList = categories.flatMap(c => c.models.map((m) => ({
+                    label: m.label,
+                    value: m.value,
+                    provider: c.provider,
+                })));
+                setModels(flatList);
+            }
+            catch (err) {
+                console.error('Failed to list providers:', err);
+            }
+            finally {
+                setLoadingModels(false);
+            }
+        }
+        init();
+    }, []);
+    const setMode = (modeName) => {
+        if (toolpack) {
+            toolpack.setMode(modeName);
+            setActiveMode(toolpack.getMode() || null);
+        }
+    };
+    const cycleMode = () => {
+        if (toolpack) {
+            toolpack.cycleMode();
+            setActiveMode(toolpack.getMode() || null);
+        }
+    };
+    const setModel = ({ value, provider, capabilities, }) => {
+        setActiveModel(value);
+        setActiveModelCapabilities(capabilities || null);
+        setToolsUnsupportedWarning(null); // Clear any previous warning
+        // If this model belongs to a specific provider, switch the active provider
+        if (toolpack && provider) {
+            try {
+                toolpack.setProvider(provider);
+            }
+            catch {
+                // Provider not registered (e.g. no API key) — ignore silently
+            }
+        }
+        else if (toolpack && !provider) {
+            // Default back to openai for non-provider-specific models
+            try {
+                toolpack.setProvider('openai');
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    };
+    const clearToolHistory = useCallback(() => {
+        setToolHistory([]);
+    }, []);
+    const clearToolsUnsupportedWarning = useCallback(() => {
+        setToolsUnsupportedWarning(null);
+    }, []);
+    const clearWorkflowProgress = useCallback(() => {
+        setWorkflowProgress(null);
+    }, []);
+    return (_jsx(ToolpackContext.Provider, { value: {
+            toolpack,
+            activeMode,
+            modes,
+            activeModel,
+            activeModelCapabilities,
+            models,
+            modelCategories,
+            loadingModels,
+            setMode,
+            setModel,
+            cycleMode,
+            workflowProgress,
+            toolHistory,
+            clearToolHistory,
+            clearWorkflowProgress,
+            toolsUnsupportedWarning,
+            clearToolsUnsupportedWarning,
+            setToolsUnsupportedWarning,
+            configSource,
+            activeConfigPath,
+        }, children: children }));
+}
+export function useToolpack() {
+    const context = useContext(ToolpackContext);
+    if (!context) {
+        throw new Error('useToolpack must be used within a ToolpackProvider');
+    }
+    return context;
+}

package/dist/custom-providers/AnthropicCustomAdapter.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Anthropic Custom Adapter - Custom Provider Example
+ *
+ * Demonstrates how to create a custom provider adapter for the Toolpack SDK.
+ * This is a custom implementation of Anthropic's API for testing purposes.
+ *
+ * API Docs: https://docs.anthropic.com/en/api
+ */
+import { ProviderAdapter, CompletionRequest, CompletionResponse, CompletionChunk, EmbeddingRequest, EmbeddingResponse, ProviderModelInfo } from 'toolpack-sdk';
+export interface AnthropicCustomAdapterConfig {
+    /** API key. If not provided, reads from ANTHROPIC_API_KEY or TOOLPACK_ANTHROPIC_KEY env vars */
+    apiKey?: string;
+    baseUrl?: string;
+    defaultModel?: string;
+}
+export declare class AnthropicCustomAdapter implements ProviderAdapter {
+    name: string;
+    private apiKey;
+    private baseUrl;
+    private defaultModel;
+    constructor(config?: AnthropicCustomAdapterConfig);
+    getDisplayName(): string;
+    getModels(): Promise<ProviderModelInfo[]>;
+    private ensureApiKey;
+    /**
+     * Sanitize tool name for Anthropic API (must match ^[a-zA-Z0-9_-]{1,128}$)
+     * Converts dots to underscores: fs.read_file -> fs_read_file
+     */
+    private sanitizeToolName;
+    /**
+     * Restore original tool name from sanitized version
+     */
+    private restoreToolName;
+    generate(request: CompletionRequest): Promise<CompletionResponse>;
+    stream(request: CompletionRequest): AsyncGenerator<CompletionChunk>;
+    embed(_request: EmbeddingRequest): Promise<EmbeddingResponse>;
+    supportsFileUpload(): boolean;
+    uploadFile(_request: {
+        filePath?: string;
+        data?: string | Buffer;
+        filename?: string;
+        purpose?: string;
+    }): Promise<{
+        id: string;
+        url?: string;
+        expiresAt?: Date;
+    }>;
+    deleteFile(_fileId: string): Promise<void>;
+}

package/dist/custom-providers/AnthropicCustomAdapter.js

@@ -0,0 +1,297 @@
+/**
+ * Anthropic Custom Adapter - Custom Provider Example
+ *
+ * Demonstrates how to create a custom provider adapter for the Toolpack SDK.
+ * This is a custom implementation of Anthropic's API for testing purposes.
+ *
+ * API Docs: https://docs.anthropic.com/en/api
+ */
+export class AnthropicCustomAdapter {
+    constructor(config = {}) {
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'anthropic-custom'
+        });
+        Object.defineProperty(this, "apiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "baseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "defaultModel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Resolve API key from config or environment (defer error to usage time)
+        this.apiKey =
+            config.apiKey ||
+                process.env['ANTHROPIC_API_KEY'] ||
+                process.env['TOOLPACK_ANTHROPIC_KEY'] ||
+                null;
+        this.baseUrl = config.baseUrl || 'https://api.anthropic.com/v1';
+        this.defaultModel = config.defaultModel || 'claude-sonnet-4-20250514';
+    }
+    getDisplayName() {
+        return 'Anthropic (Custom)';
+    }
+    async getModels() {
+        return [
+            {
+                id: 'claude-3-7-sonnet-20250219',
+                displayName: 'Claude 3.7 Sonnet',
+                capabilities: {
+                    chat: true,
+                    streaming: true,
+                    toolCalling: true,
+                    embeddings: false,
+                    vision: true,
+                },
+                contextWindow: 200000,
+            },
+            {
+                id: 'claude-3-5-sonnet-20241022',
+                displayName: 'Claude 3.5 Sonnet',
+                capabilities: {
+                    chat: true,
+                    streaming: true,
+                    toolCalling: true,
+                    embeddings: false,
+                    vision: true,
+                },
+                contextWindow: 200000,
+            },
+            {
+                id: 'claude-3-5-haiku-20241022',
+                displayName: 'Claude 3.5 Haiku',
+                capabilities: {
+                    chat: true,
+                    streaming: true,
+                    toolCalling: true,
+                    embeddings: false,
+                    vision: false,
+                },
+                contextWindow: 200000,
+            },
+        ];
+    }
+    ensureApiKey() {
+        if (!this.apiKey) {
+            throw new Error('No API key found for Anthropic Custom. Set ANTHROPIC_API_KEY or TOOLPACK_ANTHROPIC_KEY environment variable, ' +
+                'or pass apiKey in config.');
+        }
+        return this.apiKey;
+    }
+    /**
+     * Sanitize tool name for Anthropic API (must match ^[a-zA-Z0-9_-]{1,128}$)
+     * Converts dots to underscores: fs.read_file -> fs_read_file
+     */
+    sanitizeToolName(name) {
+        return name.replace(/\./g, '_');
+    }
+    /**
+     * Restore original tool name from sanitized version
+     */
+    restoreToolName(sanitized, originalTools) {
+        // Find the original tool name that matches when sanitized
+        const original = originalTools?.find(t => this.sanitizeToolName(t.function.name) === sanitized);
+        return original?.function.name || sanitized.replace(/_/g, '.');
+    }
+    async generate(request) {
+        const apiKey = this.ensureApiKey();
+        const model = request.model || this.defaultModel;
+        // Convert messages to Anthropic format
+        const systemMessage = request.messages.find(m => m.role === 'system')?.content || '';
+        const messages = request.messages
+            .filter(m => m.role !== 'system')
+            .map(m => ({
+            role: m.role === 'assistant' ? 'assistant' : 'user',
+            content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
+        }));
+        const response = await fetch(`${this.baseUrl}/messages`, {
+            method: 'POST',
+            headers: {
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model,
+                messages,
+                system: systemMessage || undefined,
+                max_tokens: request.max_tokens || 4096,
+                temperature: request.temperature,
+                top_p: request.top_p,
+                tools: request.tools?.map(t => ({
+                    name: this.sanitizeToolName(t.function.name),
+                    description: t.function.description,
+                    input_schema: t.function.parameters,
+                })),
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Anthropic Custom API error: ${response.status} - ${error}`);
+        }
+        const data = (await response.json());
+        // Extract tool calls if present (restore original tool names)
+        let toolCalls = undefined;
+        const toolUseBlocks = data.content?.filter((block) => block.type === 'tool_use');
+        if (toolUseBlocks && toolUseBlocks.length > 0) {
+            toolCalls = toolUseBlocks.map((block) => ({
+                id: block.id,
+                name: this.restoreToolName(block.name, request.tools),
+                arguments: block.input,
+            }));
+        }
+        // Extract text content
+        const textBlocks = data.content?.filter((block) => block.type === 'text');
+        const content = textBlocks?.map((block) => block.text).join('') || null;
+        return {
+            content,
+            usage: data.usage
+                ? {
+                    prompt_tokens: data.usage.input_tokens,
+                    completion_tokens: data.usage.output_tokens,
+                    total_tokens: data.usage.input_tokens + data.usage.output_tokens,
+                }
+                : undefined,
+            finish_reason: data.stop_reason === 'tool_use'
+                ? 'tool_calls'
+                : data.stop_reason === 'max_tokens'
+                    ? 'length'
+                    : 'stop',
+            tool_calls: toolCalls,
+            raw: data,
+        };
+    }
+    async *stream(request) {
+        const apiKey = this.ensureApiKey();
+        const model = request.model || this.defaultModel;
+        // Convert messages to Anthropic format
+        const systemMessage = request.messages.find(m => m.role === 'system')?.content || '';
+        const messages = request.messages
+            .filter(m => m.role !== 'system')
+            .map(m => ({
+            role: m.role === 'assistant' ? 'assistant' : 'user',
+            content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
+        }));
+        const response = await fetch(`${this.baseUrl}/messages`, {
+            method: 'POST',
+            headers: {
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model,
+                messages,
+                system: systemMessage || undefined,
+                max_tokens: request.max_tokens || 4096,
+                temperature: request.temperature,
+                stream: true,
+                tools: request.tools?.map(t => ({
+                    name: this.sanitizeToolName(t.function.name),
+                    description: t.function.description,
+                    input_schema: t.function.parameters,
+                })),
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Anthropic Custom API error: ${response.status} - ${error}`);
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        // Accumulate tool use blocks (store sanitized names, restore later)
+        const toolUseBlocks = new Map();
+        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: '))
+                    continue;
+                const data = line.slice(6).trim();
+                try {
+                    const event = JSON.parse(data);
+                    // Handle content block delta (text streaming)
+                    if (event.type === 'content_block_delta' &&
+                        event.delta?.type === 'text_delta') {
+                        yield { delta: event.delta.text };
+                    }
+                    // Handle tool use blocks
+                    if (event.type === 'content_block_start' &&
+                        event.content_block?.type === 'tool_use') {
+                        const idx = event.index ?? 0;
+                        toolUseBlocks.set(idx, {
+                            id: event.content_block.id,
+                            name: event.content_block.name,
+                            input: '',
+                        });
+                    }
+                    if (event.type === 'content_block_delta' &&
+                        event.delta?.type === 'input_json_delta') {
+                        const idx = event.index ?? 0;
+                        const block = toolUseBlocks.get(idx);
+                        if (block) {
+                            block.input += event.delta.partial_json;
+                        }
+                    }
+                    // Handle message completion
+                    if (event.type === 'message_delta') {
+                        const stopReason = event.delta?.stop_reason;
+                        if (stopReason === 'end_turn') {
+                            yield { delta: '', finish_reason: 'stop' };
+                        }
+                        else if (stopReason === 'max_tokens') {
+                            yield { delta: '', finish_reason: 'length' };
+                        }
+                        else if (stopReason === 'tool_use') {
+                            const toolCalls = Array.from(toolUseBlocks.values()).map(block => ({
+                                id: block.id,
+                                name: this.restoreToolName(block.name, request.tools),
+                                arguments: JSON.parse(block.input || '{}'),
+                            }));
+                            yield {
+                                delta: '',
+                                finish_reason: 'tool_calls',
+                                tool_calls: toolCalls,
+                            };
+                        }
+                    }
+                }
+                catch {
+                    // Ignore parse errors from partial lines
+                }
+            }
+        }
+    }
+    async embed(_request) {
+        // Anthropic doesn't support embeddings - throw a clear error
+        throw new Error('Anthropic does not support embeddings. Use OpenAI or another provider for embeddings.');
+    }
+    // File upload is not supported by Anthropic
+    supportsFileUpload() {
+        return false;
+    }
+    async uploadFile(_request) {
+        throw new Error('Anthropic does not support file uploads.');
+    }
+    async deleteFile(_fileId) {
+        throw new Error('Anthropic does not support file operations.');
+    }
+}

package/dist/custom-providers/XAIAdapter.d.ts

@@ -0,0 +1,40 @@
+/**
+ * xAI Adapter - Custom Provider Example
+ *
+ * Demonstrates how to create a custom provider adapter for the Toolpack SDK.
+ * xAI provides Grok models for fast, intelligent AI responses.
+ *
+ * API Docs: https://docs.x.ai/api
+ */
+import { ProviderAdapter, CompletionRequest, CompletionResponse, CompletionChunk, EmbeddingRequest, EmbeddingResponse, ProviderModelInfo } from 'toolpack-sdk';
+export interface XAIAdapterConfig {
+    /** API key. If not provided, reads from XAI_API_KEY or TOOLPACK_XAI_KEY env vars */
+    apiKey?: string;
+    baseUrl?: string;
+    defaultModel?: string;
+}
+export declare class XAIAdapter implements ProviderAdapter {
+    name: string;
+    private apiKey;
+    private baseUrl;
+    private defaultModel;
+    constructor(config?: XAIAdapterConfig);
+    getDisplayName(): string;
+    getModels(): Promise<ProviderModelInfo[]>;
+    private ensureApiKey;
+    generate(request: CompletionRequest): Promise<CompletionResponse>;
+    stream(request: CompletionRequest): AsyncGenerator<CompletionChunk>;
+    embed(_request: EmbeddingRequest): Promise<EmbeddingResponse>;
+    supportsFileUpload(): boolean;
+    uploadFile(_request: {
+        filePath?: string;
+        data?: string | Buffer;
+        filename?: string;
+        purpose?: string;
+    }): Promise<{
+        id: string;
+        url?: string;
+        expiresAt?: Date;
+    }>;
+    deleteFile(_fileId: string): Promise<void>;
+}