happy2 0.0.12 → 0.0.13

package/packages/happy2-server/dist/modules/agents/service.js

@@ -11,6 +11,7 @@ import { agentTurnGetRunning } from "../agent/agentTurnGetRunning.js";
 import { agentTurnFail } from "../agent/agentTurnFail.js";
 import { agentTurnComplete } from "../agent/agentTurnComplete.js";
 import { agentTurnCheckpoint } from "../agent/agentTurnCheckpoint.js";
+import { agentTurnTraceStart } from "../agent/agentTurnTraceStart.js";
 import { agentSecretRecordRegistration } from "../agent/agentSecretRecordRegistration.js";
 import { agentSecretDetachFromChannel } from "../agent/agentSecretDetachFromChannel.js";
 import { agentSecretDetachFromAgent } from "../agent/agentSecretDetachFromAgent.js";
@@ -55,6 +56,7 @@ import { CollaborationError, } from "../chat/types.js";
 import { realtimeTopics } from "../realtime/index.js";
 import { isRetryableRigError, RigDaemonClient, } from "./daemon.js";
 import { BUILTIN_AGENT_IMAGES } from "./builtin-images.js";
+import { agentChatGetIdBySession } from "../agent/agentChatGetIdBySession.js";
 import { pluginFunctionResultAcquire } from "../plugin/pluginFunctionResultAcquire.js";
 import { pluginFunctionResultComplete } from "../plugin/pluginFunctionResultComplete.js";
 import { setupBaseImageCompleteBuild, setupBaseImageFailBuild, setupBaseImageGetStatus, setupBaseImageRetryBuild, setupBaseImageSelect, } from "../setup/index.js";
@@ -75,6 +77,13 @@ const MAX_BUILD_LOG_LINE_CHARACTERS = 1_000;
 const MAX_CONCURRENT_IMAGE_BUILDS = 1;
 const AGENT_REPLY_FLUSH_INTERVAL_MS = 50;
 const AGENT_REPLY_FLUSH_CHARACTERS = 1_024;
