@markusylisiurunen/tau 0.3.45 → 0.3.46

package/dist/host/local_session_host.js

@@ -5,12 +5,11 @@ import { assistantHistoryEntries, toolHistoryEntry, userHistoryEntry, } from "..
 import { ChatRuntime } from "../core/runtime/chat_runtime.js";
 import { formatSteeringUserMessage } from "../core/runtime/steering.js";
 import { buildGoalContinuationText, prependGoalPolicy } from "../core/session/goal.js";
-import { SUBAGENT_ACTIVITY_FACET_KIND } from "../core/subagents/types.js";
 import { buildToolRunPresentation, TOOL_UI_FACET_VERSION } from "../core/tools/presentation.js";
 import { appendUsageLogEntry, getUsageCostTotal, getUsageTotals, } from "../core/usage/logs.js";
 import { filterProjectPathAutocompleteEntries, loadProjectPathAutocompleteEntriesWithBackend, } from "../core/utils/project_files.js";
 import { hasGoalTurnMetadata } from "../core/utils/user_metadata.js";
-import { applySessionProtocolDelta, createSessionProtocolDeltaMessage, createSessionProtocolEphemeralMessage, projectSessionProtocolNoticePresentation, } from "../protocol/session_protocol.js";
+import { applySessionProtocolDelta, createSessionProtocolDeltaMessage, createSessionProtocolEphemeralMessage, createSessionProtocolSubagentActivitiesMessage, projectSessionProtocolNoticePresentation, projectSessionProtocolSubagentActivity, SESSION_PROTOCOL_MAX_SUBAGENT_ACTIVITIES, } from "../protocol/session_protocol.js";
 import { LEGACY_SESSION_MODEL_CONTEXT_KEY } from "../store/session_snapshot_migrations.js";
 import { ClientToolBroker } from "./client_tool_broker.js";
 import { createExecutionEnvironmentSubagentPromptResolver } from "./execution_runtime.js";
