@northflare/runner 0.0.13 → 0.0.16

package/dist/components/message-handler-sse.js

@@ -1,17 +1,14 @@
-"use strict";
 /**
  * MessageHandler - Processes incoming JSONRPC messages from SSE events
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageHandler = void 0;
-const SSEClient_1 = require("../services/SSEClient");
-const RunnerAPIClient_1 = require("../services/RunnerAPIClient");
-const status_line_1 = require("../utils/status-line");
-const console_1 = require("../utils/console");
-const logger_1 = require("../utils/logger");
-const debug_1 = require("../utils/debug");
-const logger = (0, logger_1.createLogger)("MessageHandler");
-class MessageHandler {
+import { SSEClient } from '../services/SSEClient.js';
+import { RunnerAPIClient } from '../services/RunnerAPIClient.js';
+import { statusLineManager } from '../utils/status-line.js';
+import { console } from '../utils/console.js';
+import { createLogger } from '../utils/logger.js';
+import { isRunnerDebugEnabled } from '../utils/debug.js';
+const logger = createLogger("MessageHandler");
+export class MessageHandler {
     methodHandlers;
     runner;
     processedMessages = new Set();
@@ -21,11 +18,11 @@ class MessageHandler {
     constructor(runner) {
         this.runner = runner;
         this.methodHandlers = new Map();
-        this.apiClient = new RunnerAPIClient_1.RunnerAPIClient(runner.config_);
+        this.apiClient = new RunnerAPIClient(runner.config_);
         this.registerHandlers();
     }
     async startProcessing() {
-        console_1.console.log("MessageHandler: Starting message processing with SSE...");
+        console.log("MessageHandler: Starting message processing with SSE...");
         if (this.isProcessing) {
             logger.warn("Message processing already started");
             return;
@@ -42,7 +39,7 @@ class MessageHandler {
         await this.connectSSE();
     }
     async stopProcessing() {
-        console_1.console.log("MessageHandler: Stopping message processing...");
+        console.log("MessageHandler: Stopping message processing...");
         this.isProcessing = false;
         // Stop SSE client
         if (this.sseClient) {
@@ -61,21 +58,21 @@ class MessageHandler {
             logger.debug("No lastProcessedAt timestamp, skipping catch-up");
             return;
         }
-        console_1.console.log(`MessageHandler: Catching up on messages since ${lastProcessedAt.toISOString()}`);
+        console.log(`MessageHandler: Catching up on messages since ${lastProcessedAt.toISOString()}`);
         try {
             const messages = await this.apiClient.fetchMissedMessages({
                 since: lastProcessedAt,
                 limit: 1000,
             });
             if (messages.length > 0) {
-                console_1.console.log(`MessageHandler: Processing ${messages.length} missed messages`);
+                console.log(`MessageHandler: Processing ${messages.length} missed messages`);
                 // Process messages in order
                 for (const message of messages) {
                     await this.processMessage(message);
                 }
             }
             else {
-                console_1.console.log("MessageHandler: No missed messages to process");
+                console.log("MessageHandler: No missed messages to process");
             }
         }
         catch (error) {
@@ -95,8 +92,8 @@ class MessageHandler {
         if (!token) {
             throw new Error("Missing NORTHFLARE_RUNNER_TOKEN");
         }
-        console_1.console.log("MessageHandler: Connecting to SSE endpoint...");
-        this.sseClient = new SSEClient_1.SSEClient({
+        console.log("MessageHandler: Connecting to SSE endpoint...");
+        this.sseClient = new SSEClient({
             url: `${this.runner.config_.orchestratorUrl}/api/runner-events`,
             runnerId,
             token,
@@ -105,10 +102,10 @@ class MessageHandler {
                 logger.error("SSE connection error:", error);
             },
             onConnect: () => {
-                console_1.console.log("MessageHandler: SSE connection established");
+                console.log("MessageHandler: SSE connection established");
             },
             onDisconnect: () => {
-                console_1.console.log("MessageHandler: SSE connection closed");
+                console.log("MessageHandler: SSE connection closed");
             },
             reconnectInterval: 1000,
             maxReconnectInterval: 30000,
@@ -124,7 +121,7 @@ class MessageHandler {
     async handleSSEEvent(event) {
         if (event.type === "runner.message") {
             const message = event.data;
-            if ((0, debug_1.isRunnerDebugEnabled)()) {
+            if (isRunnerDebugEnabled()) {
                 logger.debug("Received SSE event", {
                     eventId: event.id,
                     type: event.type,
@@ -152,7 +149,7 @@ class MessageHandler {
         }
     }
     async processMessage(message) {
-        if ((0, debug_1.isRunnerDebugEnabled)()) {
+        if (isRunnerDebugEnabled()) {
             logger.debug("processMessage called", {
                 messageId: message.id,
                 method: message.payload?.method,
@@ -178,7 +175,7 @@ class MessageHandler {
             await this.sendError(message, `Unknown method: ${method}`);
             return;
         }
-        if ((0, debug_1.isRunnerDebugEnabled)()) {
+        if (isRunnerDebugEnabled()) {
             logger.debug("Processing message", {
                 messageId: message.id,
                 method: method,
@@ -191,7 +188,7 @@ class MessageHandler {
             await this.markProcessed(message);
             // Acknowledge ALL messages to update lastProcessedAt
             await this.acknowledgeMessage(message);
-            if ((0, debug_1.isRunnerDebugEnabled)()) {
+            if (isRunnerDebugEnabled()) {
                 logger.debug("Message acknowledged", {
                     messageId: message.id,
                     method: method,
@@ -201,7 +198,7 @@ class MessageHandler {
             }
         }
         catch (error) {
-            if ((0, debug_1.isRunnerDebugEnabled)()) {
+            if (isRunnerDebugEnabled()) {
                 logger.debug("Message processing error", {
                     messageId: message.id,
                     method: method,
@@ -251,7 +248,7 @@ class MessageHandler {
                 reason: "active runner, message after watermark",
             };
         })();
-        if ((0, debug_1.isRunnerDebugEnabled)()) {
+        if (isRunnerDebugEnabled()) {
             logger.debug("Message processing decision", {
                 messageId: message.id,
                 method: message.payload?.method,
@@ -277,7 +274,7 @@ class MessageHandler {
     }
     async acknowledgeMessage(message) {
         const runnerId = this.runner.getRunnerId();
-        console_1.console.log(`[MessageHandler] Sending message.acknowledge:`, {
+        console.log(`[MessageHandler] Sending message.acknowledge:`, {
             runnerId,
             messageTimestamp: message.createdAt,
             messageId: message.id,
@@ -287,7 +284,7 @@ class MessageHandler {
             await this.apiClient.acknowledgeMessage(message.createdAt);
             // Update local lastProcessedAt
             await this.runner.updateLastProcessedAt(new Date(message.createdAt));
-            console_1.console.log(`[MessageHandler] ✅ message.acknowledge sent successfully`);
+            console.log(`[MessageHandler] ✅ message.acknowledge sent successfully`);
         }
         catch (error) {
             logger.error("Failed to acknowledge message:", error);
@@ -303,8 +300,8 @@ class MessageHandler {
         const conversationObjectType = message.conversationObjectType || (message.taskId ? "Task" : undefined);
         const conversationObjectId = message.conversationObjectId || message.taskId;
         if (!conversationObjectId) {
-            console_1.console.error(`[MessageHandler] Cannot send error report - no conversationObjectId available. Error: ${errorMessage}`);
-            if ((0, debug_1.isRunnerDebugEnabled)()) {
+            console.error(`[MessageHandler] Cannot send error report - no conversationObjectId available. Error: ${errorMessage}`);
+            if (isRunnerDebugEnabled()) {
                 logger.debug("Error without conversationObjectId", {
                     messageId: message.id,
                     method: message.payload?.method,
@@ -333,8 +330,8 @@ class MessageHandler {
         const conversationObjectType = message.conversationObjectType || (message.taskId ? "Task" : undefined);
         const conversationObjectId = message.conversationObjectId || message.taskId;
         if (!conversationObjectId) {
-            console_1.console.error(`[MessageHandler] Cannot send error report - no conversationObjectId available. Processing error: ${errorMessage}`);
-            if ((0, debug_1.isRunnerDebugEnabled)()) {
+            console.error(`[MessageHandler] Cannot send error report - no conversationObjectId available. Processing error: ${errorMessage}`);
+            if (isRunnerDebugEnabled()) {
                 logger.debug("Processing error without conversationObjectId", {
                     messageId: message.id,
                     method: message.payload?.method,
@@ -359,7 +356,7 @@ class MessageHandler {
         });
     }
     registerHandlers() {
-        console_1.console.log("MessageHandler: Registering handlers...");
+        console.log("MessageHandler: Registering handlers...");
         this.methodHandlers = new Map([
             ["conversation.start", this.handleConversationStart.bind(this)],
             ["conversation.stop", this.handleConversationStop.bind(this)],
@@ -391,7 +388,7 @@ class MessageHandler {
             throw new Error("Missing conversationObjectId");
         }
         // Debug log the config
-        console_1.console.log(`[MessageHandler] conversation.start config:`, {
+        console.log(`[MessageHandler] conversation.start config:`, {
             conversationObjectId,
             hasConfig: !!config,
             hasRepository: !!config?.repository,
@@ -401,7 +398,7 @@ class MessageHandler {
             fullConfig: JSON.stringify(config, null, 2),
         });
         // Debug log workspace instructions received
-        console_1.console.log(`[MessageHandler] Received conversation with workspaceInstructions:`, {
+        console.log(`[MessageHandler] Received conversation with workspaceInstructions:`, {
             conversationId: conversationData.id,
             hasWorkspaceInstructions: !!conversationData.workspaceInstructions,
             workspaceInstructionsLength: conversationData.workspaceInstructions?.length ?? 0,
@@ -409,17 +406,34 @@ class MessageHandler {
             hasGlobalInstructions: !!conversationData.globalInstructions,
             globalInstructionsLength: conversationData.globalInstructions?.length ?? 0,
         });
+        // Check if conversation is already active (prevent duplicate starts on catch-up)
+        const conversationId = conversationData.id;
+        if (this.runner.activeConversations_.has(conversationId)) {
+            console.log(`[MessageHandler] Conversation ${conversationId} already active, skipping duplicate start`);
+            return;
+        }
+        // Check if this conversation was recently completed (prevent restart on catch-up)
+        if (this.runner.wasConversationCompleted(conversationId)) {
+            console.log(`[MessageHandler] Conversation ${conversationId} was already completed, skipping restart`);
+            return;
+        }
         const provider = this.resolveAgentProvider(conversationData, config);
         const manager = this.getManagerForProvider(provider);
         // Start the conversation with the provided/loaded conversation details
-        await manager.startConversation(finalObjectType, finalObjectId, config, initialMessages || [], conversationData);
+        // For CodexManager (openai) we pass the provider to distinguish
+        if (provider === "openai") {
+            await manager.startConversation(finalObjectType, finalObjectId, config, initialMessages || [], conversationData, provider);
+        }
+        else {
+            await manager.startConversation(finalObjectType, finalObjectId, config, initialMessages || [], conversationData, provider);
+        }
         // Update status line
-        status_line_1.statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
+        statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
     }
     async handleConversationStop(params, message) {
         // Require conversationId (present at message level); do not fall back to agentSessionId/taskId
         const { conversationId = message.conversationId, reason } = params;
-        console_1.console.log(`[MessageHandler] handleConversationStop called with:`, {
+        console.log(`[MessageHandler] handleConversationStop called with:`, {
             conversationId,
             messageConversationId: message.conversationId,
             agentSessionId: params?.agentSessionId,
@@ -435,7 +449,7 @@ class MessageHandler {
             context = this.runner.getConversationContext(conversationId);
             targetConversationId = conversationId;
         }
-        console_1.console.log(`[MessageHandler] handleConversationStop lookup result:`, {
+        console.log(`[MessageHandler] handleConversationStop lookup result:`, {
             contextFound: !!context,
             targetConversationId,
             contextTaskId: context?.taskId,
@@ -454,17 +468,17 @@ class MessageHandler {
             context.status = "stopped";
             this.runner.activeConversations_.delete(targetConversationId);
             // Update status line
-            status_line_1.statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
+            statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
         }
         else {
             // No conversation found - this is expected as conversations may have already ended
             // or been cleaned up. Just log it and update status line.
-            console_1.console.log(`Conversation stop requested for ${conversationId} - conversation not found or already cleaned up`);
+            console.log(`Conversation stop requested for ${conversationId} - conversation not found or already cleaned up`);
             // If we have a targetConversationId, ensure it's removed from tracking
             if (targetConversationId) {
                 this.runner.activeConversations_.delete(targetConversationId);
             }
-            status_line_1.statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
+            statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
         }
     }
     async handleConversationResume(params, message) {
@@ -484,11 +498,17 @@ class MessageHandler {
         }
         const provider = this.resolveAgentProvider(conversationData, config);
         const manager = this.getManagerForProvider(provider);
-        await manager.resumeConversation(conversationData.objectType, conversationData.objectId, agentSessionId, config, conversationData, resumeMessage);
+        // For CodexManager (openai) we pass the provider to distinguish
+        if (provider === "openai") {
+            await manager.resumeConversation(conversationData.objectType, conversationData.objectId, agentSessionId, config, conversationData, resumeMessage, provider);
+        }
+        else {
+            await manager.resumeConversation(conversationData.objectType, conversationData.objectId, agentSessionId, config, conversationData, resumeMessage, provider);
+        }
     }
     async handleConversationConfig(params, message) {
         const { conversationId, model, permissionsMode, config } = params;
-        console_1.console.log(`[MessageHandler] handleConversationConfig called with:`, {
+        console.log(`[MessageHandler] handleConversationConfig called with:`, {
             conversationId,
             model,
             permissionsMode,
@@ -513,28 +533,44 @@ class MessageHandler {
             ...(permissionsMode && { permissionsMode }),
             ...config, // Allow full config overrides if provided
         };
-        console_1.console.log(`[MessageHandler] Stopping conversation ${context.conversationId} to apply new config`);
+        console.log(`[MessageHandler] Stopping conversation ${context.conversationId} to apply new config`);
         // Stop the current conversation
         const manager = this.getManagerForConversationContext(context);
         await manager.stopConversation(context.agentSessionId, context, false // Not a runner shutdown, just updating config
         );
         // Remove from active conversations
         this.runner.activeConversations_.delete(context.conversationId);
-        console_1.console.log(`[MessageHandler] Resuming conversation ${context.conversationId} with new config`);
+        console.log(`[MessageHandler] Resuming conversation ${context.conversationId} with new config`);
         // Resume with new config
-        await manager.resumeConversation(context.conversationObjectType, context.conversationObjectId, context.agentSessionId, newConfig, {
-            id: context.conversationId,
-            objectType: context.conversationObjectType,
-            objectId: context.conversationObjectId,
-            model: newConfig.model,
-            globalInstructions: context.globalInstructions,
-            workspaceInstructions: context.workspaceInstructions,
-            permissionsMode: newConfig.permissionsMode,
-            agentSessionId: context.agentSessionId,
-        }, "<system-instructions>Configuration updated. Please continue with the new settings.</system-instructions>");
+        // For CodexManager (openai) we pass the provider to distinguish
+        const contextProvider = context.provider?.toLowerCase();
+        if (contextProvider === "openai") {
+            await manager.resumeConversation(context.conversationObjectType, context.conversationObjectId, context.agentSessionId, newConfig, {
+                id: context.conversationId,
+                objectType: context.conversationObjectType,
+                objectId: context.conversationObjectId,
+                model: newConfig.model,
+                globalInstructions: context.globalInstructions,
+                workspaceInstructions: context.workspaceInstructions,
+                permissionsMode: newConfig.permissionsMode,
+                agentSessionId: context.agentSessionId,
+            }, "<system-instructions>Configuration updated. Please continue with the new settings.</system-instructions>", contextProvider);
+        }
+        else {
+            await manager.resumeConversation(context.conversationObjectType, context.conversationObjectId, context.agentSessionId, newConfig, {
+                id: context.conversationId,
+                objectType: context.conversationObjectType,
+                objectId: context.conversationObjectId,
+                model: newConfig.model,
+                globalInstructions: context.globalInstructions,
+                workspaceInstructions: context.workspaceInstructions,
+                permissionsMode: newConfig.permissionsMode,
+                agentSessionId: context.agentSessionId,
+            }, "<system-instructions>Configuration updated. Please continue with the new settings.</system-instructions>");
+        }
         // Update status line
-        status_line_1.statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
-        console_1.console.log(`[MessageHandler] Conversation ${context.conversationId} config updated successfully`);
+        statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
+        console.log(`[MessageHandler] Conversation ${context.conversationId} config updated successfully`);
     }
     async handleUserMessage(params, message) {
         const { conversationId, content, config, conversationObjectType = message.conversationObjectType || "Task", conversationObjectId = message.conversationObjectId, conversation, agentSessionId, } = params;
@@ -546,15 +582,22 @@ class MessageHandler {
             throw new Error("Missing required parameter: content");
         }
         const existingContext = this.runner.getConversationContext(conversationId);
-        const manager = existingContext
-            ? this.getManagerForConversationContext(existingContext)
-            : this.getManagerForProvider(this.resolveAgentProvider(conversation, config));
-        await manager.sendUserMessage(conversationId, content, config, conversationObjectType, conversationObjectId, conversation, agentSessionId);
+        const provider = existingContext
+            ? existingContext.provider
+            : this.resolveAgentProvider(conversation, config);
+        const manager = this.getManagerForProvider(provider);
+        // For CodexManager (openai), pass the provider
+        if (provider === "openai") {
+            await manager.sendUserMessage(conversationId, content, config, conversationObjectType, conversationObjectId, conversation, agentSessionId, provider);
+        }
+        else {
+            await manager.sendUserMessage(conversationId, content, config, conversationObjectType, conversationObjectId, conversation, agentSessionId);
+        }
     }
     async handleUidChanged(params, _message) {
         const { runnerUid, lastProcessedAt } = params;
-        console_1.console.log(`MessageHandler: Handling UID change notification - new UID: ${runnerUid}, lastProcessedAt: ${lastProcessedAt}`);
-        if ((0, debug_1.isRunnerDebugEnabled)()) {
+        console.log(`MessageHandler: Handling UID change notification - new UID: ${runnerUid}, lastProcessedAt: ${lastProcessedAt}`);
+        if (isRunnerDebugEnabled()) {
             logger.debug("UID change notification received", {
                 newUid: runnerUid,
                 currentUid: this.runner.getRunnerUid(),
@@ -568,10 +611,10 @@ class MessageHandler {
         // This ensures we activate even if we received the message during catch-up
         if (runnerUid === this.runner.getRunnerUid()) {
             // This is our UID - we're the active runner
-            console_1.console.log("MessageHandler: We are now the active runner");
+            console.log("MessageHandler: We are now the active runner");
             this.runner.setIsActiveRunner(true);
             await this.runner.updateLastProcessedAt(lastProcessedAt ? new Date(lastProcessedAt) : null);
-            if ((0, debug_1.isRunnerDebugEnabled)()) {
+            if (isRunnerDebugEnabled()) {
                 logger.debug("Runner activated as primary", {
                     runnerUid: runnerUid,
                     lastProcessedAt: lastProcessedAt,
@@ -586,15 +629,15 @@ class MessageHandler {
                 });
             }
             catch (error) {
-                console_1.console.error("Failed to send activation notification:", error);
-                if ((0, debug_1.isRunnerDebugEnabled)()) {
+                console.error("Failed to send activation notification:", error);
+                if (isRunnerDebugEnabled()) {
                     logger.debug("Activation notification failed", {
                         error: error instanceof Error ? error.message : String(error),
                     });
                 }
             }
             // Start processing messages from the lastProcessedAt point
-            console_1.console.log(`MessageHandler: Will process messages after ${lastProcessedAt || "beginning"}`);
+            console.log(`MessageHandler: Will process messages after ${lastProcessedAt || "beginning"}`);
         }
         else {
             // Different UID - check if this is an old UID change that we should ignore
@@ -602,8 +645,8 @@ class MessageHandler {
             if (currentLastProcessedAt && lastProcessedAt) {
                 const newTime = new Date(lastProcessedAt);
                 if (newTime < currentLastProcessedAt) {
-                    console_1.console.log(`MessageHandler: Ignoring old UID change (${lastProcessedAt} < ${currentLastProcessedAt.toISOString()})`);
-                    if ((0, debug_1.isRunnerDebugEnabled)()) {
+                    console.log(`MessageHandler: Ignoring old UID change (${lastProcessedAt} < ${currentLastProcessedAt.toISOString()})`);
+                    if (isRunnerDebugEnabled()) {
                         logger.debug("Ignoring old UID change", {
                             newUid: runnerUid,
                             newLastProcessedAt: lastProcessedAt,
@@ -614,7 +657,7 @@ class MessageHandler {
                 }
             }
             // Different UID - we're being replaced
-            console_1.console.log(`MessageHandler: We are being replaced by runner with UID ${runnerUid}`);
+            console.log(`MessageHandler: We are being replaced by runner with UID ${runnerUid}`);
             this.runner.setIsActiveRunner(false);
             // Remember which conversations were active before handoff (by conversationId)
             for (const [conversationId, context] of this.runner
@@ -623,7 +666,7 @@ class MessageHandler {
                     this.runner.getPreHandoffConversations().add(conversationId);
                 }
             }
-            if ((0, debug_1.isRunnerDebugEnabled)()) {
+            if (isRunnerDebugEnabled()) {
                 logger.debug("Runner deactivated - being replaced", {
                     newRunnerUid: runnerUid,
                     ourUid: this.runner.getRunnerUid(),
@@ -631,7 +674,7 @@ class MessageHandler {
                     activeConversationsCount: this.runner.getPreHandoffConversations().size,
                 });
             }
-            console_1.console.log(`MessageHandler: Will complete ${this.runner.getPreHandoffConversations().size} active conversations`);
+            console.log(`MessageHandler: Will complete ${this.runner.getPreHandoffConversations().size} active conversations`);
             // Emit deactivation notification - wrap in try/catch to handle failures gracefully
             try {
                 await this.runner.notify("runner.deactivate", {
@@ -641,8 +684,8 @@ class MessageHandler {
                 });
             }
             catch (error) {
-                console_1.console.error("Failed to send deactivation notification:", error);
-                if ((0, debug_1.isRunnerDebugEnabled)()) {
+                console.error("Failed to send deactivation notification:", error);
+                if (isRunnerDebugEnabled()) {
                     logger.debug("Deactivation notification failed", {
                         error: error instanceof Error ? error.message : String(error),
                     });
@@ -655,7 +698,7 @@ class MessageHandler {
         if (!taskId || !operation) {
             throw new Error("Missing required parameters: taskId and operation");
         }
-        console_1.console.log(`MessageHandler: Handling Git operation ${operation} for task ${taskId}`);
+        console.log(`MessageHandler: Handling Git operation ${operation} for task ${taskId}`);
         const repoManager = this.runner.repositoryManager_;
         try {
             switch (operation) {
@@ -675,7 +718,7 @@ class MessageHandler {
                     break;
                 case "push":
                     // TODO: Implement push operation
-                    console_1.console.log("Push operation not yet implemented");
+                    console.log("Push operation not yet implemented");
                     break;
                 case "rebase":
                     if (!opParams?.targetBranch) {
@@ -698,7 +741,7 @@ class MessageHandler {
             }
         }
         catch (error) {
-            console_1.console.error(`Git operation ${operation} failed for task ${taskId}:`, error);
+            console.error(`Git operation ${operation} failed for task ${taskId}:`, error);
             await this.recordGitOperation(taskId, operation, "failed", {
                 error: error instanceof Error ? error.message : String(error),
             });
@@ -710,14 +753,14 @@ class MessageHandler {
         if (!taskId) {
             throw new Error("Missing required parameter: taskId");
         }
-        console_1.console.log(`MessageHandler: Cleaning up Git worktree for task ${taskId}`);
+        console.log(`MessageHandler: Cleaning up Git worktree for task ${taskId}`);
         const repoManager = this.runner.repositoryManager_;
         try {
             await repoManager.removeTaskWorktree(taskId, { preserveBranch });
-            console_1.console.log(`Successfully cleaned up worktree for task ${taskId}`);
+            console.log(`Successfully cleaned up worktree for task ${taskId}`);
         }
         catch (error) {
-            console_1.console.error(`Failed to clean up worktree for task ${taskId}:`, error);
+            console.error(`Failed to clean up worktree for task ${taskId}:`, error);
             throw error;
         }
     }
@@ -725,7 +768,7 @@ class MessageHandler {
         const repoManager = this.runner.repositoryManager_;
         const gitState = await repoManager.getTaskState(taskId);
         if (!gitState) {
-            console_1.console.error(`No Git state found for task ${taskId}`);
+            console.error(`No Git state found for task ${taskId}`);
             return;
         }
         // Send state update to orchestrator
@@ -751,39 +794,104 @@ class MessageHandler {
         });
     }
     resolveAgentProvider(conversation, config) {
+        const model = conversation?.model ||
+            config?.model ||
+            config?.defaultModel ||
+            "";
+        const normalizedModel = model.toLowerCase();
+        // First check if model has explicit provider prefix
+        if (normalizedModel.startsWith("openrouter:") || normalizedModel.startsWith("openrouter/")) {
+            return "openrouter";
+        }
+        if (normalizedModel.startsWith("groq:") || normalizedModel.startsWith("groq/")) {
+            return "groq";
+        }
+        if (normalizedModel.startsWith("openai:") || normalizedModel.startsWith("openai/")) {
+            return "openai";
+        }
+        if (normalizedModel.startsWith("claude:") || normalizedModel.startsWith("claude/")) {
+            return "claude";
+        }
+        // Respect explicit provider, but let model-based OpenRouter routing win first
         const explicitProvider = conversation?.providerType ||
             conversation?.agentProviderType ||
             config?.providerType ||
             config?.agentProviderType;
         if (typeof explicitProvider === "string") {
             const normalized = explicitProvider.toLowerCase();
+            if (normalized === "openrouter")
+                return "openrouter";
+            if (normalized === "groq")
+                return "groq";
             if (normalized === "openai")
                 return "openai";
             if (normalized === "claude")
                 return "claude";
         }
-        const model = conversation?.model ||
-            config?.model ||
-            config?.defaultModel ||
-            "";
-        const normalizedModel = model.toLowerCase();
-        const looksLikeCodex = normalizedModel.includes("gpt") ||
-            /^o\d/.test(normalizedModel) ||
-            normalizedModel.includes("openai") ||
-            normalizedModel.includes("codex");
-        return looksLikeCodex ? "openai" : "claude";
+        // Check for known Claude models (direct access, not via OpenRouter)
+        const looksLikeClaude = normalizedModel.includes("claude") ||
+            normalizedModel.includes("opus") ||
+            normalizedModel.includes("sonnet") ||
+            normalizedModel.includes("haiku");
+        // Define specific OpenAI/Codex models that should use the OpenAI provider
+        // These are models directly from OpenAI/Codex, not via OpenRouter
+        const directOpenAIModels = [
+            "gpt-3.5-turbo",
+            "gpt-4",
+            "gpt-4-turbo",
+            "gpt-4o",
+            "gpt-4o-mini",
+            "gpt-5.1",
+            "gpt-5.1-codex",
+            "gpt-5.1-codex-max",
+            "gpt-5.1-codex-mini",
+            "o1",
+            "o1-preview",
+            "o1-mini",
+            "codex"
+        ];
+        // Check if it's a direct OpenAI model (exact match or starts with the model name followed by :)
+        const isDirectOpenAIModel = directOpenAIModels.some(directModel => {
+            // Check for exact match or model with reasoning effort suffix (e.g., "gpt-5.1:high")
+            return normalizedModel === directModel ||
+                normalizedModel.startsWith(directModel + ":") ||
+                normalizedModel.startsWith(directModel + "-") ||
+                (directModel.startsWith("o") && /^o\d/.test(normalizedModel));
+        });
+        if (looksLikeClaude)
+            return "claude";
+        if (isDirectOpenAIModel)
+            return "openai";
+        // If it doesn't match known Claude or direct OpenAI models, treat as OpenRouter
+        // This includes any remaining unknown models
+        if (model && model.length > 0) {
+            return "openrouter";
+        }
+        return "claude";
     }
     getManagerForProvider(provider) {
-        if (provider?.toLowerCase() === "openai") {
+        const normalized = provider?.toLowerCase();
+        if (normalized === "openrouter" || normalized === "groq") {
+            // OpenRouter now handled by Northflare Agent manager
+            return this.runner.northflareAgentManager_;
+        }
+        if (normalized === "openai") {
             return this.runner.codexManager_;
         }
         return this.runner.claudeManager_;
     }
     getManagerForConversationContext(context) {
-        return context.provider === "openai"
+        const provider = context.provider?.toLowerCase();
+        const model = (context.model || "").toLowerCase();
+        // Route any OpenRouter-style model strings to the Northflare Agent, even if the
+        // provider was previously tagged as openai/codex.
+        const looksLikeOpenRouter = model.startsWith("openrouter:");
+        if (provider === "openrouter" || provider === "groq" || looksLikeOpenRouter) {
+            return this.runner.northflareAgentManager_;
+        }
+        return provider === "openai"
             ? this.runner.codexManager_
             : this.runner.claudeManager_;
     }
 }
-exports.MessageHandler = MessageHandler;
 //# sourceMappingURL=message-handler-sse.js.map