qwenAgentManager.ts

/**
 * @license
 * Copyright 2025 Qwen Team
 * SPDX-License-Identifier: Apache-2.0
 */
import { AcpConnection } from './acpConnection.js';
import type {
  ModelInfo,
  AvailableCommand,
  ContentBlock,
  RequestPermissionRequest,
  SessionNotification,
} from '@agentclientprotocol/sdk';
import type {
  AuthenticateUpdateNotification,
  AskUserQuestionRequest,
} from '../types/acpTypes.js';
import type { ApprovalModeValue } from '../types/approvalModeValueTypes.js';
import { QwenSessionReader, type QwenSession } from './qwenSessionReader.js';
import { QwenSessionManager } from './qwenSessionManager.js';
import type {
  ChatMessage,
  PlanEntry,
  ToolCallUpdateData,
  QwenAgentCallbacks,
  UsageStatsPayload,
} from '../types/chatTypes.js';
import {
  QwenConnectionHandler,
  type QwenConnectionResult,
} from '../services/qwenConnectionHandler.js';
import { QwenSessionUpdateHandler } from './qwenSessionUpdateHandler.js';
import { authMethod } from '../types/acpTypes.js';
import {
  extractModelInfoFromNewSessionResult,
  extractSessionModeState,
  extractSessionModelState,
} from '../utils/acpModelInfo.js';
import { isAuthenticationRequiredError } from '../utils/authErrors.js';
import { getErrorMessage } from '../utils/errorMessage.js';
import { handleAuthenticateUpdate } from '../utils/authNotificationHandler.js';

export type { ChatMessage, PlanEntry, ToolCallUpdateData };

/**
 * Extract session list items from ACP response.
 * Handles both 'sessions' (new) and 'items' (legacy) response shapes.
 * @param response - The ACP session/list response
 * @returns Array of session items, or empty array if invalid
 */
export function extractSessionListItems(
  response: unknown,
): Array<Record<string, unknown>> {
  if (!response || typeof response !== 'object') {
    return [];
  }

  const payload = response as {
    sessions?: unknown;
    items?: unknown;
  };

  // Prefer 'sessions' field, fall back to 'items' for backwards compatibility
  if (Array.isArray(payload.sessions)) {
    return payload.sessions as Array<Record<string, unknown>>;
  }

  if (Array.isArray(payload.items)) {
    return payload.items as Array<Record<string, unknown>>;
  }

  return [];
}

/**
 * Qwen Agent Manager
 *
 * Coordinates various modules and provides unified interface
 */
interface AgentConnectOptions {
  autoAuthenticate?: boolean;
}
interface AgentSessionOptions {
  autoAuthenticate?: boolean;
}

export class QwenAgentManager {
  private connection: AcpConnection;
  private sessionReader: QwenSessionReader;
  private sessionManager: QwenSessionManager;
  private connectionHandler: QwenConnectionHandler;
  private sessionUpdateHandler: QwenSessionUpdateHandler;
  private currentWorkingDir: string = process.cwd();
  // When loading a past session via ACP, the CLI replays history through
  // session/update notifications. We set this flag to route message chunks
  // (user/assistant) as discrete chat messages instead of live streaming.
  private rehydratingSessionId: string | null = null;
  // CLI is now the single source of truth for authentication state
  // Deduplicate concurrent session/new attempts
  private sessionCreateInFlight: Promise<string | null> | null = null;

  // Callback storage
  private callbacks: QwenAgentCallbacks = {};
  // Baseline state from session/new (default/settings-backed), used to clear stale
  // UI mode/model when session/load response omits optional fields.
  private baselineModeId: ApprovalModeValue = 'default';
  private baselineAvailableModes:
    | Array<{
        id: ApprovalModeValue;
        name: string;
        description: string;
      }>
    | undefined;
  private baselineModelInfo: ModelInfo | null = null;
  private baselineAvailableModels: ModelInfo[] = [];

