import type { Event as OpencodeEvent, Part } from "@opencode-ai/sdk/v2";

import { writeLlmRequestAuditLog } from "../audit/llmRequestAudit.js";
import { logger } from "../logger.js";
import { type PermissionReply, type OpencodeRuntimeAdapter } from "../runtime/opencode.js";

export const supportedModels = [
  "deepseek/deepseek-v4-flash",
  "deepseek/deepseek-v4-pro",
] as const;

export type SupportedModel = (typeof supportedModels)[number];
export type ApprovalMode = "request" | "always";

type StreamPromptOptions = {
  runtime: OpencodeRuntimeAdapter;
  sessionId: string;
  clientSessionId: string;
  message: string;
  model?: SupportedModel;
  approvalMode?: ApprovalMode;
  traceId?: string;
  projectId?: string;
  signal?: AbortSignal;
  write: (event: string, data: Record<string, unknown>) => void;
};

type ProgressStatus = "running" | "completed" | "error";

type ProgressPayload = {
  id: string;
  phase: string;
  status: ProgressStatus;
  title: string;
  detail?: string;
};

export type PermissionRequestPayload = {
  session_id: string;
  request_id: string;
  permission: string;
  patterns: string[];
  metadata: Record<string, unknown>;
  always: string[];
  tool?: {
    messageID: string;
    callID: string;
  };
  created_at: number;
};

const isDevelopmentDebugLoggingEnabled = process.env.NODE_ENV === "development";

const toolLabels: Record<string, string> = {
  memory_manager: "记忆写入",
  session_search: "历史会话检索",
  skill_manager: "流程沉淀",
  locate_features: "地图定位",
  view_history: "历史数据面板",
  view_scada: "SCADA 面板",
  show_chart: "图表渲染",
  render_junctions: "节点渲染",
};

const logDevelopmentDebug = (
  message: string,
  metadata: Record<string, unknown>,
) => {
  if (!isDevelopmentDebugLoggingEnabled) {
    return;
  }
  logger.info(metadata, message);
};

const getErrorMessage = (error: {
  name: string;
  data?: { message?: string };
}) => error.data?.message ?? error.name;

const getUnknownErrorMessage = (error: unknown) => {
  if (
    typeof error === "object" &&
    error !== null &&
    "name" in error &&
    typeof error.name === "string"
  ) {
    const maybeData = "data" in error ? error.data : undefined;
    return getErrorMessage({
      name: error.name,
      data:
        typeof maybeData === "object" && maybeData !== null && "message" in maybeData
          ? { message: typeof maybeData.message === "string" ? maybeData.message : undefined }
          : undefined,
    });
  }
  return error instanceof Error ? error.message : String(error);
};

const isObjectRecord = (value: unknown): value is Record<string, unknown> =>
  typeof value === "object" && value !== null && !Array.isArray(value);

const normalizeToolParams = (value: unknown): Record<string, unknown> => {
  if (isObjectRecord(value)) {
    return value;
  }
  if (typeof value === "string") {
    try {
      const parsed = JSON.parse(value) as unknown;
      return isObjectRecord(parsed) ? parsed : {};
    } catch {
      return {};
    }
  }
  return {};
};

const extractRequestReason = (params: Record<string, unknown>) => {
  const candidates = ["reason", "request_reason", "why", "purpose", "rationale"];
  for (const key of candidates) {
    const value = params[key];
    if (typeof value === "string") {
      const normalized = value.trim();
      if (normalized) {
        return normalized;
      }
    }
  }
  return "";
};

const isSkillEvent = (event: OpencodeEvent) => event.type.toLowerCase().includes("skill");

const extractSkillAuditInfo = (event: OpencodeEvent) => {
  const payload = isObjectRecord(event.properties)
    ? (event.properties as Record<string, unknown>)
    : {};
  const candidateName =
    typeof payload.skill === "string"
      ? payload.skill
      : typeof payload.skillName === "string"
        ? payload.skillName
        : typeof payload.name === "string"
          ? payload.name
          : event.type;
  const reason = extractRequestReason(payload);
  return {
    name: candidateName,
    reason,
    payload,
  };
};

