@timetotest/cli 0.3.1 → 0.3.2

package/dist/src/lib/agent-orchestrator.js

@@ -1,728 +1,27 @@
 /**
- * Agent Orchestrator - Main chat loop and backend integration
- * Manages conversation, tool calling, and execution
+ * AgentOrchestrator (CLI)
+ *
+ * The canonical agent loop now runs in the backend. This class is a thin client
+ * that:
+ * - starts/resumes backend sessions
+ * - registers CLI local tools (filesystem, browser MCP, command exec) via Socket.IO
+ * - executes backend-requested tool calls locally and returns results
+ *
+ * This intentionally replaces the previous TS-based ReAct loop to reduce
+ * duplicated orchestration code.
  */
-import { EventEmitter } from "events";
-import { SessionManager } from "./session-manager.js";
-import { ToolExecutor } from "./tool-executor.js";
-import { getToolSchemasByDomain } from "./tool-registry.js";
-import { isTestingMode } from "./testing-mode.js";
-import { configManager } from "./config.js";
-import { toolResultPruner } from "./tool-result-pruner.js";
-import { ContextCompactor } from "./context-compactor.js";
-import { createAgentHttpClient, } from "./http.js";
-import { build_cli_system_prompt } from "./prompts/builder.js";
-export class AgentOrchestrator extends EventEmitter {
-    sessionManager;
-    toolExecutor;
-    config;
-    conversationId;
-    httpClient;
-    isCancelled = false;
-    currentModel;
-    recentToolCalls = [];
-    static MAX_REPEATED_CALLS = 3;
-    contextCompactor;
-    // Reasoning chaining state (matches backend implementation)
-    lastResponseId = null;
-    pendingFunctionOutputs = null;
-    geminiThoughtSignatures = []; // Gemini-specific reasoning chaining
+import { BackendLoopClient } from "./backend-loop-client.js";
+export class AgentOrchestrator extends BackendLoopClient {
     constructor(config, sessionId) {
-        super(); // Initialize EventEmitter
-        this.config = config;
-        this.sessionManager = new SessionManager(sessionId);
-        this.conversationId = this.sessionManager.getSessionId();
-        this.httpClient = createAgentHttpClient({
-            baseUrl: config.apiUrl,
+        const backendCfg = {
+            apiUrl: config.apiUrl,
             token: config.token,
-        });
-        this.contextCompactor = new ContextCompactor();
-        // Initialize execution context
-        const executionContext = {
-            sessionManager: this.sessionManager,
-            testingMode: config.testingMode,
-            apiContext: {},
-            browserContext: {},
-        };
-        this.toolExecutor = new ToolExecutor(executionContext);
-        // Update session config
-        this.sessionManager.updateConfig({
-            mode: config.mode,
             testingMode: config.testingMode,
             baseUrl: config.baseUrl,
             apiBaseUrl: config.apiBaseUrl,
-        });
-    }
-    async chat(userMessage) {
-        this.isCancelled = false; // Reset cancellation flag
-        this.recentToolCalls = []; // Reset tool call tracking for new conversation turn
-        // Note: We do NOT reset lastResponseId or pendingFunctionOutputs here
-        // They persist across the conversation to enable reasoning chaining
-        // Add user message to history
-        this.sessionManager.addMessage({
-            role: "user",
-            content: userMessage,
-        });
-        const messages = this.sessionManager.getMessages();
-        const toolSchemas = this.getAvailableToolSchemas();
-        try {
-            if (this.config.mode === "local") {
-                return await this.handleLocalMode(messages, toolSchemas);
-            }
-            else {
-                throw new Error("Remote mode is no longer supported in this version.");
-            }
-        }
-        catch (error) {
-            return `Error: ${error.message}`;
-        }
-    }
-    cancel() {
-        this.isCancelled = true;
-        this.emit("agent_cancelled", {
-            message: "Agent execution cancelled",
-            data: { cancelled: true },
-        });
-    }
-    setTestingMode(mode) {
-        this.config.testingMode = mode;
-        this.sessionManager.updateConfig({
-            testingMode: mode,
-            baseUrl: this.config.baseUrl,
-            apiBaseUrl: this.config.apiBaseUrl,
-        });
-        this.toolExecutor.setTestingMode(mode, {
-            baseUrl: this.config.baseUrl,
-            apiBaseUrl: this.config.apiBaseUrl,
-        });
-    }
-    /**
-     * Set the permission prompt function for user interaction
-     */
-    setPermissionPromptFn(fn) {
-        this.toolExecutor.setPermissionPromptFn(fn);
-    }
-    async refreshHttpClient() {
-        // Refresh HTTP client with current token from config file
-        const { getAuthToken } = await import("./config.js");
-        const currentToken = getAuthToken();
-        if (currentToken) {
-            this.config.token = currentToken; // Update instance config
-        }
-        this.httpClient = createAgentHttpClient({
-            baseUrl: this.config.apiUrl,
-            token: this.config.token,
-        });
-    }
-    async handleLocalMode(messages, toolSchemas) {
-        // Auto-compact context if approaching token limits
-        this.autoCompactIfNeeded();
-        // Build system prompt with context
-        const systemPrompt = build_cli_system_prompt("unified_agent_react", {
-            user_goal: "Help the user with testing and automation tasks",
-            base_url: this.config.baseUrl,
-            api_base_url: this.config.apiBaseUrl,
-            test_type: this.config.testingMode,
-            mode: "local",
-        });
-        // Format messages and prepend system prompt
-        const formattedMessages = this.formatMessages(messages);
-        const messagesWithSystem = [
-            {
-                role: "system",
-                content: systemPrompt,
-            },
-            ...formattedMessages,
-        ];
-        // Add latest screenshot to context if available
-        const messagesWithScreenshot = this.addLatestScreenshotToContext(messagesWithSystem);
-        const payload = {
-            messages: messagesWithScreenshot,
-            tools: toolSchemas,
-            tool_choice: "auto",
-            context: {
-                test_id: this.conversationId,
-                mode: "local",
-                ...(this.currentModel && { ai_model: this.currentModel }),
-            },
-            mode: "local",
-            // Reasoning chaining (matches backend implementation):
-            // - function_outputs: Used by all providers to send tool results
-            // - previous_response_id: OpenAI-specific extended reasoning chaining
-            //   (backend filters this for non-OpenAI providers)
-            ...(this.pendingFunctionOutputs && {
-                function_outputs: this.pendingFunctionOutputs,
-            }),
-            ...(this.lastResponseId && { previous_response_id: this.lastResponseId }),
-        };
-        // Check for cancellation before HTTP request
-        if (this.isCancelled) {
-            return "Agent execution cancelled";
-        }
-        let result;
-        try {
-            result = await this.httpClient.postAgentReason(payload);
-        }
-        catch (error) {
-            // Handle 401 errors by refreshing the HTTP client and retrying once
-            if (error?.response?.status === 401) {
-                await this.refreshHttpClient();
-                result = await this.httpClient.postAgentReason(payload);
-            }
-            else {
-                throw error;
-            }
-        }
-        // Check for cancellation after HTTP request
-        if (this.isCancelled) {
-            return "Agent execution cancelled";
-        }
-        // Capture response ID for reasoning chaining (OpenAI-specific)
-        this.lastResponseId = result.id || null;
-        // Capture Gemini thought signatures for reasoning chaining
-        if (result.gemini_thought_signatures) {
-            this.geminiThoughtSignatures = result.gemini_thought_signatures;
-        }
-        // Clear pending function outputs after they've been sent
-        if (this.pendingFunctionOutputs) {
-            this.pendingFunctionOutputs = null;
-        }
-        const toolCall = this.extractToolCall(result);
-        if (toolCall) {
-            // IMPORTANT: Generate the tool call ID once and reuse everywhere to prevent mismatch
-            // If toolCall.id is undefined, we generate a fallback ID that MUST be used consistently
-            // in both the assistant message (with tool_calls) and the tool result message
-            const resolvedCallId = toolCall.id || `call_${Date.now()}`;
-            // Extract and emit assistant reasoning text first
-            const assistantReasoning = this.extractAssistantText(result);
-            if (assistantReasoning) {
-                this.emit("assistant_reasoning", {
-                    message: assistantReasoning,
-                    data: {
-                        reasoning: assistantReasoning,
-                    },
-                });
-                // Add assistant message with tool_calls to match backend format
-                const assistantMessage = {
-                    role: "assistant",
-                    content: assistantReasoning,
-                    toolCalls: [
-                        {
-                            id: resolvedCallId,
-                            name: toolCall.name,
-                            arguments: toolCall.arguments,
-                        },
-                    ],
-                };
-                // Add Gemini thought signatures if present (for reasoning chaining)
-                if (this.geminiThoughtSignatures.length > 0) {
-                    assistantMessage.gemini_thought_signatures = [
-                        ...this.geminiThoughtSignatures,
-                    ];
-                }
-                this.sessionManager.addMessage(assistantMessage);
-            }
-            else {
-                // No reasoning text, but still need to add assistant message with tool call
-                const assistantMessage = {
-                    role: "assistant",
-                    content: "",
-                    toolCalls: [
-                        {
-                            id: resolvedCallId,
-                            name: toolCall.name,
-                            arguments: toolCall.arguments,
-                        },
-                    ],
-                };
-                // Add Gemini thought signatures if present (for reasoning chaining)
-                if (this.geminiThoughtSignatures.length > 0) {
-                    assistantMessage.gemini_thought_signatures = [
-                        ...this.geminiThoughtSignatures,
-                    ];
-                }
-                this.sessionManager.addMessage(assistantMessage);
-            }
-            // Parse arguments for both event emission and tool execution
-            const parsedArguments = typeof toolCall.arguments === "string"
-                ? JSON.parse(toolCall.arguments)
-                : toolCall.arguments;
-            // Check for loop detection - same tool called repeatedly with similar args
-            const loopWarning = this.checkForToolLoop(toolCall.name, parsedArguments);
-            if (loopWarning) {
-                // Inject a warning message to help the agent break out of the loop
-                this.sessionManager.addMessage({
-                    role: "user",
-                    content: loopWarning,
-                });
-                // Continue to next iteration with the warning in context
-                return this.handleLocalMode(this.sessionManager.getMessages(), this.getAvailableToolSchemas());
-            }
-            // Emit tool start event
-            this.emit("tool_start", {
-                tool: toolCall.name,
-                message: `Running ${toolCall.name}...`,
-                data: {
-                    tool: toolCall.name,
-                    arguments: parsedArguments,
-                },
-            });
-            // Check for cancellation before tool execution
-            if (this.isCancelled) {
-                return "Agent execution cancelled";
-            }
-            const toolResult = await this.toolExecutor.execute({
-                name: toolCall.name,
-                arguments: parsedArguments,
-            });
-            const pendingScreenshot = this.toolExecutor.consumePendingScreenshot();
-            // Check for cancellation after tool execution
-            if (this.isCancelled) {
-                return "Agent execution cancelled";
-            }
-            // Emit tool result event
-            this.emit("tool_result", {
-                tool: toolCall.name,
-                message: `Completed ${toolCall.name}`,
-                data: {
-                    tool: toolCall.name,
-                    result: toolResult,
-                    success: toolResult?.success !== false,
-                },
-            });
-            if (toolCall.name === "set_testing_mode" &&
-                toolResult?.success &&
-                isTestingMode(toolResult.mode)) {
-                this.config.testingMode = toolResult.mode;
-                // Save mode preference for next session
-                configManager.setLastMode(toolResult.mode).catch(() => {
-                    // Ignore save errors - non-critical
-                });
-            }
-            // Handle finish tool - stop the agent loop
-            if (toolCall.name === "finish" && toolResult?.finished) {
-                this.sessionManager.addMessage({
-                    role: "tool",
-                    content: JSON.stringify(toolResult),
-                    toolCall: {
-                        id: resolvedCallId,
-                        name: toolCall.name,
-                        arguments: toolCall.arguments,
-                    },
-                });
-                return toolResult.summary || toolResult.message || "Task completed";
-            }
-            // Add tool result message with proper tool_call_id to match backend format
-            // Note: resolvedCallId was generated at the top of this block to ensure consistency
-            this.sessionManager.addMessage({
-                role: "tool",
-                content: JSON.stringify(toolResult),
-                toolCall: {
-                    id: resolvedCallId,
-                    name: toolCall.name,
-                    arguments: toolCall.arguments,
-                },
-            });
-            // Add to pending function outputs for reasoning chaining (matches backend)
-            const functionOutput = {
-                call_id: resolvedCallId,
-                output: JSON.stringify(toolResult),
-            };
-            if (!this.pendingFunctionOutputs) {
-                this.pendingFunctionOutputs = [];
-            }
-            this.pendingFunctionOutputs.push(functionOutput);
-            if (pendingScreenshot) {
-                const screenshotMessageId = this.handleScreenshotInHistory(pendingScreenshot.data, pendingScreenshot.action);
-                if (toolCall.name === "browser_take_screenshot" &&
-                    screenshotMessageId) {
-                    this.sessionManager.addMessage({
-                        role: "tool",
-                        content: JSON.stringify({
-                            success: true,
-                            screenshot_message_id: screenshotMessageId,
-                        }),
-                        toolCall: {
-                            id: `${toolCall.id || Date.now()}-link`,
-                            name: toolCall.name,
-                            arguments: { linked_message_id: screenshotMessageId },
-                        },
-                    });
-                }
-            }
-            // Prune tool results to optimize conversation history
-            this.pruneToolResults(toolCall.name);
-            // Check for cancellation before continuing
-            if (this.isCancelled) {
-                return "Agent execution cancelled";
-            }
-            return this.handleLocalMode(this.sessionManager.getMessages(), this.getAvailableToolSchemas());
-        }
-        const assistantMessage = this.extractAssistantText(result);
-        this.sessionManager.addMessage({
-            role: "assistant",
-            content: assistantMessage,
-        });
-        return assistantMessage;
-    }
-    getAvailableToolSchemas() {
-        const testingMode = this.config.testingMode;
-        const schemas = getToolSchemasByDomain(testingMode);
-        return Object.values(schemas).map((schema) => ({
-            type: "function",
-            function: schema,
-        }));
-    }
-    /**
-     * Check if the agent is stuck in a loop calling the same tool repeatedly
-     * Returns a warning message if loop detected, null otherwise
-     */
-    checkForToolLoop(toolName, args) {
-        const argsKey = JSON.stringify(args);
-        const callSignature = { name: toolName, args: argsKey };
-        // Track this call
-        this.recentToolCalls.push(callSignature);
-        // Keep only recent calls (last 10)
-        if (this.recentToolCalls.length > 10) {
-            this.recentToolCalls.shift();
-        }
-        // Count how many times this exact tool has been called (regardless of args for now)
-        // This catches cases where the agent keeps calling the same tool with slightly different args
-        const sameToolCalls = this.recentToolCalls.filter((call) => call.name === toolName);
-        if (sameToolCalls.length >= AgentOrchestrator.MAX_REPEATED_CALLS) {
-            // Check if args are similar
-            const similarCalls = sameToolCalls.filter((call) => this.areSimilarArgs(call.args, argsKey));
-            if (similarCalls.length >= AgentOrchestrator.MAX_REPEATED_CALLS) {
-                // Clear the tracking to allow fresh attempts after the warning
-                this.recentToolCalls = [];
-                return `[System Notice] You've called ${toolName} ${similarCalls.length} times with similar arguments. This appears to be a loop. 
-
-STOP and do one of the following:
-1. If you already have the information you need from previous tool results, USE IT to answer the user's question
-2. If the tool isn't returning what you expected, try a DIFFERENT tool or approach
-3. If you're stuck, explain what you're trying to accomplish and ask for guidance
-
-Do NOT call ${toolName} again with the same or similar arguments.`;
-            }
-        }
-        return null;
-    }
-    /**
-     * Check if two argument strings are similar (exact match or minor variations)
-     */
-    areSimilarArgs(args1, args2) {
-        // Exact match
-        if (args1 === args2)
-            return true;
-        // Parse and compare key fields for common tools
-        try {
-            const parsed1 = JSON.parse(args1);
-            const parsed2 = JSON.parse(args2);
-            // For directory/file tools, compare the path field
-            if ("path" in parsed1 && "path" in parsed2) {
-                // Normalize paths for comparison
-                const path1 = (parsed1.path || ".").replace(/^\.\//, "");
-                const path2 = (parsed2.path || ".").replace(/^\.\//, "");
-                return path1 === path2;
-            }
-            // For grep_search, compare query and path
-            if ("query" in parsed1 && "query" in parsed2) {
-                return parsed1.query === parsed2.query && parsed1.path === parsed2.path;
-            }
-            // For search_files, compare pattern
-            if ("pattern" in parsed1 && "pattern" in parsed2) {
-                return parsed1.pattern === parsed2.pattern;
-            }
-        }
-        catch {
-            // If parsing fails, fall back to string comparison
-        }
-        return false;
-    }
-    formatMessages(messages) {
-        return messages
-            .filter((msg) => msg.metadata?.type !== "screenshot")
-            .map((msg) => {
-            const base = {
-                role: msg.role,
-                content: typeof msg.content === "string"
-                    ? msg.content
-                    : JSON.stringify(msg.content),
-            };
-            // Handle assistant messages with tool calls
-            if (msg.role === "assistant" &&
-                msg.toolCalls &&
-                msg.toolCalls.length > 0) {
-                base.tool_calls = msg.toolCalls.map((tc) => ({
-                    id: tc.id,
-                    type: "function",
-                    function: {
-                        name: tc.name,
-                        arguments: typeof tc.arguments === "string"
-                            ? tc.arguments
-                            : JSON.stringify(tc.arguments),
-                    },
-                }));
-                // Include Gemini thought signatures for reasoning chaining
-                if (msg.gemini_thought_signatures &&
-                    msg.gemini_thought_signatures.length > 0) {
-                    base.gemini_thought_signatures = msg.gemini_thought_signatures;
-                }
-            }
-            // Handle tool result messages
-            if (msg.role === "tool" && msg.toolCall) {
-                base.name = msg.toolCall.name;
-                base.tool_call_id = msg.toolCall.id;
-            }
-            return base;
-        });
-    }
-    getMode() {
-        return "local";
-    }
-    getTestingMode() {
-        return this.config.testingMode;
-    }
-    getSessionId() {
-        return this.sessionManager.getSessionId();
-    }
-    getSessionPath() {
-        return this.sessionManager.getSessionPath();
-    }
-    getConversationHistory() {
-        return this.sessionManager.getMessages();
-    }
-    setModel(modelId) {
-        this.currentModel = modelId;
-    }
-    extractToolCall(result) {
-        // Check for single function call first
-        if (result.function_call &&
-            result.function_call.name &&
-            result.function_call.arguments) {
-            return {
-                id: result.function_call.id,
-                name: result.function_call.name,
-                arguments: result.function_call.arguments,
-            };
-        }
-        // Check for multiple function calls
-        if (result.multiple &&
-            Array.isArray(result.multiple) &&
-            result.multiple.length > 0) {
-            const call = result.multiple[0];
-            if (call && call.name && call.arguments) {
-                return {
-                    id: call.id,
-                    name: call.name,
-                    arguments: call.arguments,
-                };
-            }
-        }
-        // Legacy support for old format
-        if (result.name && result.arguments) {
-            return {
-                id: result.context?.tool_call_id,
-                name: result.name,
-                arguments: result.arguments,
-            };
-        }
-        return null;
-    }
-    extractAssistantText(result) {
-        if (typeof result.content === "string") {
-            return result.content;
-        }
-        if (Array.isArray(result.content)) {
-            const text = result.content
-                .map((chunk) => {
-                if (!chunk)
-                    return "";
-                if (typeof chunk === "string")
-                    return chunk;
-                if (typeof chunk?.text === "string")
-                    return chunk.text;
-                return "";
-            })
-                .filter(Boolean)
-                .join("\n")
-                .trim();
-            if (text) {
-                return text;
-            }
-        }
-        // Check reasoning field as fallback
-        if (result.reasoning) {
-            return result.reasoning;
-        }
-        return result.message || "";
-    }
-    handleScreenshotInHistory(screenshotData, actionName) {
-        try {
-            // Create a screenshot message for the conversation history
-            const screenshotMessage = {
-                id: `screenshot-${Date.now()}`,
-                role: "assistant",
-                content: "",
-                timestamp: Date.now(),
-                metadata: {
-                    type: "screenshot",
-                    action_name: actionName,
-                    screenshot_data: screenshotData,
-                    page_url: screenshotData.page_url,
-                    page_title: screenshotData.page_title,
-                    image_url: screenshotData.image_url, // CDN URL for AI usage
-                    cloudinary_uploaded: screenshotData.cloudinary_uploaded,
-                },
-            };
-            // Add screenshot message to conversation history
-            this.sessionManager.addMessage(screenshotMessage);
-            // Remove any previous screenshot messages to keep only the latest
-            this.removePreviousScreenshotMessages(screenshotMessage.id);
-            return screenshotMessage.id;
-        }
-        catch (error) {
-            // Don't fail the main flow if screenshot handling fails
-            return null;
-        }
-    }
-    removePreviousScreenshotMessages(currentScreenshotId) {
-        try {
-            const messages = this.sessionManager.getMessages();
-            const filteredMessages = messages.filter((msg) => {
-                // Keep the current screenshot message
-                if (msg.id === currentScreenshotId) {
-                    return true;
-                }
-                // Remove other screenshot messages
-                if (msg.metadata?.type === "screenshot") {
-                    return false;
-                }
-                return true;
-            });
-            // Clear and re-add filtered messages
-            this.sessionManager.clearMessages();
-            filteredMessages.forEach((msg) => this.sessionManager.addMessage(msg));
-        }
-        catch (error) {
-            // Ignore cleanup errors
-        }
-    }
-    addLatestScreenshotToContext(messages) {
-        // Only add screenshots for UI testing mode
-        if (this.config.testingMode !== "ui") {
-            return messages;
-        }
-        try {
-            const conversationMessages = this.sessionManager.getMessages();
-            // Find the latest screenshot message
-            const latestScreenshotMessage = conversationMessages
-                .filter((msg) => msg.metadata?.type === "screenshot")
-                .sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0))[0];
-            if (!latestScreenshotMessage?.metadata?.image_url) {
-                return messages;
-            }
-            const imageUrl = latestScreenshotMessage.metadata.image_url;
-            const pageUrl = latestScreenshotMessage.metadata.page_url ??
-                latestScreenshotMessage.metadata.screenshot_data?.url ??
-                latestScreenshotMessage.metadata.screenshot_data?.page_url ??
-                "unknown";
-            const pageTitle = latestScreenshotMessage.metadata.page_title ??
-                latestScreenshotMessage.metadata.screenshot_data?.page_title ??
-                "unknown";
-            const actionName = latestScreenshotMessage.metadata.action_name ??
-                latestScreenshotMessage.metadata.screenshot_data?.action_name ??
-                "snapshot_refresh";
-            // Add screenshot as image message (similar to backend)
-            const screenshotMessage = {
-                role: "user",
-                content: [
-                    {
-                        type: "image_url",
-                        image_url: {
-                            url: imageUrl,
-                            detail: "low",
-                        },
-                    },
-                    {
-                        type: "text",
-                        text: `Current page screenshot after ${actionName?.replace(/_/g, " ")}: ${pageTitle} (${pageUrl})`,
-                    },
-                ],
-            };
-            return [...messages, screenshotMessage];
-        }
-        catch (error) {
-            // Don't fail if screenshot context addition fails
-            return messages;
-        }
-    }
-    pruneToolResults(toolName) {
-        try {
-            const messages = this.sessionManager.getMessages();
-            // Prune tool results
-            const prunedMessages = toolResultPruner.pruneToolResults(messages, toolName);
-            // Cap conversation history if needed
-            const cappedMessages = toolResultPruner.capConversationHistory(prunedMessages);
-            // Update session with pruned messages
-            if (cappedMessages.length !== messages.length) {
-                this.sessionManager.clearMessages();
-                cappedMessages.forEach((msg) => this.sessionManager.addMessage(msg));
-            }
-        }
-        catch (error) {
-            // Don't fail on pruning errors
-        }
-    }
-    /**
-     * Get context compaction statistics
-     */
-    getContextStats() {
-        const messages = this.sessionManager.getMessages();
-        return this.contextCompactor.getStats(messages);
-    }
-    /**
-     * Manually compact context if needed
-     */
-    async compactContext() {
-        const messages = this.sessionManager.getMessages();
-        const result = await this.contextCompactor.compact(messages, this.httpClient);
-        if (result.removedCount > 0) {
-            this.sessionManager.clearMessages();
-            result.compactedMessages.forEach((msg) => this.sessionManager.addMessage(msg));
-        }
-        return {
-            success: true,
-            stats: {
-                removedCount: result.removedCount,
-                tokensBeforeCompaction: result.tokensBeforeCompaction,
-                tokensAfterCompaction: result.tokensAfterCompaction,
-                strategy: result.strategy,
-                summaryGenerated: result.summaryGenerated,
-            },
+            socketUrlOverride: config.socketUrlOverride,
         };
-    }
-    /**
-     * Auto-compact context before sending to backend if needed
-     */
-    async autoCompactIfNeeded() {
-        const messages = this.sessionManager.getMessages();
-        if (this.contextCompactor.needsCompaction(messages)) {
-            const result = await this.contextCompactor.compact(messages, this.httpClient);
-            this.sessionManager.clearMessages();
-            result.compactedMessages.forEach((msg) => this.sessionManager.addMessage(msg));
-            // Emit event to notify UI
-            this.emit("context_compacted", {
-                message: "Context automatically compacted to manage token limits",
-                data: {
-                    removedCount: result.removedCount,
-                    tokensBeforeCompaction: result.tokensBeforeCompaction,
-                    tokensAfterCompaction: result.tokensAfterCompaction,
-                    strategy: result.strategy,
-                    summaryGenerated: result.summaryGenerated,
-                },
-            });
-        }
+        super(backendCfg, sessionId);
     }
 }
 //# sourceMappingURL=agent-orchestrator.js.map