  constructor() {
    this.connection = new AcpConnection();
    this.sessionReader = new QwenSessionReader();
    this.sessionManager = new QwenSessionManager();
    this.connectionHandler = new QwenConnectionHandler();
    this.sessionUpdateHandler = new QwenSessionUpdateHandler({});

    // Set ACP connection callbacks
    this.connection.onSessionUpdate = (data: SessionNotification) => {
      // If we are rehydrating a loaded session, map message chunks into
      // discrete messages for the UI instead of streaming behavior.
      // During rehydration the webview is NOT in streaming mode, so
      // streaming-only callbacks (onStreamChunk, onThoughtChunk) would be
      // silently dropped by the UI.  Route all text-bearing updates through
      // onMessage which calls addMessage() regardless of streaming state.
      try {
        const targetId = this.rehydratingSessionId;
        if (
          targetId &&
          typeof data === 'object' &&
          data &&
          'update' in data &&
          (data as { sessionId?: string }).sessionId === targetId
        ) {
          const update = (
            data as unknown as {
              update: {
                sessionUpdate: string;
                content?: { text?: string };
                _meta?: Record<string, unknown>;
              };
            }
          ).update;
          const text = update?.content?.text || '';
          const metaObj = update?._meta ?? {};
          const timestamp =
            typeof metaObj['timestamp'] === 'number'
              ? (metaObj['timestamp'] as number)
              : Date.now();

          if (update?.sessionUpdate === 'user_message_chunk' && text) {
            this.callbacks.onMessage?.({
              role: 'user',
              content: text,
              timestamp,
            });
            return;
          }

          if (update?.sessionUpdate === 'agent_message_chunk' && text) {
            this.callbacks.onMessage?.({
              role: 'assistant',
              content: text,
              timestamp,
            });
            return;
          }

          if (update?.sessionUpdate === 'agent_thought_chunk' && text) {
            this.callbacks.onMessage?.({
              role: 'thinking',
              content: text,
              timestamp,
            });
            return;
          }

          // Usage-only agent_message_chunk (empty text): forward usage but
          // skip the empty stream chunk that would be discarded anyway.
          if (
            update?.sessionUpdate === 'agent_message_chunk' &&
            !text &&
            metaObj['usage']
          ) {
            if (this.callbacks.onUsageUpdate) {
              const raw = metaObj['usage'] as Record<string, unknown>;
              this.callbacks.onUsageUpdate({
                usage: {
                  inputTokens: raw['inputTokens'] as number | undefined,
                  outputTokens: raw['outputTokens'] as number | undefined,
                  totalTokens: raw['totalTokens'] as number | undefined,
                  thoughtTokens: raw['thoughtTokens'] as number | undefined,
                  cachedReadTokens: raw['cachedReadTokens'] as
                    | number
                    | undefined,
                },
                durationMs: metaObj['durationMs'] as number | undefined,
              });
            }
            return;
          }

          // Tool calls, plans, mode/model updates: fall through to the
          // normal handler which emits them via dedicated callbacks that
          // the webview can process independently of streaming state.
        }
      } catch (err) {
        console.warn('[QwenAgentManager] Rehydration routing failed:', err);
      }

      // Default handling path
      this.sessionUpdateHandler.handleSessionUpdate(data);
    };

    this.connection.onPermissionRequest = async (
      data: RequestPermissionRequest,
    ) => {
      if (this.callbacks.onPermissionRequest) {
        const optionId = await this.callbacks.onPermissionRequest(data);
        return {
          optionId:
            this.resolvePermissionOptionId(data, optionId) ||
            this.resolvePermissionOptionId(data) ||
            '',
        };
      }
      return { optionId: this.resolvePermissionOptionId(data) || '' };
    };

    this.connection.onAskUserQuestion = async (
      data: AskUserQuestionRequest,
    ) => {
      if (this.callbacks.onAskUserQuestion) {
        const result = await this.callbacks.onAskUserQuestion(data);
        return result;
      }
      return { optionId: 'cancel' };
    };

    this.connection.onEndTurn = (reason?: string) => {
      try {
        if (this.callbacks.onEndTurn) {
          this.callbacks.onEndTurn(reason);
        } else if (this.callbacks.onStreamChunk) {
          // Fallback: send a zero-length chunk then rely on streamEnd elsewhere
          this.callbacks.onStreamChunk('');
        }
      } catch (err) {
        console.warn('[QwenAgentManager] onEndTurn callback error:', err);
      }
    };

    this.connection.onAuthenticateUpdate = (
      data: AuthenticateUpdateNotification,
    ) => {
      try {
        // Handle authentication update notifications by showing VS Code notification
        handleAuthenticateUpdate(data);
      } catch (err) {
        console.warn(
          '[QwenAgentManager] onAuthenticateUpdate callback error:',
          err,
        );
      }
    };

    // Initialize callback to surface available modes and current mode to UI
    this.connection.onInitialized = (init: unknown) => {
      try {
        const obj = (init || {}) as Record<string, unknown>;
        const modes = obj['modes'] as
          | {
              currentModeId?: 'plan' | 'default' | 'auto-edit' | 'yolo';
              availableModes?: Array<{
                id: 'plan' | 'default' | 'auto-edit' | 'yolo';
                name: string;
                description: string;
              }>;
            }
          | undefined;
        if (modes && this.callbacks.onModeInfo) {
          this.callbacks.onModeInfo({
            currentModeId: modes.currentModeId,
            availableModes: modes.availableModes,
          });
        }
      } catch (err) {
        console.warn('[QwenAgentManager] onInitialized parse error:', err);
      }
    };
  }

  /**
   * Connect to Qwen service
   *
   * @param workingDir - Working directory
   * @param cliEntryPath - Path to bundled CLI entrypoint (cli.js)
   */
  async connect(
    workingDir: string,
    cliEntryPath: string,
    options?: AgentConnectOptions,
  ): Promise<QwenConnectionResult> {
    this.currentWorkingDir = workingDir;
    const res = await this.connectionHandler.connect(
      this.connection,
      workingDir,
      cliEntryPath,
      options,
    );
    if (res.modelInfo && this.callbacks.onModelInfo) {
      this.baselineModelInfo = res.modelInfo;
      this.callbacks.onModelInfo(res.modelInfo);
    }
    // Emit available models from connect result
    if (res.availableModels && res.availableModels.length > 0) {
      this.baselineAvailableModels = res.availableModels;
      console.log(
        '[QwenAgentManager] Emitting availableModels from connect():',
        res.availableModels.map((m) => m.modelId),
      );
      if (this.callbacks.onAvailableModels) {
        this.callbacks.onAvailableModels(res.availableModels);
      }
    }
    if (res.currentModeId) {
      this.baselineModeId = res.currentModeId;
      this.callbacks.onModeChanged?.(res.currentModeId);
    }
    if (res.availableModes) {
      this.baselineAvailableModes = res.availableModes;
      this.callbacks.onModeInfo?.({
        currentModeId: res.currentModeId ?? this.baselineModeId,
        availableModes: res.availableModes,
      });
    } else if (res.currentModeId) {
      this.callbacks.onModeInfo?.({
        currentModeId: res.currentModeId,
      });
    }
    return res;
  }

  /**
   * Send message
   *
   * @param message - Message content
   */
  async sendMessage(message: string | ContentBlock[]): Promise<void> {
    await this.connection.sendPrompt(message);
  }

