@geminixiang/mikan 0.5.0-beta.0 → 0.5.1

package/dist/agent.js

@@ -11,13 +11,13 @@ import { reportUserFacingError } from "./observability/sentry.js";
 import { createExecutor, } from "./sandbox/index.js";
 import { createMountedRuntimePathContext } from "./sandbox/path-context.js";
 import { addLifecycleBreadcrumb, metricAttributes, updateActiveSpanAttribution, } from "./observability/sentry.js";
-import { ChatSessionManager } from "./sessions/chat-session-manager.js";
+import { AgentMemoryFileManager } from "./sessions/agent-memory-file-manager.js";
 import { extractSessionUuid, openManagedSession, } from "./sessions/store.js";
-import { shouldSurfaceToolDiagnostic } from "./tool-diagnostics.js";
 import { createMikanTools } from "./tools/index.js";
 import * as Sentry from "@sentry/node";
 import { formatLocalTimestamp } from "./utils/date.js";
 import { resolveConfiguredModel } from "./model-registry.js";
+import { emitAgentEvent } from "./agent-events.js";
 const IMAGE_MIME_TYPES = {
     jpg: "image/jpeg",
     jpeg: "image/jpeg",
@@ -186,15 +186,9 @@ Do not add this to \`[SILENT]\` responses.
         : "";
     const slackBlockKitInstructions = platform.name === "slack"
         ? `
-## Slack Block Kit
-- On Slack, use the \`slack_blockkit\` tool when a response benefits from interaction or structured presentation.
-- Good uses: choices, confirmations, clarifying questions, quizzes, status reports, comparisons, summaries, and step lists.
-- Do not use it for normal short replies or simple factual answers.
-- Supported blocks: section, context, divider, header, actions.
-- Put buttons in actions.elements. Put static_select and multi_static_select in section.accessory.
-- Every interactive element must include action_id. Buttons must include value.
-- Always provide a plain-text fallback in text that matches the visible Block Kit content.
-- When using \`slack_blockkit\`, do not also send a normal text response in the same assistant turn; put the fallback in the tool's text field.
+## Slack Rendering
+- The Slack adapter renders responses with Block Kit automatically. Answer normally using Slack mrkdwn.
+- Do not emit markdown pipe tables; Slack does not render them as tables. Prefer short sections or bullet lists.
 `
         : "";
     return `You are mikan, a ${platform.name} bot assistant. Be concise. No emojis.
@@ -292,7 +286,7 @@ Maintain ${workspaceRoot}/SYSTEM.md to log all environment modifications:
 Update this file whenever you modify the environment. On fresh container, read it first to restore your setup.
 
 ## Log Queries (for older history)
-Format: \`{"date":"...","ts":"...","user":"...","userName":"...","text":"...","isBot":false}\`
+Format: \`{"date":"...","ts":"...","user":"...","userName":"...","text":"...","isMessagingBot":false}\`
 The log contains user messages and your final responses (not tool calls/results).
 Use \`log.jsonl\` for quick grep-style history. Use \`${conversationPath}/sessions/\` when you need structured turns, tool outputs, or thread/session lineage.
 ${isContainerLike || isFirecracker ? "Install jq: apt-get install jq" : ""}
@@ -324,11 +318,6 @@ ls -1 sessions/
 Each tool requires a "label" parameter (shown to user).
 `;
 }
