profclaw 2.0.0 → 2.4.0

package/dist/chat/agentic-executor.js

@@ -15,9 +15,25 @@ import { randomUUID } from 'node:crypto';
 import { tool as createTool, jsonSchema } from 'ai';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 import { AgentExecutor } from '../agents/index.js';
+import { bridgeStreamToSSE } from '../server/stream-bridge.js';
+import { broadcastEvent } from '../server.js';
 import { MODEL_ALIASES } from '../providers/core/models.js';
+import { routeQuery, recordRoutingDecision, isSmartRouterEnabled } from '../providers/smart-router.js';
+import { generateSuggestions, gatherContext } from './proactive/index.js';
+// Experience store lazy import to avoid circular deps
+let experienceStorePromise = null;
+function getExperienceStore() {
+    if (!experienceStorePromise) {
+        experienceStorePromise = import('../memory/experience-store.js').catch(() => {
+            experienceStorePromise = null;
+            return null;
+        });
+    }
+    return experienceStorePromise;
+}
 import { normalizeToolSchema } from '../providers/schema-utils.js';
 import { logger } from '../utils/logger.js';
+import { selectToolsForRequest } from '../agents/tool-selector.js';
 import { runWithModelFallback, getUserFriendlyErrorMessage, getProvidersInCooldown, describeFailoverError, } from './failover/index.js';
 const passthroughValidate = (value) => ({
     success: true,
@@ -142,24 +158,80 @@ export async function executeAgenticChat(request) {
         conversationId: request.conversationId,
         goal: goal.substring(0, 100),
     });
-    // Resolve the primary model and provider
+    // Team budget check (if user is in a team)
+    if (request.teamId && request.userId) {
+        try {
+            const { canMemberSpend, recordMemberUsage } = await import('../teams/index.js');
+            const budgetCheck = await canMemberSpend(request.teamId, request.userId, 0.05); // estimated min cost
+            if (!budgetCheck.allowed) {
+                return {
+                    content: `Budget exceeded: ${budgetCheck.reason}. Contact your team admin to increase the budget.`,
+                    model: 'none',
+                    provider: 'none',
+                    usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0, cost: 0 },
+                    agentState: { sessionId, totalSteps: 0, stopReason: 'budget_exceeded', artifacts: [] },
+                };
+            }
+        }
+        catch {
+            // Teams module not initialized - skip budget check
+        }
+    }
+    // Resolve the primary model and provider - fully provider-agnostic
     const explicitProvider = request.provider;
-    const modelRef = request.model || 'sonnet';
+    const configuredProviders = aiProvider.getConfiguredProviders();
+    const availableProviders = new Set(configuredProviders);
+    // Smart Model Router: auto-select model based on query complexity
+    let modelRef = request.model;
+    let smartRouted = false;
+    if (!request.model && !explicitProvider && isSmartRouterEnabled()) {
+        const routingDecision = routeQuery(goal, availableProviders, {
+            conversationLength: request.messages.length,
+            hasToolUse: request.tools.length > 0,
+            hasCodeContext: request.tools.some(t => t.name.startsWith('git_') || t.name === 'exec'),
+            hasImages: false,
+        });
+        modelRef = routingDecision.selectedModel.id;
+        smartRouted = true;
+        recordRoutingDecision(routingDecision);
+        logger.info('[AgenticChat] Smart-routed to model', {
+            tier: routingDecision.complexity.tier,
+            model: routingDecision.selectedModel.id,
+            provider: routingDecision.selectedModel.provider,
+            savings: `${routingDecision.savingsPercent}%`,
+            reasoning: routingDecision.complexity.reasoning,
+        });
+    }
+    // Fall back to provider-agnostic default if no model specified
+    if (!modelRef) {
+        modelRef = aiProvider.getDefaultProvider();
+        // Try to get the default model for the default provider
+        try {
+            const resolved = aiProvider.resolveModel(modelRef);
+            modelRef = resolved.model;
+        }
+        catch {
+            modelRef = 'sonnet'; // last resort alias
+        }
+    }
     const aliasEntry = MODEL_ALIASES[modelRef];
