profclaw 0.0.1-beta.1

package/dist/chat/execution/tool-router.js

@@ -0,0 +1,296 @@
+/**
+ * Model-Aware Tool Router
+ *
+ * Routes tools to AI models based on model capability:
+ * - Small/local models (7B-13B): essential tier (8-10 tools)
+ * - Medium models (30B-70B, GPT-3.5): standard tier (25-30 tools)
+ * - Large models (GPT-4, Claude, Gemini Pro): full tier (all tools)
+ *
+ * Prevents tool hallucination by not overwhelming small models with 72 tool schemas.
+ */
+import { logger } from '../../utils/logger.js';
+// Model Classification
+/**
+ * Known model family patterns -> capability classification.
+ * Ordered from most specific to least specific.
+ */
+const MODEL_PATTERNS = [
+    // Large reasoning models (full tier)
+    { pattern: /claude-(3\.5|4|opus|sonnet-4)/i, capability: 'reasoning', tier: 'full' },
+    { pattern: /gpt-4o|gpt-4-turbo|gpt-4\.5/i, capability: 'reasoning', tier: 'full' },
+    { pattern: /gemini-(pro|1\.5|2)/i, capability: 'reasoning', tier: 'full' },
+    { pattern: /o[13]-/i, capability: 'reasoning', tier: 'full' },
+    { pattern: /deepseek-(v3|r1|chat)/i, capability: 'reasoning', tier: 'full' },
+    { pattern: /qwen-?2\.5-(72b|110b)/i, capability: 'reasoning', tier: 'full' },
+    { pattern: /llama-?3\.1-405b/i, capability: 'reasoning', tier: 'full' },
+    { pattern: /grok-[23]/i, capability: 'reasoning', tier: 'full' },
+    { pattern: /mistral-large/i, capability: 'reasoning', tier: 'full' },
+    { pattern: /glm-(4-plus|4\.7|5)/i, capability: 'reasoning', tier: 'full' },
+    // Medium instruction-following models (standard tier)
+    { pattern: /claude-haiku|claude-3-haiku/i, capability: 'instruction', tier: 'standard' },
+    { pattern: /gpt-3\.5/i, capability: 'instruction', tier: 'standard' },
+    { pattern: /gemini-flash/i, capability: 'instruction', tier: 'standard' },
+    { pattern: /mistral-medium|mistral-small|codestral/i, capability: 'instruction', tier: 'standard' },
+    { pattern: /llama-?3\.(1-70b|3-70b)|llama-?3\.3-70b/i, capability: 'instruction', tier: 'standard' },
+    { pattern: /qwen-?2\.5-(32b|14b)/i, capability: 'instruction', tier: 'standard' },
+    { pattern: /command-r/i, capability: 'instruction', tier: 'standard' },
+    { pattern: /mixtral/i, capability: 'instruction', tier: 'standard' },
+    { pattern: /glm-4-(air|flashx|long)/i, capability: 'instruction', tier: 'standard' },
+    { pattern: /glm-4\.7-flash/i, capability: 'instruction', tier: 'standard' },
+    { pattern: /moonshot|kimi/i, capability: 'instruction', tier: 'standard' },
+    // Small/local basic models (essential tier)
+    { pattern: /llama-?3\.(2-[13]b|1-8b)|llama3\.2/i, capability: 'basic', tier: 'essential' },
+    { pattern: /qwen-?2\.5-[37]b|qwen2\.5:[37]b/i, capability: 'basic', tier: 'essential' },
+    { pattern: /mistral:?[0-9]b|mistral-[0-9]x?[0-9]b/i, capability: 'basic', tier: 'essential' },
+    { pattern: /phi-?[34]/i, capability: 'basic', tier: 'essential' },
+    { pattern: /gemma-?2?-[0-9]b/i, capability: 'basic', tier: 'essential' },
+    { pattern: /tinyllama|stablelm/i, capability: 'basic', tier: 'essential' },
+    { pattern: /deepseek-r1:[0-9]b/i, capability: 'basic', tier: 'essential' },
+];
+/**
+ * Essential tools that every model gets (core interaction tools).
+ */
+export const ESSENTIAL_TOOL_NAMES = new Set([
+    'exec',
+    'read_file',
+    'write_file',
+    'edit_file',
+    'search_files',
+    'web_search',
+    'web_fetch',
+    'complete_task',
+    'memory_search',
+    'agents_list',
+]);
+/**
+ * Tools restricted to full tier only (large capable models).
+ */
+export const FULL_ONLY_TOOL_NAMES = new Set([
+    'canvas_render',
+    'image_analyze',
+    'subagent_orchestrate',
+    'openai_image_gen',
+    'tts_speak',
+    'browser_navigate',
+    'browser_snapshot',
+    'browser_click',
+    'browser_type',
+    'browser_search',
+    'browser_screenshot',
+    'browser_pages',
+    'browser_close',
+    'discord_actions',
+    'slack_actions',
+    'telegram_actions',
+]);
+// State
+let config = {
+    enabled: true,
+    defaultTier: 'full',
+    maxToolTokenPercent: 15,
+    dynamicPromotion: true,
+};
+// Track promoted tools per conversation (conversationId -> set of tool names)
+const promotedTools = new Map();
+// Core Functions
+/**
+ * Classify a model ID into a capability profile.
+ */
+export function classifyModel(modelId) {
+    for (const entry of MODEL_PATTERNS) {
+        if (entry.pattern.test(modelId)) {
+            const contextWindow = getEstimatedContextWindow(modelId);
+            return {
+                capability: entry.capability,
+                tier: entry.tier,
+                maxTools: entry.tier === 'essential' ? 10 : entry.tier === 'standard' ? 30 : 100,
+                contextWindow,
+                toolTokenBudget: Math.floor(contextWindow * (config.maxToolTokenPercent / 100)),
+            };
+        }
+    }
+    // Infer from parameter count in model name (e.g. "my-model-7b")
+    const sizeMatch = modelId.match(/(\d+)b$/i);
+    if (sizeMatch) {
+        const size = parseInt(sizeMatch[1], 10);
+        const contextWindow = getEstimatedContextWindow(modelId);
+        if (size <= 13) {
+            return {
+                capability: 'basic',
+                tier: 'essential',
+                maxTools: 10,
+                contextWindow,
+                toolTokenBudget: Math.floor(contextWindow * (config.maxToolTokenPercent / 100)),
+            };
+        }
+        if (size <= 70) {
+            return {
+                capability: 'instruction',
+                tier: 'standard',
+                maxTools: 30,
+                contextWindow,
+                toolTokenBudget: Math.floor(contextWindow * (config.maxToolTokenPercent / 100)),
+            };
+        }
+    }
+    // Unknown model: default to configured tier (safe, won't break)
+    const contextWindow = 128000;
+    return {
+        capability: 'reasoning',
+        tier: config.defaultTier,
+        maxTools: 100,
+        contextWindow,
+        toolTokenBudget: Math.floor(contextWindow * (config.maxToolTokenPercent / 100)),
+    };
+}
+function getEstimatedContextWindow(modelId) {
+    if (/claude|gpt-4o|gemini-(1\.5|2)|llama-?3\.[123]/i.test(modelId))
+        return 128000;
+    if (/gpt-4-turbo/i.test(modelId))
+        return 128000;
+    if (/gpt-3\.5/i.test(modelId))
+        return 16385;
+    if (/qwen/i.test(modelId))
+        return 32768;
+    if (/mistral/i.test(modelId))
+        return 32768;
+    if (/glm/i.test(modelId))
+        return 128000;
+    return 32768; // Conservative default
+}
+/**
+ * Infer tool tier from tool name when no explicit tier is set.
+ */
+function inferToolTier(tool) {
+    if (ESSENTIAL_TOOL_NAMES.has(tool.name))
+        return 'essential';
+    if (FULL_ONLY_TOOL_NAMES.has(tool.name))
+        return 'full';
+    return 'standard';
+}
+/**
+ * Filter tools based on model capability.
+ * Returns tools appropriate for the given model's tier.
+ */
+export function filterToolsForModel(tools, modelId, conversationId) {
+    if (!config.enabled)
+        return tools;
+    const profile = classifyModel(modelId);
+    const promoted = conversationId ? promotedTools.get(conversationId) : undefined;
+    const filtered = tools.filter((tool) => {
+        const toolTier = tool.tier ?? inferToolTier(tool);
+        // Promoted tools always pass through
+        if (promoted?.has(tool.name))
+            return true;
+        switch (profile.tier) {
+            case 'essential':
+                return toolTier === 'essential';
+            case 'standard':
+                return toolTier === 'essential' || toolTier === 'standard';
+            case 'full':
+                return true;
+        }
+    });
+    // Enforce max tools limit - prioritise essential > standard > full
+    if (filtered.length > profile.maxTools) {
+        const tierOrder = { essential: 0, standard: 1, full: 2 };
+        const sorted = [...filtered].sort((a, b) => {
+            const aTier = a.tier ?? inferToolTier(a);
+            const bTier = b.tier ?? inferToolTier(b);
+            return tierOrder[aTier] - tierOrder[bTier];
+        });
+        return sorted.slice(0, profile.maxTools);
+    }
+    logger.debug('[ToolRouter] Filtered tools for model', {
+        model: modelId,
+        tier: profile.tier,
+        total: tools.length,
+        filtered: filtered.length,
+    });
+    return filtered;
+}
+/**
+ * Filter tools by an explicit tier ceiling (for ToolFilterOptions.tier).
+ * Includes all tools at or below the given tier.
+ */
+export function filterToolsByTier(tools, maxTier) {
+    const tierOrder = { essential: 0, standard: 1, full: 2 };
+    const ceiling = tierOrder[maxTier];
+    return tools.filter((tool) => {
+        const toolTier = tool.tier ?? inferToolTier(tool);
+        return tierOrder[toolTier] <= ceiling;
+    });
+}
+// Dynamic Promotion
+/**
+ * Promote a tool for a specific conversation (grants access above normal tier).
+ */
+export function promoteToolForConversation(conversationId, toolName) {
+    if (!config.dynamicPromotion)
+        return;
+    let promoted = promotedTools.get(conversationId);
+    if (!promoted) {
+        promoted = new Set();
+        promotedTools.set(conversationId, promoted);
+    }
+    promoted.add(toolName);
+    logger.debug('[ToolRouter] Tool promoted', { conversationId, toolName });
+}
+/**
+ * Clear promoted tools for a conversation (call on conversation end).
+ */
+export function clearPromotedTools(conversationId) {
+    promotedTools.delete(conversationId);
+}
+/**
+ * Cleanup stale promoted tools - keeps map bounded to 1000 entries.
+ */
+export function cleanupPromotedTools() {
+    if (promotedTools.size > 1000) {
+        const entries = Array.from(promotedTools.keys());
+        for (let i = 0; i < 500; i++) {
+            promotedTools.delete(entries[i]);
+        }
+    }
+}
+// Token Estimation
+/**
+ * Rough estimate: ~150 tokens per tool (name, description, params schema).
+ */
+export function estimateToolTokens(tools) {
+    return tools.length * 150;
+}
+// Compressed Descriptions
+/**
+ * Get tool descriptions optimised for the model's capability level.
+ */
+export function getCompressedDescriptions(tools, capability) {
+    if (capability === 'reasoning') {
+        return tools.map((t) => `- ${t.name}: ${t.description}`).join('\n');
+    }
+    if (capability === 'instruction') {
+        return tools
+            .map((t) => {
+            const shortDesc = t.description.split('.')[0];
+            return `- ${t.name}: ${shortDesc}`;
+        })
+            .join('\n');
+    }
+    // basic: ultra-short, name only
+    return tools.map((t) => `- ${t.name}`).join('\n');
+}
+// Configuration
+/**
+ * Configure the tool router at runtime.
+ */
+export function configureToolRouter(newConfig) {
+    config = { ...config, ...newConfig };
+    logger.info('[ToolRouter] Configuration updated', config);
+}
+/**
+ * Get a copy of the current tool router configuration.
+ */
+export function getToolRouterConfig() {
+    return { ...config };
+}
+//# sourceMappingURL=tool-router.js.map