  /**
   * Set approval mode from UI
   */
  async setApprovalModeFromUi(
    mode: ApprovalModeValue,
  ): Promise<ApprovalModeValue> {
    const modeId = mode;
    try {
      await this.connection.setMode(modeId);
      // set_mode response has no mode payload; use requested value.
      const confirmed = modeId;
      this.callbacks.onModeChanged?.(confirmed);
      return confirmed;
    } catch (err) {
      console.error('[QwenAgentManager] Failed to set mode:', err);
      throw err;
    }
  }

  /**
   * Set model from UI
   */
  async setModelFromUi(modelId: string): Promise<ModelInfo | null> {
    try {
      await this.connection.setModel(modelId);
      const confirmedModelId = modelId;
      const modelInfo = this.baselineAvailableModels.find(
        (model) => model.modelId === confirmedModelId,
      ) ?? {
        modelId: confirmedModelId,
        name: confirmedModelId,
      };
      this.baselineModelInfo = modelInfo;
      this.callbacks.onModelChanged?.(modelInfo);
      return modelInfo;
    } catch (err) {
      console.error('[QwenAgentManager] Failed to set model:', err);
      throw err;
    }
  }

  /**
   * Validate if current session is still active
   * This is a lightweight check to verify session validity
   *
   * @returns True if session is valid, false otherwise
   */
  async validateCurrentSession(): Promise<boolean> {
    try {
      // If we don't have a current session, it's definitely not valid
      if (!this.connection.currentSessionId) {
        return false;
      }

      // Try to get session list to verify our session still exists
      const sessions = await this.getSessionList();
      const currentSessionId = this.connection.currentSessionId;

      // Check if our current session exists in the session list
      const sessionExists = sessions.some(
        (session: Record<string, unknown>) =>
          session.id === currentSessionId ||
          session.sessionId === currentSessionId,
      );

      return sessionExists;
    } catch (error) {
      console.warn('[QwenAgentManager] Session validation failed:', error);
      // If we can't validate, assume session is invalid
      return false;
    }
  }

  /**
   * Get session list with version-aware strategy
   * First tries ACP method if CLI version supports it, falls back to file system method
   *
   * @returns Session list
   */
  async getSessionList(): Promise<Array<Record<string, unknown>>> {
    console.log(
      '[QwenAgentManager] Getting session list with version-aware strategy',
    );

    try {
      console.log(
        '[QwenAgentManager] Attempting to get session list via ACP method',
      );
      const response = await this.connection.listSessions();
      console.log('[QwenAgentManager] ACP session list response:', response);

      const res: unknown = response;
      const items = extractSessionListItems(res);

      console.log(
        '[QwenAgentManager] Sessions retrieved via ACP:',
        res,
        items.length,
      );
      if (items.length > 0) {
        const sessions = items.map((item) => ({
          id: item.sessionId || item.id,
          sessionId: item.sessionId || item.id,
          title: item.title || item.name || item.prompt || 'Untitled Session',
          name: item.title || item.name || item.prompt || 'Untitled Session',
          startTime: item.startTime,
          lastUpdated: item.updatedAt || item.mtime || item.lastUpdated,
          messageCount: item.messageCount || 0,
          projectHash: item.projectHash,
          filePath: item.filePath,
          cwd: item.cwd,
        }));

        console.log(
          '[QwenAgentManager] Sessions retrieved via ACP:',
          sessions.length,
        );
        return sessions;
      }
    } catch (error) {
      console.warn(
        '[QwenAgentManager] ACP session list failed, falling back to file system method:',
        error,
      );
    }

    // Always fall back to file system method
    try {
      console.log('[QwenAgentManager] Getting session list from file system');
      const sessions = await this.sessionReader.getAllSessions(undefined, true);
      console.log(
        '[QwenAgentManager] Session list from file system (all projects):',
        sessions.length,
      );

      const result = sessions.map(
        (session: QwenSession): Record<string, unknown> => ({
          id: session.sessionId,
          sessionId: session.sessionId,
          title: this.sessionReader.getSessionTitle(session),
          name: this.sessionReader.getSessionTitle(session),
          startTime: session.startTime,
          lastUpdated: session.lastUpdated,
          messageCount: session.messageCount ?? session.messages.length,
          projectHash: session.projectHash,
          filePath: session.filePath,
          cwd: session.cwd,
        }),
      );

      console.log(
        '[QwenAgentManager] Sessions retrieved from file system:',
        result.length,
      );
      return result;
    } catch (error) {
      console.error(
        '[QwenAgentManager] Failed to get session list from file system:',
        error,
      );
      return [];
    }
  }