-    const primaryProvider = explicitProvider || (aliasEntry?.provider || 'anthropic');
+    // Resolve provider from alias, smart route result, or configured default
+    const primaryProvider = explicitProvider
+        ?? (aliasEntry?.provider && availableProviders.has(aliasEntry.provider) ? aliasEntry.provider : undefined)
+        ?? aiProvider.getDefaultProvider();
     // For Azure and similar providers, use the configured deployment name, not hardcoded alias
-    let primaryModel = aliasEntry?.model || modelRef;
-    try {
-        const resolved = aiProvider.resolveModel(primaryProvider);
-        if (resolved.provider === primaryProvider && resolved.model) {
-            primaryModel = resolved.model; // Use configured deployment (e.g., 'gpt4o')
+    let primaryModel = smartRouted ? modelRef : (aliasEntry?.model || modelRef);
+    if (!smartRouted) {
+        try {
+            const resolved = aiProvider.resolveModel(primaryProvider);
+            if (resolved.provider === primaryProvider && resolved.model) {
+                primaryModel = resolved.model;
+            }
+        }
+        catch {
+            // Keep the alias model if provider not configured
         }
     }
-    catch {
-        // Keep the alias model if provider not configured
-    }
-    // Get configured providers
-    const configuredProviders = aiProvider.getConfiguredProviders();
     // Log if any providers are in cooldown
     const cooldowns = getProvidersInCooldown();
     if (cooldowns.length > 0) {
@@ -171,19 +243,79 @@ export async function executeAgenticChat(request) {
             })),
         });
     }
+    // Clone the base system prompt to avoid mutating the request object on retry
+    const baseSystemPrompt = request.systemPrompt ?? '';
+    // Volatile per-request context is kept out of the base prompt so the base stays byte-stable
+    // for prompt caching (a second system message follows the stable one)
+    let volatileContext = '';
+    // Recall relevant past experiences to enhance system prompt
+    try {
+        const store = await getExperienceStore();
+        if (store) {
+            const similar = await store.findSimilarExperiences(goal, [], 3);
+            const hints = similar
+                .filter(exp => exp.successScore >= 0.7 && exp.weight > 0.1)
+                .slice(0, 2)
+                .map(exp => {
+                if (exp.type === 'tool_chain') {
+                    const chain = exp.solution;
+                    return `Previously solved similar task using: ${chain.tools.map(t => t.name).join(' -> ')} (used ${exp.useCount}x)`;
+                }
+                return `Past experience: ${exp.intent} (score: ${exp.successScore})`;
+            });
+            if (hints.length > 0) {
+                volatileContext += `\n\nRelevant past experiences:\n${hints.join('\n')}`;
+                logger.debug('[AgenticChat] Injected experience context', { count: hints.length });
+                for (const exp of similar.slice(0, 2)) {
+                    store.markUsed(exp.id).catch(() => { });
+                }
+            }
+        }
+    }
+    catch {
+        // Experience recall is best-effort
+    }
+    // Auto-context gathering for complex queries (code/file-related tasks)
+    if (request.tools.length > 0 && goal.length > 30) {
+        try {
+            const context = await gatherContext(goal, {
+                maxSources: 4,
+                maxTokens: 2000,
+                includeFiles: true,
+                includeMemory: false, // memory handled by experience store above
+                includeHistory: false,
+            });
+            if (context.sources.length > 0) {
+                const contextBlock = context.sources
+                    .map(s => `[${s.type}${s.path ? `: ${s.path}` : ''}]\n${s.content.slice(0, 500)}`)
+                    .join('\n\n');
+                volatileContext += `\n\nProject context (auto-gathered):\n${contextBlock}`;
+                logger.debug('[AgenticChat] Injected project context', {
+                    sources: context.sources.length,
+                    tokens: context.tokens,
+                });
+            }
+        }
+        catch {
+            // Context gathering is best-effort
+        }
+    }
     // Create agent configuration
     const agentConfig = {
-        maxSteps: 50, // Allow up to 50 steps for complex tasks
-        maxBudget: 50000, // 50k token budget
+        maxSteps: 20, // Reasonable default
+        maxBudget: parseInt(process.env.PROFCLAW_AGENT_MAX_BUDGET || '30000', 10), // configurable via PROFCLAW_AGENT_MAX_BUDGET
         securityMode: 'ask', // Prompt for approval when needed
         enableStreaming: true,
         effort: request.effort,
     };
     // Store raw tool definitions - we'll convert to AI SDK format per-provider
