@geminixiang/mikan 1.0.0-beta.13 → 1.0.0-beta.15

package/dist/agent.js

@@ -2,10 +2,10 @@
  * Agent runner: prompt construction, path translation, run lifecycle, and createRunner.
  * Single module — do not split helpers that only this file uses.
  */
-import { DEFAULT_EVENT_BUDGET, defaultExtensionDirs, formatSkillsForPrompt, loadExtensions, loadSkillsFromDir, MikanAgentSession, MikanModels, } from "./harness/index.js";
+import { DEFAULT_EVENT_BUDGET, defaultExtensionDirs, formatSkillsForPrompt, loadExtensions, loadSkillsFromDir, MikanAgentSession, MikanModels, parseCommandInput, } from "./harness/index.js";
 import { createHash } from "crypto";
 import { existsSync, readFileSync } from "fs";
-import { mkdir, readFile, writeFile } from "fs/promises";
+import { mkdir, readFile } from "fs/promises";
 import { join, posix } from "path";
 import { resolveConversationSettings } from "./config.js";
 import { readEnv } from "./utils/env.js";
@@ -15,11 +15,12 @@ import { createExecutor, } from "./sandbox/index.js";
 import { createMountedRuntimePathContext } from "./sandbox/path-context.js";
 import { addLifecycleBreadcrumb, metricAttributes, reportUserFacingError, updateActiveSpanAttribution, } from "./observability/sentry.js";
 import { AgentMemoryFileManager } from "./sessions/agent-memory-file-manager.js";
+import { formatHistoryLine } from "./sessions/history-line.js";
+import { conversationIdOf, isThreadSessionKey } from "./sessions/session-key.js";
 import { extractSessionUuid, openManagedSession, } from "./sessions/store.js";
 import { HostEventStore } from "./tools/event.js";
 import { createMikanTools } from "./tools/index.js";
 import * as Sentry from "@sentry/node";