  /**
   * Get session list (paged)
   * Uses ACP session/list with cursor-based pagination when available.
   * Falls back to file system scan with equivalent pagination semantics.
   */
  async getSessionListPaged(params?: {
    cursor?: number;
    size?: number;
  }): Promise<{
    sessions: Array<Record<string, unknown>>;
    nextCursor?: number;
    hasMore: boolean;
  }> {
    const size = params?.size ?? 20;
    const cursor = params?.cursor;

    try {
      const response = await this.connection.listSessions({
        size,
        ...(cursor !== undefined ? { cursor } : {}),
      });
      const res: unknown = response;
      const items = extractSessionListItems(res);

      const mapped = items.map((item) => ({
        id: item.sessionId || item.id,
        sessionId: item.sessionId || item.id,
        title: item.title || item.name || item.prompt || 'Untitled Session',
        name: item.title || item.name || item.prompt || 'Untitled Session',
        startTime: item.startTime,
        lastUpdated: item.updatedAt || item.mtime || item.lastUpdated,
        messageCount: item.messageCount || 0,
        projectHash: item.projectHash,
        filePath: item.filePath,
        cwd: item.cwd,
      }));

      // SDK returns nextCursor as string; convert to numeric cursor for paging
      let nextCursorNum: number | undefined;
      if (typeof res === 'object' && res !== null && 'nextCursor' in res) {
        const raw = (res as { nextCursor?: unknown }).nextCursor;
        if (typeof raw === 'number') {
          nextCursorNum = raw;
        } else if (typeof raw === 'string') {
          const parsed = Number(raw);
          if (!Number.isNaN(parsed)) {
            nextCursorNum = parsed;
          }
        }
      }
      const hasMore = nextCursorNum !== undefined;

      return { sessions: mapped, nextCursor: nextCursorNum, hasMore };
    } catch (error) {
      console.warn('[QwenAgentManager] Paged ACP session list failed:', error);
      // fall through to file system
    }

    // Fallback: file system for current project only (to match ACP semantics)
    try {
      const all = await this.sessionReader.getAllSessions(
        this.currentWorkingDir,
        false,
      );
      // Sorted by lastUpdated desc already per reader
      const allWithMtime = all.map((s) => ({
        raw: s,
        mtime: new Date(s.lastUpdated).getTime(),
      }));
      const filtered =
        cursor !== undefined
          ? allWithMtime.filter((x) => x.mtime < cursor)
          : allWithMtime;
      const page = filtered.slice(0, size);
      const sessions = page.map((x) => ({
        id: x.raw.sessionId,
        sessionId: x.raw.sessionId,
        title: this.sessionReader.getSessionTitle(x.raw),
        name: this.sessionReader.getSessionTitle(x.raw),
        startTime: x.raw.startTime,
        lastUpdated: x.raw.lastUpdated,
        messageCount: x.raw.messageCount ?? x.raw.messages.length,
        projectHash: x.raw.projectHash,
        filePath: x.raw.filePath,
        cwd: x.raw.cwd,
      }));
      const nextCursorVal =
        page.length > 0 ? page[page.length - 1].mtime : undefined;
      const hasMore = filtered.length > size;
      return { sessions, nextCursor: nextCursorVal, hasMore };
    } catch (error) {
      console.error('[QwenAgentManager] File system paged list failed:', error);
      return { sessions: [], hasMore: false };
    }
  }

  /**
   * Get session messages (read from disk)
   *
   * @param sessionId - Session ID
   * @returns Message list
   */
  async getSessionMessages(sessionId: string): Promise<ChatMessage[]> {
    try {
      try {
        const list = await this.getSessionList();
        const item = list.find(
          (s) => s.sessionId === sessionId || s.id === sessionId,
        );
        console.log(
          '[QwenAgentManager] Session list item for filePath lookup:',
          item,
        );
        if (
          typeof item === 'object' &&
          item !== null &&
          'filePath' in item &&
          typeof item.filePath === 'string'
        ) {
          const messages = await this.readJsonlMessages(item.filePath);
          // Even if messages array is empty, we should return it rather than falling back
          // This ensures we don't accidentally show messages from a different session format
          return messages;
        }
      } catch (e) {
        console.warn('[QwenAgentManager] JSONL read path lookup failed:', e);
      }

      // Fallback: legacy JSON session files
      const session = await this.sessionReader.getSession(
        sessionId,
        this.currentWorkingDir,
      );
      if (!session) {
        return [];
      }
      return session.messages.map(
        (msg: { type: string; content: string; timestamp: string }) => ({
          role: msg.type === 'user' ? 'user' : 'assistant',
          content: msg.content,
          timestamp: new Date(msg.timestamp).getTime(),
        }),
      );
    } catch (error) {
      console.error(
        '[QwenAgentManager] Failed to get session messages:',
        error,
      );
      return [];
    }
  }