const hasToolParams = (params: Record<string, unknown>) =>
  Object.keys(params).length > 0;

const toRuntimeModel = (model?: SupportedModel) => {
  if (!model) {
    return undefined;
  }
  const [providerID, modelID] = model.split("/");
  if (!providerID || !modelID) {
    return undefined;
  }
  return {
    providerID,
    modelID,
  };
};

const isSessionEvent = (event: OpencodeEvent, sessionId: string) =>
  "properties" in event &&
  typeof event.properties === "object" &&
  event.properties !== null &&
  "sessionID" in event.properties &&
  event.properties.sessionID === sessionId;

const isPermissionAskedEvent = (
  event: OpencodeEvent,
): event is Extract<OpencodeEvent, { type: "permission.asked" }> =>
  event.type === "permission.asked";

const isPermissionV2AskedEvent = (
  event: OpencodeEvent,
): event is Extract<OpencodeEvent, { type: "permission.v2.asked" }> =>
  event.type === "permission.v2.asked";

const isPermissionRepliedEvent = (
  event: OpencodeEvent,
): event is Extract<OpencodeEvent, { type: "permission.replied" }> =>
  event.type === "permission.replied";

const isPermissionV2RepliedEvent = (
  event: OpencodeEvent,
): event is Extract<OpencodeEvent, { type: "permission.v2.replied" }> =>
  event.type === "permission.v2.replied";

const buildPermissionDetail = (event: Extract<OpencodeEvent, { type: "permission.asked" }>) => {
  const patterns = event.properties.patterns.length
    ? event.properties.patterns.join(", ")
    : event.properties.permission;
  return `需要用户确认权限：${event.properties.permission}；匹配规则：${patterns}`;
};

const buildPermissionV2Detail = (
  event: Extract<OpencodeEvent, { type: "permission.v2.asked" }>,
) => {
  const resources = event.properties.resources.length
    ? event.properties.resources.join(", ")
    : event.properties.action;
  return `需要用户确认权限：${event.properties.action}；资源：${resources}`;
};

export const collectTextContent = (parts: Part[]) =>
  parts
    .filter((part): part is Extract<Part, { type: "text" }> => part.type === "text")
    .map((part) => part.text)
    .join("");

const emitFallbackMessage = async (
  runtime: OpencodeRuntimeAdapter,
  sessionId: string,
  clientSessionId: string,
  write: (event: string, data: Record<string, unknown>) => void,
) => {
  const messages = await runtime.messages(sessionId);
  const assistantMessage = [...messages]
    .reverse()
    .find((message) => message.info.role === "assistant");
  const parts = assistantMessage?.parts ?? [];
  const text = collectTextContent(parts);
  if (text) {
    write("token", {
      session_id: clientSessionId,
      content: text,
    });
  }
};

const normalizeToolStatus = (status: string) => {
  if (status === "completed") return "completed";
  if (status === "error") return "error";
  return "running";
};

const formatProgressValue = (value: unknown): string => {
  if (typeof value === "string") {
    return value.length > 120 ? `${value.slice(0, 117)}...` : value;
  }
  if (
    typeof value === "number" ||
    typeof value === "boolean" ||
    value === null ||
    value === undefined
  ) {
    return String(value);
  }
  try {
    const serialized = JSON.stringify(value);
    return serialized.length > 120 ? `${serialized.slice(0, 117)}...` : serialized;
  } catch {
    return "[unserializable]";
  }
};

const normalizeProgressText = (chunks: string[]) => chunks.join("").replace(/\s+/g, " ").trim();

const truncateProgressText = (text: string, maxLength: number) =>
  text.length > maxLength ? `${text.slice(0, maxLength - 3)}...` : text;

const summarizeToolParams = (params: Record<string, unknown>) => {
  const ignoredKeys = new Set(["reason", "request_reason", "why", "purpose", "rationale"]);
  const summary = Object.entries(params)
    .filter(([key]) => !ignoredKeys.has(key))
    .slice(0, 4)
    .map(([key, value]) => `${key}=${formatProgressValue(value)}`)
    .join(", ");

  return summary || "无附加参数";
};