-import { formatLocalTimestamp } from "./utils/date.js";
 import { emitAgentEvent } from "./agent-events.js";
 export function getUnresolvedSandboxPathContext(sandboxConfig, hostWorkspaceRoot) {
     if (sandboxConfig.type === "image") {
@@ -47,9 +48,12 @@ function getImageMimeType(filename) {
     return IMAGE_MIME_TYPES[filename.toLowerCase().split(".").pop() || ""];
 }
 function formatTimestampedUserMessage(message) {
-    const timestamp = formatLocalTimestamp(new Date());
-    const threadContext = message.threadTs ? ` [in-thread:${message.threadTs}]` : "";
-    return `[${timestamp}] [${message.userName || "unknown"}]${threadContext}: ${message.text}`;
+    return formatHistoryLine({
+        date: new Date(),
+        userName: message.userName,
+        threadTs: message.threadTs,
+        text: message.text,
+    });
 }
 function collectMessageAttachments(message, workspacePath, pathContext) {
     const imageAttachments = [];
@@ -84,15 +88,6 @@ export function buildPromptPayload(message, workspacePath, pathContext) {
     }
     return { userMessage, imageAttachments };
 }
-async function writePromptDebugContext(conversationDir, systemPrompt, session, userMessage, imageAttachmentCount) {
-    const debugContext = {
-        systemPrompt,
-        messages: session.messages,
-        newUserMessage: userMessage,
-        imageAttachmentCount,
-    };
-    await writeFile(join(conversationDir, "last_prompt.jsonl"), JSON.stringify(debugContext, null, 2));
-}
 async function getMemory(conversationDir) {
     const parts = [];
     // Read workspace-level memory (shared across all conversations)
@@ -684,6 +679,12 @@ function createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner,
         exec(command, options) {
             return activeExecutor.exec(command, options);
         },
+        readFile(path, options) {
+            return activeExecutor.readFile(path, options);
+        },
+        writeFile(path, content, options) {
+            return activeExecutor.writeFile(path, content, options);
+        },
         getWorkspacePath(hostPath) {
             return activeExecutor.getWorkspacePath(hostPath);
         },
@@ -712,7 +713,7 @@ function createRunnerExecutionContext(sandboxConfig, vaultManager, provisioner,
  * notify posts through the platform bots when main.ts provides a notifier.
  */
 function buildExtensionHostServices(params) {
-    const { workspaceDir, vaultManager, platformNotifier, platformReactor } = params;
+    const { workspaceDir, vaultManager, platformNotifier, platformReactor, platformUploader } = params;
     const eventStore = HostEventStore.fromWorkspaceDir(workspaceDir);
     return {
         stateDir: readEnv("STATE_DIR"),
@@ -723,13 +724,16 @@ function buildExtensionHostServices(params) {
                 await eventStore.write(filename, payload);
             },
             delete: async (filename) => (await eventStore.delete(filename)).deleted,
-            list: async () => (await eventStore.list()).map((entry) => ({
+            list: async () => (await eventStore.list())
+                .filter((entry) => entry.payload !== null)
+                .map((entry) => ({
                 filename: entry.filename,
                 payload: entry.payload,
             })),
         },
         ...(platformNotifier ? { postMessage: platformNotifier } : {}),
         ...(platformReactor ? { addReaction: platformReactor } : {}),
+        ...(platformUploader ? { uploadFile: platformUploader } : {}),
         ...(vaultManager
             ? {
                 resolveSecrets: (slug) => vaultManager.resolve(`extensions/${slug}`)?.env ?? {},
@@ -738,7 +742,7 @@ function buildExtensionHostServices(params) {
     };
 }
 async function createConfiguredAgentSession(params) {
-    const { conversationId, workspaceDir, systemPrompt, model, thinkingLevel, tools, sessionStore, models, vaultManager, platformNotifier, platformReactor, } = params;
+    const { conversationId, workspaceDir, systemPrompt, model, thinkingLevel, tools, sessionStore, models, vaultManager, platformNotifier, platformReactor, platformUploader, } = params;
     // Host-only dirs under the state dir: extension code runs in the mikan
     // process, so it must never load from workspace paths — those are mounted
     // into sandbox containers and agent-writable (sandbox escape otherwise).
@@ -750,6 +754,7 @@ async function createConfiguredAgentSession(params) {
             vaultManager,
             platformNotifier,
             platformReactor,
+            platformUploader,
         }),
     });
     for (const err of extensionsResult.errors) {
@@ -771,7 +776,12 @@ async function createConfiguredAgentSession(params) {
     if (reloaded > 0) {
         log.logInfo(`[${conversationId}] Reloaded ${reloaded} messages from session context`);
     }
-    return { session, extensionSkills: extensionsResult.skills };
+    return {
+        session,
+        extensionSkills: extensionsResult.skills,
+        extensionRegistry: extensionsResult.registry,
+        disposeExtensions: extensionsResult.dispose,
+    };
 }
 function reloadSessionMessages(session, conversationId) {
     const reloaded = session.reloadFromSession();
@@ -782,7 +792,7 @@ function reloadSessionMessages(session, conversationId) {
 async function prepareRunContext(params) {
     const { message, responder, platform, conversationId, conversationDir, sessionUuid, runState, executor, executionResolver, resolveExecutorForRun, getPathContext, session, setEventContext, setSandboxContext, setUploadFunction, setReactFunction, bindPlatformToolPacks, } = params;
     let pathContext = params.pathContext;
-    const sessionConversation = message.sessionKey.split(":")[0];
+    const sessionConversation = conversationIdOf(message.sessionKey);
     await mkdir(join(conversationDir, "scratch"), { recursive: true });
     if (executionResolver) {
         await resolveExecutorForRun({
@@ -834,7 +844,6 @@ async function prepareRunContext(params) {
     const { userMessage, imageAttachments } = buildPromptPayload(message, pathContext.runtimeWorkspaceRoot, pathContext);
     const turnInstructions = buildTurnInstructions(message.id.startsWith("event:"), triggerAttribution, platform.name);
     const finalUserMessage = turnInstructions ? `${turnInstructions}\n\n${userMessage}` : userMessage;
-    await writePromptDebugContext(conversationDir, systemPrompt, session, finalUserMessage, imageAttachments.length);
     return {
         sessionConversation,
         runQueue,
@@ -1120,18 +1129,22 @@ function attachSessionEventHandlers(params) {
  * Runner caching is handled by the caller (channelStates in main.ts).
  * This is a stateless factory function.
  */
-export async function createRunner(sandboxConfig, sessionKey, conversationId, conversationDir, workspaceDir, sessionScope, vaultManager, provisioner, sessionView, platformNotifier, platformReactor, platformToolPackFactories) {
+export async function createRunner(options) {
+    const { sandboxConfig, sessionKey, conversationId, conversationDir, workspaceDir, sessionScope, vaultManager, provisioner, sessionView, platformNotifier, platformReactor, platformUploader, platformToolPackFactories, } = options;
     const agentConfig = resolveConversationSettings(conversationDir);
     const workspaceBase = join(conversationDir, "..");
     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, setReactFunction, bindPlatformToolPacks, setEventContext, setSandboxContext, } = createMikanTools(executor, workspaceDir, { sandbox: sandboxConfig, provisioner }, platformToolPackFactories ?? []);
-    const modelRegistry = MikanModels.create();
+    const modelRegistry = options.models ?? MikanModels.create();
     if (modelRegistry.getError()) {
         log.logWarning("models.json load error", modelRegistry.getError());
     }
     const model = modelRegistry.resolve(agentConfig.provider, agentConfig.model);
+    // Create tools (per-runner, with per-runner upload function setter)
+    const { tools, setUploadFunction, setReactFunction, bindPlatformToolPacks, setEventContext, setSandboxContext, } = createMikanTools(executor, workspaceDir, { sandbox: sandboxConfig, provisioner }, platformToolPackFactories ?? [], {
+        model,
+        getApiKey: () => modelRegistry.getApiKeyForProvider(model.provider),
+    });
     // Initial system prompt (will be updated each run with fresh memory/channels/users/skills)
     const memory = await getMemory(conversationDir);
     const skills = loadMikanSkills(conversationDir, pathContext.runtimeWorkspaceRoot);
@@ -1146,7 +1159,7 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
     // Create session manager and settings manager. Top-level/private sessions
     // use the conversation's current pointer; scoped sessions use fixed files.
     // Platform-specific scope behavior is resolved before runner creation.
-    const isThread = sessionKey.includes(":");
+    const isThread = isThreadSessionKey(sessionKey);
     const { contextFile, threadRootMessage } = sessionScope;
     const sessionManager = openManagedSession(contextFile, pathContext.runtimeWorkspaceRoot);
     const threadSessionName = buildThreadSessionName(threadRootMessage);
@@ -1155,7 +1168,7 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
     }
     const sessionUuid = extractSessionUuid(contextFile);
     const chatSessionManager = new AgentMemoryFileManager();
-    const { session, extensionSkills } = await createConfiguredAgentSession({
+    const { session, extensionSkills, extensionRegistry, disposeExtensions } = await createConfiguredAgentSession({
         conversationId,
         workspaceDir,
         systemPrompt,
@@ -1167,6 +1180,7 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
         vaultManager,
         platformNotifier,
         platformReactor,
+        platformUploader,
     });
     // Mutable per-run state - event handler references this
     const runState = createRunState();
@@ -1228,10 +1242,39 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
             // Autonomous (event/trigger) runs get an explicit resource ceiling since
             // no human is watching the loop; interactive turns stay human-gated.
             const isEventRun = message.id.startsWith("event:");
-            await session.prompt(prepared.userMessage, {
+            // Event runs have no triggering platform message, so identity fields
+            // stay unset and extensions must null-check them.
+            const origin = isEventRun
+                ? { kind: "event", platform: platform.name }
+                : {
+                    kind: "interactive",
+                    platform: platform.name,
+                    messageTs: message.id,
+                    userId: message.userId,
+                    userName: message.userName,
+                    threadTs: message.threadTs,
+                    attachments: message.attachments,
+                };
+            const outcome = await session.prompt(prepared.userMessage, {
+                origin,
                 ...(prepared.imageAttachments.length > 0 ? { images: prepared.imageAttachments } : {}),
                 ...(isEventRun ? { budget: DEFAULT_EVENT_BUDGET } : {}),
             });
+            if (outcome?.blocked) {
+                const text = outcome.reason
+                    ? `_Turn blocked by an extension: ${outcome.reason}_`
+                    : "_Turn blocked by an extension._";
+                sendAgentEvent({
+                    sessionId: sessionUuid,
+                    actorName: formatAgentActorName(message.userName, prepared.sessionConversation),
+                    event: { kind: "diagnostic", text },
+                });
+                await responder.respondDiagnostic(text, { style: "muted" });
+                runState.responder = null;
+                runState.logCtx = null;
+                runState.queue = null;
+                return { stopReason: "blocked" };
+            }
             // Wait for queued messages
             await prepared.runQueue.wait();
             const sessionViewTokenStore = sessionView?.tokenStore;
@@ -1277,6 +1320,21 @@ export async function createRunner(sandboxConfig, sessionKey, conversationId, co
         abort() {
             session.abort();
         },
+        async tryExtensionCommand(message, responder) {
+            const parsed = parseCommandInput(message.text);
+            if (!parsed)
+                return false;
+            return extensionRegistry.dispatchCommand(parsed.name, {
+                args: parsed.args,
+                conversationId,
+                userId: message.userId,
+                userName: message.userName,
+                respond: (text) => responder.respond(text),
+            });
+        },
+        async dispose() {
+            await disposeExtensions();
+        },
         getCurrentStep() {
             const pending = runState.pendingTools;
             if (pending.size === 0)