  // Read CLI JSONL session file and convert to ChatMessage[] for UI
  private async readJsonlMessages(filePath: string): Promise<ChatMessage[]> {
    const fs = await import('fs');
    const readline = await import('readline');
    try {
      if (!fs.existsSync(filePath)) {
        return [];
      }
      const fileStream = fs.createReadStream(filePath, { encoding: 'utf-8' });
      const rl = readline.createInterface({
        input: fileStream,
        crlfDelay: Infinity,
      });
      const records: unknown[] = [];
      for await (const line of rl) {
        const trimmed = line.trim();
        if (!trimmed) {
          continue;
        }
        try {
          const obj = JSON.parse(trimmed);
          records.push(obj);
        } catch {
          /* ignore */
        }
      }
      // Simple linear reconstruction: filter user/assistant and sort by timestamp
      console.log(
        '[QwenAgentManager] JSONL records read:',
        records.length,
        filePath,
      );

      // Include all types of records, not just user/assistant
      // Narrow unknown JSONL rows into a minimal shape we can work with.
      type JsonlRecord = {
        type: string;
        timestamp: string;
        message?: unknown;
        toolCallResult?: { callId?: string; status?: string } | unknown;
        subtype?: string;
        systemPayload?: { uiEvent?: Record<string, unknown> } | unknown;
        plan?: { entries?: Array<Record<string, unknown>> } | unknown;
      };

      const isJsonlRecord = (x: unknown): x is JsonlRecord =>
        typeof x === 'object' &&
        x !== null &&
        typeof (x as Record<string, unknown>).type === 'string' &&
        typeof (x as Record<string, unknown>).timestamp === 'string';

      const allRecords = records
        .filter(isJsonlRecord)
        .sort(
          (a, b) =>
            new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime(),
        );

      const msgs: ChatMessage[] = [];
      for (const r of allRecords) {
        // Handle user and assistant messages
        if ((r.type === 'user' || r.type === 'assistant') && r.message) {
          msgs.push({
            role:
              r.type === 'user' ? ('user' as const) : ('assistant' as const),
            content: this.contentToText(r.message),
            timestamp: new Date(r.timestamp).getTime(),
          });
        }
        // Handle tool call records that might have content we want to show
        else if (r.type === 'tool_call' || r.type === 'tool_call_update') {
          // Convert tool calls to messages if they have relevant content
          const toolContent = this.extractToolCallContent(r as unknown);
          if (toolContent) {
            msgs.push({
              role: 'assistant',
              content: toolContent,
              timestamp: new Date(r.timestamp).getTime(),
            });
          }
        }
        // Handle tool result records
        else if (
          r.type === 'tool_result' &&
          r.toolCallResult &&
          typeof r.toolCallResult === 'object'
        ) {
          const toolResult = r.toolCallResult as {
            callId?: string;
            status?: string;
          };
          const callId = toolResult.callId ?? 'unknown';
          const status = toolResult.status ?? 'unknown';
          const resultText = `Tool Result (${callId}): ${status}`;
          msgs.push({
            role: 'assistant',
            content: resultText,
            timestamp: new Date(r.timestamp).getTime(),
          });
        }
        // Handle system telemetry records
        else if (
          r.type === 'system' &&
          r.subtype === 'ui_telemetry' &&
          r.systemPayload &&
          typeof r.systemPayload === 'object' &&
          'uiEvent' in r.systemPayload &&
          (r.systemPayload as { uiEvent?: Record<string, unknown> }).uiEvent
        ) {
          const uiEvent = (
            r.systemPayload as {
              uiEvent?: Record<string, unknown>;
            }
          ).uiEvent as Record<string, unknown>;
          let telemetryText = '';

          if (
            typeof uiEvent['event.name'] === 'string' &&
            (uiEvent['event.name'] as string).includes('tool_call')
          ) {
            const functionName =
              (uiEvent['function_name'] as string | undefined) ||
              'Unknown tool';
            const status =
              (uiEvent['status'] as string | undefined) || 'unknown';
            const duration =
              typeof uiEvent['duration_ms'] === 'number'
                ? ` (${uiEvent['duration_ms']}ms)`
                : '';
            telemetryText = `Tool Call: ${functionName} - ${status}${duration}`;
          } else if (
            typeof uiEvent['event.name'] === 'string' &&
            (uiEvent['event.name'] as string).includes('api_response')
          ) {
            const statusCode =
              (uiEvent['status_code'] as string | number | undefined) ||
              'unknown';
            const duration =
              typeof uiEvent['duration_ms'] === 'number'
                ? ` (${uiEvent['duration_ms']}ms)`
                : '';
            telemetryText = `API Response: Status ${statusCode}${duration}`;
          } else {
            // Generic system telemetry
            const eventName =
              (uiEvent['event.name'] as string | undefined) || 'Unknown event';
            telemetryText = `System Event: ${eventName}`;
          }

          if (telemetryText) {
            msgs.push({
              role: 'assistant',
              content: telemetryText,
              timestamp: new Date(r.timestamp).getTime(),
            });
          }
        }
        // Handle plan entries
        else if (
          r.type === 'plan' &&
          r.plan &&
          typeof r.plan === 'object' &&
          'entries' in r.plan
        ) {
          const planEntries =
            ((r.plan as { entries?: Array<Record<string, unknown>> })
              .entries as Array<Record<string, unknown>> | undefined) || [];
          if (planEntries.length > 0) {
            const planText = planEntries
              .map(
                (entry: Record<string, unknown>, index: number) =>
                  `${index + 1}. ${
                    entry.description || entry.title || 'Unnamed step'
                  }`,
              )
              .join('\n');
            msgs.push({
              role: 'assistant',
              content: `Plan:\n${planText}`,
              timestamp: new Date(r.timestamp).getTime(),
            });
          }
        }
        // Handle other types if needed
      }

      console.log(
        '[QwenAgentManager] JSONL messages reconstructed:',
        msgs.length,
      );
      return msgs;
    } catch (err) {
      console.warn('[QwenAgentManager] Failed to read JSONL messages:', err);
      return [];
    }
  }

  // Extract meaningful content from tool call records
  private extractToolCallContent(record: unknown): string | null {
    try {
      // Type guard for record
      if (typeof record !== 'object' || record === null) {
        return null;
      }

      // Cast to a more specific type for easier handling
      const typedRecord = record as Record<string, unknown>;

      // If the tool call has a result or output, include it
      if ('toolCallResult' in typedRecord && typedRecord.toolCallResult) {
        return `Tool result: ${this.formatValue(typedRecord.toolCallResult)}`;
      }

      // If the tool call has content, include it
      if ('content' in typedRecord && typedRecord.content) {
        return this.formatValue(typedRecord.content);
      }

      // If the tool call has a title or name, include it
      if (
        ('title' in typedRecord && typedRecord.title) ||
        ('name' in typedRecord && typedRecord.name)
      ) {
        return `Tool: ${typedRecord.title || typedRecord.name}`;
      }

      // Handle tool_call records with more details
      if (
        typedRecord.type === 'tool_call' &&
        'toolCall' in typedRecord &&
        typedRecord.toolCall
      ) {
        const toolCall = typedRecord.toolCall as Record<string, unknown>;
        if (
          ('title' in toolCall && toolCall.title) ||
          ('name' in toolCall && toolCall.name)
        ) {
          return `Tool call: ${toolCall.title || toolCall.name}`;
        }
        if ('rawInput' in toolCall && toolCall.rawInput) {
          return `Tool input: ${this.formatValue(toolCall.rawInput)}`;
        }
      }

      // Handle tool_call_update records with status
      if (typedRecord.type === 'tool_call_update') {
        const status =
          ('status' in typedRecord && typedRecord.status) || 'unknown';
        const title =
          ('title' in typedRecord && typedRecord.title) ||
          ('name' in typedRecord && typedRecord.name) ||
          'Unknown tool';
        return `Tool ${status}: ${title}`;
      }

      return null;
    } catch {
      return null;
    }
  }

