@northflare/runner 0.0.8 → 0.0.9

package/src/components/message-handler-sse.ts

@@ -3,7 +3,12 @@
  */
 
 import { IRunnerApp } from "../types/runner-interface";
-import { RunnerMessage, MethodHandler, ConversationContext } from "../types";
+import {
+  RunnerMessage,
+  MethodHandler,
+  ConversationContext,
+  ConversationConfig,
+} from "../types";
 import { SSEClient, SSEEvent } from "../services/SSEClient";
 import { RunnerAPIClient } from "../services/RunnerAPIClient";
 import { statusLineManager } from "../utils/status-line";
@@ -499,8 +504,11 @@ export class MessageHandler {
       }
     );
 
+    const provider = this.resolveAgentProvider(conversationData, config);
+    const manager = this.getManagerForProvider(provider);
+
     // Start the conversation with the provided/loaded conversation details
-    await this.runner.claudeManager_.startConversation(
+    await manager.startConversation(
       finalObjectType,
       finalObjectId,
       config,
@@ -551,7 +559,8 @@ export class MessageHandler {
 
     if (context && targetConversationId) {
       context.status = "stopping";
-      await this.runner.claudeManager_.stopConversation(
+      const manager = this.getManagerForConversationContext(context);
+      await manager.stopConversation(
         context.agentSessionId,
         context,
         false, // Not a runner shutdown
@@ -611,7 +620,9 @@ export class MessageHandler {
       throw new Error("Cannot resume conversation without agentSessionId");
     }
 
-    await this.runner.claudeManager_.resumeConversation(
+    const provider = this.resolveAgentProvider(conversationData, config);
+    const manager = this.getManagerForProvider(provider);
+    await manager.resumeConversation(
       conversationData.objectType,
       conversationData.objectId,
       agentSessionId,
@@ -666,7 +677,9 @@ export class MessageHandler {
     );
 
     // Stop the current conversation
-    await this.runner.claudeManager_.stopConversation(
+    const manager = this.getManagerForConversationContext(context);
+
+    await manager.stopConversation(
       context.agentSessionId,
       context,
       false // Not a runner shutdown, just updating config
@@ -680,7 +693,7 @@ export class MessageHandler {
     );
 
     // Resume with new config
-    await this.runner.claudeManager_.resumeConversation(
+    await manager.resumeConversation(
       context.conversationObjectType,
       context.conversationObjectId,
       context.agentSessionId,
@@ -717,6 +730,7 @@ export class MessageHandler {
       conversationObjectType = message.conversationObjectType || "Task",
       conversationObjectId = message.conversationObjectId,
       conversation,
+      agentSessionId,
     } = params;
 
     // Validate required parameters
@@ -728,13 +742,21 @@ export class MessageHandler {
       throw new Error("Missing required parameter: content");
     }
 
-    await this.runner.claudeManager_.sendUserMessage(
+    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
+      conversation,
+      agentSessionId
     );
   }
 
@@ -1022,4 +1044,53 @@ export class MessageHandler {
       timestamp: new Date(),
     });
   }
+
+  private resolveAgentProvider(
+    conversation?: {
+      providerType?: string;
+      agentProviderType?: string;
+      model?: string;
+    },
+    config?: ConversationConfig
+  ): "openai" | "claude" {
+    const explicitProvider =
+      conversation?.providerType ||
+      conversation?.agentProviderType ||
+      (config as any)?.providerType ||
+      (config as any)?.agentProviderType;
+
+    if (typeof explicitProvider === "string") {
+      const normalized = explicitProvider.toLowerCase();
+      if (normalized === "openai") return "openai";
+      if (normalized === "claude") return "claude";
+    }
+
+    const model =
+      conversation?.model ||
+      (config as any)?.model ||
+      (config as any)?.defaultModel ||
+      "";
+    const normalizedModel = model.toLowerCase();
+
+    const looksLikeCodex =
+      normalizedModel.includes("gpt") ||
+      /^o\d/.test(normalizedModel) ||
+      normalizedModel.includes("openai") ||
+      normalizedModel.includes("codex");
+
+    return looksLikeCodex ? "openai" : "claude";
+  }
+
+  private getManagerForProvider(provider?: string) {
+    if (provider?.toLowerCase() === "openai") {
+      return this.runner.codexManager_;
+    }
+    return this.runner.claudeManager_;
+  }
+
+  private getManagerForConversationContext(context: ConversationContext) {
+    return context.provider === "openai"
+      ? this.runner.codexManager_
+      : this.runner.claudeManager_;
+  }
 }

package/src/runner-sse.ts

@@ -13,6 +13,7 @@ import {
 import { IRunnerApp } from "./types/runner-interface";
 import { MessageHandler } from "./components/message-handler-sse";
 import { ClaudeManager } from "./components/claude-sdk-manager";
+import { CodexManager } from "./components/codex-sdk-manager";
 import { EnhancedRepositoryManager } from "./components/enhanced-repository-manager";
 import { StateManager } from "./utils/StateManager";
 import { createLogger } from "./utils/logger";
@@ -23,9 +24,137 @@ import computerName from "computer-name";
 
 const logger = createLogger("RunnerApp");
 
+const TOOL_RESPONSE_BYTE_LIMIT = 500 * 1024; // 500 KiB per tool response field
+const TOOL_RESPONSE_SUFFIX = "... [truncated]";
+
+function sanitizeToolResponsePayload(
+  method: string | undefined,
+  params: any
+): any {
+  if (method !== "message.agent" || !params) {
+    return params;
+  }
+
+  if (!isToolResultPayload(params)) {
+    return params;
+  }
+
+  const [sanitized, changed] = truncateStringsRecursively(params);
+  if (!changed) {
+    return params;
+  }
+
+  const toolUseId = extractToolUseId(params);
+  const message = `Tool response exceeded ${TOOL_RESPONSE_BYTE_LIMIT} bytes and was truncated`;
+  if (toolUseId) {
+    logger.warn(message, { toolUseId });
+  } else {
+    logger.warn(message);
+  }
+  return sanitized;
+}
+
+function isToolResultPayload(payload: any): boolean {
+  if (!payload) {
+    return false;
+  }
+  if (payload.type === "tool_result" || payload.subtype === "tool_result") {
+    return true;
+  }
+  if (Array.isArray(payload.content)) {
+    return payload.content.some((entry: any) => isToolResultBlock(entry));
+  }
+  return isToolResultBlock(payload.content);
+}
+
+function isToolResultBlock(block: any): boolean {
+  if (!block) {
+    return false;
+  }
+  return (
+    block.type === "tool_result" ||
+    block.subtype === "tool_result" ||
+    typeof block.tool_use_id === "string"
+  );
+}
+
+function extractToolUseId(payload: any): string | undefined {
+  if (!payload) {
+    return undefined;
+  }
+  if (typeof payload.tool_use_id === "string") {
+    return payload.tool_use_id;
+  }
+  if (Array.isArray(payload.content)) {
+    const match = payload.content.find(
+      (entry: any) => entry && typeof entry.tool_use_id === "string"
+    );
+    if (match) {
+      return match.tool_use_id;
+    }
+  }
+  if (payload.content && typeof payload.content === "object") {
+    return extractToolUseId(payload.content);
+  }
+  return undefined;
+}
+
+function truncateStringsRecursively(value: any): [any, boolean] {
+  if (typeof value === "string") {
+    return truncateStringValue(value);
+  }
+
+  if (Array.isArray(value)) {
+    let mutated = false;
+    let result: any[] = value;
+    for (let i = 0; i < value.length; i++) {
+      const [newItem, changed] = truncateStringsRecursively(value[i]);
+      if (changed) {
+        if (!mutated) {
+          result = value.slice();
+          mutated = true;
+        }
+        result[i] = newItem;
+      }
+    }
+    return [result, mutated];
+  }
+
+  if (value && typeof value === "object") {
+    let mutated = false;
+    let result: any = value;
+    for (const key of Object.keys(value)) {
+      const [newVal, changed] = truncateStringsRecursively(value[key]);
+      if (changed) {
+        if (!mutated) {
+          result = { ...value };
+          mutated = true;
+        }
+        result[key] = newVal;
+      }
+    }
+    return [result, mutated];
+  }
+
+  return [value, false];
+}
+
+function truncateStringValue(value: string): [string, boolean] {
+  const byteLength = Buffer.byteLength(value, "utf8");
+  if (byteLength <= TOOL_RESPONSE_BYTE_LIMIT) {
+    return [value, false];
+  }
+
+  const suffixBytes = Buffer.byteLength(TOOL_RESPONSE_SUFFIX, "utf8");
+  const maxBytes = Math.max(0, TOOL_RESPONSE_BYTE_LIMIT - suffixBytes);
+  const truncatedBuffer = Buffer.from(value, "utf8").subarray(0, maxBytes);
+  return [truncatedBuffer.toString("utf8") + TOOL_RESPONSE_SUFFIX, true];
+}
+
 export class RunnerApp implements IRunnerApp {
   private messageHandler!: MessageHandler;
   private claudeManager!: ClaudeManager;
+  private codexManager!: CodexManager;
   private repositoryManager!: EnhancedRepositoryManager;
   private stateManager!: StateManager;
   private agentConversations: Map<string, ConversationContext>; // Keyed by conversation.id
@@ -91,6 +220,9 @@ export class RunnerApp implements IRunnerApp {
     // Initialize Claude manager with repository manager (using SDK-native manager)
     this.claudeManager = new ClaudeManager(this, this.repositoryManager);
 
+    // Initialize Codex manager for OpenAI-based conversations
+    this.codexManager = new CodexManager(this, this.repositoryManager);
+
     // Initialize message handler with SSE support
     this.messageHandler = new MessageHandler(this);
   }
@@ -193,17 +325,18 @@ export class RunnerApp implements IRunnerApp {
 
   async notify(method: string, params: any): Promise<void> {
     try {
+      const safeParams = sanitizeToolResponsePayload(method, params);
       // Log RPC notification in debug mode
       logger.debug(`[RPC] Sending notification: ${method}`, {
         method,
-        params: JSON.stringify(params, null, 2),
+        params: JSON.stringify(safeParams, null, 2),
       });
 
       // Send notification with retry logic
       await this.sendToOrchestratorWithRetry({
         jsonrpc: "2.0",
         method,
-        params,
+        params: safeParams,
       });
     } catch (error) {
       // Special handling for heartbeat errors - just log a simple line
@@ -224,13 +357,25 @@ export class RunnerApp implements IRunnerApp {
   }
 
   async sendToOrchestrator(message: JsonRpcMessage): Promise<any> {
+    const sanitizedParams = sanitizeToolResponsePayload(
+      message.method,
+      message.params
+    );
+    const messageToSend =
+      sanitizedParams === message.params
+        ? message
+        : {
+            ...message,
+            params: sanitizedParams,
+          };
+
     try {
       // Log RPC request in debug mode
       logger.debug(`[RPC] Sending request:`, {
-        method: message.method,
-        id: message.id,
-        params: message.params
-          ? JSON.stringify(message.params, null, 2)
+        method: messageToSend.method,
+        id: messageToSend.id,
+        params: messageToSend.params
+          ? JSON.stringify(messageToSend.params, null, 2)
           : undefined,
       });
 
@@ -250,7 +395,7 @@ export class RunnerApp implements IRunnerApp {
         {
           method: "POST",
           headers,
-          body: JSON.stringify(message),
+          body: JSON.stringify(messageToSend),
           signal: AbortSignal.timeout(30000), // 30 second timeout
         }
       );
@@ -264,8 +409,8 @@ export class RunnerApp implements IRunnerApp {
 
       // Log RPC response in debug mode
       logger.debug(`[RPC] Received response:`, {
-        method: message.method,
-        id: message.id,
+        method: messageToSend.method,
+        id: messageToSend.id,
         result: result?.result
           ? JSON.stringify(result.result, null, 2)
           : undefined,
@@ -288,8 +433,8 @@ export class RunnerApp implements IRunnerApp {
       } else {
         // For other RPC messages, log the attempted message and error
         logger.error(`RPC failed:`, {
-          method: message.method,
-          params: message.params,
+          method: messageToSend.method,
+          params: messageToSend.params,
           error: errorMessage,
         });
       }
@@ -302,7 +447,7 @@ export class RunnerApp implements IRunnerApp {
   ): ConversationContext | undefined {
     // Using conversation.id as primary key for conversation tracking
     const context = this.agentConversations.get(conversationId);
-    console.log(`[Runner] getConversationContext lookup:`, {
+    logger.debug(`[Runner] getConversationContext lookup:`, {
       conversationId,
       found: !!context,
       totalConversations: this.agentConversations.size,
@@ -327,12 +472,12 @@ export class RunnerApp implements IRunnerApp {
                 `RunnerRepo validated: ${repo.name} at ${resolvedPath}`
               );
             } else {
-              logger.error(
+              logger.warn(
                 `RunnerRepo path is not a directory: ${repo.name} at ${resolvedPath}`
               );
             }
           } catch (error) {
-            logger.error(
+            logger.warn(
               `RunnerRepo path does not exist: ${repo.name} at ${repo.path}`
             );
           }
@@ -760,8 +905,9 @@ export class RunnerApp implements IRunnerApp {
 
     for (const [conversationId, context] of this.agentConversations) {
       if (context.status === "active" || context.status === "starting") {
+        const manager = this.getManagerForContext(context);
         stopPromises.push(
-          this.claudeManager
+          manager
             .stopConversation(context.agentSessionId, context, isRunnerShutdown)
             .catch((error) => {
               logger.error(
@@ -797,6 +943,9 @@ export class RunnerApp implements IRunnerApp {
   get claudeManager_(): ClaudeManager {
     return this.claudeManager;
   }
+  get codexManager_(): CodexManager {
+    return this.codexManager;
+  }
   get repositoryManager_(): EnhancedRepositoryManager {
     return this.repositoryManager;
   }
@@ -859,4 +1008,14 @@ export class RunnerApp implements IRunnerApp {
   setDelayFunction(fn: (ms: number) => Promise<void>): void {
     this.delayFn = fn;
   }
+
+  private getManagerForContext(
+    context?: ConversationContext | null
+  ): ClaudeManager | CodexManager {
+    const provider = context?.provider?.toLowerCase();
+    if (provider === "openai") {
+      return this.codexManager;
+    }
+    return this.claudeManager;
+  }
 }

package/src/types/claude.ts

@@ -3,6 +3,7 @@
  */
 
 import { Conversation } from "@botanicastudios/claude-code-sdk-ts";
+import type { Thread } from "@northflare/codex-sdk";
 
 // Repository information passed in conversation config
 export interface RepositoryInfo {
@@ -25,6 +26,7 @@ export interface ConversationConfig {
   repository?: RepositoryInfo; // Repository details from orchestrator
   sessionId?: string; // For resume operations
   runnerRepoPath?: string; // Path to local runner repo for local workspaces
+  codexAuth?: CodexAuthConfig;
 }
 
 // Internal conversation tracking
@@ -39,7 +41,9 @@ export interface ConversationContext {
   config: ConversationConfig;
   startedAt: Date;
   lastActivityAt: Date;
-  conversation?: Conversation; // Claude SDK conversation instance (stateful)
+  conversation?: Conversation | Thread; // Conversation or Codex thread instance
+  provider?: "claude" | "openai" | string;
+  metadata?: Record<string, any>;
 
   // Additional conversation details from database
   model: string;
@@ -48,6 +52,13 @@ export interface ConversationContext {
   permissionsMode: string;
 }
 
+export interface CodexAuthConfig {
+  accessToken: string;
+  idToken: string;
+  accountId: string;
+  lastRefresh?: string | null;
+}
+
 // Message type for initial messages
 export interface Message {
   content: string;

package/src/types/runner-interface.ts

@@ -4,6 +4,7 @@
 
 import { RunnerConfig, ConversationContext, JsonRpcMessage } from './index';
 import { ClaudeManager } from '../components/claude-sdk-manager';
+import { CodexManager } from '../components/codex-sdk-manager';
 import { EnhancedRepositoryManager } from '../components/enhanced-repository-manager';
 
 export interface IRunnerApp {
@@ -18,6 +19,7 @@ export interface IRunnerApp {
   get config_(): RunnerConfig;
   get activeConversations_(): Map<string, ConversationContext>;
   get claudeManager_(): ClaudeManager;
+  get codexManager_(): CodexManager;
   get repositoryManager_(): EnhancedRepositoryManager;
   
   // Runner state
@@ -31,4 +33,4 @@ export interface IRunnerApp {
   
   // Optional methods for SSE implementation
   updateLastProcessedAt?(timestamp: Date | null): Promise<void>;
-}
+}

package/src/utils/model.ts

@@ -0,0 +1,29 @@
+export type ModelReasoningEffort = "low" | "medium" | "high";
+
+const REASONING_VALUES: readonly ModelReasoningEffort[] = [
+  "low",
+  "medium",
+  "high",
+];
+
+export function parseModelValue(value?: string | null): {
+  baseModel?: string;
+  reasoningEffort?: ModelReasoningEffort;
+} {
+  if (!value) {
+    return {};
+  }
+
+  const [model, possibleEffort] = value.split(":");
+  if (
+    possibleEffort &&
+    REASONING_VALUES.includes(possibleEffort as ModelReasoningEffort)
+  ) {
+    return {
+      baseModel: model,
+      reasoningEffort: possibleEffort as ModelReasoningEffort,
+    };
+  }
+
+  return { baseModel: value };
+}

package/src/utils/status-line.ts

@@ -1,8 +1,8 @@
 /**
- * StatusLineManager - Manages persistent status line output for active Claude Code processes
+ * StatusLineManager - Manages persistent status line output for active agent processes
  * 
  * This component maintains a single-line status output that updates every minute to show
- * the count of active Claude Code processes. It prevents the machine from entering idle
+ * the count of active agent processes. It prevents the machine from entering idle
  * state while processes are running and provides clear visual feedback without cluttering
  * the terminal with multiple log lines.
  */
@@ -84,11 +84,11 @@ export class StatusLineManager {
 
     let newLine: string;
     if (this.activeCount === 0) {
-      newLine = "No active Claude Code processes";
+      newLine = "No active agent processes";
     } else if (this.activeCount === 1) {
-      newLine = `${timeStr} 1 active Claude Code process`;
+      newLine = `${timeStr} 1 active agent process`;
     } else {
-      newLine = `${timeStr} ${this.activeCount} active Claude Code processes`;
+      newLine = `${timeStr} ${this.activeCount} active agent processes`;
     }
 
     // If this is the first status line, position it
@@ -118,4 +118,4 @@ export class StatusLineManager {
 }
 
 // Singleton instance
-export const statusLineManager = new StatusLineManager();
+export const statusLineManager = new StatusLineManager();