package/dist/chat/execution/tools/agents-list.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Agents List Tool
+ *
+ * Lists available AI agents with their capabilities and status.
+ * Inspired by OpenClaw's agents_list tool.
+ */
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+import type { AgentCapability, AgentHealth } from '../../../types/agent.js';
+declare const AgentsListParamsSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodString>;
+    capability: z.ZodOptional<z.ZodString>;
+    healthyOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    includeDetails: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    healthyOnly: boolean;
+    includeDetails: boolean;
+    type?: string | undefined;
+    capability?: string | undefined;
+}, {
+    type?: string | undefined;
+    capability?: string | undefined;
+    healthyOnly?: boolean | undefined;
+    includeDetails?: boolean | undefined;
+}>;
+export type AgentsListParams = z.infer<typeof AgentsListParamsSchema>;
+export interface AgentInfo {
+    id: string;
+    type: string;
+    name: string;
+    description: string;
+    enabled: boolean;
+    priority: number;
+    capabilities: AgentCapability[];
+    taskTypes?: string[];
+    labels?: string[];
+    health?: AgentHealth;
+    maxConcurrent: number;
+}
+export interface AgentsListResult {
+    agents: AgentInfo[];
+    total: number;
+    activeCount: number;
+    adapterTypes: string[];
+    message: string;
+}
+export declare const agentsListTool: ToolDefinition<AgentsListParams, AgentsListResult>;
+export default agentsListTool;
+//# sourceMappingURL=agents-list.d.ts.map

