@geminixiang/mama 0.1.9 → 0.2.0-beta.0

package/dist/agent.js

@@ -1,7 +1,7 @@
 import { Agent } from "@mariozechner/pi-agent-core";
 import { getModel } from "@mariozechner/pi-ai";
-import { AgentSession, AuthStorage, convertToLlm, createExtensionRuntime, formatSkillsForPrompt, loadSkillsFromDir, ModelRegistry, SessionManager, } from "@mariozechner/pi-coding-agent";
-import { existsSync, mkdirSync, readFileSync } from "fs";
+import { AgentSession, AuthStorage, convertToLlm, DefaultResourceLoader, formatSkillsForPrompt, loadSkillsFromDir, ModelRegistry, } from "@mariozechner/pi-coding-agent";
+import { existsSync, readFileSync } from "fs";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
 import { join } from "path";
@@ -9,7 +9,10 @@ import { loadAgentConfig } from "./config.js";
 import { createMamaSettingsManager, syncLogToSessionManager } from "./context.js";
 import * as log from "./log.js";
 import { createExecutor } from "./sandbox.js";
+import { addLifecycleBreadcrumb, metricAttributes } from "./sentry.js";
+import { createManagedSessionFileAtPath, extractSessionSuffix, extractSessionUuid, forkThreadSessionFile, getSessionDir, getThreadSessionFile, openManagedSession, resolveChannelSessionFile, resolveManagedSessionFile, tryResolveThreadSession, } from "./session-store.js";
 import { createMamaTools } from "./tools/index.js";