@@ -119,18 +118,22 @@ export class LocalSessionHost {
     }
     async createLocalSessionHandleFromRuntimeContext(executionEnvironment, runtimeContext, bootstrap, catalog, committedSnapshot, createParams, forceNextSnapshotRevision = false) {
         let hostedSession;
+        const sessionId = committedSnapshot?.sessionId ?? randomUUID();
+        const createdAt = committedSnapshot?.createdAt ?? this.sessionOptions.environment.now();
         const runtime = ChatRuntime.create({
+            sessionId,
+            createdAt,
             persona: bootstrap.persona,
             backend: executionEnvironment.getToolExecutionBackend(),
             clientTools: (sessionId) => this.clientToolBroker.getToolDefinitions(sessionId),
             modelResolver: bootstrap.modelResolver,
             resolveSubagentPrompts: createExecutionEnvironmentSubagentPromptResolver({
+                sessionId,
                 executionEnvironment,
                 includeAgentContext: this.sessionOptions.includeAgentContext,
-                now: this.sessionOptions.environment.now,
+                sessionStartedAt: createdAt,
             }),
             promptContext: runtimeContext.promptBootstrap.promptContext,
-            environment: this.sessionOptions.environment,
             eventSink: async (event) => await hostedSession.enqueueRuntimeEvent(event),
             subagentEventSink: async (event) => await hostedSession.recordSubagentEvent(event),
             goalManager: {
@@ -150,7 +153,6 @@ export class LocalSessionHost {
         if (!attributes) {
             throw new Error("session attributes are required");
         }
-        const createdAt = committedSnapshot?.createdAt ?? this.sessionOptions.environment.now();
         hostedSession = new LocalHostedSessionHandle(runtime, runtimeContext.promptBootstrap, catalog, bootstrap, this.sessionOptions.includeAgentContext, executionEnvironment, this.store, this.history, this.historyRemote, attributes, createdAt, committedSnapshot, forceNextSnapshotRevision, this.sessionOptions.recordUsage ?? appendUsageLogEntry, (session) => this.sessions.delete(session));
         const historyFailure = this.history.registerSession({
             sessionId: committedSnapshot?.sessionId ?? hostedSession.sessionId,
@@ -377,6 +379,9 @@ class LocalHostedSessionHandle {
     facets = new Map();
     deltaListeners = new Set();
     ephemeralListeners = new Set();
+    subagentActivitiesByAgent = new Map();
+    subagentActivitiesListeners = new Set();
+    subagentActivitiesRevision = 1;
     ephemeralAgentSessions = new Map();
     pathAutocompleteCache;
     pathAutocompleteLoad;
@@ -447,6 +452,18 @@ class LocalHostedSessionHandle {
             this.ephemeralListeners.delete(handler);
         };
     }
+    subagentActivities() {
+        return {
+            revision: this.subagentActivitiesRevision,
+            agents: structuredClone(Object.fromEntries(this.subagentActivitiesByAgent)),
+        };
+    }
+    onSubagentActivities(handler) {
+        this.subagentActivitiesListeners.add(handler);
+        return () => {
+            this.subagentActivitiesListeners.delete(handler);
+        };
+    }
     getGoal() {
         return structuredClone(this.goal);
     }
@@ -1054,6 +1071,8 @@ class LocalHostedSessionHandle {
         const contextId = `ephemeral-${randomUUID()}`;
         const session = new HostedEphemeralAgentSession({
             contextId,
+            sessionId: this.sessionId,
+            sessionStartedAt: this.createdAt,
             persona: this.runtime.persona,
             config: this.bootstrap.config ?? {},
             discoveredSkills: this.bootstrap.discoveredSkills,
@@ -1292,9 +1311,9 @@ class LocalHostedSessionHandle {
         await this.resolveCommittedLogicalSteering(committedSteering, outcome);
         return outcome;
     }
-    async commitSnapshot() {
+    async commitSnapshot(options = {}) {
         this.assertNotDisposed();
-        this.reconcileProjections();
+        this.reconcileProjections(options);
         const draft = this.buildSnapshotDraft();
         await this.switchSnapshotSession(draft.sessionId);
         const snapshot = {
@@ -1302,6 +1321,9 @@ class LocalHostedSessionHandle {
             revision: this.nextSnapshotRevision(draft),
         };
         if (this.persistedSnapshot && isDeepStrictEqual(this.persistedSnapshot, snapshot)) {
+            if (options.removeMissingAgents) {
+                this.removeMissingSubagentActivities();
+            }
             return cloneSessionProtocolSnapshot(this.committedSnapshot ?? snapshot);
         }
         await this.store.commitSessionSnapshot(snapshot, {
@@ -1309,6 +1331,9 @@ class LocalHostedSessionHandle {
         });
         this.persistedSnapshot = cloneSessionProtocolSnapshot(snapshot);
         this.committedSnapshot = cloneSessionProtocolSnapshot(snapshot);
+        if (options.removeMissingAgents) {
+            this.removeMissingSubagentActivities();
+        }
         return cloneSessionProtocolSnapshot(snapshot);
     }
     async commitProjectedSnapshot() {
@@ -1616,7 +1641,7 @@ class LocalHostedSessionHandle {
         return JSON.stringify(current) === JSON.stringify(next) ? revision : revision + 1;
     }
     async recordSubagentEvent(event) {
-        await this.enqueueMutation(() => this.recordSubagentUiEvent(event));
+        await this.enqueueMutation(() => this.applySubagentEvent(event));
     }
     async enqueueRuntimeEvent(event) {
         await this.enqueueMutation(() => this.recordRuntimeEvent(event));
@@ -1846,8 +1871,7 @@ class LocalHostedSessionHandle {
                 }
                 const cutoffSequence = rewindItem.sequence - 1;
                 this.timeline.items = this.timeline.items.filter((item) => item.sequence <= cutoffSequence);
-                this.reconcileProjections({ removeMissingAgents: true });
-                const snapshot = await this.commitSnapshot();
+                const snapshot = await this.commitSnapshot({ removeMissingAgents: true });
                 this.emitSnapshotReset({ type: "rewind", epoch: this.timeline.epoch, cutoffSequence }, snapshot);
                 await this.recordHistoryFailure(this.history.truncateFromSources(this.sessionId, event.removedEntryIds, this.historyRemote));
                 return;
@@ -2103,13 +2127,12 @@ class LocalHostedSessionHandle {
                 this.operations.clear();
                 this.facets.clear();
                 this.draftAssistantMessage = undefined;
-                this.reconcileProjections({ removeMissingAgents: true });
                 const summary = this.session.rawHistoryEntries.find((entry) => entry.id === event.result.summaryHistoryEntryId);
                 if (!summary) {
                     throw new Error(`missing compaction summary '${event.result.summaryHistoryEntryId}' in runtime history`);
                 }
                 this.appendMessageTimelineItem(summary.id, summary.message.timestamp);
-                const snapshot = await this.commitSnapshot();
+                const snapshot = await this.commitSnapshot({ removeMissingAgents: true });
                 this.emitSnapshotReset({
                     type: "compaction",
                     previousEpoch,
@@ -2170,36 +2193,71 @@ class LocalHostedSessionHandle {
             { type: "facet.set", facet: structuredClone(facet) },
         ], { persist: false });
     }
-    async recordSubagentUiEvent(event) {
+    async applySubagentEvent(event) {
         const agent = agentRunFromSubagentEvent(event);
-        const previousCost = this.agentCostTotals.get(agent.id) ?? 0;
-        this.costTotal += Math.max(0, agent.costTotal - previousCost);
-        this.agentCostTotals.set(agent.id, agent.costTotal);
         if (!this.session.hasSubagent(agent.id)) {
             return;
         }
+        if (event.type === "subagent_activity") {
+            const current = this.subagentActivitiesByAgent.get(agent.id);
+            if (!current || current.runRevision !== agent.run.revision) {
+                throw new Error(`missing activity state for subagent run '${agent.id}'`);
+            }
+            current.activities.push(projectSessionProtocolSubagentActivity(event.activity));
+            if (current.activities.length > SESSION_PROTOCOL_MAX_SUBAGENT_ACTIVITIES) {
+                current.activities.splice(0, current.activities.length - SESSION_PROTOCOL_MAX_SUBAGENT_ACTIVITIES);
+            }
+            this.publishSubagentActivities([
+                { type: "agent.set", agentId: agent.id, state: structuredClone(current) },
+            ]);
+            return;
+        }
+        const previousCost = this.agentCostTotals.get(agent.id) ?? 0;
+        this.costTotal += Math.max(0, agent.costTotal - previousCost);
+        this.agentCostTotals.set(agent.id, agent.costTotal);
         this.agents.set(agent.id, agent);
-        const changes = [
+        await this.emitPatch("agent-run", [
             { type: "cost.set", costTotal: this.costTotal },
             { type: "agent.set", agent: structuredClone(agent) },
-        ];
-        const facetId = `subagent-activity-${agent.id}`;
-        if (event.type === "subagent_activity") {
-            const facet = {
-                id: facetId,
-                subject: { type: "agent", id: agent.id },
-                kind: SUBAGENT_ACTIVITY_FACET_KIND,
-                version: 1,
-                data: { text: event.text },
+        ]);
+        if (event.type === "subagent_spawned" || event.type === "subagent_run_started") {
+            const state = {
+                runRevision: agent.run.revision,
+                activities: [],
             };
-            this.facets.set(facet.id, facet);
-            changes.push({ type: "facet.set", facet: structuredClone(facet) });
+            this.subagentActivitiesByAgent.set(agent.id, state);
+            this.publishSubagentActivities([
+                { type: "agent.set", agentId: agent.id, state: structuredClone(state) },
+            ]);
         }
-        else if ((event.type === "subagent_run_started" || event.type === "subagent_finished") &&
-            this.facets.delete(facetId)) {
-            changes.push({ type: "facet.remove", id: facetId });
+    }
+    removeMissingSubagentActivities() {
+        const changes = [];
+        for (const id of this.subagentActivitiesByAgent.keys()) {
+            if (!this.session.hasSubagent(id)) {
+                this.subagentActivitiesByAgent.delete(id);
+                changes.push({ type: "agent.remove", agentId: id });
+            }
+        }
+        if (changes.length > 0) {
+            this.publishSubagentActivities(changes);
+        }
+    }
+    publishSubagentActivities(changes) {
+        this.subagentActivitiesRevision += 1;
+        const message = createSessionProtocolSubagentActivitiesMessage({
+            sessionId: this.sessionId,
+            revision: this.subagentActivitiesRevision,
+            changes,
+        });
+        for (const listener of [...this.subagentActivitiesListeners]) {
+            try {
+                listener(message);
+            }
+            catch {
+                // Subagent activity observers must not be able to fail hosted session work.
+            }
         }
-        await this.emitPatch("agent-run", changes, event.type === "subagent_activity" ? { persist: false } : {});
     }
     buildAssistantPartialChanges(previousDraft, nextDraft) {
         if (!previousDraft) {