  // Format any value to a string for display
  private formatValue(value: unknown): string {
    if (value === null || value === undefined) {
      return '';
    }
    if (typeof value === 'string') {
      return value;
    }
    if (typeof value === 'object') {
      try {
        return JSON.stringify(value, null, 2);
      } catch (_e) {
        return String(value);
      }
    }
    return String(value);
  }

  // Extract plain text from Content (genai Content)
  private contentToText(message: unknown): string {
    try {
      // Type guard for message
      if (typeof message !== 'object' || message === null) {
        return '';
      }

      // Cast to a more specific type for easier handling
      const typedMessage = message as Record<string, unknown>;

      const parts = Array.isArray(typedMessage.parts) ? typedMessage.parts : [];
      const texts: string[] = [];
      for (const p of parts) {
        // Type guard for part
        if (typeof p !== 'object' || p === null) {
          continue;
        }

        const typedPart = p as Record<string, unknown>;
        if (typeof typedPart.text === 'string') {
          texts.push(typedPart.text);
        } else if (typeof typedPart.data === 'string') {
          texts.push(typedPart.data);
        }
      }
      return texts.join('\n');
    } catch {
      return '';
    }
  }

  /**
   * Try to load session via ACP session/load method
   * This method will only be used if CLI version supports it
   *
   * @param sessionId - Session ID
   * @returns Load response or error
   */
  async loadSessionViaAcp(
    sessionId: string,
    cwdOverride?: string,
  ): Promise<unknown> {
    try {
      // Route upcoming session/update messages as discrete messages for replay
      this.rehydratingSessionId = sessionId;
      console.log(
        '[QwenAgentManager] Rehydration start for session:',
        sessionId,
      );
      console.log(
        '[QwenAgentManager] Attempting session/load via ACP for session:',
        sessionId,
      );
      const response = await this.connection.loadSession(
        sessionId,
        cwdOverride,
      );
      console.log(
        '[QwenAgentManager] Session load succeeded. Response:',
        JSON.stringify(response).substring(0, 200),
      );
      this.applySessionStateFromResult(response);
      this.restoreBaselineSessionStateAfterLoad(response);

      return response;
    } catch (error) {
      const errorMessage = getErrorMessage(error);
      console.error(
        '[QwenAgentManager] Session load via ACP failed for session:',
        sessionId,
      );
      console.error('[QwenAgentManager] Error type:', error?.constructor?.name);
      console.error('[QwenAgentManager] Error message:', errorMessage);

      // Check if error is from ACP response
      if (error && typeof error === 'object') {
        // Safely check if 'error' property exists
        if ('error' in error) {
          const acpError = error as {
            error?: { code?: number; message?: string };
          };
          if (acpError.error) {
            console.error(
              '[QwenAgentManager] ACP error code:',
              acpError.error.code,
            );
            console.error(
              '[QwenAgentManager] ACP error message:',
              acpError.error.message,
            );
          }
        } else {
          console.error('[QwenAgentManager] Non-ACPIf error details:', error);
        }
      }

      throw error;
    } finally {
      // End rehydration routing regardless of outcome
      console.log('[QwenAgentManager] Rehydration end for session:', sessionId);
      this.rehydratingSessionId = null;
    }
  }

  /**
   * Load session with version-aware strategy
   * First tries ACP method if CLI version supports it, falls back to file system method
   *
   * @param sessionId - Session ID to load
   * @returns Loaded session messages or null
   */
  async loadSession(sessionId: string): Promise<ChatMessage[] | null> {
    console.log(
      '[QwenAgentManager] Loading session with version-aware strategy:',
      sessionId,
    );

    try {
      console.log(
        '[QwenAgentManager] Attempting to load session via ACP method',
      );
      await this.loadSessionViaAcp(sessionId);
      console.log('[QwenAgentManager] Session loaded successfully via ACP');

      // After loading via ACP, we still need to get messages from file system
      // In future, we might get them directly from the ACP response
    } catch (error) {
      console.warn(
        '[QwenAgentManager] ACP session load failed, falling back to file system method:',
        error,
      );
    }

    // Always fall back to file system method
    try {
      console.log(
        '[QwenAgentManager] Loading session messages from file system',
      );
      const messages = await this.loadSessionMessagesFromFile(sessionId);
      console.log(
        '[QwenAgentManager] Session messages loaded successfully from file system',
      );
      return messages;
    } catch (error) {
      console.error(
        '[QwenAgentManager] Failed to load session messages from file system:',
        error,
      );
      return null;
    }
  }

  /**
   * Load session messages from file system
   *
   * @param sessionId - Session ID to load
   * @returns Loaded session messages
   */
  private async loadSessionMessagesFromFile(
    sessionId: string,
  ): Promise<ChatMessage[] | null> {
    try {
      console.log(
        '[QwenAgentManager] Loading session from file system:',
        sessionId,
      );

      // Load session from file system
      const session = await this.sessionManager.loadSession(
        sessionId,
        this.currentWorkingDir,
      );

      if (!session) {
        console.log(
          '[QwenAgentManager] Session not found in file system:',
          sessionId,
        );
        return null;
      }

      // Convert message format
      const messages: ChatMessage[] = session.messages.map((msg) => ({
        role: msg.type === 'user' ? 'user' : 'assistant',
        content: msg.content,
        timestamp: new Date(msg.timestamp).getTime(),
      }));

      return messages;
    } catch (error) {
      console.error(
        '[QwenAgentManager] Session load from file system failed:',
        error,
      );
      throw error;
    }
  }