const buildSessionStatusDetail = (status: { type: string; message?: string }) => {
  if (status.type === "retry") {
    return status.message
      ? `模型请求需要重试，原因：${status.message}`
      : "模型请求正在重试，等待下一次响应。";
  }
  if (status.type === "busy") {
    return status.message
      ? `Agent 正在处理中：${status.message}`
      : "Agent 正在执行推理、工具调用或结果整理。";
  }
  if (status.type === "idle") {
    return status.message
      ? `Agent 已空闲：${status.message}`
      : "当前会话暂时没有待处理任务。";
  }
  return status.message ? `会话状态更新：${status.message}` : `会话状态更新：${status.type}`;
};

const buildReasoningProgressDetail = (chunks: string[], ended?: string | number | Date | null) => {
  const reasoningText = truncateProgressText(normalizeProgressText(chunks), 800);
  if (ended) {
    return reasoningText
      ? `推理过程：${reasoningText}`
      : "当前推理阶段已完成，Agent 将继续输出答案或进入工具执行。";
  }
  return reasoningText
    ? `正在推理：${reasoningText}`
    : "Agent 正在拆解问题、梳理执行步骤并判断是否需要调用工具。";
};

const buildToolProgressDetail = (
  tool: string,
  status: string,
  params: Record<string, unknown>,
  reason: string,
  error?: string,
) => {
  const toolName = toolLabels[tool] ?? tool;
  const reasonText = reason ? `；调用原因：${reason}` : "";
  const paramsText = `；关键参数：${summarizeToolParams(params)}`;

  if (status === "error") {
    const errorText = error ? `；错误：${error}` : "";
    return `${toolName} 调用失败${reasonText}${paramsText}${errorText}`;
  }
  if (status === "completed") {
    return `${toolName} 已执行完成${reasonText}${paramsText}`;
  }
  if (status === "pending") {
    return `${toolName} 已进入待执行状态${reasonText}${paramsText}`;
  }
  return `${toolName} 正在执行${reasonText}${paramsText}`;
};

const getToolProgressTitle = (tool: string, status: string) => {
  const toolName = toolLabels[tool] ?? tool;
  if (status === "completed") return `${toolName} 已完成`;
  if (status === "error") return `${toolName} 执行失败`;
  if (status === "pending") return `准备调用 ${toolName}`;
  return `正在调用 ${toolName}`;
};