+const MAX_TRACE_DETAIL_CHARACTERS = 64 * 1_024;
+const MAX_TRACE_SUMMARY_CHARACTERS = 500;
+const MAX_TRACE_COLLECTION_ITEMS = 32;
+const MAX_TRACE_ID_CHARACTERS = 128;
+const MAX_ACTIVITY_TEXT_CHARACTERS = 240;
+const MAX_PENDING_TRACE_UPDATES = 512;
+const MAX_TRACKED_TOOL_NAMES = 512;
 const AGENT_CONTAINER_SECURITY = {
     init: true,
     readonlyRootFilesystem: true,
@@ -104,7 +113,7 @@ export class AgentService {
     daemon;
     sandboxRuntime;
     defaultCwd;
-    pluginFunctions;
+    pluginCapabilities;
     onError;
     workerId = createId();
     bindingCreations = new Map();
@@ -122,13 +131,13 @@ export class AgentService {
     shutdown = new AbortController();
     queueTask;
     stopping = false;
-    constructor(executor, pubsub, daemon, sandboxRuntime, defaultCwd, pluginFunctions, onError = () => undefined) {
+    constructor(executor, pubsub, daemon, sandboxRuntime, defaultCwd, pluginCapabilities, onError = () => undefined) {
         this.executor = executor;
         this.pubsub = pubsub;
         this.daemon = daemon;
         this.sandboxRuntime = sandboxRuntime;
         this.defaultCwd = defaultCwd;
-        this.pluginFunctions = pluginFunctions;
+        this.pluginCapabilities = pluginCapabilities;
         this.onError = onError;
     }
     async createAgent(input) {
@@ -247,25 +256,24 @@ export class AgentService {
         this.startDrain(chatId);
     }
     async getAgentEffort(input) {
-        const context = await agentEffortGetContext(this.executor, input.actorUserId, input.agentUserId);
+        const context = await agentEffortGetContext(this.executor, input.actorUserId, input.chatId, input.agentUserId);
         return this.agentEffortConfiguration(context);
     }
     async changeAgentEffort(input) {
-        return this.serializeAgentConfiguration(input.agentUserId, async () => {
-            const context = await agentEffortGetContext(this.executor, input.actorUserId, input.agentUserId, true);
+        return this.serializeAgentConfiguration(`${input.agentUserId}:${input.chatId}`, async () => {
+            const context = await agentEffortGetContext(this.executor, input.actorUserId, input.chatId, input.agentUserId);
             const configuration = await this.agentEffortConfiguration(context);
             if (!configuration.options.includes(input.effort))
                 throw new CollaborationError("invalid", `Effort must be one of: ${configuration.options.join(", ")}`);
             const result = await agentEffortUpdate(this.executor, input);
             try {
-                await Promise.all(context.sessionIds.map((sessionId) => this.reconcileSessionEffort(sessionId, input.effort)));
+                await this.reconcileSessionEffort(context.sessionId, input.effort);
             }
             finally {
                 if (result.hint)
                     await this.publishAgentHint(result.hint);
             }
             return {
-                agent: result.user,
                 agentUserId: input.agentUserId,
                 effort: input.effort,
                 options: configuration.options,
@@ -368,7 +376,7 @@ export class AgentService {
                     workspaceDirectory: binding.cwd,
                 }, this.shutdown.signal);
                 try {
-                    const session = await this.daemon.createSession(binding.cwd, containerName, context.user.agentEffort, this.shutdown.signal);
+                    const session = await this.daemon.createSession(binding.cwd, containerName, binding.effort ?? context.user.agentEffort, this.shutdown.signal);
                     replacements.push({
                         chatId: binding.chatId,
                         containerName,
@@ -435,7 +443,7 @@ export class AgentService {
         return this.serializeAgentSecret(input.id, () => this.createAgentSecretMutation(input));
     }
     async createAgentSecretMutation(input) {
-        await agentSecretAuthorizeManagement(this.executor, input.actorUserId);
+        await agentSecretAuthorizeManagement(this.executor, input.actorUserId, "manageSecrets");
         const secret = await this.daemon.registerSecret({
             id: input.id,
             description: input.description,
@@ -461,7 +469,7 @@ export class AgentService {
         return this.serializeAgentSecret(input.secretId, () => this.deleteAgentSecretMutation(input));
     }
     async deleteAgentSecretMutation(input) {
-        await agentSecretAuthorizeManagement(this.executor, input.actorUserId);
+        await agentSecretAuthorizeManagement(this.executor, input.actorUserId, "manageSecrets");
         const sync = await agentSecretAssignmentDelete(this.executor, input);
         let removed;
         try {
@@ -588,8 +596,9 @@ export class AgentService {
         if (!context)
             return undefined;
         if (context.binding) {
-            if (context.agentEffort)
-                await this.reconcileSessionEffort(context.binding.sessionId, context.agentEffort);
+            const effort = context.binding.effort ?? context.agentDefaultEffort;
+            if (effort)
+                await this.reconcileSessionEffort(context.binding.sessionId, effort);
             await this.reconcileSecretBindings({
                 agentUserId: context.agentUserId,
                 chatId,
@@ -605,8 +614,9 @@ export class AgentService {
             if (!latest)
                 throw new CollaborationError("not_found", "Agent conversation was not found");
             if (latest.binding) {
-                if (latest.agentEffort)
-                    await this.reconcileSessionEffort(latest.binding.sessionId, latest.agentEffort);
+                const effort = latest.binding.effort ?? latest.agentDefaultEffort;
+                if (effort)
+                    await this.reconcileSessionEffort(latest.binding.sessionId, effort);
                 return latest.binding;
             }
             const sandbox = sandboxDirectories(this.defaultCwd, latest.agentUserId, latest.sandboxScope.kind, latest.sandboxScope.id, latest.sandboxScope.conversationId);
@@ -632,13 +642,14 @@ export class AgentService {
                 workspaceDirectory: sandbox.workspace,
             }, this.shutdown.signal);
             try {
-                const session = await this.daemon.createSession(sandbox.workspace, containerName, latest.agentEffort, this.shutdown.signal);
+                const session = await this.daemon.createSession(sandbox.workspace, containerName, latest.agentDefaultEffort, this.shutdown.signal);
                 const binding = await agentChatBind(this.executor, {
                     actorUserId,
                     agentUserId: latest.agentUserId,
                     chatId,
                     containerName,
                     cwd: sandbox.workspace,
+                    effort: session.effort,
                     imageId: latest.image.id,
                     sessionId: session.id,
                 });
@@ -837,15 +848,12 @@ export class AgentService {
         }
     }
     async agentEffortConfiguration(context) {
-        if (!context.sessionIds.length)
-            throw new CollaborationError("conflict", "Agent has no active Rig session");
-        const configurations = await Promise.all(context.sessionIds.map((sessionId) => this.daemon.effortConfiguration(sessionId, this.shutdown.signal)));
-        const options = configurations[0].options.filter((option) => configurations.every((configuration) => configuration.options.includes(option)));
-        const effort = context.effort ?? configurations[0].effort;
+        const configuration = await this.daemon.effortConfiguration(context.sessionId, this.shutdown.signal);
+        const effort = [context.effort, context.defaultEffort].find((candidate) => candidate && configuration.options.includes(candidate)) ?? configuration.effort;
         return {
             agentUserId: context.agentUserId,
             effort,
-            options,
+            options: configuration.options,
         };
     }
     async reconcileAgentEfforts() {
@@ -857,15 +865,14 @@ export class AgentService {
             byAgent.set(binding.agentUserId, group);
         }
         for (const [agentUserId, agentBindings] of byAgent) {
-            const configured = agentBindings.find((binding) => binding.effort)?.effort;
-            const effort = configured ??
-                (await this.daemon.effortConfiguration(agentBindings[0].sessionId, this.shutdown.signal)).effort;
-            if (!configured) {
-                const hint = await agentEffortInitialize(this.executor, agentUserId, effort);
+            let defaultEffort = agentBindings[0]?.defaultEffort;
+            if (!defaultEffort) {
+                defaultEffort = (await this.daemon.effortConfiguration(agentBindings[0].sessionId, this.shutdown.signal)).effort;
+                const hint = await agentEffortInitialize(this.executor, agentUserId, defaultEffort);
                 if (hint)
                     await this.publishAgentHint(hint);
             }
-            await Promise.all(agentBindings.map((binding) => this.reconcileSessionEffort(binding.sessionId, effort)));
+            await Promise.all(agentBindings.map((binding) => this.reconcileSessionEffort(binding.sessionId, binding.effort ?? defaultEffort)));
         }
     }
     async reconcileFunctionPermissions() {
@@ -883,7 +890,7 @@ export class AgentService {
         await this.daemon.changeEffort(sessionId, effort, this.shutdown.signal);
     }
     async requireAgentSecret(actorUserId, secretId) {
-        await agentSecretAuthorizeManagement(this.executor, actorUserId);
+        await agentSecretAuthorizeManagement(this.executor, actorUserId, "assignSecrets");
         const secrets = await this.daemon.listSecrets(this.shutdown.signal);
         if (!secrets.some((secret) => secret.id === secretId))
             throw new CollaborationError("not_found", "Agent secret was not found");
@@ -961,7 +968,9 @@ export class AgentService {
         const event = entry.event;
         if (event.type === "external_tool_call_requested" && event.data.call) {
             const call = event.data.call;
-            const result = await this.executePluginFunctionCall(event.sessionId, call.id, call.definition.name, call.arguments);
+            const result = call.skill
+                ? await this.executePluginSkillRead(event.sessionId, call.id, call.definition.name, call.skill)
+                : await this.executePluginFunctionCall(event.sessionId, call.id, call.definition.name, call.arguments);
             await this.daemon.resolveExternalToolCall(event.sessionId, call.id, result, this.shutdown.signal);
             return;
         }
@@ -1015,6 +1024,49 @@ export class AgentService {
         throw new Error(`Rig run ${runId} finished before its session snapshot was complete.`);
     }
     async executePluginFunctionCall(sessionId, callId, functionName, args) {
+        return this.executeDurablePluginCall(sessionId, callId, async () => {
+            if (!this.pluginCapabilities)
+                return {
+                    status: "failed",
+                    error: {
+                        code: "plugin_functions_unavailable",
+                        message: "Plugin functions are unavailable on this server",
+                    },
+                };
+            const chatId = await agentChatGetIdBySession(this.executor, sessionId);
+            if (!chatId)
+                return {
+                    status: "failed",
+                    error: {
+                        code: "plugin_chat_unavailable",
+                        message: "The agent session is not bound to one current chat",
+                    },
+                };
+            return this.pluginCapabilities.callFunction(functionName, args, { chatId }, this.shutdown.signal);
+        });
+    }
+    async executePluginSkillRead(sessionId, callId, functionName, skill) {
+        return this.executeDurablePluginCall(sessionId, callId, () => {
+            if (functionName !== "read_skill")
+                return Promise.resolve({
+                    status: "failed",
+                    error: {
+                        code: "plugin_skill_invalid",
+                        message: "Rig requested a durable skill through an unknown function",
+                    },
+                });
+            return this.pluginCapabilities
+                ? this.pluginCapabilities.readSkill(skill, this.shutdown.signal)
+                : Promise.resolve({
+                    status: "failed",
+                    error: {
+                        code: "plugin_skills_unavailable",
+                        message: "Plugin skills are unavailable on this server",
+                    },
+                });
+        });
+    }
+    async executeDurablePluginCall(sessionId, callId, execute) {
         const leaseToken = createId();
         for (;;) {
             this.shutdown.signal.throwIfAborted();
@@ -1032,15 +1084,7 @@ export class AgentService {
                 await delay(Math.min(Math.max(claim.retryAt - now, EVENT_RETRY_INTERVAL_MS), PLUGIN_FUNCTION_WAIT_INTERVAL_MS), this.shutdown.signal);
                 continue;
             }
-            const result = this.pluginFunctions
-                ? await this.pluginFunctions.callFunction(functionName, args, this.shutdown.signal)
-                : {
-                    status: "failed",
-                    error: {
-                        code: "plugin_functions_unavailable",
-                        message: "Plugin functions are unavailable on this server",
-                    },
-                };
+            const result = await execute();
             return pluginFunctionResultComplete(this.executor, {
                 callId,
                 leaseToken,
@@ -1079,6 +1123,9 @@ export class AgentService {
             if (!input)
                 return;
             try {
+                const traced = await agentTurnTraceStart(this.executor, input);
+                if (traced)
+                    await this.publishAgentReplyHint(input.chatId, traced.hint);
                 await this.startAgentActivity(input);
                 await this.startTyping(input);
                 const submission = await this.ensureTurnSubmitted(input);
@@ -1146,11 +1193,14 @@ export class AgentService {
                         runId,
                     }),
             };
-        const externalTools = (await this.pluginFunctions?.listFunctions(this.shutdown.signal)) ?? [];
+        const [externalTools, skills] = await Promise.all([
+            this.pluginCapabilities?.listFunctions(this.shutdown.signal) ?? [],
+            this.pluginCapabilities?.listSkills(this.shutdown.signal) ?? [],
+        ]);
         for (;;) {
             let submitted;
             try {
-                submitted = await this.daemon.submitTurn(input.sessionId, input.text, externalTools, this.shutdown.signal);
+                submitted = await this.daemon.submitTurn(input.sessionId, input.text, externalTools, skills, this.shutdown.signal);
             }
             catch (error) {
                 if (this.shutdown.signal.aborted)
@@ -1220,6 +1270,9 @@ export class AgentService {
                 sessionId: input.sessionId,
                 streamCommittedText: update.streamCommittedText,
                 text: update.text,
+                traceUpdates: update.traceUpdates,
+                subagents: update.subagents,
+                backgroundTerminals: update.backgroundTerminals,
                 userMessageId: input.userMessageId,
                 workerId: input.workerId,
             });
@@ -1284,8 +1337,11 @@ export class AgentService {
                             shouldPersist = true;
                         }
                     }
-                    if (runId && event.data.runId === runId) {
-                        await this.updateAgentActivity(input, event);
+                    if (runId &&
+                        (event.data.runId === runId || event.type === "subagent_changed")) {
+                        const traceUpdates = await this.updateAgentActivity(input, event);
+                        if (traceUpdates.length > 0)
+                            shouldPersist = true;
                         if (event.type === "agent_event") {
                             const nextPartial = agentLoopText(event);
                             if (nextPartial !== undefined) {
@@ -1301,12 +1357,29 @@ export class AgentService {
                                 shouldPersist = true;
                             }
                         }
+                        if (shouldPersist) {
+                            const activity = this.agentActivities.get(input.userMessageId);
+                            output.add({
+                                eventId: event.id,
+                                streamCommittedText: committedText,
+                                text: appendAgentText(committedText, partialText),
+                                traceUpdates,
+                                ...(activity
+                                    ? {
+                                        subagents: activitySubagents(activity),
+                                        backgroundTerminals: activityBackgroundTerminals(activity),
+                                    }
+                                    : {}),
+                            });
+                            shouldPersist = false;
+                        }
                     }
                     if (shouldPersist)
                         output.add({
                             eventId: event.id,
                             streamCommittedText: committedText,
                             text: appendAgentText(committedText, partialText),
+                            traceUpdates: [],
                         });
                 }, signal);
                 after = output.lastEventId;
@@ -1399,6 +1472,13 @@ export class AgentService {
     async startAgentActivity(input) {
         if (this.agentActivities.has(input.userMessageId))
             return;
+        let snapshot;
+        try {
+            snapshot = await this.daemon.turnActivity(input.sessionId, this.shutdown.signal);
+        }
+        catch (error) {
+            this.onError(error);
+        }
         let activity;
         const timer = setInterval(() => {
             if (this.agentActivities.get(input.userMessageId) !== activity)
@@ -1407,11 +1487,25 @@ export class AgentService {
         }, AGENT_ACTIVITY_RENEW_INTERVAL_MS);
         timer.unref();
         activity = {
+            backgroundTerminals: new Map((snapshot?.backgroundProcesses ?? [])
+                .slice(0, MAX_TRACE_COLLECTION_ITEMS)
+                .map((process) => {
+                const terminal = backgroundTerminalSummary(process, Date.now());
+                return [terminal.id, terminal];
+            })),
             lastOccurredAt: 0,
             phase: "thinking",
             startedAt: sqliteTimestamp(input.startedAt),
+            subagents: new Map((snapshot?.subagents ?? [])
+                .filter(subagentIsActive)
+                .slice(0, MAX_TRACE_COLLECTION_ITEMS)
+                .map((subagent) => {
+                const summary = subagentSummary(subagent);
+                return [summary.id, summary];
+            })),
             timer,
             tokenCounts: new Map(),
+            toolNames: new Map(),
             userMessageId: input.userMessageId,
         };
         this.agentActivities.set(input.userMessageId, activity);
@@ -1425,7 +1519,8 @@ export class AgentService {
     async updateAgentActivity(input, event) {
         const activity = this.agentActivities.get(input.userMessageId);
         if (!activity)
-            return;
+            return [];
+        const traceUpdates = agentTurnTraceUpdates(event, activity);
         if (event.type === "run_started" &&
             Number.isSafeInteger(event.createdAt) &&
             event.createdAt >= 0)
@@ -1434,17 +1529,19 @@ export class AgentService {
         const phaseChanged = phase !== undefined && phase !== activity.phase;
         if (phase !== undefined)
             activity.phase = phase;
+        const workChanged = agentActivityWorkApply(activity, event);
         const usage = agentEventTokenCount(event);
         if (usage)
             activity.tokenCounts.set(usage.messageId, usage.tokenCount);
-        if (!phaseChanged)
-            return;
+        if (!phaseChanged && !workChanged)
+            return traceUpdates;
         try {
             await this.publishAgentActivity(input, activity, true);
         }
         catch (error) {
             this.onError(error);
         }
+        return traceUpdates;
     }
     async stopAgentActivity(input) {
         const activity = this.agentActivities.get(input.userMessageId);
@@ -1467,7 +1564,7 @@ export class AgentService {
     publishAgentActivity(input, activity, active) {
         const occurredAt = Math.max(Date.now(), activity.lastOccurredAt + 1);
         activity.lastOccurredAt = occurredAt;
-        const tokenCount = [...activity.tokenCounts.values()].reduce((total, count) => total + count, 0);
+        const tokenCount = boundedInteger([...activity.tokenCounts.values()].reduce((total, count) => Math.min(Number.MAX_SAFE_INTEGER, total + count), 0), 0);
         return this.pubsub.publish(realtimeTopics.chat(input.chatId), {
             type: "agent.activity",
             chatId: input.chatId,
@@ -1476,8 +1573,10 @@ export class AgentService {
             active,
             phase: activity.phase,
             tokenCount,
-            startedAt: activity.startedAt,
+            startedAt: Math.min(boundedTimestamp(activity.startedAt), occurredAt),
             occurredAt,
+            subagents: activitySubagents(activity),
+            backgroundTerminals: activityBackgroundTerminals(activity),
             ...(active
                 ? {
                     expiresAt: occurredAt + AGENT_ACTIVITY_TTL_MS,
@@ -1580,7 +1679,19 @@ class AgentReplyStreamOutput {
     add(update) {
         if (this.failure)
             return;
-        this.pending = update;
+        const traces = new Map((this.pending?.traceUpdates ?? []).map((trace) => [trace.traceKey, trace]));
+        for (const trace of update.traceUpdates) {
+            if (!traces.has(trace.traceKey) && traces.size >= MAX_PENDING_TRACE_UPDATES)
+                continue;
+            traces.delete(trace.traceKey);
+            traces.set(trace.traceKey, trace);
+        }
+        this.pending = {
+            ...update,
+            traceUpdates: [...traces.values()],
+            subagents: update.subagents ?? this.pending?.subagents,
+            backgroundTerminals: update.backgroundTerminals ?? this.pending?.backgroundTerminals,
+        };
         if (Math.abs(update.text.length - this.persistedTextLength) >= AGENT_REPLY_FLUSH_CHARACTERS) {
             this.flushInBackground();
             return;
@@ -1800,6 +1911,343 @@ function agentLoopText(event) {
         return undefined;
     return textBlocks.map((block) => block.text ?? "").join("");
 }
+function agentActivityWorkApply(activity, event) {
+    if (event.type === "subagent_changed" && event.data.subagent) {
+        const summary = subagentSummary(event.data.subagent);
+        if (subagentIsActive(event.data.subagent) &&
+            (activity.subagents.has(summary.id) ||
+                activity.subagents.size < MAX_TRACE_COLLECTION_ITEMS))
+            activity.subagents.set(summary.id, summary);
+        else
+            activity.subagents.delete(summary.id);
+        return true;
+    }
+    const loop = event.type === "agent_event" ? event.data.event : undefined;
+    if (loop?.type !== "background_processes_changed")
+        return false;
+    const processes = loop.processes ?? (loop.running === 0 ? [] : undefined);
+    if (!processes)
+        return false;
+    const observedAt = boundedTimestamp(event.createdAt);
+    const next = new Map();
+    for (const process of processes.slice(0, MAX_TRACE_COLLECTION_ITEMS)) {
+        const id = boundedIdentifier(String(process.sessionId), "terminal");
+        next.set(id, activity.backgroundTerminals.get(id) ?? backgroundTerminalSummary(process, observedAt));
+    }
+    activity.backgroundTerminals = next;
+    return true;
+}
+function agentTurnTraceUpdates(event, activity) {
+    const occurredAt = boundedTimestamp(event.createdAt);
+    if (event.type === "subagent_changed" && event.data.subagent) {
+        const subagent = subagentSummary(event.data.subagent);
+        const status = traceStatusForSubagent(subagent.status);
+        return [
+            {
+                traceKey: `subagent:${subagent.id}`,
+                sessionEventId: event.id,
+                kind: "subagent",
+                title: subagent.description,
+                ...(subagent.latestText ? { detail: traceDetail(subagent.latestText) } : {}),
+                status,
+                occurredAt,
+                ...(status === "running" ? {} : { completedAt: occurredAt }),
+            },
+        ];
+    }
+    if (event.type === "run_started")
+        return [
+            {
+                traceKey: `run:${event.data.runId ?? "active"}`,
+                sessionEventId: event.id,
+                kind: "status",
+                title: "Thinking",
+                status: "running",
+                occurredAt,
+            },
+        ];
+    if (event.type === "agent_message") {
+        const detail = messageText(event.data.message);
+        return detail
+            ? [
+                {
+                    traceKey: `response:${event.data.message?.id ?? "active"}`,
+                    sessionEventId: event.id,
+                    kind: "response",
+                    title: "Response completed",
+                    detail: traceDetail(detail),
+                    status: "complete",
+                    occurredAt,
+                    completedAt: occurredAt,
+                },
+            ]
+            : [];
+    }
+    const loop = event.type === "agent_event" ? event.data.event : undefined;
+    const type = loop?.type;
+    if (!loop || !type)
+        return [];
+    if (type.startsWith("thinking_")) {
+        const detail = agentLoopContent(loop, "thinking");
+        return [
+            {
+                traceKey: `reasoning:${loop.partial?.id ?? "active"}:${loop.contentIndex ?? 0}`,
+                sessionEventId: event.id,
+                kind: "reasoning",
+                title: "Reasoning",
+                ...(detail ? { detail: traceDetail(detail) } : {}),
+                status: type === "thinking_end" ? "complete" : "running",
+                occurredAt,
+                ...(type === "thinking_end" ? { completedAt: occurredAt } : {}),
+            },
+        ];
+    }
+    if (type.startsWith("text_")) {
+        const detail = agentLoopContent(loop, "text");
+        return [
+            {
+                traceKey: `response:${loop.partial?.id ?? "active"}:${loop.contentIndex ?? 0}`,
+                sessionEventId: event.id,
+                kind: "response",
+                title: type === "text_end" ? "Response drafted" : "Writing response",
+                ...(detail ? { detail: traceDetail(detail) } : {}),
+                status: type === "text_end" ? "complete" : "running",
+                occurredAt,
+                ...(type === "text_end" ? { completedAt: occurredAt } : {}),
+            },
+        ];
+    }
+    if (type === "toolcall_end" && loop.toolCall?.id) {
+        const toolCallId = boundedIdentifier(loop.toolCall.id, "tool");
+        const name = traceSummary(loop.toolCall.name ?? "tool") || "tool";
+        if (activity.toolNames.has(toolCallId) || activity.toolNames.size < MAX_TRACKED_TOOL_NAMES)
+            activity.toolNames.set(toolCallId, name);
+        return [
+            {
+                traceKey: `tool:${toolCallId}`,
+                sessionEventId: event.id,
+                kind: "tool",
+                title: traceTitle(`Calling ${humanizeTraceToolName(name)}`),
+                detail: traceDetail(JSON.stringify(loop.toolCall.arguments ?? {})),
+                status: "running",
+                occurredAt,
+            },
+        ];
+    }
+    if (type === "tool_execution_start" && loop.toolCall?.id) {
+        const toolCallId = boundedIdentifier(loop.toolCall.id, "tool");
+        const name = traceSummary(loop.toolCall.name ?? "tool") || "tool";
+        if (activity.toolNames.has(toolCallId) || activity.toolNames.size < MAX_TRACKED_TOOL_NAMES)
+            activity.toolNames.set(toolCallId, name);
+        return [
+            {
+                traceKey: `tool:${toolCallId}`,
+                sessionEventId: event.id,
+                kind: "tool",
+                title: traceTitle(`Running ${humanizeTraceToolName(name)}`),
+                detail: traceDetail(JSON.stringify(loop.toolCall.arguments ?? {})),
+                status: "running",
+                occurredAt,
+            },
+        ];
+    }
+    if ((type === "tool_execution_progress" || type === "tool_execution_status") &&
+        loop.toolCallId) {
+        const toolCallId = boundedIdentifier(loop.toolCallId, "tool");
+        const name = activity.toolNames.get(toolCallId) ?? "tool";
+        const detail = type === "tool_execution_progress" ? loop.display : loop.status;
+        return [
+            {
+                traceKey: `tool:${toolCallId}`,
+                sessionEventId: event.id,
+                kind: "tool",
+                title: traceTitle(`Running ${humanizeTraceToolName(name)}`),
+                ...(detail ? { detail: traceDetail(detail) } : {}),
+                status: "running",
+                occurredAt,
+            },
+        ];
+    }
+    if (type === "tool_execution_end" && loop.result?.toolCallId) {
+        const toolCallId = boundedIdentifier(loop.result.toolCallId, "tool");
+        const name = traceSummary(loop.result.toolName ?? activity.toolNames.get(toolCallId) ?? "tool") ||
+            "tool";
+        activity.toolNames.delete(toolCallId);
+        return [
+            {
+                traceKey: `tool:${toolCallId}`,
+                sessionEventId: event.id,
+                kind: "tool",
+                title: traceTitle(`${humanizeTraceToolName(name)} ${loop.result.isError ? "failed" : "completed"}`),
+                ...(loop.result.display ? { detail: traceDetail(loop.result.display) } : {}),
+                status: loop.result.isError ? "failed" : "complete",
+                occurredAt,
+                completedAt: occurredAt,
+            },
+        ];
+    }
+    if (type === "background_processes_changed") {
+        const processes = loop.processes ?? (loop.running === 0 ? [] : undefined);
+        if (!processes)
+            return [];
+        const boundedProcesses = processes.slice(0, MAX_TRACE_COLLECTION_ITEMS);
+        const nextIds = new Set(boundedProcesses.map((process) => boundedIdentifier(String(process.sessionId), "terminal")));
+        const completed = [...activity.backgroundTerminals.values()]
+            .filter((terminal) => !nextIds.has(terminal.id))
+            .map((terminal) => ({
+            traceKey: `terminal:${terminal.id}`,
+            sessionEventId: event.id,
+            kind: "terminal",
+            title: "Background terminal completed",
+            detail: traceDetail(terminal.command),
+            status: "complete",
+            occurredAt: terminal.startedAt,
+            completedAt: occurredAt,
+        }));
+        const running = boundedProcesses.map((process) => {
+            const id = boundedIdentifier(String(process.sessionId), "terminal");
+            const existing = activity.backgroundTerminals.get(id);
+            return {
+                traceKey: `terminal:${id}`,
+                sessionEventId: event.id,
+                kind: "terminal",
+                title: "Background terminal running",
+                detail: traceDetail(process.command),
+                status: "running",
+                occurredAt: existing?.startedAt ?? occurredAt,
+            };
+        });
+        return [...completed, ...running];
+    }
+    if (type === "inference_iteration_start")
+        return [
+            {
+                traceKey: `inference:${loop.iteration ?? event.id}`,
+                sessionEventId: event.id,
+                kind: "status",
+                title: traceTitle(`Inference ${loop.iteration ?? "started"}`),
+                status: "complete",
+                occurredAt,
+                completedAt: occurredAt,
+            },
+        ];
+    if (type === "context_compacted")
+        return [
+            {
+                traceKey: `context:${event.id}`,
+                sessionEventId: event.id,
+                kind: "status",
+                title: "Context compacted",
+                status: "complete",
+                occurredAt,
+                completedAt: occurredAt,
+            },
+        ];
+    return [];
+}
+function subagentSummary(subagent) {
+    const latestText = subagent.latestText ? activityText(subagent.latestText) : "";
+    return {
+        id: boundedIdentifier(subagent.id, "subagent"),
+        depth: boundedInteger(subagent.depth, 1),
+        description: activityText(subagent.description) || "Subagent",
+        status: subagentStatus(subagent.status),
+        ...(latestText ? { latestText } : {}),
+        startedAt: boundedTimestamp(subagent.activeSince ?? subagent.createdAt),
+        totalTokens: boundedInteger(subagent.totalTokens ?? 0, 0),
+    };
+}
+function subagentIsActive(subagent) {
+    return ((subagent.status === "queued" || subagent.status === "running") &&
+        !subagent.taskName?.startsWith("workflow_"));
+}
+function traceStatusForSubagent(status) {
+    if (status === "queued" || status === "running")
+        return "running";
+    return status === "error" || status === "aborted" ? "failed" : "complete";
+}
+function backgroundTerminalSummary(process, startedAt) {
+    return {
+        id: boundedIdentifier(String(process.sessionId), "terminal"),
+        command: activityText(process.command) || "Background command",
+        cwd: activityText(process.cwd) || ".",
+        startedAt: boundedTimestamp(startedAt),
+    };
+}
+function activitySubagents(activity) {
+    return [...activity.subagents.values()].slice(0, MAX_TRACE_COLLECTION_ITEMS);
+}
+function activityBackgroundTerminals(activity) {
+    return [...activity.backgroundTerminals.values()].slice(0, MAX_TRACE_COLLECTION_ITEMS);
+}
+function agentLoopContent(loop, kind) {
+    const blocks = loop.partial?.content ?? loop.message?.content ?? loop.error?.content ?? [];
+    const content = blocks
+        .filter((block) => block.type === kind)
+        .map((block) => (kind === "text" ? block.text : block.thinking) ?? "")
+        .join("");
+    return content || (typeof loop.content === "string" ? loop.content : undefined);
+}
+function humanizeTraceToolName(name) {
+    const spaced = name
+        .replaceAll(/[_-]+/gu, " ")
+        .replaceAll(/([a-z\d])([A-Z])/gu, "$1 $2")
+        .trim();
+    return spaced ? `${spaced[0].toUpperCase()}${spaced.slice(1)}` : "Tool";
+}
+function traceDetail(value) {
+    return textValue(value).trim().slice(-MAX_TRACE_DETAIL_CHARACTERS);
+}
+function traceSummary(value) {
+    return textValue(value).trim().slice(-MAX_TRACE_SUMMARY_CHARACTERS);
+}
+function activityText(value) {
+    return textValue(value).trim().slice(-MAX_ACTIVITY_TEXT_CHARACTERS);
+}
+function traceTitle(value) {
+    return traceSummary(value) || "Agent activity";
+}
+function boundedIdentifier(value, prefix) {
+    const text = textValue(value);
+    const clean = [...text]
+        .filter((character) => {
+        const code = character.charCodeAt(0);
+        return code > 31 && code !== 127;
+    })
+        .join("");
+    if (clean.length > 0 && clean.length <= MAX_TRACE_ID_CHARACTERS)
+        return clean;
+    return `${prefix}-${createHash("sha256").update(text).digest("hex").slice(0, 32)}`;
+}
+function boundedTimestamp(value) {
+    const now = Date.now();
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0
+        ? Math.min(value, now)
+        : now;
+}
+function boundedInteger(value, minimum) {
+    return typeof value === "number" && Number.isSafeInteger(value)
+        ? Math.max(minimum, Math.min(value, Number.MAX_SAFE_INTEGER))
+        : minimum;
+}
+function textValue(value) {
+    return typeof value === "string"
+        ? value
+        : value === undefined || value === null
+            ? ""
+            : String(value);
+}
+function subagentStatus(value) {
+    return value === "idle" ||
+        value === "queued" ||
+        value === "running" ||
+        value === "completed" ||
+        value === "aborted" ||
+        value === "suspended" ||
+        value === "error"
+        ? value
+        : "error";
+}
 function agentActivityPhase(event) {
     if (event.type === "run_started")
         return "thinking";