package/dist/chat/execution/tools/agents-list.js

@@ -0,0 +1,165 @@
+/**
+ * Agents List Tool
+ *
+ * Lists available AI agents with their capabilities and status.
+ * Inspired by OpenClaw's agents_list tool.
+ */
+import { z } from 'zod';
+import { getAgentRegistry } from '../../../adapters/registry.js';
+// Schema
+const AgentsListParamsSchema = z.object({
+    type: z.string().optional()
+        .describe('Filter by agent type (e.g., "openclaw", "claude-code", "ollama")'),
+    capability: z.string().optional()
+        .describe('Filter by capability (e.g., "code_generation", "bug_fix", "testing")'),
+    healthyOnly: z.boolean().optional().default(false)
+        .describe('Only show agents that are currently healthy'),
+    includeDetails: z.boolean().optional().default(true)
+        .describe('Include full capability list and health details'),
+});
+// Tool Definition
+export const agentsListTool = {
+    name: 'agents_list',
+    description: `List available AI agents and their capabilities.
+
+Use this tool to:
+- Discover what agents are available for tasks
+- Check agent health status
+- Find agents with specific capabilities
+- Help decide which agent to use for a task
+
+Available agent types:
+- **openclaw**: Full autonomous coding agent with context window
+- **claude-code**: Claude Code CLI for terminal-based coding
+- **ollama**: Local LLM inference with custom models
+
+Available capabilities:
+- code_generation, code_review, bug_fix, testing
+- documentation, refactoring, research
+- git_operations, file_operations, web_browsing
+- api_calls, image_generation, data_analysis`,
+    category: 'system',
+    securityLevel: 'safe',
+    allowedHosts: ['gateway', 'local'],
+    parameters: AgentsListParamsSchema,
+    examples: [
+        { description: 'List all agents', params: {} },
+        { description: 'List only healthy agents', params: { healthyOnly: true } },
+        { description: 'Find agents that can fix bugs', params: { capability: 'bug_fix' } },
+        { description: 'List OpenClaw agents', params: { type: 'openclaw' } },
+    ],
+    async execute(context, params) {
+        try {
+            const registry = getAgentRegistry();
+            const adapterTypes = registry.getAdapterTypes();
+            const activeAdapters = registry.getActiveAdapters();
+            // Collect agent info from all active adapters
+            const agents = [];
+            for (const adapter of activeAdapters) {
+                // Check health if requested
+                let health;
+                if (params.includeDetails || params.healthyOnly) {
+                    try {
+                        health = await adapter.healthCheck();
+                    }
+                    catch {
+                        health = {
+                            healthy: false,
+                            message: 'Health check failed',
+                            lastChecked: new Date(),
+                        };
+                    }
+                }
+                // Skip unhealthy agents if healthyOnly
+                if (params.healthyOnly && health && !health.healthy) {
+                    continue;
+                }
+                // Filter by type if specified
+                if (params.type && adapter.type !== params.type) {
+                    continue;
+                }
+                // Filter by capability if specified
+                if (params.capability) {
+                    const hasCapability = adapter.capabilities.includes(params.capability);
+                    if (!hasCapability) {
+                        continue;
+                    }
+                }
+                // Find config for this adapter
+                // Note: We need to iterate through configs to find matching adapter
+                // This is a workaround since registry doesn't expose configs directly
+                agents.push({
+                    id: adapter.type, // Using type as ID for now
+                    type: adapter.type,
+                    name: adapter.name,
+                    description: adapter.description,
+                    enabled: true,
+                    priority: 1,
+                    capabilities: adapter.capabilities,
+                    health: params.includeDetails ? health : undefined,
+                    maxConcurrent: 1, // Default
+                });
+            }
+            // Build human-readable output
+            const lines = ['## Available Agents\n'];
+            if (agents.length === 0) {
+                lines.push('No agents found matching your criteria.\n');
+                lines.push('**Tip**: Check agent configuration or remove filters.');
+            }
+            else {
+                for (const agent of agents) {
+                    const healthIcon = !agent.health
+                        ? '⚪'
+                        : agent.health.healthy
+                            ? '🟢'
+                            : '🔴';
+                    const statusText = !agent.health
+                        ? ''
+                        : agent.health.healthy
+                            ? ' (healthy)'
+                            : ` (unhealthy: ${agent.health.message})`;
+                    lines.push(`### ${healthIcon} ${agent.name}${statusText}`);
+                    lines.push(`- **Type**: \`${agent.type}\``);
+                    lines.push(`- **Description**: ${agent.description}`);
+                    if (params.includeDetails) {
+                        lines.push(`- **Capabilities**: ${agent.capabilities.join(', ')}`);
+                        if (agent.taskTypes && agent.taskTypes.length > 0) {
+                            lines.push(`- **Task Types**: ${agent.taskTypes.join(', ')}`);
+                        }
+                        if (agent.labels && agent.labels.length > 0) {
+                            lines.push(`- **Labels**: ${agent.labels.join(', ')}`);
+                        }
+                        if (agent.health?.latencyMs) {
+                            lines.push(`- **Latency**: ${agent.health.latencyMs}ms`);
+                        }
+                    }
+                    lines.push('');
+                }
+                lines.push('---');
+                lines.push(`*${agents.length} agent(s) available. Adapter types: ${adapterTypes.join(', ')}*`);
+            }
+            return {
+                success: true,
+                data: {
+                    agents,
+                    total: agents.length,
+                    activeCount: activeAdapters.length,
+                    adapterTypes,
+                    message: lines.join('\n'),
+                },
+                output: lines.join('\n'),
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: {
+                    code: 'LIST_AGENTS_ERROR',
+                    message: `Failed to list agents: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            };
+        }
+    },
+};
+export default agentsListTool;
+//# sourceMappingURL=agents-list.js.map

package/dist/chat/execution/tools/browser.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Browser Automation Tools (Chat Execution)
+ *
+ * Browser tools for chat agents.
+ * Uses centralized definitions from src/browser/tools.ts
+ */
+import { SAFE_BROWSER_TOOL_NAMES } from '../../../browser/index.js';
+export declare const browserTools: import("../types.js").ToolDefinition<unknown, unknown>[];
+export declare const browserNavigateTool: import("../types.js").ToolDefinition<unknown, unknown>, browserSnapshotTool: import("../types.js").ToolDefinition<unknown, unknown>, browserClickTool: import("../types.js").ToolDefinition<unknown, unknown>, browserTypeTool: import("../types.js").ToolDefinition<unknown, unknown>, browserSearchTool: import("../types.js").ToolDefinition<unknown, unknown>, browserScreenshotTool: import("../types.js").ToolDefinition<unknown, unknown>, browserPagesTool: import("../types.js").ToolDefinition<unknown, unknown>, browserCloseTool: import("../types.js").ToolDefinition<unknown, unknown>;
+export { SAFE_BROWSER_TOOL_NAMES };
+export type { NavigateResult as BrowserNavigateResult, SnapshotResult as BrowserSnapshotResult, ClickResult as BrowserClickResult, TypeResult as BrowserTypeResult, SearchResult as BrowserSearchResult, ScreenshotResult as BrowserScreenshotResult, PagesResult as BrowserPagesResult, CloseResult as BrowserCloseResult, } from '../../../browser/tools.js';
+//# sourceMappingURL=browser.d.ts.map

package/dist/chat/execution/tools/browser.js

@@ -0,0 +1,14 @@
+/**
+ * Browser Automation Tools (Chat Execution)
+ *
+ * Browser tools for chat agents.
+ * Uses centralized definitions from src/browser/tools.ts
+ */
+import { CHAT_BROWSER_TOOLS, SAFE_BROWSER_TOOL_NAMES } from '../../../browser/index.js';
+// Re-export chat tool definitions for registry
+export const browserTools = CHAT_BROWSER_TOOLS;
+// Individual tool exports for direct imports
+export const [browserNavigateTool, browserSnapshotTool, browserClickTool, browserTypeTool, browserSearchTool, browserScreenshotTool, browserPagesTool, browserCloseTool,] = CHAT_BROWSER_TOOLS;
+// Re-export safe tool names for default chat tools
+export { SAFE_BROWSER_TOOL_NAMES };
+//# sourceMappingURL=browser.js.map

package/dist/chat/execution/tools/canvas.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Canvas Render Tool
+ *
+ * Lets the AI agent render visual artifacts (code blocks, charts, diagrams,
+ * tables, HTML, markdown, mermaid diagrams, SVG) that appear in the dashboard
+ * Live Canvas panel.
+ */
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+export interface CanvasArtifact {
+    id: string;
+    type: 'code' | 'chart' | 'diagram' | 'table' | 'html' | 'markdown' | 'mermaid' | 'svg';
+    content: string;
+    title?: string;
+    language?: string;
+    metadata?: Record<string, unknown>;
+    conversationId: string;
+    createdAt: number;
+}
+export interface CanvasRenderResult {
+    artifactId: string;
+    type: string;
+    title?: string;
+    /** First 200 chars of content for confirmation */
+    preview: string;
+}
+/**
+ * Retrieve a stored artifact by ID.
+ */
+export declare function getArtifact(id: string): CanvasArtifact | undefined;
+/**
+ * List stored artifacts, optionally filtered by conversation.
+ */
+export declare function listArtifacts(conversationId?: string): CanvasArtifact[];
+/**
+ * Clear stored artifacts. Returns the count of removed entries.
+ */
+export declare function clearArtifacts(conversationId?: string): number;
+declare const CanvasRenderParamsSchema: z.ZodObject<{
+    type: z.ZodEnum<["code", "chart", "diagram", "table", "html", "markdown", "mermaid", "svg"]>;
+    content: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type: "code" | "markdown" | "table" | "chart" | "diagram" | "html" | "mermaid" | "svg";
+    content: string;
+    title?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    language?: string | undefined;
+}, {
+    type: "code" | "markdown" | "table" | "chart" | "diagram" | "html" | "mermaid" | "svg";
+    content: string;
+    title?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    language?: string | undefined;
+}>;
+export type CanvasRenderParams = z.infer<typeof CanvasRenderParamsSchema>;
+export declare const canvasRenderTool: ToolDefinition<CanvasRenderParams, CanvasRenderResult>;
+export {};
+//# sourceMappingURL=canvas.d.ts.map