@geminixiang/mikan 1.0.0-beta.80 → 1.0.0-beta.82

package/dist/harness/presenter.js

@@ -1,10 +1,10 @@
 import { contentText } from "@earendil-works/pi-ai";
-import { mergeSubagentProgress, parseSubagentProgressSnapshot, renderSubagentDashboard, settleSubagentProgress, } from "./tools/subagent.js";
+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 { JEV_TOOL } from "./tools/jev.js";
-import { JEV_BROWSER_TOOL } from "./tools/jev-browser.js";
+import { toRunEvent, toolResultText } from "./run-events.js";
+import { REACT_TOOL } from "./tools/react.js";
 import * as log from "../log.js";
 import { errorMessage } from "../unknown-values.js";
 const operationSpans = new WeakMap();
@@ -53,6 +53,9 @@ function createRunStateDefaults() {
         subagentToolCalls: new Set(),
         subagentProgressShown: false,
         suppressResponseDeltas: false,
+        answerStreamStarted: false,
+        workAcknowledged: false,
+        publishRunEvent: undefined,
         lastSubagentProgressAt: 0,
         toolProgressTimer: undefined,
         totalUsage: createEmptyUsageTotals(),
@@ -92,6 +95,7 @@ export function activateRunPresentation(runState, context) {
             sessionId: context.sessionUuid,
         },
         triggerAttribution: context.triggerAttribution,
+        publishRunEvent: context.publishRunEvent,
     });
     const { responder } = context;
     let queueChain = Promise.resolve();
@@ -124,6 +128,7 @@ export function activateRunPresentation(runState, context) {
             runState.responder = null;
             runState.logCtx = null;
             runState.queue = null;
+            runState.publishRunEvent = undefined;
         },
     };
 }