export const streamPromptResponse = async ({
  runtime,
  sessionId,
  clientSessionId,
  message,
  model,
  approvalMode = "request",
  traceId,
  projectId,
  signal,
  write,
}: StreamPromptOptions): Promise<{
  aborted: boolean;
  failed: boolean;
  toolCallCount: number;
}> => {
  const eventStream = await runtime.subscribeEvents();
  const iterator = eventStream[Symbol.asyncIterator]();
  const requestStartedAt = Date.now();
  const promptStartedAt = Date.now();
  const progressStartedAtMap = new Map<string, number>();
  const finalizedProgressIds = new Set<string>();
  const emittedToolParts = new Set<string>();
  const partTypes = new Map<string, Part["type"]>();
  const pendingPartTextDeltas = new Map<string, string[]>();
  const reasoningDeltas = new Map<string, string[]>();
  const reasoningStatuses = new Map<string, "running" | "completed">();
  const toolStatuses = new Map<string, string>();
  let firstSessionEventLogged = false;
  let firstNonStatusEventLogged = false;
  let firstTokenLogged = false;
  let firstReasoningLogged = false;
  let firstToolEventLogged = false;
  let lastSessionStatus: string | null = null;
  let lastSessionStatusMessage: string | null = null;
  let sawResponseActivity = false;
  let emittedText = false;
  let toolCallCount = 0;
  let done = false;
  let promptSettled = false;
  let aborted = signal?.aborted ?? false;
  let failed = false;
  const debugContext = {
    sessionId,
    clientSessionId,
    traceId,
    projectId,
    model: model ?? null,
  };

  logDevelopmentDebug("chat stream started", {
    ...debugContext,
    messageChars: message.length,
  });

  const abortPromise = signal
    ? new Promise<{ type: "abort" }>((resolve) => {
        if (signal.aborted) {
          resolve({ type: "abort" });
          return;
        }
        signal.addEventListener("abort", () => resolve({ type: "abort" }), {
          once: true,
        });
      })
    : null;

  const emitProgress = ({ id, phase, status, title, detail }: ProgressPayload) => {
    if (status === "running" && finalizedProgressIds.has(id)) {
      return;
    }

    const now = Date.now();
    const startedAt = progressStartedAtMap.get(id) ?? now;
    if (!progressStartedAtMap.has(id)) {
      progressStartedAtMap.set(id, startedAt);
    }

    if (status === "running") {
      write("progress", {
        session_id: clientSessionId,
        id,
        phase,
        status,
        title,
        detail,
        started_at: startedAt,
        elapsed_ms: Math.max(0, now - startedAt),
      });
      return;
    }

    const durationMs = Math.max(0, now - startedAt);
    finalizedProgressIds.add(id);
    progressStartedAtMap.delete(id);
    write("progress", {
      session_id: clientSessionId,
      id,
      phase,
      status,
      title,
      detail,
      started_at: startedAt,
      ended_at: now,
      duration_ms: durationMs,
    });
  };

  emitProgress({
    id: "request-received",
    phase: "start",
    status: "running",
    title: "已收到请求，正在启动 Agent 分析",
    detail: "已接收用户消息，正在建立会话并准备进入分析、规划和工具调用阶段。",
  });

  const promptPromise = runtime
    .prompt(sessionId, message, toRuntimeModel(model))
    .then(() => {
      promptSettled = true;
      logDevelopmentDebug("runtime.prompt resolved", {
        ...debugContext,
        elapsedMs: Math.max(0, Date.now() - promptStartedAt),
      });
    })
    .catch((error: unknown) => {
      promptSettled = true;
      logDevelopmentDebug("runtime.prompt failed", {
        ...debugContext,
        elapsedMs: Math.max(0, Date.now() - promptStartedAt),
        error: getUnknownErrorMessage(error),
      });
      throw error;
    });

  logDevelopmentDebug("runtime.prompt dispatched", {
    ...debugContext,
  });

  try {
    while (!done) {
      if (signal?.aborted) {
        aborted = true;
        logDevelopmentDebug("chat stream noticed abort signal", {
          ...debugContext,
          elapsedMs: Math.max(0, Date.now() - requestStartedAt),
        });
        break;
      }

      const nextEvent = iterator
        .next()
        .then((result) => ({ type: "event" as const, result }));
      const nextPrompt = promptSettled
        ? null
        : promptPromise.then(
            () => ({ type: "prompt" as const }),
            (error: unknown) => ({ type: "prompt-error" as const, error }),
          );
      const next = await Promise.race(
        [
          ...(nextPrompt ? [nextEvent, nextPrompt] : [nextEvent]),
          ...(abortPromise ? [abortPromise] : []),
        ],
      );

      if (next.type === "abort") {
        aborted = true;
        break;
      }

      if (next.type === "prompt-error") {
        throw next.error;
      }
      if (next.type === "prompt") {
        continue;
      }
      if (next.result.done) {
        break;
      }

      const event = next.result.value as OpencodeEvent;
      if (!isSessionEvent(event, sessionId)) {
        continue;
      }

      if (!firstSessionEventLogged) {
        firstSessionEventLogged = true;
        logDevelopmentDebug("first session event received", {
          ...debugContext,
          eventType: event.type,
          elapsedMs: Math.max(0, Date.now() - requestStartedAt),
          sincePromptDispatchMs: Math.max(0, Date.now() - promptStartedAt),
        });
      }

      if (event.type === "session.status") {
        const nextStatus = event.properties.status.type;
        const nextStatusMessage =
          "message" in event.properties.status &&
          typeof event.properties.status.message === "string"
            ? event.properties.status.message
            : null;
        if (
          nextStatus !== lastSessionStatus ||
          nextStatusMessage !== lastSessionStatusMessage
        ) {
          lastSessionStatus = nextStatus;
          lastSessionStatusMessage = nextStatusMessage;
          logDevelopmentDebug("session status updated", {
            ...debugContext,
            status: nextStatus,
            statusMessage: nextStatusMessage,
            elapsedMs: Math.max(0, Date.now() - requestStartedAt),
          });
        }
        emitProgress({
          id: "session-status",
          phase: "session",
          status: event.properties.status.type === "idle" ? "completed" : "running",
          title:
            event.properties.status.type === "retry"
              ? `模型请求重试中：${event.properties.status.message}`
              : event.properties.status.type === "busy"
                ? "Agent 正在处理请求"
                : "Agent 已空闲",
          detail: buildSessionStatusDetail(event.properties.status),
        });
        continue;
      }

      if (!firstNonStatusEventLogged) {
        firstNonStatusEventLogged = true;
        logDevelopmentDebug("first non-status session event received", {
          ...debugContext,
          eventType: event.type,
          elapsedMs: Math.max(0, Date.now() - requestStartedAt),
          sincePromptDispatchMs: Math.max(0, Date.now() - promptStartedAt),
        });
      }

      if (isPermissionAskedEvent(event)) {
        sawResponseActivity = true;
        logDevelopmentDebug("permission request received", {
          ...debugContext,
          requestId: event.properties.id,
          permission: event.properties.permission,
          patterns: event.properties.patterns,
          elapsedMs: Math.max(0, Date.now() - requestStartedAt),
        });
        emitProgress({
          id: `permission-${event.properties.id}`,
          phase: "permission",
          status: approvalMode === "always" ? "completed" : "running",
          title: approvalMode === "always" ? "已自动允许权限请求" : "等待权限确认",
          detail:
            approvalMode === "always"
              ? "当前批准模式为始终允许，已自动允许本次权限请求。"
              : buildPermissionDetail(event),
        });
        if (approvalMode === "always") {
          await runtime.replyPermission({
            requestId: event.properties.id,
            sessionId,
            reply: "always",
          });
          write("permission_response", {
            session_id: clientSessionId,
            request_id: event.properties.id,
            reply: "always" satisfies PermissionReply,
          });
          continue;
        }
        write("permission_request", {
          session_id: clientSessionId,
          request_id: event.properties.id,
          permission: event.properties.permission,
          patterns: event.properties.patterns,
          metadata: event.properties.metadata,
          always: event.properties.always,
          tool: event.properties.tool,
          created_at: Date.now(),
        } satisfies PermissionRequestPayload);
        continue;
      }

      if (isPermissionV2AskedEvent(event)) {
        sawResponseActivity = true;
        logDevelopmentDebug("permission v2 request received", {
          ...debugContext,
          requestId: event.properties.id,
          action: event.properties.action,
          resources: event.properties.resources,
          elapsedMs: Math.max(0, Date.now() - requestStartedAt),
        });
        emitProgress({
          id: `permission-${event.properties.id}`,
          phase: "permission",
          status: approvalMode === "always" ? "completed" : "running",
          title: approvalMode === "always" ? "已自动允许权限请求" : "等待权限确认",
          detail:
            approvalMode === "always"
              ? "当前批准模式为始终允许，已自动允许本次权限请求。"
              : buildPermissionV2Detail(event),
        });
        if (approvalMode === "always") {
          await runtime.replyPermission({
            requestId: event.properties.id,
            sessionId,
            reply: "always",
          });
          write("permission_response", {
            session_id: clientSessionId,
            request_id: event.properties.id,
            reply: "always" satisfies PermissionReply,
          });
          continue;
        }
        write("permission_request", {
          session_id: clientSessionId,
          request_id: event.properties.id,
          permission: event.properties.action,
          patterns: event.properties.resources,
          metadata: event.properties.metadata ?? {},
          always: event.properties.save ?? [],
          tool: undefined,
          created_at: Date.now(),
        } satisfies PermissionRequestPayload);
        continue;
      }

      if (isPermissionRepliedEvent(event)) {
        sawResponseActivity = true;
        logDevelopmentDebug("permission request replied", {
          ...debugContext,
          requestId: event.properties.requestID,
          reply: event.properties.reply,
          elapsedMs: Math.max(0, Date.now() - requestStartedAt),
        });
        emitProgress({
          id: `permission-${event.properties.requestID}`,
          phase: "permission",
          status: event.properties.reply === "reject" ? "error" : "completed",
          title:
            event.properties.reply === "reject"
              ? "权限请求已拒绝"
              : "权限请求已允许",
          detail:
            event.properties.reply === "always"
              ? "已允许本次请求，并记住同类权限。"
              : event.properties.reply === "once"
                ? "已允许本次请求。"
                : "已拒绝本次请求。",
        });
        write("permission_response", {
          session_id: clientSessionId,
          request_id: event.properties.requestID,
          reply: event.properties.reply satisfies PermissionReply,
        });
        continue;
      }

      if (isPermissionV2RepliedEvent(event)) {
        sawResponseActivity = true;
        logDevelopmentDebug("permission v2 request replied", {
          ...debugContext,
          requestId: event.properties.requestID,
          reply: event.properties.reply,
          elapsedMs: Math.max(0, Date.now() - requestStartedAt),
        });
        emitProgress({
          id: `permission-${event.properties.requestID}`,
          phase: "permission",
          status: event.properties.reply === "reject" ? "error" : "completed",
          title:
            event.properties.reply === "reject"
              ? "权限请求已拒绝"
              : "权限请求已允许",
          detail:
            event.properties.reply === "always"
              ? "已允许本次请求，并记住同类权限。"
              : event.properties.reply === "once"
                ? "已允许本次请求。"
                : "已拒绝本次请求。",
        });
        write("permission_response", {
          session_id: clientSessionId,
          request_id: event.properties.requestID,
          reply: event.properties.reply satisfies PermissionReply,
        });
        continue;
      }

      if (isSkillEvent(event)) {
        sawResponseActivity = true;
        const { name, reason, payload } = extractSkillAuditInfo(event);
        logDevelopmentDebug("skill event received", {
          ...debugContext,
          skill: name,
          reason: reason || null,
          payloadKeys: Object.keys(payload).slice(0, 8),
          elapsedMs: Math.max(0, Date.now() - requestStartedAt),
        });
        void writeLlmRequestAuditLog({
          kind: "skill",
          sessionId: sessionId,
          clientSessionId,
          traceId,
          projectId,
          target: name,
          reason,
          reasonProvided: Boolean(reason),
          payload,
        }).catch((error) => {
          logger.warn({ err: error }, "failed to write skill audit log");
        });
      }

      if (event.type === "message.updated") {
        if (event.properties.info.role === "assistant") {
          sawResponseActivity = true;
        }
        continue;
      }

      if (event.type === "message.part.delta" && event.properties.field === "text") {
        sawResponseActivity = true;
        const partType = partTypes.get(event.properties.partID);
        if (partType === "text") {
          if (!firstTokenLogged) {
            firstTokenLogged = true;
            logDevelopmentDebug("first response token emitted", {
              ...debugContext,
              partId: event.properties.partID,
              elapsedMs: Math.max(0, Date.now() - requestStartedAt),
              sincePromptDispatchMs: Math.max(0, Date.now() - promptStartedAt),
            });
          }
          emittedText = true;
          write("token", {
            session_id: clientSessionId,
            content: event.properties.delta,
          });
        } else if (partType === "reasoning") {
          if (!firstReasoningLogged) {
            firstReasoningLogged = true;
            logDevelopmentDebug("first reasoning delta received", {
              ...debugContext,
              partId: event.properties.partID,
              elapsedMs: Math.max(0, Date.now() - requestStartedAt),
              sincePromptDispatchMs: Math.max(0, Date.now() - promptStartedAt),
            });
          }
          const pending = reasoningDeltas.get(event.properties.partID) ?? [];
          pending.push(event.properties.delta);
          reasoningDeltas.set(event.properties.partID, pending);
        } else if (!partType) {
          const pending = pendingPartTextDeltas.get(event.properties.partID) ?? [];
          pending.push(event.properties.delta);
          pendingPartTextDeltas.set(event.properties.partID, pending);
        }
        continue;
      }

      if (event.type === "message.part.updated") {
        sawResponseActivity = true;
        const part = event.properties.part;
        partTypes.set(part.id, part.type);
        if (part.type === "text") {
          const pending = pendingPartTextDeltas.get(part.id) ?? [];
          pendingPartTextDeltas.delete(part.id);
          for (const content of pending) {
            emittedText = true;
            write("token", {
              session_id: clientSessionId,
              content,
            });
          }
        } else if (part.type === "reasoning") {
          const pending = pendingPartTextDeltas.get(part.id) ?? [];
          if (pending.length > 0) {
            const existing = reasoningDeltas.get(part.id) ?? [];
            reasoningDeltas.set(part.id, existing.concat(pending));
          }
          pendingPartTextDeltas.delete(part.id);
          const reasoningStatus = part.time.end ? "completed" : "running";
          if (reasoningStatuses.get(part.id) !== reasoningStatus) {
            reasoningStatuses.set(part.id, reasoningStatus);
            logDevelopmentDebug("reasoning part status changed", {
              ...debugContext,
              partId: part.id,
              status: reasoningStatus,
              chunkCount: (reasoningDeltas.get(part.id) ?? []).length,
              elapsedMs: Math.max(0, Date.now() - requestStartedAt),
            });
          }
          const reasoningDetail = buildReasoningProgressDetail(
            reasoningDeltas.get(part.id) ?? [],
            part.time.end,
          );
          emitProgress({
            id: part.id,
            phase: "planning",
            status: part.time.end ? "completed" : "running",
            title: part.time.end ? "分析规划完成" : "正在规划分析步骤",
            detail: reasoningDetail,
          });
        }
        if (part.type === "tool") {
          if (!firstToolEventLogged) {
            firstToolEventLogged = true;
            logDevelopmentDebug("first tool event received", {
              ...debugContext,
              partId: part.id,
              tool: part.tool,
              status: part.state.status,
              elapsedMs: Math.max(0, Date.now() - requestStartedAt),
              sincePromptDispatchMs: Math.max(0, Date.now() - promptStartedAt),
            });
          }
          const toolParams = normalizeToolParams(part.state.input);
          const reason = extractRequestReason(toolParams);
          const isToolFinalState =
            part.state.status === "completed" || part.state.status === "error";
          const nextToolStatus = String(part.state.status);

          if (toolStatuses.get(part.id) !== nextToolStatus) {
            toolStatuses.set(part.id, nextToolStatus);
            logDevelopmentDebug("tool part status changed", {
              ...debugContext,
              partId: part.id,
              tool: part.tool,
              status: nextToolStatus,
              reason: reason || null,
              inputKeys: Object.keys(toolParams).slice(0, 8),
              error:
                part.state.status === "error" ? (part.state.error ?? "unknown") : null,
              elapsedMs: Math.max(0, Date.now() - requestStartedAt),
            });
          }

          emitProgress({
            id: part.id,
            phase: "tool",
            status: normalizeToolStatus(part.state.status),
            title: getToolProgressTitle(part.tool, part.state.status),
            detail: buildToolProgressDetail(
              part.tool,
              part.state.status,
              toolParams,
              reason,
              part.state.status === "error" ? part.state.error : undefined,
            ),
          });
          if (
            !emittedToolParts.has(part.id) &&
            (hasToolParams(toolParams) || isToolFinalState)
          ) {
            emittedToolParts.add(part.id);
            toolCallCount += 1;
            if (!reason) {
              logger.warn(
                {
                  tool: part.tool,
                  sessionId: sessionId,
                  clientSessionId,
                },
                "llm tool request missing reason",
              );
            }
            void writeLlmRequestAuditLog({
              kind: "tool",
              sessionId: sessionId,
              clientSessionId,
              traceId,
              projectId,
              target: part.tool,
              reason,
              reasonProvided: Boolean(reason),
              payload: toolParams,
            }).catch((error) => {
              logger.warn({ err: error }, "failed to write tool audit log");
            });
            write("tool_call", {
              session_id: clientSessionId,
              tool: part.tool,
              params: toolParams,
              reason,
            });
          }
        }
        continue;
      }

      if (event.type === "todo.updated") {
        sawResponseActivity = true;
        const completed = event.properties.todos.filter(
          (todo) => todo.status === "completed",
        ).length;
        emitProgress({
          id: "todo-progress",
          phase: "planning",
          status: completed === event.properties.todos.length ? "completed" : "running",
          title: `计划进度 ${completed}/${event.properties.todos.length}`,
          detail: event.properties.todos
            .map((todo) => `${todo.status}: ${todo.content}`)
            .join("\n"),
        });
        continue;
      }

      if (event.type === "session.error") {
        sawResponseActivity = true;
        logDevelopmentDebug("session error received", {
          ...debugContext,
          elapsedMs: Math.max(0, Date.now() - requestStartedAt),
          error: event.properties.error
            ? getErrorMessage(event.properties.error)
            : "opencode session error",
        });
        write("error", {
          session_id: clientSessionId,
          message: event.properties.error
            ? getErrorMessage(event.properties.error)
            : "opencode session error",
          detail: event.properties.error?.name,
          total_duration_ms: Math.max(0, Date.now() - requestStartedAt),
        });
        failed = true;
        done = true;
        continue;
      }

      if (event.type === "session.idle") {
        if (!sawResponseActivity) {
          logDevelopmentDebug("ignoring session idle before response activity", {
            ...debugContext,
            elapsedMs: Math.max(0, Date.now() - requestStartedAt),
          });
          continue;
        }
        logDevelopmentDebug("session idle received", {
          ...debugContext,
          emittedText,
          toolCallCount,
          elapsedMs: Math.max(0, Date.now() - requestStartedAt),
        });
        emitProgress({
          id: "session-status",
          phase: "session",
          status: "completed",
          title: "Agent 已完成处理",
          detail: "当前会话已无待执行任务，正在收尾并准备返回最终结果。",
        });
        done = true;
      }
    }

    if (aborted) {
      logDevelopmentDebug("chat stream aborting session", {
        ...debugContext,
        elapsedMs: Math.max(0, Date.now() - requestStartedAt),
      });
      await runtime.abortSession(sessionId).catch((error) => {
        logger.warn({ sessionId: sessionId, err: error }, "failed to abort opencode session");
      });
      await runtime.waitForSessionIdle(sessionId).catch((error) => {
        logger.warn(
          { sessionId: sessionId, err: error },
          "failed while waiting for aborted opencode session to become idle",
        );
      });
      return { aborted: true, failed: false, toolCallCount };
    }

    if (failed) {
      return { aborted: false, failed: true, toolCallCount };
    }

    await promptPromise;
    if (!emittedText) {
      logDevelopmentDebug("no streamed text emitted, falling back to messages()", {
        ...debugContext,
        elapsedMs: Math.max(0, Date.now() - requestStartedAt),
      });
      await emitFallbackMessage(runtime, sessionId, clientSessionId, write);
    }
    emitProgress({
      id: "request-received",
      phase: "start",
      status: "completed",
      title: "请求处理完成",
      detail: "本次请求的分析、工具执行和结果整理流程已经完成。",
    });
    emitProgress({
      id: "request-completed",
      phase: "complete",
      status: "completed",
      title: "分析完成",
      detail: emittedText
        ? "最终回答已生成并推送到前端。"
        : "已完成分析，并通过兜底消息补发最终回答内容。",
    });
    write("done", {
      session_id: clientSessionId,
      total_duration_ms: Math.max(0, Date.now() - requestStartedAt),
    });
    logDevelopmentDebug("chat stream completed", {
      ...debugContext,
      emittedText,
      toolCallCount,
      totalDurationMs: Math.max(0, Date.now() - requestStartedAt),
    });
    return { aborted: false, failed: false, toolCallCount };
  } finally {
    await iterator.return?.(undefined);
    if (!promptSettled && !aborted) {
      await promptPromise.catch(() => undefined);
    } else if (!promptSettled) {
      void promptPromise.catch(() => undefined);
    }
    logDevelopmentDebug("chat stream cleanup finished", {
      ...debugContext,
      promptSettled,
      totalDurationMs: Math.max(0, Date.now() - requestStartedAt),
    });
  }
};