@geminixiang/mikan 1.0.0-beta.9 → 1.0.0-beta.91

package/dist/harness/presenter.js

@@ -0,0 +1,867 @@
+import { contentText } from "@earendil-works/pi-ai";
+import { mergeSubagentProgress, renderSubagentDashboard, settleSubagentProgress, } from "./tools/subagent.js";
+import { addLifecycleEvent, metricAttributes, recordCounter, recordDistribution, recordGauge, reportUserFacingError, startOperationSpan, updateActiveSpanAttribution, } from "../observability/index.js";
+import { appendTriggerAttribution } from "./prompt.js";
+import { START_TASK_TOOL, TASK_STATUS_TOOL } from "./tools/task.js";
+import { toRunEvent, toolResultText } from "./run-events.js";
+import { REACT_TOOL } from "./tools/react.js";
+import * as log from "../log.js";
+import { errorMessage, isRecord } from "../unknown-values.js";
+import { formatBudgetStop } from "./budget-stop.js";
+const operationSpans = new WeakMap();
+function spansFor(runState) {
+    let spans = operationSpans.get(runState);
+    if (!spans) {
+        spans = { llm: [], tools: new Map() };
+        operationSpans.set(runState, spans);
+    }
+    return spans;
+}
+function operationError(name) {
+    const error = new Error();
+    error.name = name;
+    return error;
+}
+function endOutstandingOperationSpans(runState) {
+    const spans = operationSpans.get(runState);
+    if (!spans)
+        return;
+    const aborted = operationError("AbortError");
+    for (const entry of spans.llm)
+        entry.span.end({ error: aborted });
+    for (const span of spans.tools.values())
+        span.end({ error: aborted });
+    operationSpans.delete(runState);
+}
+function createEmptyUsageTotals() {
+    return {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
+}
+function createRunStateDefaults() {
+    return {
+        responder: null,
+        logCtx: null,
+        queue: null,
+        pendingTools: new Map(),
+        completedTools: [],
+        toolProgress: new Map(),
+        subagentProgress: new Map(),
+        completedSubagentProgress: [],
+        subagentToolCalls: new Set(),
+        subagentProgressShown: false,
+        suppressResponseDeltas: false,
+        answerStreamStarted: false,
+        workAcknowledged: false,
+        publishRunEvent: undefined,
+        lastSubagentProgressAt: 0,
+        toolProgressTimer: undefined,
+        totalUsage: createEmptyUsageTotals(),
+        llmCallCount: 0,
+        toolCallCount: 0,
+        toolErrorCount: 0,
+        toolInputCharacters: 0,
+        toolOutputCharacters: 0,
+        assistantMessageCount: 0,
+        outputCharacters: 0,
+        reasoningTokens: 0,
+        retryCount: 0,
+        compactionCount: 0,
+        budgetExceeded: false,
+        firstTokenLatencyMs: undefined,
+        responseModel: undefined,
+        stopReason: "stop",
+        errorMessage: undefined,
+        reportedLlmError: false,
+        finalResponseHandledByTool: false,
+        triggerAttribution: undefined,
+    };
+}
+export function createRunState() {
+    return createRunStateDefaults();
+}
+export function activateRunPresentation(runState, context) {
+    endOutstandingOperationSpans(runState);
+    if (runState.toolProgressTimer)
+        clearTimeout(runState.toolProgressTimer);
+    Object.assign(runState, createRunStateDefaults(), {
+        responder: context.responder,
+        logCtx: {
+            conversationId: context.sessionConversation,
+            userName: context.userName,
+            conversationName: undefined,
+            sessionId: context.sessionUuid,
+        },
+        triggerAttribution: context.triggerAttribution,
+        publishRunEvent: context.publishRunEvent,
+    });
+    const { responder } = context;
+    let queueChain = Promise.resolve();
+    runState.queue = {
+        enqueue(fn, errorContext) {
+            queueChain = queueChain.then(async () => {
+                if (runState.finalResponseHandledByTool)
+                    return;
+                try {
+                    await fn();
+                }
+                catch (err) {
+                    const errMsg = errorMessage(err);
+                    log.logWarning(`API error (${errorContext})`, errMsg);
+                    try {
+                        await responder.respondDiagnostic(`Error: ${errMsg}`, { style: "error" });
+                    }
+                    catch { }
+                }
+            });
+        },
+    };
+    return {
+        wait: () => queueChain,
+        dispose() {
+            endOutstandingOperationSpans(runState);
+            if (runState.toolProgressTimer)
+                clearTimeout(runState.toolProgressTimer);
+            runState.toolProgressTimer = undefined;
+            runState.responder = null;
+            runState.logCtx = null;
+            runState.queue = null;
+            runState.publishRunEvent = undefined;
+        },
+    };
+}
+export function getFinalAssistantText(session) {
+    const lastAssistant = session.lastRunMessages.findLast((message) => message.role === "assistant");
+    return contentText(lastAssistant?.content ?? []);
+}
+export function isEventTriggerAttribution(triggerAttribution) {
+    return triggerAttribution?.startsWith("[event:") === true;
+}
+function formatToolProgress(runState) {
+    const lines = Array.from(runState.toolProgress.entries()).flatMap(([toolCallId, item]) => {
+        if (runState.subagentToolCalls.has(toolCallId))
+            return [];
+        const marker = item.status === "running" ? "•" : item.status === "error" ? "✗" : "✓";
+        return [`${marker} ${item.label}`];
+    });
+    return lines.join("\n");
+}
+function formatResponseWithToolProgress(text, runState) {
+    const progress = formatToolProgress(runState);
+    return [progress, text].filter(Boolean).join("\n\n");
+}
+async function replaceWithSubagentDashboard(responder, snapshot, finalText, options) {
+    if (responder.replaceSubagentProgress) {
+        await responder.replaceSubagentProgress(snapshot, finalText);
+        return;
+    }
+    const dashboard = renderSubagentDashboard(snapshot);
+    await responder.replaceResponse(finalText ? `${dashboard}\n\n${finalText}` : dashboard, options);
+}
+async function replaceResponseWithToolProgress(responder, runState, subagentProgress = mergeSubagentProgress([...runState.subagentProgress.values()])) {
+    if (subagentProgress) {
+        await replaceWithSubagentDashboard(responder, subagentProgress);
+        return;
+    }
+    const progress = formatToolProgress(runState);
+    if (progress)
+        await responder.replaceResponse(progress);
+}
+const TOOL_PROGRESS_DEBOUNCE_MS = 500;
+const SUBAGENT_PROGRESS_THROTTLE_MS = 2000;
+function subagentProgressDelay(runState) {
+    if (!runState.subagentProgressShown)
+        return 0;
+    return Math.max(0, runState.lastSubagentProgressAt + SUBAGENT_PROGRESS_THROTTLE_MS - Date.now());
+}
+function markSubagentProgressShown(runState, snapshot) {
+    if (!snapshot)
+        return;
+    runState.subagentProgressShown = true;
+    runState.lastSubagentProgressAt = Date.now();
+}
+function scheduleToolProgressUpdate(responder, runState) {
+    if (runState.toolProgressTimer)
+        return;
+    const subagentProgress = mergeSubagentProgress([...runState.subagentProgress.values()]);
+    const delay = subagentProgress ? subagentProgressDelay(runState) : TOOL_PROGRESS_DEBOUNCE_MS;
+    runState.toolProgressTimer = setTimeout(() => {
+        runState.toolProgressTimer = undefined;
+        const snapshot = mergeSubagentProgress([...runState.subagentProgress.values()]);
+        markSubagentProgressShown(runState, snapshot);
+        runState.queue?.enqueue(() => replaceResponseWithToolProgress(responder, runState, snapshot), "tool progress update");
+    }, delay);
+    runState.toolProgressTimer.unref();
+}
+function flushToolProgressUpdate(responder, runState) {
+    if (runState.toolProgressTimer)
+        clearTimeout(runState.toolProgressTimer);
+    runState.toolProgressTimer = undefined;
+    const subagentProgress = mergeSubagentProgress([...runState.subagentProgress.values()]);
+    markSubagentProgressShown(runState, subagentProgress);
+    runState.queue?.enqueue(() => replaceResponseWithToolProgress(responder, runState, subagentProgress), "tool progress update");
+}
+async function finalizeErrorResponse(responder, runState, options) {
+    if (!runState.reportedLlmError) {
+        runState.reportedLlmError = true;
+        reportUserFacingError(new Error("LLM run completed with error stop reason"), {
+            domain: "llm",
+            surface: "assistant_response",
+            operation: "llm_turn",
+            severity: "error",
+            platform: options?.platform,
+            provider: options?.model?.provider,
+            model: options?.model?.name,
+            stopReason: runState.stopReason,
+            context: {
+                sessionConversation: options?.sessionConversation,
+                sessionUuid: options?.sessionUuid,
+                hasErrorMessage: true,
+                llmCallCount: runState.llmCallCount,
+            },
+        });
+    }
+    try {
+        await responder.replaceResponse("_Sorry, something went wrong_");
+        await responder.respondDiagnostic(`Error: ${runState.errorMessage}`, { style: "error" });
+    }
+    catch (err) {
+        const errMsg = errorMessage(err);
+        log.logWarning("Failed to post error message", errMsg);
+        reportUserFacingError(err, {
+            domain: "chat_platform",
+            surface: "final_response",
+            operation: "finalize_error_response",
+            severity: "error",
+            platform: options?.platform,
+            context: {
+                sessionConversation: options?.sessionConversation,
+                sessionUuid: options?.sessionUuid,
+                stopReason: runState.stopReason,
+            },
+        });
+    }
+}
+export async function finalizeRunResponse(responder, session, runState, options) {
+    if (runState.stopReason === "error" && runState.errorMessage) {
+        await finalizeErrorResponse(responder, runState, options);
+        return;
+    }
+    const finalText = getFinalAssistantText(session);
+    if (runState.finalResponseHandledByTool) {
+        log.logInfo("Final response already handled by tool - skipping final replacement");
+        return;
+    }
+    if (isSilentResponse(finalText)) {
+        await deleteForSilentResponse(responder);
+        return;
+    }
+    if (!finalText.trim())
+        return;
+    const published = await publishFinalResponse(responder, runState, finalText, options);
+    const didWork = Object.keys(session.getLastRunStats().toolCallCounts).some((name) => ![TASK_STATUS_TOOL, START_TASK_TOOL, REACT_TOOL].includes(name));
+    if (published && runState.stopReason === "stop" && (didWork || options?.initialTask))
+        await responder.notifyCompletion?.();
+}
+function isSilentResponse(finalText) {
+    return finalText.trim().startsWith("[SILENT]");
+}
+async function deleteForSilentResponse(responder) {
+    try {
+        await responder.deleteResponse();
+        log.logInfo("Silent response - deleted message and thread");
+    }
+    catch (err) {
+        const errMsg = errorMessage(err);
+        log.logWarning("Failed to delete message for silent response", errMsg);
+    }
+}
+function resolveSingleCompletedProfile(runState) {
+    const nodes = runState.completedSubagentProgress.flatMap((snapshot) => snapshot.nodes);
+    if (nodes.length === 0)
+        return undefined;
+    const profiles = new Set(nodes.map((node) => node.profile));
+    if (profiles.size !== 1)
+        return undefined;
+    const [profile] = profiles;
+    if (!profile)
+        return undefined;
+    return nodes.every((node) => node.status === "completed") ? profile : undefined;
+}
+async function publishFinalResponse(responder, runState, finalText, options) {
+    try {
+        const finalResponse = appendTriggerAttribution(finalText, runState.triggerAttribution, options?.triggerSessionLink);
+        const finalDashboard = mergeSubagentProgress(runState.completedSubagentProgress);
+        if (finalDashboard) {
+            const resolvedProfile = resolveSingleCompletedProfile(runState);
+            if (resolvedProfile && responder.respondAsRole) {
+                await replaceWithSubagentDashboard(responder, finalDashboard, undefined, {
+                    createOverflowLink: options?.createOverflowLink,
+                });
+                await responder.respondAsRole(resolvedProfile, finalResponse);
+                return true;
+            }
+            await replaceWithSubagentDashboard(responder, finalDashboard, finalResponse, {
+                createOverflowLink: options?.createOverflowLink,
+            });
+            return true;
+        }
+        await responder.replaceResponse(formatResponseWithToolProgress(finalResponse, runState), {
+            createOverflowLink: options?.createOverflowLink,
+        });
+        return true;
+    }
+    catch (err) {
+        const errMsg = errorMessage(err);
+        log.logWarning("Failed to replace message with final text", errMsg);
+        reportUserFacingError(err, {
+            domain: "chat_platform",
+            surface: "final_response",
+            operation: "replace_final_response",
+            severity: "error",
+            platform: options?.platform,
+            context: {
+                sessionConversation: options?.sessionConversation,
+                sessionUuid: options?.sessionUuid,
+                finalTextLength: finalText.length,
+            },
+        });
+        return false;
+    }
+}
+export async function reportUsageSummary(ctx) {
+    const { session, runState, responder, platform, model, sessionConversation, sessionUuid, waitForQueue, } = ctx;
+    const contextTokens = await session.sessionStore.getContextTokens();
+    const contextWindow = model.contextWindow || 200000;
+    const { totalUsage } = runState;
+    const runMetricAttributes = metricAttributes({
+        provider: model.provider,
+        model: model.id,
+        channel_id: sessionConversation,
+        session_id: sessionUuid,
+        stop_reason: runState.stopReason,
+        llm_calls: runState.llmCallCount,
+    });
+    recordDistribution("agent.run.tokens_in", totalUsage.input, {
+        attributes: runMetricAttributes,
+    });
+    recordDistribution("agent.run.tokens_out", totalUsage.output, {
+        attributes: runMetricAttributes,
+    });
+    recordDistribution("agent.run.cache_read", totalUsage.cacheRead, {
+        attributes: runMetricAttributes,
+    });
+    recordDistribution("agent.run.cache_write", totalUsage.cacheWrite, {
+        attributes: runMetricAttributes,
+    });
+    recordDistribution("agent.run.cost", totalUsage.cost.total, {
+        attributes: runMetricAttributes,
+    });
+    const contextUtilization = contextTokens === undefined ? undefined : contextTokens / contextWindow;
+    if (contextUtilization !== undefined) {
+        recordGauge("agent.context.utilization", contextUtilization, {
+            unit: "ratio",
+            attributes: runMetricAttributes,
+        });
+    }
+    updateActiveSpanAttribution({
+        "gen_ai.request.model": model.id,
+        "gen_ai.response.model": runState.responseModel ?? model.id,
+        "gen_ai.usage.input_tokens": totalUsage.input + totalUsage.cacheRead + totalUsage.cacheWrite,
+        "gen_ai.usage.input_tokens.cached": totalUsage.cacheRead,
+        "gen_ai.usage.input_tokens.cache_write": totalUsage.cacheWrite,
+        "gen_ai.usage.output_tokens": totalUsage.output,
+        "gen_ai.usage.output_tokens.reasoning": runState.reasoningTokens,
+        "mikan.usage.cost_usd": totalUsage.cost.total,
+        "mikan.llm.call_count": runState.llmCallCount,
+        "mikan.tool.call_count": runState.toolCallCount,
+        "mikan.tool.error_count": runState.toolErrorCount,
+        "mikan.tool.input.characters": runState.toolInputCharacters,
+        "mikan.tool.output.characters": runState.toolOutputCharacters,
+        "mikan.output.message_count": runState.assistantMessageCount,
+        "mikan.output.characters": runState.outputCharacters,
+        "mikan.retry.count": runState.retryCount,
+        "mikan.compaction.count": runState.compactionCount,
+        "mikan.budget.exceeded": runState.budgetExceeded,
+        ...(contextUtilization === undefined
+            ? {}
+            : { "mikan.context.utilization": contextUtilization }),
+        ...(runState.firstTokenLatencyMs === undefined
+            ? {}
+            : { "mikan.response.first_token_ms": runState.firstTokenLatencyMs }),
+    });
+    const summary = log.logUsageSummary(runState.logCtx, runState.totalUsage, contextTokens, contextWindow);
+    const toolNames = Object.keys(session.getLastRunStats().toolCallCounts);
+    const statusOnly = toolNames.length > 0 && toolNames.every((name) => name === TASK_STATUS_TOOL);
+    if (platform.diagnostics?.showUsageSummary === true &&
+        !runState.finalResponseHandledByTool &&
+        !statusOnly &&
+        !isSilentResponse(getFinalAssistantText(session))) {
+        runState.queue.enqueue(() => responder.respondDiagnostic(summary, { style: "muted" }), "usage summary");
+        await waitForQueue();
+    }
+}
+function serializedLength(value) {
+    if (typeof value === "string")
+        return value.length;
+    try {
+        return JSON.stringify(value)?.length ?? 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function toolCategory(name, roles) {
+    if (["read", "write", "edit", "bash"].includes(name))
+        return "sandbox";
+    if (name === "subagent")
+        return "agent";
+    if (name.startsWith("mcp__"))
+        return "mcp";
+    if (name.startsWith("github_"))
+        return "github";
+    if (roles.platformTools.has(name))
+        return "platform";
+    return "function";
+}
+function toolLabel(args, toolName) {
+    const label = isRecord(args) && typeof args.label === "string" ? args.label.trim() : "";
+    return label || toolName;
+}
+function runningTools(runState) {
+    const now = Date.now();
+    return [...runState.pendingTools.values()]
+        .filter((pending) => pending.toolName !== START_TASK_TOOL)
+        .map((pending) => ({
+        label: toolLabel(pending.args, pending.toolName),
+        toolName: pending.toolName,
+        durationMs: now - pending.startTime,
+        isError: false,
+    }));
+}
+function observeToolStart(event, context) {
+    const { runState, logCtx, baseAttrs } = context;
+    const args = (event.args ?? {});
+    const label = args.label || event.toolName;
+    runState.toolCallCount += 1;
+    runState.toolInputCharacters += serializedLength(event.args);
+    runState.pendingTools.set(event.toolCallId, {
+        toolName: event.toolName,
+        args: event.args,
+        startTime: Date.now(),
+    });
+    if (event.toolName === START_TASK_TOOL)
+        return;
+    spansFor(runState).tools.set(event.toolCallId, startOperationSpan(`execute_tool ${event.toolName}`, metricAttributes({
+        "gen_ai.operation.name": "execute_tool",
+        "gen_ai.tool.name": event.toolName,
+        "gen_ai.tool.type": "function",
+        "mikan.tool.category": toolCategory(event.toolName, context.platformToolRoles),
+        "mikan.tool.input.characters": serializedLength(event.args),
+        "openinference.span.kind": "TOOL",
+        ...baseAttrs,
+    })));
+    addLifecycleEvent("agent.tool.started", { tool: event.toolName, ...baseAttrs });
+    log.logToolStart(logCtx, event.toolName, label, event.args);
+}
+function recordToolMetrics(event, durationMs, context) {
+    recordCounter("agent.tool.calls", 1, metricAttributes({
+        tool: event.toolName,
+        error: String(event.isError),
+        ...context.baseAttrs,
+    }));
+    recordDistribution("agent.tool.duration", durationMs, {
+        unit: "millisecond",
+        attributes: metricAttributes({ tool: event.toolName, ...context.baseAttrs }),
+    });
+    addLifecycleEvent("agent.tool.completed", {
+        tool: event.toolName,
+        error: event.isError,
+        duration_ms: durationMs,
+        ...context.baseAttrs,
+    });
+}
+function observeToolEnd(event, context) {
+    const { runState, logCtx } = context;
+    const outputCharacters = serializedLength(event.result);
+    runState.toolOutputCharacters += outputCharacters;
+    if (event.isError)
+        runState.toolErrorCount += 1;
+    const pending = runState.pendingTools.get(event.toolCallId);
+    runState.pendingTools.delete(event.toolCallId);
+    if (event.toolName === START_TASK_TOOL) {
+        if (!event.isError)
+            runState.finalResponseHandledByTool = true;
+        else
+            reportUserFacingError(new Error("Task admission failed"), {
+                domain: "mikan",
+                surface: "task_handoff",
+                operation: "admit_task",
+                severity: "error",
+                context: { sessionId: logCtx.sessionId, toolCallId: event.toolCallId },
+            });
+        return;
+    }
+    const durationMs = pending ? Date.now() - pending.startTime : 0;
+    runState.completedTools.push({
+        label: toolLabel(pending?.args, event.toolName),
+        toolName: event.toolName,
+        durationMs,
+        isError: event.isError,
+    });
+    const toolSpan = spansFor(runState).tools.get(event.toolCallId);
+    toolSpan?.end({
+        attributes: metricAttributes({
+            "gen_ai.tool.name": event.toolName,
+            "gen_ai.tool.type": "function",
+            "mikan.tool.category": toolCategory(event.toolName, context.platformToolRoles),
+            "mikan.tool.output.characters": outputCharacters,
+            "openinference.span.kind": "TOOL",
+            duration_ms: durationMs,
+            ...context.baseAttrs,
+        }),
+        error: event.isError ? operationError("ToolError") : undefined,
+    });
+    spansFor(runState).tools.delete(event.toolCallId);
+    recordToolMetrics(event, durationMs, context);
+    const resultStr = toolResultText(event.result);
+    if (event.isError) {
+        log.logToolError(logCtx, event.toolName, durationMs, resultStr);
+        return;
+    }
+    log.logToolSuccess(logCtx, event.toolName, durationMs, resultStr);
+    if (context.platformToolRoles.finalResponseTools.has(event.toolName)) {
+        runState.finalResponseHandledByTool = true;
+    }
+}
+function observeMessageStart(event, context) {
+    if (event.message.role !== "assistant")
+        return;
+    context.runState.llmCallCount += 1;
+    spansFor(context.runState).llm.push({
+        span: startOperationSpan(`chat ${context.model.id}`, metricAttributes({
+            "gen_ai.operation.name": "chat",
+            "gen_ai.provider.name": context.model.provider,
+            "gen_ai.request.model": context.model.id,
+            "openinference.span.kind": "LLM",
+            "llm.provider": context.model.provider,
+            "llm.model_name": context.model.id,
+            ...context.baseAttrs,
+        })),
+        startedAt: Date.now(),
+    });
+    addLifecycleEvent("agent.llm.call.started", {
+        call_index: context.runState.llmCallCount,
+        provider: context.model.provider,
+        model: context.agentConfig.model,
+        ...context.baseAttrs,
+    });
+    log.logResponseStart(context.logCtx);
+}
+function observeTextDelta(_event, context) {
+    const llmEntry = spansFor(context.runState).llm[0];
+    if (llmEntry && llmEntry.firstTokenAt === undefined) {
+        llmEntry.firstTokenAt = Date.now();
+        context.runState.firstTokenLatencyMs ??= llmEntry.firstTokenAt - llmEntry.startedAt;
+    }
+}
+function recordAssistantUsage(message, context) {
+    if (!message.usage)
+        return;
+    const { totalUsage } = context.runState;
+    totalUsage.input += message.usage.input;
+    totalUsage.output += message.usage.output;
+    totalUsage.cacheRead += message.usage.cacheRead;
+    totalUsage.cacheWrite += message.usage.cacheWrite;
+    totalUsage.cost.input += message.usage.cost.input;
+    totalUsage.cost.output += message.usage.cost.output;
+    totalUsage.cost.cacheRead += message.usage.cost.cacheRead;
+    totalUsage.cost.cacheWrite += message.usage.cost.cacheWrite;
+    totalUsage.cost.total += message.usage.cost.total;
+    context.runState.reasoningTokens += message.usage.reasoning ?? 0;
+    context.runState.responseModel = message.responseModel ?? message.model;
+    const attributes = metricAttributes({
+        provider: context.model.provider,
+        model: context.agentConfig.model,
+        ...context.baseAttrs,
+        stop_reason: message.stopReason,
+        error: Boolean(message.errorMessage),
+    });
+    recordCounter("agent.llm.calls", 1, attributes);
+    recordDistribution("agent.llm.tokens_in", message.usage.input, { attributes });
+    recordDistribution("agent.llm.tokens_out", message.usage.output, { attributes });
+    if (message.usage.cacheRead > 0) {
+        recordDistribution("agent.llm.cache_read", message.usage.cacheRead, { attributes });
+    }
+    if (message.usage.cacheWrite > 0) {
+        recordDistribution("agent.llm.cache_write", message.usage.cacheWrite, { attributes });
+    }
+    recordDistribution("agent.llm.cost_per_turn", message.usage.cost.total, { attributes });
+    addLifecycleEvent("agent.llm.call.completed", {
+        call_index: context.runState.llmCallCount,
+        provider: context.model.provider,
+        model: context.agentConfig.model,
+        stop_reason: message.stopReason,
+        error: Boolean(message.errorMessage),
+        input_tokens: message.usage.input,
+        output_tokens: message.usage.output,
+        cost_total_usd: message.usage.cost.total,
+    });
+}
+function observeMessageEnd(event, context) {
+    if (event.message.role !== "assistant")
+        return;
+    const message = event.message;
+    context.runState.assistantMessageCount += 1;
+    context.runState.outputCharacters += message.content.reduce((total, part) => total + (part.type === "text" ? part.text.length : 0), 0);
+    if (message.stopReason) {
+        context.runState.stopReason = message.stopReason;
+        context.runState.errorMessage = message.errorMessage;
+    }
+    recordAssistantUsage(message, context);
+    const llmEntry = spansFor(context.runState).llm.shift();
+    const inputTokens = message.usage
+        ? message.usage.input + message.usage.cacheRead + message.usage.cacheWrite
+        : undefined;
+    llmEntry?.span.end({
+        attributes: metricAttributes({
+            "gen_ai.provider.name": context.model.provider,
+            "gen_ai.request.model": context.model.id,
+            "gen_ai.response.model": message.responseModel ?? message.model,
+            "gen_ai.usage.input_tokens": inputTokens,
+            "gen_ai.usage.output_tokens": message.usage?.output,
+            "gen_ai.usage.input_tokens.cached": message.usage?.cacheRead,
+            "gen_ai.usage.input_tokens.cache_write": message.usage?.cacheWrite,
+            "gen_ai.usage.output_tokens.reasoning": message.usage?.reasoning,
+            "mikan.usage.cost_usd": message.usage?.cost.total,
+            "mikan.response.first_token_ms": llmEntry?.firstTokenAt === undefined
+                ? undefined
+                : llmEntry.firstTokenAt - llmEntry.startedAt,
+            "mikan.output.characters": message.content.reduce((total, part) => total + (part.type === "text" ? part.text.length : 0), 0),
+            "openinference.span.kind": "LLM",
+            "llm.provider": context.model.provider,
+            "llm.model_name": context.model.id,
+            "llm.token_count.prompt": inputTokens,
+            "llm.token_count.completion": message.usage?.output,
+            "llm.token_count.total": inputTokens !== undefined && message.usage ? inputTokens + message.usage.output : undefined,
+            "llm.token_count.prompt_details.cache_read": message.usage?.cacheRead,
+            "llm.token_count.prompt_details.cache_write": message.usage?.cacheWrite,
+            stop_reason: message.stopReason,
+            ...context.baseAttrs,
+        }),
+        error: message.errorMessage ? operationError("LLMError") : undefined,
+    });
+}
+function observeLifecycleEvent(event, context) {
+    if (event.type === "compaction_start") {
+        context.runState.compactionCount += 1;
+        log.logInfo(`Auto-compaction started (reason: ${event.reason})`);
+        return;
+    }
+    if (event.type === "compaction_end") {
+        if (event.aborted)
+            log.logInfo("Auto-compaction aborted");
+        else if (event.errorMessage)
+            log.logWarning("Auto-compaction failed", event.errorMessage);
+        else
+            log.logInfo("Auto-compaction complete");
+        return;
+    }
+    if (event.type === "auto_retry_start") {
+        context.runState.retryCount += 1;
+        log.logWarning(`Retrying (${event.attempt}/${event.maxAttempts})`, event.errorMessage);
+        return;
+    }
+    context.runState.budgetExceeded = true;
+    log.logWarning("Run stopped by budget circuit breaker", `${event.reason} (tokens=${event.tokens}, cost=${event.costUsd.toFixed(2)}, calls=${event.llmCalls}, ${event.durationMs}ms)`);
+}
+function observeHarnessEvent(event, context) {
+    switch (event.type) {
+        case "tool_execution_start":
+            observeToolStart(event, context);
+            return;
+        case "tool_execution_end":
+            observeToolEnd(event, context);
+            return;
+        case "message_start":
+            observeMessageStart(event, context);
+            return;
+        case "text_delta":
+            observeTextDelta(event, context);
+            return;
+        case "message_end":
+            observeMessageEnd(event, context);
+            return;
+        case "compaction_start":
+        case "compaction_end":
+        case "auto_retry_start":
+        case "budget_exceeded":
+            observeLifecycleEvent(event, context);
+            return;
+        default:
+            return;
+    }
+}
+const WORK_ACKNOWLEDGEMENT_REACTION = "saluting_face";
+const TOOLS_THAT_ARE_NOT_WORK = new Set([START_TASK_TOOL, TASK_STATUS_TOOL, REACT_TOOL]);
+function acknowledgeWorkOnce(context) {
+    const { runState, responder } = context;
+    if (runState.workAcknowledged || !responder.react)
+        return;
+    runState.workAcknowledged = true;
+    responder.react(WORK_ACKNOWLEDGEMENT_REACTION).catch((error) => {
+        log.logWarning("Could not acknowledge work with a reaction", errorMessage(error));
+    });
+}
+function presentToolStarted(event, context) {
+    const { runState, responder, queue } = context;
+    if (!TOOLS_THAT_ARE_NOT_WORK.has(event.toolName))
+        acknowledgeWorkOnce(context);
+    if (event.toolName === START_TASK_TOOL || event.toolName === TASK_STATUS_TOOL)
+        return;
+    runState.answerStreamStarted = false;
+    runState.toolProgress.set(event.toolCallId, { label: event.label, status: "running" });
+    if (event.toolName === "subagent") {
+        runState.subagentToolCalls.add(event.toolCallId);
+        return;
+    }
+    queue.enqueue(() => replaceResponseWithToolProgress(responder, runState), "tool progress update");
+}
+function presentSubagentProgress(event, context) {
+    context.runState.subagentProgress.set(event.toolCallId, event.snapshot);
+    context.runState.subagentToolCalls.add(event.toolCallId);
+    context.runState.suppressResponseDeltas = true;
+    scheduleToolProgressUpdate(context.responder, context.runState);
+}
+function presentToolEnded(event, context) {
+    const { runState, responder } = context;
+    if (event.toolName === START_TASK_TOOL)
+        return;
+    const progress = runState.toolProgress.get(event.toolCallId);
+    if (progress)
+        progress.status = event.isError ? "error" : "done";
+    const subagentProgress = runState.subagentProgress.get(event.toolCallId);
+    if (subagentProgress) {
+        runState.subagentProgress.set(event.toolCallId, settleSubagentProgress(subagentProgress, event.isError));
+    }
+    if (event.toolName !== TASK_STATUS_TOOL)
+        flushToolProgressUpdate(responder, runState);
+    const completedProgress = runState.subagentProgress.get(event.toolCallId);
+    if (completedProgress)
+        runState.completedSubagentProgress.push(completedProgress);
+    runState.subagentProgress.delete(event.toolCallId);
+}
+function presentAssistantDelta(event, context) {
+    const { runState } = context;
+    if (!context.responder.appendResponseDelta || runState.suppressResponseDeltas)
+        return;
+    const delta = runState.answerStreamStarted
+        ? event.delta
+        : formatResponseWithToolProgress(event.delta, runState);
+    runState.answerStreamStarted = true;
+    context.queue.enqueue(async () => {
+        await context.responder.appendResponseDelta?.(delta);
+    }, "response delta");
+}
+function presentThinking(thinking, context) {
+    log.logThinking(context.logCtx, thinking);
+    context.queue.enqueue(() => context.responder.respond(`_${thinking}_`), "thinking main");
+    context.queue.enqueue(() => context.responder.respondDiagnostic(`_${thinking}_`), "thinking diagnostic");
+}
+function presentFinalText(text, context) {
+    const finalText = appendTriggerAttribution(formatResponseWithToolProgress(text, context.runState), context.runState.triggerAttribution);
+    log.logResponse(context.logCtx, text);
+    if (context.runState.completedSubagentProgress.length > 0)
+        return;
+    if (context.responder.finishResponse) {
+        context.queue.enqueue(async () => {
+            await context.responder.finishResponse?.(finalText);
+        }, "response finish");
+    }
+    else {
+        context.queue.enqueue(() => context.responder.respond(finalText), "response main");
+    }
+}
+function presentAssistantMessage(event, context) {
+    for (const thinking of event.thinking)
+        presentThinking(thinking, context);
+    if (!event.text.trim() || event.callsTools || context.runState.finalResponseHandledByTool)
+        return;
+    presentFinalText(event.text, context);
+}
+function presentRunEvent(event, context) {
+    switch (event.type) {
+        case "tool_started":
+            presentToolStarted(event, context);
+            return;
+        case "subagent_progress":
+            presentSubagentProgress(event, context);
+            return;
+        case "tool_ended":
+            presentToolEnded(event, context);
+            return;
+        case "assistant_delta":
+            presentAssistantDelta(event, context);
+            return;
+        case "assistant_message":
+            presentAssistantMessage(event, context);
+            return;
+        case "compaction_started":
+            context.queue.enqueue(() => context.responder.respond("_Compacting context..._"), "compaction start");
+            return;
+        case "retry_started": {
+            const text = `_Retrying (${event.attempt}/${event.maxAttempts})..._`;
+            context.queue.enqueue(() => context.responder.respond(text), "retry");
+            return;
+        }
+        case "budget_exceeded": {
+            const text = formatBudgetStop({
+                reason: event.reason,
+                llmCalls: event.llmCalls,
+                durationMs: event.durationMs,
+                completed: context.runState.completedTools,
+                running: runningTools(context.runState),
+            });
+            context.queue.enqueue(() => context.responder.respondDiagnostic(text, { style: "error" }), "budget exceeded");
+            return;
+        }
+        case "run_started":
+        case "run_ended":
+            return;
+        default:
+            event;
+    }
+}
+export function attachSessionEventHandlers(params) {
+    const { session, runState, model, agentConfig, platformToolRoles } = params;
+    session.subscribe((event) => {
+        if (!runState.responder || !runState.logCtx || !runState.queue)
+            return;
+        observeHarnessEvent(event, {
+            runState,
+            logCtx: runState.logCtx,
+            baseAttrs: {
+                channel_id: runState.logCtx.conversationId,
+                session_id: runState.logCtx.sessionId,
+            },
+            model,
+            agentConfig,
+            platformToolRoles,
+        });
+        const runEvent = toRunEvent(event);
+        if (!runEvent)
+            return;
+        runState.publishRunEvent?.(runEvent);
+        presentRunEvent(runEvent, {
+            runState,
+            responder: runState.responder,
+            logCtx: runState.logCtx,
+            queue: runState.queue,
+        });
+    });
+}
+//# sourceMappingURL=presenter.js.map