@northflare/runner 0.0.30 → 0.0.32

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

@@ -1,1224 +0,0 @@
-/**
- * MessageHandler - Processes incoming JSONRPC messages from SSE events
- */
-import { SSEClient } from '../services/SSEClient.js';
-import { RunnerAPIClient } from '../services/RunnerAPIClient.js';
-import { statusLineManager } from '../utils/status-line.js';
-import { createLogger } from '../utils/logger.js';
-import { isDebugEnabledFor } from '../utils/debug.js';
-import { buildIncomingMessageLog, messageFlowLogger, messagesDebugEnabled, } from '../utils/message-log.js';
-import fs from "fs/promises";
-import path from "path";
-const logger = createLogger("MessageHandler", "rpc");
-const sseLogger = createLogger("MessageHandler:SSE", "sse");
-// Use getters so debug state is checked at call time, not module load time
-const rpcDebugEnabled = () => isDebugEnabledFor("rpc");
-const sseDebugEnabled = () => isDebugEnabledFor("sse");
-const isSubPath = (base, candidate) => {
-    if (!base || !candidate)
-        return false;
-    const normBase = path.resolve(base);
-    const normCandidate = path.resolve(candidate);
-    return (normCandidate === normBase ||
-        normCandidate.startsWith(normBase.endsWith(path.sep) ? normBase : normBase + path.sep));
-};
-export class MessageHandler {
-    methodHandlers;
-    runner;
-    /** Map of message ID to message timestamp for deduplication */
-    processedMessages = new Map();
-    /**
-     * Queue SSE events to provide backpressure.
-     * Without this, async handler promises can accumulate unbounded under load.
-     */
-    sseEventQueue = [];
-    isDrainingSseQueue = false;
-    isRecoveringSse = false;
-    maxSseQueueLength;
-    sseClient = null;
-    apiClient;
-    isProcessing = false;
-    constructor(runner) {
-        this.runner = runner;
-        this.methodHandlers = new Map();
-        this.apiClient = new RunnerAPIClient(runner.config_);
-        this.maxSseQueueLength = this.readMaxSseQueueLength();
-        this.registerHandlers();
-    }
-    async startProcessing() {
-        logger.info("Starting message processing with SSE", {
-            runnerId: this.runner.getRunnerId(),
-        });
-        if (this.isProcessing) {
-            logger.warn("Message processing already started");
-            return;
-        }
-        this.isProcessing = true;
-        // Update API client with runner ID if available
-        const runnerId = this.runner.getRunnerId();
-        if (runnerId) {
-            this.apiClient.setRunnerId(runnerId);
-        }
-        // Catch up on missed messages first
-        await this.catchUpMissedMessages();
-        // Start SSE connection
-        await this.connectSSE();
-    }
-    async stopProcessing() {
-        logger.info("Stopping message processing");
-        this.isProcessing = false;
-        // Stop SSE client
-        if (this.sseClient) {
-            this.sseClient.stop();
-            this.sseClient = null;
-        }
-        // Clear queued events and stop drain loop
-        this.sseEventQueue.length = 0;
-        this.isDrainingSseQueue = false;
-        this.isRecoveringSse = false;
-        // NOTE: Do NOT clear processedMessages here. Keeping the map across
-        // reconnections provides dedup protection in case the high watermark
-        // wasn't persisted before disconnect. The pruneProcessedMessages()
-        // method handles cleanup based on the acknowledged watermark.
-    }
-    /**
-     * Prune processed messages older than the given watermark.
-     * Messages at or before the watermark are filtered server-side,
-     * so we don't need to track them for deduplication anymore.
-     */
-    pruneProcessedMessages(watermark) {
-        const beforeSize = this.processedMessages.size;
-        for (const [messageId, timestamp] of this.processedMessages) {
-            if (timestamp <= watermark) {
-                this.processedMessages.delete(messageId);
-            }
-        }
-        const pruned = beforeSize - this.processedMessages.size;
-        if (pruned > 0 && rpcDebugEnabled()) {
-            logger.debug("Pruned processed messages", {
-                pruned,
-                remaining: this.processedMessages.size,
-                watermark: watermark.toISOString(),
-            });
-        }
-    }
-    /**
-     * Catch up on missed messages since lastProcessedAt
-     */
-    async catchUpMissedMessages() {
-        const lastProcessedAt = this.runner.getLastProcessedAt();
-        if (!lastProcessedAt) {
-            logger.debug("No lastProcessedAt timestamp, skipping catch-up");
-            return;
-        }
-        logger.info("Catching up on messages", {
-            since: lastProcessedAt.toISOString(),
-        });
-        try {
-            const messages = await this.apiClient.fetchMissedMessages({
-                since: lastProcessedAt,
-                limit: 1000,
-            });
-            if (messages.length > 0) {
-                logger.info("Processing missed messages", { count: messages.length });
-                // Process messages in order
-                for (const message of messages) {
-                    await this.processMessage(message);
-                }
-            }
-        }
-        catch (error) {
-            logger.error("Failed to catch up on missed messages:", error);
-            // Continue anyway - SSE connection might still work
-        }
-    }
-    /**
-     * Connect to SSE endpoint
-     */
-    async connectSSE() {
-        const runnerId = this.runner.getRunnerId();
-        if (!runnerId) {
-            throw new Error("Cannot connect to SSE without runner ID");
-        }
-        const token = process.env["NORTHFLARE_RUNNER_TOKEN"];
-        if (!token) {
-            throw new Error("Missing NORTHFLARE_RUNNER_TOKEN");
-        }
-        logger.info("Connecting to SSE endpoint", { runnerId });
-        this.sseClient = new SSEClient({
-            url: `${this.runner.config_.orchestratorUrl}/api/runner-events`,
-            runnerId,
-            token,
-            // Important: onMessage must be sync to avoid accumulating unawaited promises.
-            // Queue events and process them sequentially to provide backpressure.
-            onMessage: this.enqueueSseEvent.bind(this),
-            onError: (error) => {
-                logger.error("SSE connection error:", error);
-            },
-            onConnect: () => {
-                sseLogger.info("SSE connection established", { runnerId });
-            },
-            onDisconnect: () => {
-                sseLogger.info("SSE connection closed", { runnerId });
-            },
-            reconnectInterval: 1000,
-            maxReconnectInterval: 30000,
-            reconnectMultiplier: 2,
-            // Provide callback to get current lastProcessedAt for reconnection
-            getLastProcessedAt: () => this.runner.getLastProcessedAt()?.toISOString(),
-        });
-        // Connect with lastProcessedAt for server-side filtering
-        const lastProcessedAt = this.runner.getLastProcessedAt();
-        await this.sseClient.connect(lastProcessedAt?.toISOString());
-    }
-    readMaxSseQueueLength() {
-        const raw = process.env["NORTHFLARE_RUNNER_SSE_QUEUE_MAX"];
-        if (!raw)
-            return 5000;
-        const parsed = Number(raw);
-        if (!Number.isFinite(parsed) || parsed <= 0)
-            return 5000;
-        return Math.floor(parsed);
-    }
-    enqueueSseEvent(event) {
-        if (!this.isProcessing)
-            return;
-        this.sseEventQueue.push(event);
-        if (this.sseEventQueue.length > this.maxSseQueueLength) {
-            // Apply backpressure by reconnecting and catching up from lastProcessedAt.
-            // We intentionally clear the queue: unacknowledged messages will be
-            // returned by catchUpMissedMessages() because lastProcessedAt hasn't advanced.
-            sseLogger.warn("SSE event queue overflow; reconnecting to catch up", {
-                queued: this.sseEventQueue.length,
-                max: this.maxSseQueueLength,
-                lastProcessedAt: this.runner.getLastProcessedAt()?.toISOString() || "null",
-            });
-            void this.recoverSseFromBackpressure();
-            return;
-        }
-        if (!this.isDrainingSseQueue) {
-            void this.drainSseQueue();
-        }
-    }
-    async recoverSseFromBackpressure() {
-        if (this.isRecoveringSse)
-            return;
-        this.isRecoveringSse = true;
-        try {
-            // Stop current SSE connection if any
-            if (this.sseClient) {
-                this.sseClient.stop();
-                this.sseClient = null;
-            }
-            // Clear queue to free memory immediately
-            this.sseEventQueue.length = 0;
-            // Catch up via REST, then reconnect SSE
-            await this.catchUpMissedMessages();
-            if (this.isProcessing) {
-                await this.connectSSE();
-            }
-        }
-        catch (error) {
-            sseLogger.error("Failed to recover SSE after backpressure", error);
-        }
-        finally {
-            this.isRecoveringSse = false;
-        }
-    }
-    async drainSseQueue() {
-        if (this.isDrainingSseQueue)
-            return;
-        this.isDrainingSseQueue = true;
-        try {
-            while (this.isProcessing && this.sseEventQueue.length > 0) {
-                const next = this.sseEventQueue.shift();
-                if (!next)
-                    break;
-                await this.handleSSEEvent(next);
-            }
-        }
-        catch (error) {
-            sseLogger.error("SSE queue drain failed", error);
-        }
-        finally {
-            this.isDrainingSseQueue = false;
-        }
-    }
-    /**
-     * Handle SSE event
-     */
-    async handleSSEEvent(event) {
-        if (event.type === "runner.message") {
-            const message = event.data;
-            if (sseDebugEnabled()) {
-                sseLogger.debug("Received SSE event", {
-                    eventId: event.id,
-                    type: event.type,
-                    messageId: message?.id,
-                    method: message?.payload?.method,
-                    createdAt: message?.createdAt,
-                });
-            }
-            try {
-                // Process the message
-                await this.processMessage(message);
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                logger.error("Failed to process runner.message:", msg);
-                // Do not crash the runner on a single bad message
-                return;
-            }
-        }
-        else if (event.type === "connection.established") {
-            sseLogger.debug("SSE connection established", event.data);
-        }
-        else if (event.type === "runnerRepo.created" || event.type === "runnerRepo.updated") {
-            await this.handleRunnerRepoUpsert(event.data);
-        }
-        else if (event.type === "runnerRepo.deleted") {
-            await this.handleRunnerRepoDeleted(event.data);
-        }
-        else {
-            sseLogger.debug(`Received event type: ${event.type}`, event.data);
-        }
-    }
-    async processMessage(message) {
-        if (rpcDebugEnabled()) {
-            logger.debug("processMessage called", {
-                messageId: message.id,
-                method: message.payload?.method,
-                direction: message.direction,
-                createdAt: message.createdAt,
-            });
-        }
-        // Check for version update signal (do this early, before any filtering)
-        if (message.expectedRunnerVersion) {
-            await this.runner.checkForUpdate(message.expectedRunnerVersion);
-        }
-        // Skip if already processed
-        if (this.processedMessages.has(message.id)) {
-            return;
-        }
-        if (messagesDebugEnabled()) {
-            messageFlowLogger.debug("[incoming] orchestrator -> runner", buildIncomingMessageLog(message));
-        }
-        // Check if we should process this message based on ownership
-        if (!this.shouldProcessMessage(message)) {
-            return;
-        }
-        const { method, params } = message.payload;
-        if (!method) {
-            await this.sendError(message, "Missing method in message payload");
-            return;
-        }
-        const handler = this.methodHandlers.get(method);
-        if (!handler) {
-            await this.sendError(message, `Unknown method: ${method}`);
-            return;
-        }
-        if (rpcDebugEnabled()) {
-            logger.debug("Processing message", {
-                messageId: message.id,
-                method: method,
-                taskId: message.taskId,
-                isActionMessage: this.isActionMessage(message),
-            });
-        }
-        try {
-            await handler(params, message);
-            await this.markProcessed(message);
-            // Acknowledge ALL messages to update lastProcessedAt
-            await this.acknowledgeMessage(message);
-            if (rpcDebugEnabled()) {
-                logger.debug("Message acknowledged", {
-                    messageId: message.id,
-                    method: method,
-                    timestamp: message.createdAt,
-                    wasActionMessage: this.isActionMessage(message),
-                });
-            }
-        }
-        catch (error) {
-            if (rpcDebugEnabled()) {
-                logger.debug("Message processing error", {
-                    messageId: message.id,
-                    method: method,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-            await this.handleError(message, error);
-        }
-    }
-    async handleRunnerRepoUpsert(eventData) {
-        const runnerExternalId = this.runner.getRunnerId();
-        if (!runnerExternalId)
-            return;
-        const targetRunnerExternalId = eventData?.runner?.id;
-        if (targetRunnerExternalId && targetRunnerExternalId !== runnerExternalId) {
-            return;
-        }
-        const runnerType = eventData?.runner?.type || "local";
-        if (runnerType !== "local")
-            return;
-        const runnerPath = eventData?.runnerPath;
-        const repoName = eventData?.name;
-        const repoUuid = eventData?.uuid;
-        const external = eventData?.external === true;
-        if (!runnerPath || !repoName || !repoUuid)
-            return;
-        const workspacePath = this.runner.getWorkspacePath?.();
-        const pathAllowed = external || (workspacePath ? isSubPath(workspacePath, runnerPath) : true);
-        if (!pathAllowed) {
-            logger.warn(`Ignoring runnerRepo upsert outside workspace from SSE: ${runnerPath}`);
-            return;
-        }
-        try {
-            await fs.mkdir(runnerPath, { recursive: true });
-            logger.info(`Ensured local workspace directory exists at ${runnerPath}`);
-        }
-        catch (error) {
-            logger.error("Failed to create workspace directory", error);
-        }
-        const repos = Array.isArray(this.runner.config_.runnerRepos)
-            ? [...this.runner.config_.runnerRepos]
-            : [];
-        const existingIndex = repos.findIndex((r) => r.uuid === repoUuid || r.path === runnerPath || r.name === repoName);
-        const updatedEntry = {
-            uuid: repoUuid,
-            name: repoName,
-            path: runnerPath,
-            external,
-        };
-        if (existingIndex >= 0) {
-            repos[existingIndex] = updatedEntry;
-        }
-        else {
-            repos.push(updatedEntry);
-        }
-        // Persist to runner cache if available
-        if (typeof this.runner.replaceRunnerRepos === "function") {
-            await this.runner.replaceRunnerRepos(repos);
-        }
-        else {
-            this.runner.config_.runnerRepos = repos;
-        }
-        logger.info(`Updated in-memory runnerRepo ${repoName} from SSE event`);
-    }
-    async handleRunnerRepoDeleted(eventData) {
-        const runnerExternalId = this.runner.getRunnerId();
-        if (!runnerExternalId)
-            return;
-        const targetRunnerExternalId = eventData?.runner?.id;
-        if (targetRunnerExternalId && targetRunnerExternalId !== runnerExternalId) {
-            return;
-        }
-        const runnerType = eventData?.runner?.type || "local";
-        if (runnerType !== "local")
-            return;
-        const repoUuid = eventData?.uuid;
-        const repoName = eventData?.name;
-        if (!repoUuid && !repoName)
-            return;
-        const repos = Array.isArray(this.runner.config_.runnerRepos)
-            ? [...this.runner.config_.runnerRepos]
-            : [];
-        const filtered = repos.filter((repo) => (repoUuid ? repo.uuid !== repoUuid : true) &&
-            (repoName ? repo.name !== repoName : true));
-        if (filtered.length === repos.length) {
-            return;
-        }
-        if (typeof this.runner.replaceRunnerRepos === "function") {
-            await this.runner.replaceRunnerRepos(filtered);
-        }
-        else {
-            this.runner.config_.runnerRepos = filtered;
-        }
-        logger.info(`Removed runnerRepo ${repoName || repoUuid} from in-memory state after deletion event`);
-    }
-    shouldProcessMessage(message) {
-        const decision = (() => {
-            // Always process our own responses going to orchestrator
-            if (message.direction === "to_orchestrator") {
-                return { shouldProcess: true, reason: "own response to orchestrator" };
-            }
-            // Always process UID change messages BEFORE checking timestamp
-            // This is critical because UID changes can update lastProcessedAt itself
-            if (message.payload?.method === "runner.uid.changed") {
-                return { shouldProcess: true, reason: "UID change message" };
-            }
-            // Filter by lastProcessedAt (after checking for UID change messages)
-            const lastProcessedAt = this.runner.getLastProcessedAt();
-            if (lastProcessedAt && message.createdAt) {
-                const messageTime = new Date(message.createdAt);
-                if (messageTime <= lastProcessedAt) {
-                    return {
-                        shouldProcess: false,
-                        reason: "message before lastProcessedAt",
-                    };
-                }
-            }
-            // If we're not the active runner
-            if (!this.runner.getIsActiveRunner()) {
-                // Only process if it's for a pre-handoff conversation by conversationId
-                const cid = message.conversationId || message.payload?.params?.conversationId;
-                if (cid && this.runner.getPreHandoffConversations().has(cid)) {
-                    return {
-                        shouldProcess: true,
-                        reason: "pre-handoff conversation (by conversationId)",
-                    };
-                }
-                return { shouldProcess: false, reason: "not active runner" };
-            }
-            // We're active and message is after lastProcessedAt
-            return {
-                shouldProcess: true,
-                reason: "active runner, message after watermark",
-            };
-        })();
-        if (rpcDebugEnabled()) {
-            logger.debug("Message processing decision", {
-                messageId: message.id,
-                method: message.payload?.method,
-                shouldProcess: decision.shouldProcess,
-                reason: decision.reason,
-                runnerUid: this.runner.getRunnerUid(),
-                isActiveRunner: this.runner.getIsActiveRunner(),
-                lastProcessedAt: this.runner.getLastProcessedAt()?.toISOString() || "null",
-                messageCreatedAt: message.createdAt,
-            });
-        }
-        return decision.shouldProcess;
-    }
-    isActionMessage(message) {
-        const actionMethods = [
-            "conversation.start",
-            "conversation.stop",
-            "conversation.resume",
-            "conversation.config",
-            "conversation.summary",
-            "message.user",
-        ];
-        return actionMethods.includes(message.payload?.method || "");
-    }
-    async acknowledgeMessage(message) {
-        const runnerId = this.runner.getRunnerId();
-        if (rpcDebugEnabled()) {
-            logger.debug("Sending message.acknowledge", {
-                runnerId,
-                messageTimestamp: message.createdAt,
-                messageId: message.id,
-                method: message.payload?.method,
-            });
-        }
-        try {
-            await this.apiClient.acknowledgeMessage(message.createdAt);
-            // Update local lastProcessedAt
-            const newWatermark = new Date(message.createdAt);
-            await this.runner.updateLastProcessedAt(newWatermark);
-            // Prune old entries from processedMessages map to prevent unbounded growth.
-            // Messages at or before the watermark are filtered server-side, so we
-            // don't need to track them for deduplication anymore.
-            this.pruneProcessedMessages(newWatermark);
-            if (rpcDebugEnabled()) {
-                logger.debug("message.acknowledge sent", {
-                    runnerId,
-                    messageId: message.id,
-                });
-            }
-        }
-        catch (error) {
-            logger.error("Failed to acknowledge message:", error);
-            // Continue processing even if acknowledgment fails
-        }
-    }
-    async markProcessed(message) {
-        // Track processed messages with their timestamp for later pruning
-        const timestamp = message.createdAt ? new Date(message.createdAt) : new Date();
-        this.processedMessages.set(message.id, timestamp);
-        this.pruneProcessedMessagesFailsafe();
-    }
-    /**
-     * Failsafe pruning to prevent unbounded growth if acknowledgements fail
-     * and lastProcessedAt can't advance (so watermark-based pruning can't run).
-     */
-    pruneProcessedMessagesFailsafe() {
-        const MAX_ENTRIES = 20_000;
-        const MAX_AGE_MS = 2 * 60 * 60 * 1000; // 2 hours
-        const now = Date.now();
-        const cutoff = now - MAX_AGE_MS;
-        // Fast path: nothing to do
-        if (this.processedMessages.size <= MAX_ENTRIES) {
-            // Still prune by age if we can do it cheaply from the head
-            const first = this.processedMessages.entries().next().value;
-            if (!first)
-                return;
-            if (first[1].getTime() >= cutoff)
-                return;
-        }
-        // Prune oldest entries by age first (Map preserves insertion order)
-        while (this.processedMessages.size > 0) {
-            const first = this.processedMessages.entries().next().value;
-            if (!first)
-                break;
-            const [, ts] = first;
-            if (ts.getTime() >= cutoff)
-                break;
-            this.processedMessages.delete(first[0]);
-        }
-        // Enforce max size (delete oldest until within bound)
-        while (this.processedMessages.size > MAX_ENTRIES) {
-            const firstKey = this.processedMessages.keys().next().value;
-            if (!firstKey)
-                break;
-            this.processedMessages.delete(firstKey);
-        }
-    }
-    async sendError(message, errorMessage) {
-        // Send error report with conversation object info if available
-        const conversationObjectType = message.conversationObjectType || (message.taskId ? "Task" : undefined);
-        const conversationObjectId = message.conversationObjectId || message.taskId;
-        if (!conversationObjectId) {
-            logger.warn("Cannot send error report - missing conversationObjectId", {
-                messageId: message.id,
-                method: message.payload?.method,
-                error: errorMessage,
-                runnerId: message.runnerId,
-            });
-            return;
-        }
-        await this.runner.notify("error.report", {
-            conversationObjectType,
-            conversationObjectId,
-            messageId: message.id,
-            errorType: "method_error",
-            message: errorMessage,
-            details: {
-                originalMessage: message,
-                timestamp: new Date(),
-            },
-        });
-    }
-    async handleError(message, error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const errorStack = error instanceof Error ? error.stack : undefined;
-        // Send error report with conversation object info if available
-        const conversationObjectType = message.conversationObjectType || (message.taskId ? "Task" : undefined);
-        const conversationObjectId = message.conversationObjectId || message.taskId;
-        if (!conversationObjectId) {
-            logger.warn("Cannot send processing error report - missing conversationObjectId", {
-                messageId: message.id,
-                method: message.payload?.method,
-                error: errorMessage,
-                stack: errorStack,
-                runnerId: message.runnerId,
-            });
-            return;
-        }
-        await this.runner.notify("error.report", {
-            conversationObjectType,
-            conversationObjectId,
-            messageId: message.id,
-            errorType: "processing_error",
-            message: errorMessage,
-            details: {
-                stack: errorStack,
-                originalMessage: message,
-                timestamp: new Date(),
-            },
-        });
-    }
-    registerHandlers() {
-        logger.info("Registering message handlers");
-        this.methodHandlers = new Map([
-            ["conversation.start", this.handleConversationStart.bind(this)],
-            ["conversation.stop", this.handleConversationStop.bind(this)],
-            ["conversation.resume", this.handleConversationResume.bind(this)],
-            ["conversation.config", this.handleConversationConfig.bind(this)],
-            ["conversation.summary", this.handleConversationSummary.bind(this)],
-            ["message.user", this.handleUserMessage.bind(this)],
-            ["runner.uid.changed", this.handleUidChanged.bind(this)],
-            ["git.operation", this.handleGitOperation.bind(this)],
-            ["git.cleanup", this.handleGitCleanup.bind(this)],
-        ]);
-    }
-    // All the handler methods remain the same as in the original file
-    // Just copy them from the original message-handler.ts starting from line 386
-    async handleConversationStart(params, message) {
-        const { conversationObjectType = message.conversationObjectType || "Task", conversationObjectId = message.conversationObjectId ||
-            params.conversation?.objectId, config, initialMessages, conversation, } = params;
-        // Validate required parameters
-        if (!config) {
-            throw new Error("Missing required parameter: config");
-        }
-        // Require a conversation object
-        const conversationData = conversation;
-        if (!conversationData) {
-            throw new Error("Missing required parameter: conversation object must be provided");
-        }
-        const finalObjectType = conversationObjectType || conversationData.objectType;
-        const finalObjectId = conversationObjectId || conversationData.objectId;
-        if (!finalObjectId) {
-            throw new Error("Missing conversationObjectId");
-        }
-        if (rpcDebugEnabled()) {
-            // Debug log the config
-            logger.debug("conversation.start config", {
-                conversationObjectId,
-                hasConfig: !!config,
-                hasRepository: !!config?.repository,
-                repositoryType: config?.repository?.type,
-                repositoryUrl: config?.repository?.url,
-                workspaceId: config?.workspaceId,
-                fullConfig: JSON.stringify(config, null, 2),
-            });
-            logger.debug("Received conversation instructions", {
-                conversationId: conversationData.id,
-                hasWorkspaceInstructions: !!conversationData.workspaceInstructions,
-                workspaceInstructionsLength: conversationData.workspaceInstructions?.length ?? 0,
-                workspaceInstructionsPreview: conversationData.workspaceInstructions?.slice(0, 100),
-                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)) {
-            logger.info("Conversation already active, skipping duplicate start", {
-                conversationId,
-            });
-            return;
-        }
-        // Check if this conversation was recently completed (prevent restart on catch-up)
-        if (this.runner.wasConversationCompleted(conversationId)) {
-            logger.info("Conversation already completed recently, skipping restart", { conversationId });
-            return;
-        }
-        const provider = this.resolveAgentProvider(conversationData, config);
-        const manager = this.getManagerForProvider(provider);
-        // Start the conversation with the provided/loaded conversation details
-        // 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
-        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;
-        if (rpcDebugEnabled()) {
-            logger.debug("handleConversationStop invoked", {
-                conversationId,
-                messageConversationId: message.conversationId,
-                agentSessionId: params?.agentSessionId,
-                taskId: params?.taskId,
-                params: JSON.stringify(params),
-                activeConversations: this.runner.activeConversations_.size,
-                conversationIds: Array.from(this.runner.activeConversations_.keys()),
-            });
-        }
-        // Lookup strictly by conversationId
-        let context;
-        let targetConversationId;
-        if (conversationId) {
-            context = this.runner.getConversationContext(conversationId);
-            targetConversationId = conversationId;
-        }
-        if (rpcDebugEnabled()) {
-            logger.debug("handleConversationStop lookup", {
-                contextFound: !!context,
-                targetConversationId,
-                contextTaskId: context?.taskId,
-                contextAgentSessionId: context?.agentSessionId,
-            });
-        }
-        // Check if we have any identifier to work with
-        if (!conversationId) {
-            throw new Error("Missing required parameter: conversationId");
-        }
-        if (context && targetConversationId) {
-            context.status = "stopping";
-            const manager = this.getManagerForConversationContext(context);
-            await manager.stopConversation(context.agentSessionId, context, false, // Not a runner shutdown
-            reason // Pass the reason through
-            );
-            context.status = "stopped";
-            this.runner.activeConversations_.delete(targetConversationId);
-            // Update status line
-            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.
-            logger.info("Conversation stop requested but not found", {
-                conversationId,
-            });
-            // If we have a targetConversationId, ensure it's removed from tracking
-            if (targetConversationId) {
-                this.runner.activeConversations_.delete(targetConversationId);
-            }
-            statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
-        }
-    }
-    async handleConversationResume(params, message) {
-        const { conversationId = message.conversationId, conversation: resumeConversation, config, message: resumeMessage, } = params;
-        const cid = params.conversationId || conversationId;
-        if (!cid) {
-            throw new Error("Missing required parameter: conversationId");
-        }
-        // Require conversation details
-        const conversationData = resumeConversation;
-        if (!conversationData) {
-            throw new Error("Missing required parameter: conversation object must be provided");
-        }
-        const agentSessionId = conversationData.agentSessionId;
-        if (!agentSessionId) {
-            throw new Error("Cannot resume conversation without agentSessionId");
-        }
-        const provider = this.resolveAgentProvider(conversationData, config);
-        const manager = this.getManagerForProvider(provider);
-        // 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;
-        if (rpcDebugEnabled()) {
-            logger.debug("handleConversationConfig invoked", {
-                conversationId,
-                model,
-                permissionsMode,
-                hasConfig: !!config,
-            });
-        }
-        // Find the active conversation by conversationId only
-        let context;
-        if (conversationId) {
-            context = this.runner.getConversationContext(conversationId);
-        }
-        if (!context) {
-            throw new Error(`No active conversation found for conversationId: ${conversationId}`);
-        }
-        // Validate required parameters
-        if (!model && !permissionsMode) {
-            throw new Error("At least one of model or permissionsMode must be provided");
-        }
-        // Update the config with new values
-        const newConfig = {
-            ...context.config,
-            ...(model && { model }),
-            ...(permissionsMode && { permissionsMode }),
-            ...config, // Allow full config overrides if provided
-        };
-        logger.info("Stopping conversation to apply new config", {
-            conversationId: context.conversationId,
-        });
-        // 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);
-        logger.info("Resuming conversation with updated config", {
-            conversationId: context.conversationId,
-        });
-        // Resume with new config
-        // 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
-        statusLineManager.updateActiveCount(this.runner.activeConversations_.size);
-        logger.info("Conversation config updated", {
-            conversationId: context.conversationId,
-        });
-    }
-    async handleConversationSummary(params, _message) {
-        const { conversationId, summary } = params;
-        if (!conversationId) {
-            throw new Error("Missing required parameter: conversationId");
-        }
-        // Allow null to mean "no summary available yet"
-        if (summary != null && typeof summary !== "string") {
-            throw new Error("Invalid parameter: summary must be a string or null");
-        }
-        const normalized = typeof summary === "string" ? summary.replace(/\s+/g, " ").trim() : "";
-        if (rpcDebugEnabled()) {
-            logger.debug("handleConversationSummary invoked", {
-                conversationId,
-                hasSummary: Boolean(normalized),
-                summaryLength: normalized.length,
-            });
-        }
-        this.runner.applyConversationSummary(conversationId, normalized || null);
-    }
-    async handleUserMessage(params, message) {
-        const { conversationId, content, config, conversationObjectType = message.conversationObjectType || "Task", conversationObjectId = message.conversationObjectId, conversation, agentSessionId, } = params;
-        // Validate required parameters
-        if (!conversationId) {
-            throw new Error("Missing required parameter: conversationId");
-        }
-        if (!content) {
-            throw new Error("Missing required parameter: content");
-        }
-        let context = this.runner.getConversationContext(conversationId);
-        let provider;
-        let manager;
-        if (context) {
-            provider = context.provider;
-            if (!provider) {
-                throw new Error(`Conversation context missing provider for conversationId ${conversationId}. Orchestrator must set providerType/agentProviderType or prefix the model when starting the conversation.`);
-            }
-            manager = this.getManagerForProvider(provider);
-        }
-        else {
-            // Conversation is not active anymore (likely completed/cleaned up). We can
-            // only restart it if the orchestrator provided full conversation details
-            // and a resolvable provider.
-            if (!conversation) {
-                throw new Error(`No active conversation found for ${conversationId}, and no conversation details provided to restart it.`);
-            }
-            provider = this.resolveAgentProvider(conversation, config);
-            manager = this.getManagerForProvider(provider);
-            const targetObjectId = conversationObjectId ||
-                conversation.conversationObjectId ||
-                conversation.objectId;
-            if (!targetObjectId) {
-                throw new Error(`Missing conversationObjectId for ${conversationId}; cannot start conversation.`);
-            }
-            // Start a fresh conversation so the SDK process exists before streaming
-            await manager.startConversation(conversationObjectType, targetObjectId, config, [], // no initial messages here; this is a follow-up turn
-            conversation, provider);
-            context = this.runner.getConversationContext(conversationId);
-            if (!context) {
-                throw new Error(`Failed to start conversation for ${conversationId}; no context created.`);
-            }
-        }
-        // 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;
-        logger.info("Handling UID change notification", {
-            runnerUid,
-            lastProcessedAt,
-        });
-        if (rpcDebugEnabled()) {
-            logger.debug("UID change notification received", {
-                newUid: runnerUid,
-                currentUid: this.runner.getRunnerUid(),
-                newLastProcessedAt: lastProcessedAt,
-                currentLastProcessedAt: this.runner.getLastProcessedAt()?.toISOString() || "null",
-                wasActiveRunner: this.runner.getIsActiveRunner(),
-                activeConversations: this.runner.activeConversations_.size,
-            });
-        }
-        // Check if the UID matches ours FIRST, before checking timestamps
-        // 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
-            logger.info("Runner activated as primary", {
-                runnerUid,
-            });
-            this.runner.setIsActiveRunner(true);
-            await this.runner.updateLastProcessedAt(lastProcessedAt ? new Date(lastProcessedAt) : null);
-            if (rpcDebugEnabled()) {
-                logger.debug("Runner activated as primary", {
-                    runnerUid: runnerUid,
-                    lastProcessedAt: lastProcessedAt,
-                    orchestratorUrl: this.runner.config_.orchestratorUrl,
-                });
-            }
-            // Emit activation notification - wrap in try/catch to handle failures gracefully
-            try {
-                await this.runner.notify("runner.activate", {
-                    runnerId: this.runner.getRunnerId(),
-                    runnerUid: runnerUid,
-                });
-            }
-            catch (error) {
-                logger.error("Failed to send activation notification", error);
-                if (rpcDebugEnabled()) {
-                    logger.debug("Activation notification failed", {
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                }
-            }
-            // Start processing messages from the lastProcessedAt point
-            logger.info("Activation complete; setting message watermark", {
-                after: lastProcessedAt || "beginning",
-            });
-        }
-        else {
-            // Different UID - check if this is an old UID change that we should ignore
-            const currentLastProcessedAt = this.runner.getLastProcessedAt();
-            if (currentLastProcessedAt && lastProcessedAt) {
-                const newTime = new Date(lastProcessedAt);
-                if (newTime < currentLastProcessedAt) {
-                    logger.info("Ignoring old UID change", {
-                        lastProcessedAt,
-                        currentLastProcessedAt: currentLastProcessedAt.toISOString(),
-                    });
-                    if (rpcDebugEnabled()) {
-                        logger.debug("Ignoring old UID change", {
-                            newUid: runnerUid,
-                            newLastProcessedAt: lastProcessedAt,
-                            currentLastProcessedAt: currentLastProcessedAt.toISOString(),
-                        });
-                    }
-                    return;
-                }
-            }
-            // Different UID - we're being replaced
-            logger.info("Runner deactivated; replacement detected", { runnerUid });
-            this.runner.setIsActiveRunner(false);
-            // Remember which conversations were active before handoff (by conversationId)
-            for (const [conversationId, context] of this.runner
-                .activeConversations_) {
-                if (context.status === "active") {
-                    this.runner.getPreHandoffConversations().add(conversationId);
-                }
-            }
-            if (rpcDebugEnabled()) {
-                logger.debug("Runner deactivated - being replaced", {
-                    newRunnerUid: runnerUid,
-                    ourUid: this.runner.getRunnerUid(),
-                    preHandoffConversations: Array.from(this.runner.getPreHandoffConversations()),
-                    activeConversationsCount: this.runner.getPreHandoffConversations().size,
-                });
-            }
-            logger.info("Runner replacement: completing active conversations", {
-                activeConversationCount: this.runner.getPreHandoffConversations().size,
-            });
-            // Emit deactivation notification - wrap in try/catch to handle failures gracefully
-            try {
-                await this.runner.notify("runner.deactivate", {
-                    runnerId: this.runner.getRunnerId(),
-                    runnerUid: this.runner.getRunnerUid(),
-                    activeConversations: this.runner.getPreHandoffConversations().size,
-                });
-            }
-            catch (error) {
-                logger.error("Failed to send deactivation notification", error);
-                if (rpcDebugEnabled()) {
-                    logger.debug("Deactivation notification failed", {
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                }
-            }
-        }
-    }
-    async handleGitOperation(params, message) {
-        const { taskId, operation, params: opParams } = params;
-        if (!taskId || !operation) {
-            throw new Error("Missing required parameters: taskId and operation");
-        }
-        logger.info("Handling Git operation", { operation, taskId });
-        const repoManager = this.runner.repositoryManager_;
-        try {
-            switch (operation) {
-                case "stage":
-                    await repoManager.stageAll(taskId);
-                    await this.sendGitStateUpdate(taskId);
-                    break;
-                case "commit":
-                    if (!opParams?.message) {
-                        throw new Error("Commit message is required");
-                    }
-                    const commitHash = await repoManager.commit(taskId, opParams.message, opParams.author);
-                    await this.recordGitOperation(taskId, "commit", "succeeded", {
-                        commitHash,
-                    });
-                    await this.sendGitStateUpdate(taskId);
-                    break;
-                case "push":
-                    // TODO: Implement push operation
-                    logger.warn("Git push operation not yet implemented", { taskId });
-                    break;
-                case "rebase":
-                    if (!opParams?.targetBranch) {
-                        throw new Error("Target branch is required for rebase");
-                    }
-                    const rebaseResult = await repoManager.rebaseTask(taskId, opParams.targetBranch);
-                    await this.recordGitOperation(taskId, "rebase", rebaseResult.success ? "succeeded" : "failed", rebaseResult);
-                    await this.sendGitStateUpdate(taskId);
-                    break;
-                case "merge":
-                    if (!opParams?.targetBranch) {
-                        throw new Error("Target branch is required for merge");
-                    }
-                    const mergeResult = await repoManager.mergeTask(taskId, opParams.targetBranch, opParams.mode);
-                    await this.recordGitOperation(taskId, "merge", mergeResult.success ? "succeeded" : "failed", mergeResult);
-                    await this.sendGitStateUpdate(taskId);
-                    break;
-                default:
-                    throw new Error(`Unknown Git operation: ${operation}`);
-            }
-        }
-        catch (error) {
-            logger.error(`Git operation ${operation} failed`, {
-                taskId,
-                error,
-            });
-            await this.recordGitOperation(taskId, operation, "failed", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            throw error;
-        }
-    }
-    async handleGitCleanup(params, message) {
-        const { taskId, preserveBranch = false } = params;
-        if (!taskId) {
-            throw new Error("Missing required parameter: taskId");
-        }
-        logger.info("Cleaning up Git worktree", { taskId });
-        const repoManager = this.runner.repositoryManager_;
-        try {
-            await repoManager.removeTaskWorktree(taskId, { preserveBranch });
-            logger.info("Git worktree cleaned up", { taskId, preserveBranch });
-        }
-        catch (error) {
-            logger.error(`Failed to clean up worktree for task ${taskId}`, error);
-            throw error;
-        }
-    }
-    async sendGitStateUpdate(taskId) {
-        const repoManager = this.runner.repositoryManager_;
-        const gitState = await repoManager.getTaskState(taskId);
-        if (!gitState) {
-            logger.warn(`No Git state found for task ${taskId}`);
-            return;
-        }
-        // Send state update to orchestrator
-        await this.runner.notify("git.state.update", {
-            taskId,
-            state: {
-                branch: gitState.branch,
-                commit: gitState.lastCommit || "",
-                isDirty: false, // TODO: Check actual dirty state
-                ahead: 0, // TODO: Calculate ahead/behind
-                behind: 0,
-            },
-        });
-    }
-    async recordGitOperation(taskId, operation, status, details) {
-        // Send operation record to orchestrator
-        await this.runner.notify("git.operation.record", {
-            taskId,
-            operation,
-            status,
-            details,
-            timestamp: new Date(),
-        });
-    }
-    resolveAgentProvider(conversation, config) {
-        const model = conversation?.model ||
-            config?.model ||
-            config?.defaultModel ||
-            "";
-        const normalizedModel = model.toLowerCase();
-        // 1) Trust explicit provider from orchestrator/config first
-        const explicitProvider = conversation?.providerType ||
-            conversation?.agentProviderType ||
-            config?.providerType ||
-            config?.agentProviderType;
-        const normalizeProvider = (provider) => {
-            if (!provider || typeof provider !== "string")
-                return null;
-            const normalized = provider.toLowerCase();
-            if (normalized === "codex")
-                return "openai"; // codex alias for OpenAI
-            if (normalized === "openai")
-                return "openai";
-            if (normalized === "openrouter")
-                return "openrouter";
-            if (normalized === "groq")
-                return "groq";
-            if (normalized === "claude")
-                return "claude";
-            return null;
-        };
-        const explicit = normalizeProvider(explicitProvider);
-        if (explicit) {
-            return explicit;
-        }
-        // 2) Fallback to model prefix hints (non-fragile)
-        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";
-        }
-        // 3) No explicit provider and no prefix – treat as configuration error
-        throw new Error("Agent provider is required. Orchestrator must set providerType/agentProviderType or prefix the model (openai:/openrouter:/groq:/claude:).");
-    }
-    getManagerForProvider(provider) {
-        const manager = this.resolveProviderManager(provider?.toLowerCase());
-        if (manager) {
-            return manager;
-        }
-        throw new Error(`Unknown agent provider: ${provider || "<unset>"}`);
-    }
-    getManagerForConversationContext(context) {
-        const manager = this.resolveProviderManager(context.provider?.toLowerCase());
-        if (manager) {
-            return manager;
-        }
-        throw new Error(`Unknown or missing agent provider on conversation context: ${context.provider || "<unset>"}`);
-    }
-    resolveProviderManager(provider) {
-        if (provider === "openrouter" || provider === "groq") {
-            // OpenRouter now handled by Northflare Agent manager
-            return this.runner.northflareAgentManager_;
-        }
-        if (provider === "openai" || provider === "codex") {
-            return this.runner.codexManager_;
-        }
-        if (provider === "claude") {
-            return this.runner.claudeManager_;
-        }
-        return null;
-    }
-}
-//# sourceMappingURL=message-handler-sse.js.map