  /**
   * Create new session
   *
   * Note: Authentication should be done in connect() method, only create session here
   *
   * @param workingDir - Working directory
   * @returns Newly created session ID
   */
  async createNewSession(
    workingDir: string,
    options?: AgentSessionOptions,
  ): Promise<string | null> {
    const autoAuthenticate = options?.autoAuthenticate ?? true;
    // Reuse existing session if present
    if (this.connection.currentSessionId) {
      console.log(
        '[QwenAgentManager] createNewSession: reusing existing session',
        this.connection.currentSessionId,
      );
      return this.connection.currentSessionId;
    }
    // Deduplicate concurrent session/new attempts
    if (this.sessionCreateInFlight) {
      console.log(
        '[QwenAgentManager] createNewSession: session creation already in flight',
      );
      return this.sessionCreateInFlight;
    }

    console.log('[QwenAgentManager] Creating new session...');

    this.sessionCreateInFlight = (async () => {
      try {
        let newSessionResult: unknown;
        // Try to create a new ACP session. If Qwen asks for auth, let it handle authentication.
        try {
          newSessionResult = await this.connection.newSession(workingDir);
          console.log(
            '[QwenAgentManager] newSession returned:',
            JSON.stringify(newSessionResult, null, 2),
          );
        } catch (err) {
          const requiresAuth = isAuthenticationRequiredError(err);

          if (requiresAuth) {
            if (!autoAuthenticate) {
              console.warn(
                '[QwenAgentManager] session/new requires authentication but auto-auth is disabled. Deferring until user logs in.',
              );
              throw err;
            }
            console.warn(
              '[QwenAgentManager] session/new requires authentication. Retrying with authenticate...',
            );
            try {
              // Let CLI handle authentication - it's the single source of truth
              await this.connection.authenticate(authMethod);
              console.log(
                '[QwenAgentManager] createNewSession Authentication successful. Retrying session/new...',
              );
              // Add a slight delay to ensure auth state is settled
              await new Promise((resolve) => setTimeout(resolve, 300));
              newSessionResult = await this.connection.newSession(workingDir);
            } catch (reauthErr) {
              console.error(
                '[QwenAgentManager] Re-authentication failed:',
                reauthErr,
              );
              throw reauthErr;
            }
          } else {
            throw err;
          }
        }

        this.applySessionStateFromResult(newSessionResult);

        const newSessionId = this.connection.currentSessionId;
        console.log(
          '[QwenAgentManager] New session created with ID:',
          newSessionId,
        );
        return newSessionId;
      } finally {
        this.sessionCreateInFlight = null;
      }
    })();

    return this.sessionCreateInFlight;
  }

  /**
   * Switch to specified session
   *
   * @param sessionId - Session ID
   */
  async switchToSession(sessionId: string): Promise<void> {
    await this.connection.switchSession(sessionId);
  }

  /**
   * Cancel current prompt
   */
  async cancelCurrentPrompt(): Promise<void> {
    console.log('[QwenAgentManager] Cancelling current prompt');
    await this.connection.cancelSession();
  }

  /**
   * Register message callback
   *
   * @param callback - Message callback function
   */
  onMessage(callback: (message: ChatMessage) => void): void {
    this.callbacks.onMessage = callback;
    this.sessionUpdateHandler.updateCallbacks(this.callbacks);
  }

  /**
   * Register stream chunk callback
   *
   * @param callback - Stream chunk callback function
   */
  onStreamChunk(callback: (chunk: string) => void): void {
    this.callbacks.onStreamChunk = callback;
    this.sessionUpdateHandler.updateCallbacks(this.callbacks);
  }

  /**
   * Register thought chunk callback
   *
   * @param callback - Thought chunk callback function
   */
  onThoughtChunk(callback: (chunk: string) => void): void {
    this.callbacks.onThoughtChunk = callback;
    this.sessionUpdateHandler.updateCallbacks(this.callbacks);
  }

  /**
   * Register tool call callback
   *
   * @param callback - Tool call callback function
   */
  onToolCall(callback: (update: ToolCallUpdateData) => void): void {
    this.callbacks.onToolCall = callback;
    this.sessionUpdateHandler.updateCallbacks(this.callbacks);
  }

  /**
   * Register plan callback
   *
   * @param callback - Plan callback function
   */
  onPlan(callback: (entries: PlanEntry[]) => void): void {
    this.callbacks.onPlan = callback;
    this.sessionUpdateHandler.updateCallbacks(this.callbacks);
  }

  /**
   * Register permission request callback
   *
   * @param callback - Permission request callback function
   */
  onPermissionRequest(
    callback: (request: RequestPermissionRequest) => Promise<string>,
  ): void {
    this.callbacks.onPermissionRequest = callback;
    this.sessionUpdateHandler.updateCallbacks(this.callbacks);
  }

  /**
   * Register ask user question callback
   *
   * @param callback - Ask user question callback function
   */
  onAskUserQuestion(
    callback: (
      request: AskUserQuestionRequest,
    ) => Promise<{ optionId: string; answers?: Record<string, string> }>,
  ): void {
    this.callbacks.onAskUserQuestion = callback;
    this.sessionUpdateHandler.updateCallbacks(this.callbacks);
  }

