Implement TSX-based prompt composition for AgentPanelProvider (#397)

plusplusoneplusplus · web-flow · commit dc2dd4646c32 · 2025-06-28T16:04:18.000-07:00
- Replace string concatenation with sophisticated TSX-based prompt composition - Add AgentPrompt component with intelligent priority-based message ordering - Implement token allocation strategy with configurable limits - Add graceful fallback from TSX to string concatenation for backward compatibility - Extend AgentCapabilities interface with TSX support metadata - Create comprehensive test suite for TSX integration - Add conversation history integration with smart truncation - Implement configuration options for token limits and prioritization Resolves #378
diff --git a/wu-wei/src/interfaces/agentInterface.ts b/wu-wei/src/interfaces/agentInterface.ts
@@ -53,7 +53,15 @@ export interface AgentCapabilities {
     version: string;
     methods: string[];
     description?: string;
-    metadata?: Record<string, any>;
+    metadata?: {
+        promptSupport?: {
+            supportsPrompts: boolean;
+            supportsTsxMessages?: boolean;
+            promptParameterName?: string;
+            variableResolution?: boolean;
+        };
+        [key: string]: any;
+    };
 }
 
 /**
diff --git a/wu-wei/src/providers/agentPanelProvider.ts b/wu-wei/src/providers/agentPanelProvider.ts
@@ -10,23 +10,42 @@ import {
     GitHubCopilotAgent,
     AgentMessage
 } from '../interfaces/agentInterface';
-import { PromptService, PromptUsageContext } from '../shared/promptManager/types';
+import { PromptService, PromptUsageContext, TsxRenderOptions, TsxRenderResult } from '../shared/promptManager/types';
 import { PromptServiceFactory } from '../shared/promptManager/PromptServiceFactory';
+import { AgentPrompt } from '../shared/promptManager/tsx/components/AgentPrompt';
+import { ChatMessage, DEFAULT_PRIORITIES } from '../shared/promptManager/tsx/types';
+
+/**
+ * Configuration interface for agent prompt handling
+ */
+interface AgentPromptConfig {
+    maxTokens: number;
+    historyMessageCount: number;
+    enablePrioritization: boolean;
+    fallbackToStringConcatenation: boolean;
+}
 
 /**
  * Wu Wei Agent Panel Provider (Enhanced with Prompt Integration)
  * Provides a panel for triggering agents with messages using separated HTML, CSS, and JavaScript files
  * Phase 4: Added prompt selection and integration capabilities
+ * Phase 5: Enhanced with TSX-based prompt composition (Issue #378)
  */
 export class AgentPanelProvider extends BaseWebviewProvider implements vscode.WebviewViewProvider {
     private _agentRegistry: AgentRegistry;
     private _messageHistory: AgentMessage[] = [];
     private _promptService: PromptService;
     private _selectedPromptContext?: PromptUsageContext;
+    private _agentPromptConfig: AgentPromptConfig = {
+        maxTokens: 4096,
+        historyMessageCount: 4,
+        enablePrioritization: true,
+        fallbackToStringConcatenation: true
+    };
 
     constructor(context: vscode.ExtensionContext) {
         super(context);
-        logger.debug('Wu Wei Agent Panel Provider initialized with prompt integration');
+        logger.debug('Wu Wei Agent Panel Provider initialized with prompt integration and TSX support');
 
         // Initialize prompt service
         this._promptService = PromptServiceFactory.createService(context);
@@ -266,6 +285,21 @@ export class AgentPanelProvider extends BaseWebviewProvider implements vscode.We
             return params;
         }
 
+        // Try TSX-based rendering first if enabled
+        if (this._agentPromptConfig.enablePrioritization) {
+            try {
+                return await this.enhanceParamsWithTsxPrompt(params, promptContext, agent);
+            } catch (error) {
+                logger.warn('TSX prompt rendering failed, falling back to string concatenation', error);
+
+                // If fallback is disabled, re-throw the error
+                if (!this._agentPromptConfig.fallbackToStringConcatenation) {
+                    throw error;
+                }
+            }
+        }
+
+        // Original string concatenation logic (fallback)
         const capabilities = agent.getCapabilities();
         const promptSupport = capabilities.metadata?.promptSupport;
 
@@ -320,6 +354,146 @@ export class AgentPanelProvider extends BaseWebviewProvider implements vscode.We
         return params;
     }
 
+    /**
+     * Enhanced TSX-based prompt parameter enhancement
+     * Replaces string concatenation with intelligent TSX composition
+     */
+    private async enhanceParamsWithTsxPrompt(
+        params: any,
+        promptContext: any,
+        agent: AbstractAgent
+    ): Promise<any> {
+        if (!promptContext) {
+            return params;
+        }
+
+        const userInput = params.message || params.question || params.query || params.input;
+        if (!userInput) {
+            throw new Error('Please provide a custom message to combine with the prompt template');
+        }
+
+        // Render the prompt with variables
+        const rendered = await this._promptService.renderPromptWithVariables(
+            promptContext.promptId,
+            promptContext.variables
+        );
+
+        // Convert message history to ChatMessage format
+        const conversationHistory: ChatMessage[] = this._messageHistory
+            .filter(msg => msg.type === 'request' || msg.type === 'response')
+            .slice(-this._agentPromptConfig.historyMessageCount)
+            .map(msg => ({
+                role: msg.type === 'request' ? 'user' : 'assistant',
+                content: this.extractMessageContent(msg),
+                timestamp: msg.timestamp,
+                id: msg.id
+            }));
+
+        // Prepare TSX rendering options
+        const tsxOptions: TsxRenderOptions = {
+            modelMaxPromptTokens: this._agentPromptConfig.maxTokens,
+            enablePrioritization: this._agentPromptConfig.enablePrioritization,
+            tokenBudget: this._agentPromptConfig.maxTokens
+        };
+
+        // Render TSX prompt with intelligent composition
+        const tsxResult: TsxRenderResult = await this._promptService.renderTsxPrompt(
+            AgentPrompt,
+            {
+                systemPrompt: rendered,
+                userInput: userInput,
+                conversationHistory: conversationHistory,
+                contextData: params.context || '',
+                maxTokens: this._agentPromptConfig.maxTokens,
+                priorityStrategy: DEFAULT_PRIORITIES
+            },
+            tsxOptions
+        );
+
+        // Check agent capabilities for TSX support
+        const capabilities = agent.getCapabilities();
+        const promptSupport = capabilities.metadata?.promptSupport;
+
+        if (promptSupport?.supportsPrompts && promptSupport.supportsTsxMessages) {
+            // Agent supports TSX messages directly
+            return {
+                ...params,
+                messages: tsxResult.messages,
+                tokenCount: tsxResult.tokenCount,
+                renderingMetadata: tsxResult.renderingMetadata
+            };
+        } else {
+            // Convert TSX messages back to string format for compatibility
+            const combinedMessage = this.convertTsxMessagesToString(tsxResult.messages);
+
+            return {
+                ...params,
+                message: combinedMessage,
+                tokenCount: tsxResult.tokenCount,
+                renderingMetadata: tsxResult.renderingMetadata
+            };
+        }
+    }
+
+    /**
+     * Extract content from AgentMessage for conversation history
+     */
+    private extractMessageContent(message: AgentMessage): string {
+        if (message.type === 'request') {
+            return message.params?.message || message.params?.query || message.params?.input || 'Request';
+        } else if (message.type === 'response') {
+            return message.result?.message || message.result?.content || JSON.stringify(message.result || {});
+        }
+        return 'Unknown message';
+    }
+
+    /**
+     * Convert TSX messages to string format for agents that don't support TSX
+     */
+    private convertTsxMessagesToString(messages: vscode.LanguageModelChatMessage[]): string {
+        return messages.map(msg => {
+            // Map roles to string labels
+            let role = 'USER';
+            if (msg.role === vscode.LanguageModelChatMessageRole.User) {
+                role = 'USER';
+            } else {
+                // For any other role (system, assistant, etc.), use generic labels
+                role = 'ASSISTANT';
+            }
+
+            // Extract text content from message
+            const content = Array.isArray(msg.content)
+                ? msg.content.map(part => {
+                    if (typeof part === 'string') {
+                        return part;
+                    } else if (part && typeof part === 'object' && 'text' in part) {
+                        return part.text;
+                    } else if (part && typeof part === 'object' && 'value' in part) {
+                        return String(part.value);
+                    }
+                    return JSON.stringify(part);
+                }).join(' ')
+                : String(msg.content);
+
+            return `${role}: ${content}`;
+        }).join('\n\n');
+    }
+
+    /**
+     * Update agent prompt configuration
+     */
+    public updateAgentPromptConfig(config: Partial<AgentPromptConfig>): void {
+        this._agentPromptConfig = { ...this._agentPromptConfig, ...config };
+        logger.info('Agent prompt configuration updated', this._agentPromptConfig);
+    }
+
+    /**
+     * Get current agent prompt configuration
+     */
+    public getAgentPromptConfig(): AgentPromptConfig {
+        return { ...this._agentPromptConfig };
+    }
+
     private async sendAvailablePrompts(): Promise<void> {
         try {
             const prompts = await this._promptService.getAllPrompts();
diff --git a/wu-wei/src/shared/promptManager/tsx/components/AgentPrompt.tsx b/wu-wei/src/shared/promptManager/tsx/components/AgentPrompt.tsx
@@ -1,14 +1,13 @@
-import { PromptElement } from '@vscode/prompt-tsx';
+import { PromptElement, SystemMessage, UserMessage } from '@vscode/prompt-tsx';
 import { AgentPromptProps, DEFAULT_PRIORITIES } from '../types';
 import { PromptHelpers } from '../utils';
-// import { SystemInstructionMessage } from './SystemInstructionMessage';
-// import { UserQueryMessage } from './UserQueryMessage';
-// import { ConversationHistoryMessages } from './ConversationHistoryMessages';
-// import { ContextDataMessage } from './ContextDataMessage';
+import { ConversationHistoryMessages } from './ConversationHistoryMessages';
 
 /**
  * AgentPrompt - Main prompt composition component with priority-based message composition
  * This component orchestrates all message types and handles token budgeting and prioritization
+ * 
+ * Replaces string concatenation in AgentPanelProvider with intelligent TSX-based composition
  */
 export class AgentPrompt extends PromptElement<AgentPromptProps> {
     render() {
@@ -17,7 +16,7 @@ export class AgentPrompt extends PromptElement<AgentPromptProps> {
             userInput,
             conversationHistory = [],
             contextData,
-            maxTokens = 4000,
+            maxTokens = 4096,
             priorityStrategy = DEFAULT_PRIORITIES,
             ...rest
         } = this.props;
@@ -28,12 +27,53 @@ export class AgentPrompt extends PromptElement<AgentPromptProps> {
             throw new Error(`AgentPrompt validation failed: ${errors.join(', ')}`);
         }
 
-        // For now, return a simple structure while we resolve typing issues
+        // Split conversation history for prioritization
+        const recentHistory = conversationHistory.slice(-2); // Last 2 messages - high priority
+        const olderHistory = conversationHistory.slice(0, -2); // Older messages - medium priority
+
+        // Prepare context data with token limit
+        const contextWithLabel = contextData
+            ? `Additional Context:\n${PromptHelpers.truncateToTokenLimit(contextData, Math.floor(maxTokens * 0.2))}`
+            : null;
+
         return (
             <>
-                {/* TODO: Implement full component composition once typing issues are resolved */}
-                {systemPrompt}
-                {userInput}
+                {/* System instructions - highest priority, never pruned */}
+                <SystemMessage priority={priorityStrategy.systemInstructions}>
+                    {systemPrompt}
+                </SystemMessage>
+
+                {/* Current user query - very high priority */}
+                <UserMessage priority={priorityStrategy.userQuery}>
+                    {userInput}
+                </UserMessage>
+
+                {/* Recent conversation history - high priority */}
+                {recentHistory.length > 0 && (
+                    <ConversationHistoryMessages
+                        history={recentHistory}
+                        priority={85}
+                        maxMessages={2}
+                        includeTimestamps={false}
+                    />
+                )}
+
+                {/* Older conversation history - medium priority */}
+                {olderHistory.length > 0 && (
+                    <ConversationHistoryMessages
+                        history={olderHistory}
+                        priority={priorityStrategy.conversationHistory}
+                        maxMessages={4}
+                        includeTimestamps={false}
+                    />
+                )}
+
+                {/* Additional context - flexible priority, can be pruned */}
+                {contextWithLabel && (
+                    <UserMessage priority={priorityStrategy.contextData}>
+                        {contextWithLabel}
+                    </UserMessage>
+                )}
             </>
         );
     }
@@ -67,4 +107,23 @@ export class AgentPrompt extends PromptElement<AgentPromptProps> {
 
         return messageCount;
     }
+
+    /**
+     * Get token allocation strategy for different content types
+     */
+    private getTokenAllocation(maxTokens: number): {
+        system: number;
+        userQuery: number;
+        recentHistory: number;
+        olderHistory: number;
+        context: number;
+    } {
+        return {
+            system: Math.floor(maxTokens * 0.3), // 30% for system instructions
+            userQuery: Math.floor(maxTokens * 0.2), // 20% for user query
+            recentHistory: Math.floor(maxTokens * 0.2), // 20% for recent history
+            olderHistory: Math.floor(maxTokens * 0.15), // 15% for older history
+            context: Math.floor(maxTokens * 0.15) // 15% for context data
+        };
+    }
 } 
diff --git a/wu-wei/src/test/integration/promptStore/agentPromptIntegration.test.ts b/wu-wei/src/test/integration/promptStore/agentPromptIntegration.test.ts