-    const toolDefinitions = request.tools;
+    // Per-turn tool selection (core set + relevant groups + load_tools meta-tool)
+    const turnUserMessage = [...request.messages].reverse().find((m) => m.role === 'user');
+    const toolDefinitions = selectToolsForRequest(request.tools, request.conversationId, typeof turnUserMessage?.content === 'string' ? turnUserMessage.content : '');
     // Build messages with system prompt
     const messages = [
-        { role: 'system', content: request.systemPrompt },
+        { role: 'system', content: baseSystemPrompt },
+        ...(volatileContext ? [{ role: 'system', content: volatileContext.trim() }] : []),
         ...request.messages.map((m) => ({
             role: m.role,
             content: m.content,
@@ -223,8 +355,10 @@ export async function executeAgenticChat(request) {
                         request.onToolResult(state, toolCall.name, toolCall.result);
                     });
                 }
-                // Run the agent with normalized tools (pass provider hint for effort/thinking)
-                return agent.run(modelInstance, messages, aiSdkTools, onToolExecute, provider);
+                // Run the agent with normalized tools (pass provider hint for effort/thinking).
+                // Bridge the stream to SSE so connected clients receive real-time events.
+                await bridgeStreamToSSE(agent.stream(modelInstance, messages, aiSdkTools, onToolExecute, provider), broadcastEvent, sessionId);
+                return agent.getState();
             },
             onError: (attempt) => {
                 const described = describeFailoverError(attempt.error);
@@ -290,6 +424,51 @@ export async function executeAgenticChat(request) {
             model: actualModel,
             usedFallback,
         });
+        // Record team usage (async, non-blocking)
+        if (request.teamId && request.userId) {
+            import('../teams/index.js').then(({ recordMemberUsage }) => {
+                const estimatedCost = finalState.usedBudget * 0.00001; // rough token-to-cost estimate
+                recordMemberUsage(request.teamId, request.userId, estimatedCost).catch(() => { });
+            }).catch(() => { });
+        }
+        // Record successful tool chains to experience store (async, non-blocking)
+        if (toolCalls.length > 0) {
+            const successfulCalls = toolCalls.filter(tc => tc.status === 'success');
+            if (successfulCalls.length > 0) {
+                getExperienceStore().then(async (store) => {
+                    if (!store)
+                        return;
+                    try {
+                        await store.recordExperience({
+                            type: 'tool_chain',
+                            intent: goal.slice(0, 200),
+                            solution: {
+                                tools: successfulCalls.map(tc => ({ name: tc.name, params: tc.arguments })),
+                                totalDurationMs: finalState.usedBudget,
+                                allSucceeded: successfulCalls.length === toolCalls.length,
+                            },
+                            successScore: successfulCalls.length / Math.max(toolCalls.length, 1),
+                            tags: [
+                                ...new Set(successfulCalls.map(tc => tc.name)),
+                                actualProvider,
+                                actualModel,
+                            ],
+                            sourceConversationId: request.conversationId,
+                        });
+                    }
+                    catch {
+                        // Non-critical - don't break execution
+                    }
+                }).catch(() => { });
+            }
+        }
+        // Generate proactive follow-up suggestions
+        const suggestions = generateSuggestions(goal, {
+            failedTests: toolCalls.filter(tc => tc.name === 'test_run' && tc.status === 'error').length,
+            createdFiles: toolCalls.filter(tc => tc.name === 'write_file' && tc.status === 'success')
+                .map(tc => String(tc.arguments['path'] ?? '')).filter(Boolean),
+            prCreated: toolCalls.some(tc => tc.name === 'github_pr' && tc.status === 'success'),
+        });
         return {
             content,
             model: actualModel,
@@ -313,6 +492,7 @@ export async function executeAgenticChat(request) {
                 requestedModel: primaryModel,
                 attempts: fallbackResult.attempts,
             },
+            suggestions: suggestions.length > 0 ? suggestions : undefined,
         };
     }
     catch (error) {
@@ -375,18 +555,40 @@ export async function* streamAgenticChat(request) {
         goal: goal.substring(0, 100),
         showThinking,
     });