  /**
   * Register end-of-turn callback
   *
   * @param callback - Called when ACP stopReason is reported
   */
  onEndTurn(callback: (reason?: string) => void): void {
    this.callbacks.onEndTurn = callback;
    this.sessionUpdateHandler.updateCallbacks(this.callbacks);
  }

  /**
   * Register initialize mode info callback
   */
  onModeInfo(
    callback: (info: {
      currentModeId?: 'plan' | 'default' | 'auto-edit' | 'yolo';
      availableModes?: Array<{
        id: 'plan' | 'default' | 'auto-edit' | 'yolo';
        name: string;
        description: string;
      }>;
    }) => void,
  ): void {
    this.callbacks.onModeInfo = callback;
    this.sessionUpdateHandler.updateCallbacks(this.callbacks);
  }

  /**
   * Register mode changed callback
   */
  onModeChanged(
    callback: (modeId: 'plan' | 'default' | 'auto-edit' | 'yolo') => void,
  ): void {
    this.callbacks.onModeChanged = callback;
    this.sessionUpdateHandler.updateCallbacks(this.callbacks);
  }

  /**
   * Register callback for usage metadata updates
   */
  onUsageUpdate(callback: (stats: UsageStatsPayload) => void): void {
    this.callbacks.onUsageUpdate = callback;
    this.sessionUpdateHandler.updateCallbacks(this.callbacks);
  }

  /**
   * Register callback for model info updates
   */
  onModelInfo(callback: (info: ModelInfo) => void): void {
    this.callbacks.onModelInfo = callback;
    this.sessionUpdateHandler.updateCallbacks(this.callbacks);
  }

  /**
   * Register callback for model changed updates.
   */
  onModelChanged(callback: (model: ModelInfo) => void): void {
    this.callbacks.onModelChanged = callback;
    this.sessionUpdateHandler.updateCallbacks(this.callbacks);
  }

  /**
   * Register callback for available commands updates (from ACP available_commands_update)
   */
  onAvailableCommands(callback: (commands: AvailableCommand[]) => void): void {
    this.callbacks.onAvailableCommands = callback;
    this.sessionUpdateHandler.updateCallbacks(this.callbacks);
  }

  /**
   * Register callback for available models updates (from session/new response)
   */
  onAvailableModels(callback: (models: ModelInfo[]) => void): void {
    this.callbacks.onAvailableModels = callback;
    this.sessionUpdateHandler.updateCallbacks(this.callbacks);
  }

  /**
   * Disconnect
   */
  disconnect(): void {
    this.connection.disconnect();
  }

  /**
   * Check if connected
   */
  get isConnected(): boolean {
    return this.connection.isConnected;
  }

  /**
   * Get current session ID
   */
  get currentSessionId(): string | null {
    return this.connection.currentSessionId;
  }

  private applySessionStateFromResult(result: unknown): void {
    const modelInfo = extractModelInfoFromNewSessionResult(result);
    if (modelInfo) {
      this.baselineModelInfo = modelInfo;
      this.callbacks.onModelInfo?.(modelInfo);
    }

    const modelState = extractSessionModelState(result);
    if (modelState?.availableModels && modelState.availableModels.length > 0) {
      this.baselineAvailableModels = modelState.availableModels;
      this.callbacks.onAvailableModels?.(modelState.availableModels);
    }

    const modeState = extractSessionModeState(result);
    if (modeState?.currentModeId) {
      this.baselineModeId = modeState.currentModeId;
      this.callbacks.onModeChanged?.(modeState.currentModeId);
    }
    if (modeState?.availableModes && modeState.availableModes.length > 0) {
      this.baselineAvailableModes = modeState.availableModes;
    }
    if (modeState) {
      this.callbacks.onModeInfo?.({
        currentModeId: modeState.currentModeId ?? this.baselineModeId,
        availableModes: modeState.availableModes ?? this.baselineAvailableModes,
      });
    }
  }

  private restoreBaselineSessionStateAfterLoad(result: unknown): void {
    const obj = (result || {}) as Record<string, unknown>;
    const hasModes = !!obj['modes'];
    const hasModels = !!obj['models'];

    if (!hasModes) {
      this.callbacks.onModeInfo?.({
        currentModeId: this.baselineModeId,
        availableModes: this.baselineAvailableModes,
      });
      this.callbacks.onModeChanged?.(this.baselineModeId);
    }

    if (!hasModels) {
      if (this.baselineModelInfo) {
        this.callbacks.onModelInfo?.(this.baselineModelInfo);
      }
      if (this.baselineAvailableModels.length > 0) {
        this.callbacks.onAvailableModels?.(this.baselineAvailableModels);
      }
    }
  }

  private resolvePermissionOptionId(
    request: RequestPermissionRequest,
    preferredOptionId?: string,
  ): string | undefined {
    // Keep this mapping aligned with AcpConnection.resolvePermissionOptionId:
    // Webview callbacks may provide a semantic choice (allow/reject) while the
    // CLI requires a concrete ToolConfirmationOutcome optionId.
    // Always normalize to an optionId that exists in request.options.
    const options = Array.isArray(request.options) ? request.options : [];
    if (options.length === 0) {
      return undefined;
    }

    if (
      preferredOptionId &&
      options.some((option) => option.optionId === preferredOptionId)
    ) {
      return preferredOptionId;
    }

    return (
      options.find((option) => option.kind === 'allow_once')?.optionId ||
      options.find((option) => option.optionId === 'proceed_once')?.optionId ||
      options.find((option) => option.optionId.includes('proceed_once'))
        ?.optionId ||
      options[0]?.optionId
    );
  }
}