+import * as Sentry from "@sentry/node";
 const IMAGE_MIME_TYPES = {
     jpg: "image/jpeg",
     jpeg: "image/jpeg",
@@ -86,6 +89,7 @@ function loadMamaSkills(channelDir, workspacePath) {
 function buildSystemPrompt(workspacePath, channelId, memory, sandboxConfig, platform, skills) {
     const channelPath = `${workspacePath}/${channelId}`;
     const isDocker = sandboxConfig.type === "docker";
+    const isFirecracker = sandboxConfig.type === "firecracker";
     // Format channel mappings
     const channelMappings = platform.channels.length > 0
         ? platform.channels.map((c) => `${c.id}\t#${c.name}`).join("\n")
@@ -99,7 +103,12 @@ function buildSystemPrompt(workspacePath, channelId, memory, sandboxConfig, plat
 - Bash working directory: / (use cd or absolute paths)
 - Install tools with: apk add <package>
 - Your changes persist across sessions`
-        : `You are running directly on the host machine.
+        : isFirecracker
+            ? `You are running inside a Firecracker microVM.
+- Bash working directory: / (use cd or absolute paths)
+- Install tools with: apt-get install <package> (Debian-based)
+- Your changes persist across sessions`
+            : `You are running directly on the host machine.
 - Bash working directory: ${process.cwd()}
 - Be careful with system modifications`;
     return `You are mama, a ${platform.name} bot assistant. Be concise. No emojis.
@@ -108,6 +117,7 @@ function buildSystemPrompt(workspacePath, channelId, memory, sandboxConfig, plat
 - For current date/time, use: date
 - You have access to previous conversation context including tool results from prior turns.
 - For older history beyond your context, search log.jsonl (contains user messages and your final responses, but not tool results).
+- User messages include a \`[in-thread:TS]\` marker when sent from within a Slack thread (TS is the root message timestamp). Without this marker, the message is a top-level channel message.
 
 ${platform.formattingGuide}
 
@@ -163,17 +173,17 @@ You can schedule events that wake you up at specific times or when external thin
 
 **Immediate** - Triggers as soon as harness sees the file. Use in scripts/webhooks to signal external events.
 \`\`\`json
-{"type": "immediate", "channelId": "${channelId}", "text": "New GitHub issue opened"}
+{"type": "immediate", "platform": "${platform.name}", "channelId": "${channelId}", "text": "New GitHub issue opened"}
 \`\`\`
 
 **One-shot** - Triggers once at a specific time. Use for reminders.
 \`\`\`json
-{"type": "one-shot", "channelId": "${channelId}", "text": "Remind Mario about dentist", "at": "2025-12-15T09:00:00+01:00"}
+{"type": "one-shot", "platform": "${platform.name}", "channelId": "${channelId}", "text": "Remind Mario about dentist", "at": "2025-12-15T09:00:00+01:00"}
 \`\`\`
 
 **Periodic** - Triggers on a cron schedule. Use for recurring tasks.
 \`\`\`json
-{"type": "periodic", "channelId": "${channelId}", "text": "Check inbox and summarize", "schedule": "0 9 * * 1-5", "timezone": "${Intl.DateTimeFormat().resolvedOptions().timeZone}"}
+{"type": "periodic", "platform": "${platform.name}", "channelId": "${channelId}", "text": "Check inbox and summarize", "schedule": "0 9 * * 1-5", "timezone": "${Intl.DateTimeFormat().resolvedOptions().timeZone}"}
 \`\`\`
 
 ### Cron Format
@@ -186,11 +196,14 @@ You can schedule events that wake you up at specific times or when external thin
 ### Timezones
 All \`at\` timestamps must include offset (e.g., \`+01:00\`). Periodic events use IANA timezone names. The harness runs in ${Intl.DateTimeFormat().resolvedOptions().timeZone}. When users mention times without timezone, assume ${Intl.DateTimeFormat().resolvedOptions().timeZone}.
 
+### Platform Routing
+Set \`platform\` to the target bot platform (\`${platform.name}\` for this conversation). When only one platform is running, omitting \`platform\` is allowed for backward compatibility, but include it by default to avoid ambiguity.
+
 ### Creating Events
 Use unique filenames to avoid overwriting existing events. Include a timestamp or random suffix:
 \`\`\`bash
 cat > ${workspacePath}/events/dentist-reminder-$(date +%s).json << 'EOF'
-{"type": "one-shot", "channelId": "${channelId}", "text": "Dentist tomorrow", "at": "2025-12-14T09:00:00+01:00"}
+{"type": "one-shot", "platform": "${platform.name}", "channelId": "${channelId}", "text": "Dentist tomorrow", "at": "2025-12-14T09:00:00+01:00"}
 EOF
 \`\`\`
 Or check if file exists first before creating.
@@ -238,6 +251,7 @@ Update this file whenever you modify the environment. On fresh container, read i
 Format: \`{"date":"...","ts":"...","user":"...","userName":"...","text":"...","isBot":false}\`
 The log contains user messages and your final responses (not tool calls/results).
 ${isDocker ? "Install jq: apk add jq" : ""}
+${isFirecracker ? "Install jq: apt-get install jq" : ""}
 
 \`\`\`bash
 # Recent messages
@@ -350,12 +364,45 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
     };
     const systemPrompt = buildSystemPrompt(workspacePath, channelId, memory, sandboxConfig, emptyPlatform, skills);
     // Create session manager and settings manager
-    // Per-session context file: {channelDir}/sessions/{rootTs}/context.jsonl
-    const rootTs = sessionKey.includes(":") ? sessionKey.split(":").pop() : sessionKey;
-    const sessionDir = join(channelDir, "sessions", rootTs);
-    mkdirSync(sessionDir, { recursive: true });
-    const contextFile = join(sessionDir, "context.jsonl");
-    const sessionManager = SessionManager.open(contextFile, channelDir);
+    // Channel sessions use {channelDir}/sessions/current.
+    // Thread sessions use fixed files: {channelDir}/sessions/{threadTs}.jsonl
+    const sessionDir = getSessionDir(channelDir, sessionKey);
+    const isThread = sessionKey.includes(":");
+    let sessionManager;
+    let contextFile;
+    if (isThread) {
+        const threadFile = getThreadSessionFile(channelDir, sessionKey);
+        const existing = tryResolveThreadSession(threadFile);
+        if (existing) {
+            contextFile = existing;
+            sessionManager = openManagedSession(contextFile, sessionDir, channelDir);
+        }
+        else {
+            const channelSource = resolveChannelSessionFile(channelDir);
+            if (channelSource) {
+                try {
+                    contextFile = forkThreadSessionFile(channelSource, threadFile, channelDir);
+                    sessionManager = openManagedSession(contextFile, sessionDir, channelDir);
+                }
+                catch {
+                    contextFile = createManagedSessionFileAtPath(threadFile, channelDir);
+                    sessionManager = openManagedSession(contextFile, sessionDir, channelDir);
+                }
+            }
+            else {
+                contextFile = createManagedSessionFileAtPath(threadFile, channelDir);
+                sessionManager = openManagedSession(contextFile, sessionDir, channelDir);
+            }
+        }
+    }
+    else {
+        // Channel/DM session: normal resolve
+        contextFile = resolveManagedSessionFile(sessionDir, channelDir);
+        sessionManager = openManagedSession(contextFile, sessionDir, channelDir);
+    }
+    const sessionUuid = extractSessionUuid(contextFile);
+    // Used for Slack thread filtering — for non-Slack platforms this is effectively a no-op
+    const rootTs = extractSessionSuffix(sessionKey);
     const settingsManager = createMamaSettingsManager(join(channelDir, ".."));
     // Create AuthStorage and ModelRegistry
     // Auth stored outside workspace so agent can't access it
@@ -371,7 +418,7 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
         },
         convertToLlm,
         getApiKey: async () => {
-            const key = await modelRegistry.getApiKey(model);
+            const key = await modelRegistry.getApiKeyForProvider(model.provider);
             if (!key)
                 throw new Error(`No API key for provider "${model.provider}". Set the appropriate environment variable or configure via auth.json`);
             return key;
@@ -383,25 +430,33 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
         agent.replaceMessages(loadedSession.messages);
         log.logInfo(`[${channelId}] Loaded ${loadedSession.messages.length} messages from context.jsonl`);
     }
-    const resourceLoader = {
-        getExtensions: () => ({ extensions: [], errors: [], runtime: createExtensionRuntime() }),
-        getSkills: () => ({ skills: [], diagnostics: [] }),
-        getPrompts: () => ({ prompts: [], diagnostics: [] }),
-        getThemes: () => ({ themes: [], diagnostics: [] }),
-        getAgentsFiles: () => ({ agentsFiles: [] }),
-        getSystemPrompt: () => systemPrompt,
-        getAppendSystemPrompt: () => [],
-        getPathMetadata: () => new Map(),
-        extendResources: () => { },
-        reload: async () => { },
-    };
+    // Load extensions, skills, prompts, themes via DefaultResourceLoader
+    // This reads ~/.pi/agent/settings.json (packages, extensions enable/disable)
+    // and discovers resources from standard locations + npm/git packages.
+    const resourceLoader = new DefaultResourceLoader({
+        cwd: workspaceDir,
+        systemPrompt,
+    });
+    try {
+        await resourceLoader.reload();
+        const extResult = resourceLoader.getExtensions();
+        if (extResult.errors.length > 0) {
+            for (const err of extResult.errors) {
+                log.logWarning(`[${channelId}] Extension load error: ${err.path}`, err.error);
+            }
+        }
+        log.logInfo(`[${channelId}] Loaded ${extResult.extensions.length} extension(s): ${extResult.extensions.map((e) => e.path).join(", ")}`);
+    }
+    catch (error) {
+        log.logWarning(`[${channelId}] Failed to load resources`, String(error));
+    }
     const baseToolsOverride = Object.fromEntries(tools.map((tool) => [tool.name, tool]));
     // Create AgentSession wrapper
     const session = new AgentSession({
         agent,
         sessionManager,
         settingsManager,
-        cwd: process.cwd(),
+        cwd: workspaceDir,
         modelRegistry,
         resourceLoader,
         baseToolsOverride,
@@ -419,6 +474,7 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
             cacheWrite: 0,
             cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
         },
+        llmCallCount: 0,
         stopReason: "stop",
         errorMessage: undefined,
     };
@@ -428,6 +484,7 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
         if (!runState.responseCtx || !runState.logCtx || !runState.queue)
             return;
         const { responseCtx, logCtx, queue, pendingTools } = runState;
+        const baseAttrs = { channel_id: logCtx.channelId, session_id: logCtx.sessionId };
         if (event.type === "tool_execution_start") {
             const agentEvent = event;
             const args = agentEvent.args;
@@ -437,12 +494,13 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
                 args: agentEvent.args,
                 startTime: Date.now(),
             });
+            addLifecycleBreadcrumb("agent.tool.started", {
+                tool: agentEvent.toolName,
+                ...baseAttrs,
+            });
             log.logToolStart(logCtx, agentEvent.toolName, label, agentEvent.args);
-            // Split long tool labels to avoid msg_too_long error
-            const labelParts = splitForSlack(`_→ ${label}_`);
-            for (const part of labelParts) {
-                queue.enqueue(() => responseCtx.respond(part), "tool label");
-            }
+            // Tool labels are omitted from the main message to reduce Slack noise.
+            // Tool execution details are still posted to the thread (see tool_execution_end).
         }
         else if (event.type === "tool_execution_end") {
             const agentEvent = event;
@@ -450,6 +508,26 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
             const pending = pendingTools.get(agentEvent.toolCallId);
             pendingTools.delete(agentEvent.toolCallId);
             const durationMs = pending ? Date.now() - pending.startTime : 0;
+            Sentry.metrics.count("agent.tool.calls", 1, {
+                attributes: metricAttributes({
+                    tool: agentEvent.toolName,
+                    error: String(agentEvent.isError),
+                    ...baseAttrs,
+                }),
+            });
+            Sentry.metrics.distribution("agent.tool.duration", durationMs, {
+                unit: "millisecond",
+                attributes: metricAttributes({
+                    tool: agentEvent.toolName,
+                    ...baseAttrs,
+                }),
+            });
+            addLifecycleBreadcrumb("agent.tool.completed", {
+                tool: agentEvent.toolName,
+                error: agentEvent.isError,
+                duration_ms: durationMs,
+                ...baseAttrs,
+            });
             if (agentEvent.isError) {
                 log.logToolError(logCtx, agentEvent.toolName, durationMs, resultStr);
             }
@@ -469,7 +547,12 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
             if (argsFormatted)
                 threadMessage += `\`\`\`\n${argsFormatted}\n\`\`\`\n`;
             threadMessage += `*Result:*\n\`\`\`\n${resultStr}\n\`\`\``;
-            queue.enqueueMessage(threadMessage, "thread", "tool result thread", false);
+            // Only post thread details for tools with meaningful output (bash, attach).
+            // Skip read/write/edit to reduce Slack noise — their results are in the log.
+            const quietTools = new Set(["read", "write", "edit"]);
+            if (!quietTools.has(agentEvent.toolName)) {
+                queue.enqueueMessage(threadMessage, "thread", "tool result thread", false);
+            }
             if (agentEvent.isError) {
                 queue.enqueue(() => responseCtx.respond(`_Error: ${truncate(resultStr, 200)}_`), "tool error");
             }
@@ -477,6 +560,13 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
         else if (event.type === "message_start") {
             const agentEvent = event;
             if (agentEvent.message.role === "assistant") {
+                runState.llmCallCount += 1;
+                addLifecycleBreadcrumb("agent.llm.call.started", {
+                    call_index: runState.llmCallCount,
+                    provider: model.provider,
+                    model: agentConfig.model,
+                    ...baseAttrs,
+                });
                 log.logResponseStart(logCtx);
             }
         }
@@ -500,6 +590,44 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
                     runState.totalUsage.cost.cacheRead += assistantMsg.usage.cost.cacheRead;
                     runState.totalUsage.cost.cacheWrite += assistantMsg.usage.cost.cacheWrite;
                     runState.totalUsage.cost.total += assistantMsg.usage.cost.total;
+                    // Per-turn LLM metrics
+                    const llmAttributes = metricAttributes({
+                        provider: model.provider,
+                        model: agentConfig.model,
+                        ...baseAttrs,
+                        stop_reason: assistantMsg.stopReason,
+                        error: Boolean(assistantMsg.errorMessage),
+                    });
+                    Sentry.metrics.count("agent.llm.calls", 1, { attributes: llmAttributes });
+                    Sentry.metrics.distribution("agent.llm.tokens_in", assistantMsg.usage.input, {
+                        attributes: llmAttributes,
+                    });
+                    Sentry.metrics.distribution("agent.llm.tokens_out", assistantMsg.usage.output, {
+                        attributes: llmAttributes,
+                    });
+                    if (assistantMsg.usage.cacheRead > 0) {
+                        Sentry.metrics.distribution("agent.llm.cache_read", assistantMsg.usage.cacheRead, {
+                            attributes: llmAttributes,
+                        });
+                    }
+                    if (assistantMsg.usage.cacheWrite > 0) {
+                        Sentry.metrics.distribution("agent.llm.cache_write", assistantMsg.usage.cacheWrite, {
+                            attributes: llmAttributes,
+                        });
+                    }
+                    Sentry.metrics.distribution("agent.llm.cost_per_turn", assistantMsg.usage.cost.total, {
+                        attributes: llmAttributes,
+                    });
+                    addLifecycleBreadcrumb("agent.llm.call.completed", {
+                        call_index: runState.llmCallCount,
+                        provider: model.provider,
+                        model: agentConfig.model,
+                        stop_reason: assistantMsg.stopReason,
+                        error: Boolean(assistantMsg.errorMessage),
+                        input_tokens: assistantMsg.usage.input,
+                        output_tokens: assistantMsg.usage.output,
+                        cost_total_usd: assistantMsg.usage.cost.total,
+                    });
                 }
                 const content = agentEvent.message.content;
                 const thinkingParts = [];
@@ -521,15 +649,18 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
                 if (text.trim()) {
                     log.logResponse(logCtx, text);
                     queue.enqueueMessage(text, "main", "response main");
-                    queue.enqueueMessage(text, "thread", "response thread", false);
+                    // Only overflow to thread for texts that will be truncated in main
+                    if (text.length > SLACK_MAX_LENGTH) {
+                        queue.enqueueMessage(text, "thread", "response thread", false);
+                    }
                 }
             }
         }
-        else if (event.type === "auto_compaction_start") {
+        else if (event.type === "compaction_start") {
             log.logInfo(`Auto-compaction started (reason: ${event.reason})`);
             queue.enqueue(() => responseCtx.respond("_Compacting context..._"), "compaction start");
         }
-        else if (event.type === "auto_compaction_end") {
+        else if (event.type === "compaction_end") {
             const compEvent = event;
             if (compEvent.result) {
                 log.logInfo(`Auto-compaction complete: ${compEvent.result.tokensBefore} tokens compacted`);
@@ -570,7 +701,11 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
             // Sync messages from log.jsonl that arrived while we were offline or busy
             // Exclude the current message (it will be added via prompt())
             // Default sync range is 10 days (handled by syncLogToSessionManager)
-            const syncedCount = await syncLogToSessionManager(sessionManager, channelDir, message.id);
+            // Thread filter ensures only messages from this session's thread are synced
+            const threadFilter = message.sessionKey.includes(":")
+                ? { scope: "thread", rootTs, threadTs: message.threadTs }
+                : { scope: "top-level", rootTs };
+            const syncedCount = await syncLogToSessionManager(sessionManager, channelDir, message.id, undefined, threadFilter);
             if (syncedCount > 0) {
                 log.logInfo(`[${channelId}] Synced ${syncedCount} messages from log.jsonl`);
             }
@@ -597,6 +732,7 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
                 channelId: sessionChannel,
                 userName: message.userName,
                 channelName: undefined,
+                sessionId: sessionUuid,
             };
             runState.pendingTools.clear();
             runState.totalUsage = {
@@ -606,6 +742,7 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
                 cacheWrite: 0,
                 cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
             };
+            runState.llmCallCount = 0;
             runState.stopReason = "stop";
             runState.errorMessage = undefined;
             // Create queue for this run
@@ -651,7 +788,8 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
             const offsetHours = pad(Math.floor(Math.abs(offset) / 60));
             const offsetMins = pad(Math.abs(offset) % 60);
             const timestamp = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}${offsetSign}${offsetHours}:${offsetMins}`;
-            let userMessage = `[${timestamp}] [${message.userName || "unknown"}]: ${message.text}`;
+            const threadContext = message.threadTs ? ` [in-thread:${message.threadTs}]` : "";
+            let userMessage = `[${timestamp}] [${message.userName || "unknown"}]${threadContext}: ${message.text}`;
             const imageAttachments = [];
             const nonImagePaths = [];
             for (const a of message.attachments || []) {
@@ -685,6 +823,14 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
                 imageAttachmentCount: imageAttachments.length,
             };
             await writeFile(join(channelDir, "last_prompt.jsonl"), JSON.stringify(debugContext, null, 2));
+            addLifecycleBreadcrumb("agent.prompt.sent", {
+                provider: model.provider,
+                model: agentConfig.model,
+                channel_id: sessionChannel,
+                session_id: sessionUuid,
+                attachment_count: message.attachments?.length ?? 0,
+                image_attachment_count: imageAttachments.length,
+            });
             await session.prompt(userMessage, imageAttachments.length > 0 ? { images: imageAttachments } : undefined);
             // Wait for queued messages
             await queueChain;
@@ -750,11 +896,40 @@ export async function createRunner(sandboxConfig, sessionKey, channelId, channel
                         lastAssistantMessage.usage.cacheWrite
                     : 0;
                 const contextWindow = model.contextWindow || 200000;
+                // Run-level Sentry metrics
+                const { totalUsage } = runState;
+                const runMetricAttributes = metricAttributes({
+                    provider: model.provider,
+                    model: agentConfig.model,
+                    channel_id: sessionChannel,
+                    session_id: sessionUuid,
+                    stop_reason: runState.stopReason,
+                    llm_calls: runState.llmCallCount,
+                });
+                Sentry.metrics.distribution("agent.run.tokens_in", totalUsage.input, {
+                    attributes: runMetricAttributes,
+                });
+                Sentry.metrics.distribution("agent.run.tokens_out", totalUsage.output, {
+                    attributes: runMetricAttributes,
+                });
+                Sentry.metrics.distribution("agent.run.cache_read", totalUsage.cacheRead, {
+                    attributes: runMetricAttributes,
+                });
+                Sentry.metrics.distribution("agent.run.cache_write", totalUsage.cacheWrite, {
+                    attributes: runMetricAttributes,
+                });
+                Sentry.metrics.distribution("agent.run.cost", totalUsage.cost.total, {
+                    attributes: runMetricAttributes,
+                });
+                Sentry.metrics.gauge("agent.context.utilization", contextTokens / contextWindow, {
+                    unit: "ratio",
+                    attributes: runMetricAttributes,
+                });
                 const summary = log.logUsageSummary(runState.logCtx, runState.totalUsage, contextTokens, contextWindow);
                 // Split long summaries to avoid msg_too_long
                 const summaryParts = splitForSlack(summary);
                 for (const part of summaryParts) {
-                    runState.queue.enqueue(() => responseCtx.respondInThread(part), "usage summary");
+                    runState.queue.enqueue(() => responseCtx.respondInThread(part, { style: "muted" }), "usage summary");
                 }
                 await queueChain;
             }