@@ -134,14 +139,6 @@ export function getFinalAssistantText(session) {
 export function isEventTriggerAttribution(triggerAttribution) {
     return triggerAttribution?.startsWith("[event:") === true;
 }
-function extractToolLabel(toolName, args) {
-    const label = args?.label;
-    const text = typeof label === "string" ? label.trim() || toolName : toolName;
-    if ((toolName === JEV_TOOL || toolName === JEV_BROWSER_TOOL) && text !== toolName) {
-        return `${toolName} · ${text}`;
-    }
-    return text;
-}
 function formatToolProgress(runState) {
     const lines = Array.from(runState.toolProgress.entries()).flatMap(([toolCallId, item]) => {
         if (runState.subagentToolCalls.has(toolCallId))
@@ -206,14 +203,6 @@ function flushToolProgressUpdate(responder, runState) {
     markSubagentProgressShown(runState, subagentProgress);
     runState.queue?.enqueue(() => replaceResponseWithToolProgress(responder, runState, subagentProgress), "tool progress update");
 }
-function extractSubagentProgress(partialResult) {
-    if (!partialResult || typeof partialResult !== "object")
-        return undefined;
-    const details = partialResult.details;
-    if (!details || typeof details !== "object")
-        return undefined;
-    return parseSubagentProgressSnapshot(details.progress);
-}
 async function finalizeErrorResponse(responder, runState, options) {
     if (!runState.reportedLlmError) {
         runState.reportedLlmError = true;
@@ -272,7 +261,7 @@ export async function finalizeRunResponse(responder, session, runState, options)
     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"].includes(name));
+    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?.();
 }
@@ -416,22 +405,6 @@ export async function reportUsageSummary(ctx) {
         await waitForQueue();
     }
 }
-function toolResultContentText(result) {
-    if (!result || typeof result !== "object" || !("content" in result))
-        return undefined;
-    const content = result.content;
-    if (!Array.isArray(content))
-        return undefined;
-    const textParts = content
-        .filter((part) => part.type === "text" && part.text)
-        .map((part) => part.text);
-    return textParts.length > 0 ? textParts.join("\n") : undefined;
-}
-function extractToolResultText(result) {
-    if (typeof result === "string")
-        return result;
-    return toolResultContentText(result) ?? JSON.stringify(result);
-}
 function serializedLength(value) {
     if (typeof value === "string")
         return value.length;
@@ -455,8 +428,8 @@ function toolCategory(name, roles) {
         return "platform";
     return "function";
 }
-function handleToolStart(event, context) {
-    const { runState, responder, logCtx, queue, baseAttrs } = context;
+function observeToolStart(event, context) {
+    const { runState, logCtx, baseAttrs } = context;
     const args = (event.args ?? {});
     const label = args.label || event.toolName;
     runState.toolCallCount += 1;
@@ -468,18 +441,6 @@ function handleToolStart(event, context) {
     });
     if (event.toolName === START_TASK_TOOL)
         return;
-    if (event.toolName !== TASK_STATUS_TOOL) {
-        runState.toolProgress.set(event.toolCallId, {
-            label: extractToolLabel(event.toolName, event.args),
-            status: "running",
-        });
-    }
-    if (event.toolName === "subagent") {
-        runState.subagentToolCalls.add(event.toolCallId);
-    }
-    else if (event.toolName !== TASK_STATUS_TOOL) {
-        queue.enqueue(() => replaceResponseWithToolProgress(responder, runState), "tool progress update");
-    }
     spansFor(runState).tools.set(event.toolCallId, startOperationSpan(`execute_tool ${event.toolName}`, metricAttributes({
         "gen_ai.operation.name": "execute_tool",
         "gen_ai.tool.name": event.toolName,
@@ -492,15 +453,6 @@ function handleToolStart(event, context) {
     addLifecycleEvent("agent.tool.started", { tool: event.toolName, ...baseAttrs });
     log.logToolStart(logCtx, event.toolName, label, event.args);
 }
-function handleToolUpdate(event, context) {
-    const subagentProgress = extractSubagentProgress(event.partialResult);
-    if (!subagentProgress)
-        return;
-    context.runState.subagentProgress.set(event.toolCallId, subagentProgress);
-    context.runState.subagentToolCalls.add(event.toolCallId);
-    context.runState.suppressResponseDeltas = true;
-    scheduleToolProgressUpdate(context.responder, context.runState);
-}
 function recordToolMetrics(event, durationMs, context) {
     recordCounter("agent.tool.calls", 1, metricAttributes({
         tool: event.toolName,
@@ -518,16 +470,15 @@ function recordToolMetrics(event, durationMs, context) {
         ...context.baseAttrs,
     });
 }
-function handleToolEnd(event, context) {
-    const { runState, responder, logCtx } = context;
-    const resultStr = extractToolResultText(event.result);
+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) {
-        runState.pendingTools.delete(event.toolCallId);
         if (!event.isError)
             runState.finalResponseHandledByTool = true;
         else
@@ -540,20 +491,6 @@ function handleToolEnd(event, context) {
             });
         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);
-    runState.pendingTools.delete(event.toolCallId);
     const durationMs = pending ? Date.now() - pending.startTime : 0;
     const toolSpan = spansFor(runState).tools.get(event.toolCallId);
     toolSpan?.end({
@@ -570,6 +507,7 @@ function handleToolEnd(event, context) {
     });
     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;
@@ -579,7 +517,7 @@ function handleToolEnd(event, context) {
         runState.finalResponseHandledByTool = true;
     }
 }
-function handleMessageStart(event, context) {
+function observeMessageStart(event, context) {
     if (event.message.role !== "assistant")
         return;
     context.runState.llmCallCount += 1;
@@ -603,7 +541,7 @@ function handleMessageStart(event, context) {
     });
     log.logResponseStart(context.logCtx);
 }
-function handleMessageUpdate(event, context) {
+function observeMessageUpdate(event, context) {
     const update = event.assistantMessageEvent;
     if (update.type !== "text_delta" || !update.delta)
         return;
@@ -612,11 +550,6 @@ function handleMessageUpdate(event, context) {
         llmEntry.firstTokenAt = Date.now();
         context.runState.firstTokenLatencyMs ??= llmEntry.firstTokenAt - llmEntry.startedAt;
     }
-    if (context.responder.appendResponseDelta && !context.runState.suppressResponseDeltas) {
-        context.queue.enqueue(async () => {
-            await context.responder.appendResponseDelta?.(update.delta);
-        }, "response delta");
-    }
 }
 function recordAssistantUsage(message, context) {
     if (!message.usage)
@@ -661,43 +594,7 @@ function recordAssistantUsage(message, context) {
         cost_total_usd: message.usage.cost.total,
     });
 }
-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(message, context) {
-    const thinkingParts = [];
-    const textParts = [];
-    const hasToolCall = message.content.some((part) => ["tool_use", "toolCall", "tool-call"].includes(part.type ?? ""));
-    for (const part of message.content) {
-        if (part.type === "thinking")
-            thinkingParts.push(part.thinking);
-        else if (part.type === "text")
-            textParts.push(part.text);
-    }
-    for (const thinking of thinkingParts)
-        presentThinking(thinking, context);
-    const text = textParts.join("\n");
-    if (!text.trim() || hasToolCall || context.runState.finalResponseHandledByTool)
-        return;
-    presentFinalText(text, context);
-}
-function handleMessageEnd(event, context) {
+function observeMessageEnd(event, context) {
     if (event.message.role !== "assistant")
         return;
     const message = event.message;
@@ -740,14 +637,11 @@ function handleMessageEnd(event, context) {
         }),
         error: message.errorMessage ? operationError("LLMError") : undefined,
     });
-    presentAssistantMessage(message, context);
 }
-function handleLifecycleEvent(event, context) {
+function observeLifecycleEvent(event, context) {
     if (event.type === "compaction_start") {
         context.runState.compactionCount += 1;
-        const text = "_Compacting context..._";
         log.logInfo(`Auto-compaction started (reason: ${event.reason})`);
-        context.queue.enqueue(() => context.responder.respond(text), "compaction start");
         return;
     }
     if (event.type === "compaction_end") {
@@ -762,55 +656,168 @@ function handleLifecycleEvent(event, context) {
     if (event.type === "auto_retry_start") {
         context.runState.retryCount += 1;
         log.logWarning(`Retrying (${event.attempt}/${event.maxAttempts})`, event.errorMessage);
-        const text = `_Retrying (${event.attempt}/${event.maxAttempts})..._`;
-        context.queue.enqueue(() => context.responder.respond(text), "retry");
         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)`);
-    const text = `_Stopped: run budget exceeded (${event.reason})_`;
-    context.queue.enqueue(() => context.responder.respondDiagnostic(text, { style: "error" }), "budget exceeded");
 }
-function handlePresenterEvent(event, context) {
+function observeHarnessEvent(event, context) {
     switch (event.type) {
         case "tool_execution_start":
-            handleToolStart(event, context);
-            return;
-        case "tool_execution_update":
-            handleToolUpdate(event, context);
+            observeToolStart(event, context);
             return;
         case "tool_execution_end":
-            handleToolEnd(event, context);
+            observeToolEnd(event, context);
             return;
         case "message_start":
-            handleMessageStart(event, context);
+            observeMessageStart(event, context);
             return;
         case "message_update":
-            handleMessageUpdate(event, context);
+            observeMessageUpdate(event, context);
             return;
         case "message_end":
-            handleMessageEnd(event, context);
+            observeMessageEnd(event, context);
             return;
         case "compaction_start":
         case "compaction_end":
         case "auto_retry_start":
         case "budget_exceeded":
-            handleLifecycleEvent(event, context);
+            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 = `_Stopped: run budget exceeded (${event.reason})_`;
+            context.queue.enqueue(() => context.responder.respondDiagnostic(text, { style: "error" }), "budget exceeded");
+            return;
+        }
+        case "run_started":
+        case "run_ended":
+            return;
+    }
+}
 export function attachSessionEventHandlers(params) {
     const { session, runState, model, agentConfig, platformToolRoles } = params;
     session.subscribe((event) => {
         if (!runState.responder || !runState.logCtx || !runState.queue)
             return;
-        handlePresenterEvent(event, {
+        observeHarnessEvent(event, {
             runState,
-            responder: runState.responder,
             logCtx: runState.logCtx,
-            queue: runState.queue,
             baseAttrs: {
                 channel_id: runState.logCtx.conversationId,
                 session_id: runState.logCtx.sessionId,
@@ -819,6 +826,16 @@ export function attachSessionEventHandlers(params) {
             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