-    // Resolve the primary model and provider
-    // If provider is explicitly given, use it directly
+    // Resolve the primary model and provider - provider-agnostic
     const explicitProvider = request.provider;
-    const modelRef = request.model || 'sonnet';
+    const configuredProviders = aiProvider.getConfiguredProviders();
+    const availableProviders = new Set(configuredProviders);
+    // Use smart routing for streaming too
+    let modelRef = request.model;
+    if (!request.model && !explicitProvider && isSmartRouterEnabled()) {
+        const routingDecision = routeQuery(goal, availableProviders, {
+            conversationLength: request.messages.length,
+            hasToolUse: request.tools.length > 0,
+        });
+        modelRef = routingDecision.selectedModel.id;
+        recordRoutingDecision(routingDecision);
+    }
+    // Fall back to provider-agnostic default
+    if (!modelRef) {
+        try {
+            const resolved = aiProvider.resolveModel(aiProvider.getDefaultProvider());
+            modelRef = resolved.model;
+        }
+        catch {
+            modelRef = 'sonnet';
+        }
+    }
     const aliasEntry = MODEL_ALIASES[modelRef];
-    const primaryProvider = explicitProvider || (aliasEntry?.provider || 'anthropic');
-    // For Azure and similar providers, use the configured deployment name, not hardcoded alias
+    const primaryProvider = explicitProvider
+        ?? (aliasEntry?.provider && availableProviders.has(aliasEntry.provider) ? aliasEntry.provider : undefined)
+        ?? aiProvider.getDefaultProvider();
+    // For Azure and similar providers, use the configured deployment name
     let primaryModel = aliasEntry?.model || modelRef;
     try {
         const resolved = aiProvider.resolveModel(primaryProvider);
         if (resolved.provider === primaryProvider && resolved.model) {
-            primaryModel = resolved.model; // Use configured deployment (e.g., 'gpt4o')
+            primaryModel = resolved.model;
         }
     }
     catch {
@@ -398,8 +600,6 @@ export async function* streamAgenticChat(request) {
         primaryProvider,
         primaryModel,
     });