-function truncate(text, maxLen) {
-    if (text.length <= maxLen)
-        return text;
-    return `${text.substring(0, maxLen - 3)}...`;
-}
 export function getUnresolvedSandboxPathContext(sandboxConfig, hostWorkspaceRoot) {
     if (sandboxConfig.type === "image") {
         return createMountedRuntimePathContext(hostWorkspaceRoot, "/workspace");
@@ -439,10 +428,11 @@ function createEmptyUsageTotals() {
 }
 function createRunState() {
     return {
-        responseCtx: null,
+        responder: null,
         logCtx: null,
         queue: null,
         pendingTools: new Map(),
+        toolProgress: new Map(),
         totalUsage: createEmptyUsageTotals(),
         llmCallCount: 0,
         stopReason: "stop",
@@ -452,8 +442,8 @@ function createRunState() {
         triggerAttribution: undefined,
     };
 }
-function resetRunState(runState, responseCtx, sessionConversation, userName, sessionUuid, triggerAttribution) {
-    runState.responseCtx = responseCtx;
+function resetRunState(runState, responder, sessionConversation, userName, sessionUuid, triggerAttribution) {
+    runState.responder = responder;
     runState.logCtx = {
         conversationId: sessionConversation,
         userName,
@@ -461,6 +451,7 @@ function resetRunState(runState, responseCtx, sessionConversation, userName, ses
         sessionId: sessionUuid,
     };
     runState.pendingTools.clear();
+    runState.toolProgress.clear();
     runState.totalUsage = createEmptyUsageTotals();
     runState.llmCallCount = 0;
     runState.stopReason = "stop";
@@ -469,7 +460,7 @@ function resetRunState(runState, responseCtx, sessionConversation, userName, ses
     runState.finalResponseHandledByTool = false;
     runState.triggerAttribution = triggerAttribution;
 }
-function createRunQueue(responseCtx, runState) {
+function createRunQueue(responder, runState) {
     let queueChain = Promise.resolve();
     return {
         queue: {
@@ -484,7 +475,7 @@ function createRunQueue(responseCtx, runState) {
                         const errMsg = err instanceof Error ? err.message : String(err);
                         log.logWarning(`API error (${errorContext})`, errMsg);
                         try {
-                            await responseCtx.respondDiagnostic(`Error: ${errMsg}`, { style: "error" });
+                            await responder.respondDiagnostic(`Error: ${errMsg}`, { style: "error" });
                         }
                         catch {
                             // Ignore
@@ -558,7 +549,29 @@ export function appendTriggerAttribution(text, triggerAttribution) {
         return text;
     return `${text.trimEnd()}\n\n${suffix}`;
 }
-async function finalizeRunResponse(responseCtx, session, runState, options) {
+function extractToolLabel(toolName, args) {
+    const label = args?.label;
+    if (typeof label !== "string")
+        return toolName;
+    return label.trim() || toolName;
+}
+function formatToolProgress(runState) {
+    const lines = Array.from(runState.toolProgress.values()).map((item) => {
+        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 ? `${progress}\n\n${text}` : text;
+}
+async function replaceResponseWithToolProgress(responder, runState) {
+    const progress = formatToolProgress(runState);
+    if (progress)
+        await responder.replaceResponse(progress);
+}
+async function finalizeRunResponse(responder, session, runState, options) {
     if (runState.stopReason === "error" && runState.errorMessage) {
         if (!runState.reportedLlmError) {
             runState.reportedLlmError = true;
@@ -580,8 +593,8 @@ async function finalizeRunResponse(responseCtx, session, runState, options) {
             });
         }
         try {
-            await responseCtx.replaceResponse("_Sorry, something went wrong_");
-            await responseCtx.respondDiagnostic(`Error: ${runState.errorMessage}`, {
+            await responder.replaceResponse("_Sorry, something went wrong_");
+            await responder.respondDiagnostic(`Error: ${runState.errorMessage}`, {
                 style: "error",
             });
         }
@@ -610,7 +623,7 @@ async function finalizeRunResponse(responseCtx, session, runState, options) {
     }
     if (finalText.trim() === "[SILENT]" || finalText.trim().startsWith("[SILENT]")) {
         try {
-            await responseCtx.deleteResponse();
+            await responder.deleteResponse();
             log.logInfo("Silent response - deleted message and thread");
         }
         catch (err) {
@@ -622,7 +635,7 @@ async function finalizeRunResponse(responseCtx, session, runState, options) {
     if (!finalText.trim())
         return;
     try {
-        await responseCtx.replaceResponse(appendTriggerAttribution(finalText, options?.triggerAttribution), { createOverflowLink: options?.createOverflowLink });
+        await responder.replaceResponse(appendTriggerAttribution(formatResponseWithToolProgress(finalText, runState), options?.triggerAttribution), { createOverflowLink: options?.createOverflowLink });
     }
     catch (err) {
         const errMsg = err instanceof Error ? err.message : String(err);
@@ -642,9 +655,7 @@ async function finalizeRunResponse(responseCtx, session, runState, options) {
     }
 }
 async function reportUsageSummary(ctx) {
-    const { session, runState, responseCtx, platform, model, agentConfig, sessionConversation, sessionUuid, waitForQueue, } = ctx;
-    if (runState.totalUsage.cost.total <= 0)
-        return;
+    const { session, runState, responder, platform, model, agentConfig, sessionConversation, sessionUuid, waitForQueue, } = ctx;
     const lastAssistantMessage = session.messages
         .slice()
         .toReversed()
@@ -686,7 +697,7 @@ async function reportUsageSummary(ctx) {
     });
     const summary = log.logUsageSummary(runState.logCtx, runState.totalUsage, contextTokens, contextWindow);
     if (platform.diagnostics?.showUsageSummary === true) {
-        runState.queue.enqueue(() => responseCtx.respondDiagnostic(summary, { style: "muted" }), "usage summary");
+        runState.queue.enqueue(() => responder.respondDiagnostic(summary, { style: "muted" }), "usage summary");
         await waitForQueue();
     }
 }
@@ -698,7 +709,7 @@ function reloadSessionMessages(sessionManager, conversationId, agent) {
     }
 }
 async function prepareRunContext(params) {
-    const { message, responseCtx, platform, conversationId, conversationDir, sessionUuid, runState, executor, executionResolver, resolveExecutorForRun, getPathContext, sessionManager, session, agent, setEventContext, setSandboxContext, setUploadFunction, setBlockKitResponseFunction, } = params;
+    const { message, responder, platform, conversationId, conversationDir, sessionUuid, runState, executor, executionResolver, resolveExecutorForRun, getPathContext, sessionManager, session, agent, setEventContext, setSandboxContext, setUploadFunction, } = params;
     let pathContext = params.pathContext;
     const sessionConversation = message.sessionKey.split(":")[0];
     await mkdir(join(conversationDir, "scratch"), { recursive: true });
@@ -725,19 +736,10 @@ async function prepareRunContext(params) {
     setSandboxContext({ conversationId, userId: message.userId });
     setUploadFunction(async (filePath, title) => {
         const hostPath = translateAttachPathToHost(filePath, pathContext);
-        await responseCtx.uploadFile(hostPath, title);
-    });
-    setBlockKitResponseFunction(async (response) => {
-        if (platform.name === "slack" && responseCtx.respondBlockKit) {
-            await responseCtx.respondBlockKit(response);
-        }
-        else {
-            await responseCtx.replaceResponse(response.text);
-        }
-        runState.finalResponseHandledByTool = true;
+        await responder.uploadFile(hostPath, title);
     });
-    resetRunState(runState, responseCtx, sessionConversation, message.userName, sessionUuid, triggerAttribution);
-    const runQueue = createRunQueue(responseCtx, runState);
+    resetRunState(runState, responder, sessionConversation, message.userName, sessionUuid, triggerAttribution);
+    const runQueue = createRunQueue(responder, runState);
     runState.queue = runQueue.queue;
     log.logInfo(`Context sizes - system: ${systemPrompt.length} chars, memory: ${memory.length} chars`);
     log.logInfo(`Channels: ${platform.channels.length}, Users: ${platform.users.length}`);
@@ -752,21 +754,43 @@ async function prepareRunContext(params) {
         pathContext,
     };
 }
+function formatAgentActorName(userName, fallback) {
+    return userName ? `DM:${userName}` : fallback;
+}
+function sendAgentEvent(payload) {
+    emitAgentEvent({ source: "mikan", ...payload });
+}
 function attachSessionEventHandlers(params) {
     const { session, runState, model, agentConfig } = params;
     session.subscribe(async (event) => {
-        if (!runState.responseCtx || !runState.logCtx || !runState.queue)
+        if (!runState.responder || !runState.logCtx || !runState.queue)
             return;
-        const { responseCtx, logCtx, queue, pendingTools } = runState;
+        const { responder, logCtx, queue, pendingTools } = runState;
         const baseAttrs = { channel_id: logCtx.conversationId, session_id: logCtx.sessionId };
+        const agentEventSessionId = logCtx.sessionId ?? logCtx.conversationId;
         if (event.type === "tool_execution_start") {
             const args = (event.args ?? {});
             const label = args.label || event.toolName;
+            sendAgentEvent({
+                sessionId: agentEventSessionId,
+                actorName: formatAgentActorName(logCtx.userName, logCtx.conversationId),
+                event: {
+                    kind: "toolStart",
+                    toolId: event.toolCallId,
+                    toolName: event.toolName,
+                    input: { label },
+                },
+            });
             pendingTools.set(event.toolCallId, {
                 toolName: event.toolName,
                 args: event.args,
                 startTime: Date.now(),
             });
+            runState.toolProgress.set(event.toolCallId, {
+                label: extractToolLabel(event.toolName, event.args),
+                status: "running",
+            });
+            queue.enqueue(() => replaceResponseWithToolProgress(responder, runState), "tool progress update");
             addLifecycleBreadcrumb("agent.tool.started", {
                 tool: event.toolName,
                 ...baseAttrs,
@@ -777,6 +801,15 @@ function attachSessionEventHandlers(params) {
         if (event.type === "tool_execution_end") {
             const resultStr = extractToolResultText(event.result);
             const pending = pendingTools.get(event.toolCallId);
+            sendAgentEvent({
+                sessionId: agentEventSessionId,
+                actorName: formatAgentActorName(logCtx.userName, logCtx.conversationId),
+                event: { kind: "toolEnd", toolId: event.toolCallId },
+            });
+            const progress = runState.toolProgress.get(event.toolCallId);
+            if (progress)
+                progress.status = event.isError ? "error" : "done";
+            queue.enqueue(() => replaceResponseWithToolProgress(responder, runState), "tool progress update");
             pendingTools.delete(event.toolCallId);
             const durationMs = pending ? Date.now() - pending.startTime : 0;
             Sentry.metrics.count("agent.tool.calls", 1, {
@@ -805,25 +838,16 @@ function attachSessionEventHandlers(params) {
             else {
                 log.logToolSuccess(logCtx, event.toolName, durationMs, resultStr);
             }
-            if (shouldSurfaceToolDiagnostic(event.toolName)) {
-                const toolResult = {
-                    toolName: event.toolName,
-                    label: pending?.args ? pending.args.label : undefined,
-                    args: pending?.args,
-                    result: truncate(resultStr, TOOL_RESULT_DIAGNOSTIC_CAP),
-                    isError: event.isError,
-                    durationMs,
-                };
-                queue.enqueue(() => responseCtx.respondToolResult(toolResult), "tool result diagnostic");
-            }
-            if (event.isError && shouldSurfaceToolDiagnostic(event.toolName)) {
-                queue.enqueue(() => responseCtx.respond(`_Error: ${truncate(resultStr, 200)}_`), "tool error");
-            }
             return;
         }
         if (event.type === "message_start") {
             if (event.message.role === "assistant") {
                 runState.llmCallCount += 1;
+                sendAgentEvent({
+                    sessionId: agentEventSessionId,
+                    actorName: formatAgentActorName(logCtx.userName, logCtx.conversationId),
+                    event: { kind: "sessionStart" },
+                });
                 addLifecycleBreadcrumb("agent.llm.call.started", {
                     call_index: runState.llmCallCount,
                     provider: model.provider,
@@ -838,9 +862,9 @@ function attachSessionEventHandlers(params) {
             const assistantMessageEvent = event.assistantMessageEvent;
             if (assistantMessageEvent?.type === "text_delta" &&
                 assistantMessageEvent.delta &&
-                responseCtx.appendResponseDelta) {
+                responder.appendResponseDelta) {
                 queue.enqueue(async () => {
-                    await responseCtx.appendResponseDelta?.(assistantMessageEvent.delta ?? "");
+                    await responder.appendResponseDelta?.(assistantMessageEvent.delta ?? "");
                 }, "response delta");
             }
             return;
@@ -916,21 +940,26 @@ function attachSessionEventHandlers(params) {
                 const text = textParts.join("\n");
                 for (const thinking of thinkingParts) {
                     log.logThinking(logCtx, thinking);
-                    queue.enqueue(() => responseCtx.respond(`_${thinking}_`), "thinking main");
-                    queue.enqueue(() => responseCtx.respondDiagnostic(`_${thinking}_`), "thinking diagnostic");
+                    queue.enqueue(() => responder.respond(`_${thinking}_`), "thinking main");
+                    queue.enqueue(() => responder.respondDiagnostic(`_${thinking}_`), "thinking diagnostic");
                 }
                 if (text.trim() && !hasToolCall) {
                     if (runState.finalResponseHandledByTool)
                         return;
-                    const finalText = appendTriggerAttribution(text, runState.triggerAttribution);
+                    const finalText = appendTriggerAttribution(formatResponseWithToolProgress(text, runState), runState.triggerAttribution);
                     log.logResponse(logCtx, text);
-                    if (responseCtx.finishResponse) {
+                    sendAgentEvent({
+                        sessionId: agentEventSessionId,
+                        actorName: formatAgentActorName(logCtx.userName, logCtx.conversationId),
+                        event: { kind: "turnEnd" },
+                    });
+                    if (responder.finishResponse) {
                         queue.enqueue(async () => {
-                            await responseCtx.finishResponse?.(finalText);
+                            await responder.finishResponse?.(finalText);
                         }, "response finish");
                     }
                     else {
-                        queue.enqueue(() => responseCtx.respond(finalText), "response main");
+                        queue.enqueue(() => responder.respond(finalText), "response main");
                     }
                 }
             }
@@ -938,7 +967,7 @@ function attachSessionEventHandlers(params) {
         }
         if (event.type === "compaction_start") {
             log.logInfo(`Auto-compaction started (reason: ${event.reason})`);
-            queue.enqueue(() => responseCtx.respond("_Compacting context..._"), "compaction start");
+            queue.enqueue(() => responder.respond("_Compacting context..._"), "compaction start");
             return;
         }
         if (event.type === "compaction_end") {
@@ -952,13 +981,15 @@ function attachSessionEventHandlers(params) {
         }
         if (event.type === "auto_retry_start") {
             log.logWarning(`Retrying (${event.attempt}/${event.maxAttempts})`, event.errorMessage);
-            queue.enqueue(() => responseCtx.respond(`_Retrying (${event.attempt}/${event.maxAttempts})..._`), "retry");
+            sendAgentEvent({
+                sessionId: agentEventSessionId,
+                actorName: formatAgentActorName(logCtx.userName, logCtx.conversationId),
+                event: { kind: "sessionStart" },
+            });
+            queue.enqueue(() => responder.respond(`_Retrying (${event.attempt}/${event.maxAttempts})..._`), "retry");
         }
     });
 }
-// Cap raw tool output before handing it to adapters. Bash output can be MB; without
-// this each adapter's splitter would fan it out into many sequential platform posts.
-const TOOL_RESULT_DIAGNOSTIC_CAP = 8000;
 function extractToolResultText(result) {
     if (typeof result === "string") {
         return result;
@@ -981,7 +1012,7 @@ function extractToolResultText(result) {
     return JSON.stringify(result);
 }
 /**
- * Create a new AgentRunner for a channel.
+ * Create a new PiAgentWrapper for a channel.
  * Sets up the session and subscribes to events once.
  *
  * Runner caching is handled by the caller (channelStates in main.ts).
@@ -993,7 +1024,7 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
     const { executionResolver, executor, getPathContext, resolveExecutorForRun } = createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner, workspaceDir, workspaceBase);
     let pathContext = getUnresolvedSandboxPathContext(sandboxConfig, workspaceBase);
     // Create tools (per-runner, with per-runner upload function setter)
-    const { tools, setUploadFunction, setBlockKitResponseFunction, setEventContext, setSandboxContext, } = createMikanTools(executor, workspaceDir, { sandbox: sandboxConfig, provisioner });
+    const { tools, setUploadFunction, setEventContext, setSandboxContext } = createMikanTools(executor, workspaceDir, { sandbox: sandboxConfig, provisioner });
     const authStorage = AuthStorage.create(join(homedir(), ".pi", "mikan", "auth.json"));
     const modelRegistry = ModelRegistry.create(authStorage);
     const model = resolveConfiguredModel(modelRegistry, agentConfig.provider, agentConfig.model);
@@ -1018,7 +1049,7 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
         sessionManager.appendSessionInfo(threadSessionName);
     }
     const sessionUuid = extractSessionUuid(contextFile);
-    const chatSessionManager = new ChatSessionManager();
+    const chatSessionManager = new AgentMemoryFileManager();
     const settingsManager = SettingsManager.inMemory();
     const { agent, session } = await createConfiguredAgentSession({
         conversationId,
@@ -1044,10 +1075,10 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                 currentMessageId,
             });
         },
-        async run(message, responseCtx, platform) {
+        async run(message, responder, platform) {
             const prepared = await prepareRunContext({
                 message,
-                responseCtx,
+                responder,
                 platform,
                 conversationId,
                 conversationDir,
@@ -1063,7 +1094,6 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                 setEventContext,
                 setSandboxContext,
                 setUploadFunction,
-                setBlockKitResponseFunction,
                 pathContext,
             });
             pathContext = prepared.pathContext;
@@ -1084,6 +1114,11 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                 attachment_count: message.attachments?.length ?? 0,
                 image_attachment_count: prepared.imageAttachments.length,
             });
+            sendAgentEvent({
+                sessionId: sessionUuid,
+                actorName: formatAgentActorName(message.userName, prepared.sessionConversation),
+                event: { kind: "sessionStart" },
+            });
             await session.prompt(prepared.userMessage, prepared.imageAttachments.length > 0 ? { images: prepared.imageAttachments } : undefined);
             // Wait for queued messages
             await prepared.runQueue.wait();
@@ -1095,7 +1130,7 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                     return `${sessionViewPortalBaseUrl}/session?token=${token.token}`;
                 }
                 : undefined;
-            await finalizeRunResponse(responseCtx, session, runState, {
+            await finalizeRunResponse(responder, session, runState, {
                 triggerAttribution: prepared.triggerAttribution,
                 createOverflowLink,
                 platform: platform.name,
@@ -1106,7 +1141,7 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
             await reportUsageSummary({
                 session,
                 runState,
-                responseCtx,
+                responder,
                 platform,
                 model,
                 agentConfig,
@@ -1115,7 +1150,7 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
                 waitForQueue: () => prepared.runQueue.wait(),
             });
             // Clear run state
-            runState.responseCtx = null;
+            runState.responder = null;
             runState.logCtx = null;
             runState.queue = null;
             return { stopReason: runState.stopReason, errorMessage: runState.errorMessage };