-    // Get configured providers
-    const configuredProviders = aiProvider.getConfiguredProviders();
     if (configuredProviders.length === 0) {
         yield {
             type: 'error',
@@ -438,14 +638,18 @@ export async function* streamAgenticChat(request) {
     };
     // Create agent configuration
     const agentConfig = {
-        maxSteps: request.maxSteps ?? 50,
-        maxBudget: request.maxBudget ?? 50000,
+        maxSteps: request.maxSteps ?? 20,
+        // Azure counts cached prompt tokens in totalUsage (inflates to ~75K for tool schemas)
+        // Set budget high enough for multi-step tasks without premature abort
+        maxBudget: request.maxBudget ?? 500000,
         securityMode: 'ask',
         enableStreaming: true,
         effort: request.effort,
     };
     // Store raw tool definitions - we'll convert to AI SDK format per-provider
-    const toolDefinitions = request.tools;
+    // Per-turn tool selection, same as the non-streaming path
+    const turnUserMessage = [...request.messages].reverse().find((m) => m.role === 'user');
+    const toolDefinitions = selectToolsForRequest(request.tools, request.conversationId, typeof turnUserMessage?.content === 'string' ? turnUserMessage.content : '');
     // Build messages with system prompt
     const messages = [
         { role: 'system', content: request.systemPrompt },
@@ -608,8 +812,10 @@ export async function* streamAgenticChat(request) {
                     // Convert tool definitions to AI SDK format with execute wrappers
                     const aiSdkTools = convertToolsToAiSdk(toolDefinitions, provider, 'AgenticChat/Stream', onToolExecute);
                     // Run the agent — tools already have execute functions,
-                    // pass provider hint for effort/thinking options
-                    return agent.run(modelInstance, messages, aiSdkTools, onToolExecute, provider);
+                    // pass provider hint for effort/thinking options.
+                    // Bridge the stream to SSE so connected clients receive real-time events.
+                    await bridgeStreamToSSE(agent.stream(modelInstance, messages, aiSdkTools, onToolExecute, provider), broadcastEvent, sessionId);
+                    return agent.getState();
                 },
                 onError: (attempt) => {
                     const described = describeFailoverError(attempt.error);
@@ -734,6 +940,31 @@ export async function* streamAgenticChat(request) {
             usedFallback,
             attempts: fallbackAttempts.length,
         });
+        // Record tool chain to experience store (async, non-blocking)
+        const successfulCalls = toolCalls.filter(tc => tc.status === 'success');
+        if (successfulCalls.length > 0) {
+            getExperienceStore().then(async (store) => {
+                if (!store)
+                    return;
+                try {
+                    await store.recordExperience({
+                        type: 'tool_chain',
+                        intent: goal.slice(0, 200),
+                        solution: {
+                            tools: successfulCalls.map(tc => ({ name: tc.name, params: tc.arguments })),
+                            totalDurationMs: state.usedBudget,
+                            allSucceeded: successfulCalls.length === toolCalls.length,
+                        },
+                        successScore: successfulCalls.length / Math.max(toolCalls.length, 1),
+                        tags: [...new Set(successfulCalls.map(tc => tc.name)), actualProvider, actualModel],
+                        sourceConversationId: request.conversationId,
+                    });
+                }
+                catch {
+                    // Non-critical
+                }
+            }).catch(() => { });
+        }
     }
 }
 //# sourceMappingURL=agentic-executor.js.map

package/dist/chat/conversations.d.ts

@@ -76,6 +76,7 @@ export declare function getRecentConversationsWithPreview(limit?: number): Promi
     preview: string;
     messageCount: number;
 }>>;
+export declare function deleteMessage(conversationId: string, messageId: string): Promise<void>;
 declare const _default: {
     initConversationTables: typeof initConversationTables;
     createConversation: typeof createConversation;
@@ -86,6 +87,7 @@ declare const _default: {
     addMessage: typeof addMessage;
     getConversationMessages: typeof getConversationMessages;
     getRecentConversationsWithPreview: typeof getRecentConversationsWithPreview;
+    deleteMessage: typeof deleteMessage;
 };
 export default _default;
 //# sourceMappingURL=conversations.d.ts.map

package/dist/chat/conversations.js

@@ -283,6 +283,13 @@ export async function getRecentConversationsWithPreview(limit = 10) {
         messageCount: Number(row.message_count),
     }));
 }
+export async function deleteMessage(conversationId, messageId) {
+    const client = getClient();
+    await client.execute({
+        sql: `DELETE FROM conversation_messages WHERE id = ? AND conversation_id = ?`,
+        args: [messageId, conversationId],
+    });
+}
 export default {
     initConversationTables,
     createConversation,
@@ -293,5 +300,6 @@ export default {
     addMessage,
     getConversationMessages,
     getRecentConversationsWithPreview,
+    deleteMessage,
 };
 //# sourceMappingURL=conversations.js.map

package/dist/chat/execution/executor.d.ts

@@ -8,6 +8,14 @@
 import type { ToolExecutionContext, AIToolCall, ToolCallResult, ApprovalRequest, ApprovalDecision } from "./types.js";
 export declare class ToolExecutor {
     private abortControllers;
+    /**
+     * One CorrectionTracker per conversation, reset when a conversation ends.
+     * Key: conversationId
+     */
+    private correctionTrackers;
+    private getOrCreateTracker;
+    /** Call this when a conversation is done to free the tracker. */
+    resetCorrectionBudget(conversationId: string): void;
     /**
      * Execute a single tool call
      */