@markusylisiurunen/tau 0.3.19 → 0.3.20

package/dist/host/local_session_host.js

@@ -2,9 +2,10 @@ import { randomUUID } from "node:crypto";
 import { resolvePromptTemplateWithBackend } from "../core/config/index.js";
 import { ChatRuntime } from "../core/runtime/chat_runtime.js";
 import { filterProjectPathAutocompleteEntries, loadProjectPathAutocompleteEntriesWithBackend, } from "../core/utils/project_files.js";
-import { hasAutoCompactionContinuationMetadata } from "../core/utils/user_metadata.js";
+import { hasAutoCompactionContinuationMetadata, isTauUserMessageHidden, } from "../core/utils/user_metadata.js";
 import { applySessionProtocolDelta, createSessionProtocolDeltaMessage, createSessionProtocolEphemeralMessage, } from "../protocol/session_protocol.js";
 import { ClientToolBroker } from "./client_tool_broker.js";
+import { createExecutionEnvironmentSubagentRuntimeResolver } from "./execution_runtime.js";
 import { HostedEphemeralAgentSession } from "./hosted_ephemeral_agent_session.js";
 const PATH_AUTOCOMPLETE_CACHE_TTL_MS = 5_000;
 export class LocalSessionHost {
@@ -53,14 +54,6 @@ export class LocalSessionHost {
         }
         return hostedSession;
     }
-    createSessionNow(executionEnvironment, initialHistory = []) {
-        this.assertHostActive();
-        const hostedSession = this.createLocalSessionHandleSync(executionEnvironment);
-        for (const message of initialHistory) {
-            hostedSession.session.addMessage(message);
-        }
-        return hostedSession;
-    }
     async createRecoveredSession(snapshot, executionEnvironment) {
         const recovered = normalizeRecoveredSnapshot(snapshot);
         const hostedSession = await this.createLocalSessionHandle(executionEnvironment, recovered.snapshot, undefined, recovered.changed);
@@ -81,33 +74,26 @@ export class LocalSessionHost {
             this.applyCreateParamsToBootstrap(bootstrap, createParams);
         }
         const runtimeContext = await executionEnvironment.resolveRuntimeContext({
+            cwd: executionEnvironment.snapshot().cwd,
             persona: bootstrap.persona,
             discoveredSkills: bootstrap.discoveredSkills,
             includeAgentContext: this.sessionOptions.includeAgentContext,
+            agentContextFiles: bootstrap.config?.agentContextFiles ?? [],
         });
         const catalog = createContentCatalogSnapshot(bootstrap);
         return this.createLocalSessionHandleFromRuntimeContext(executionEnvironment, runtimeContext, bootstrap, catalog, committedSnapshot, forceNextSnapshotRevision);
     }
-    createLocalSessionHandleSync(executionEnvironment, committedSnapshot) {
-        const bootstrap = committedSnapshot
-            ? this.applySnapshotSettingsToBootstrap(this.defaultSessionBootstrap(), committedSnapshot)
-            : this.defaultSessionBootstrap();
-        const runtimeContext = executionEnvironment.resolveRuntimeContext({
-            persona: bootstrap.persona,
-            discoveredSkills: bootstrap.discoveredSkills,
-            includeAgentContext: this.sessionOptions.includeAgentContext,
-        });
-        if (isPromiseLike(runtimeContext)) {
-            throw new Error("cannot synchronously create a session for an async execution environment");
-        }
-        return this.createLocalSessionHandleFromRuntimeContext(executionEnvironment, runtimeContext, bootstrap, createContentCatalogSnapshot(bootstrap), committedSnapshot);
-    }
     createLocalSessionHandleFromRuntimeContext(executionEnvironment, runtimeContext, bootstrap, catalog, committedSnapshot, forceNextSnapshotRevision = false) {
         const runtime = ChatRuntime.create({
             persona: bootstrap.persona,
-            riskLevel: bootstrap.riskLevel,
             toolRegistry: runtimeContext.toolRegistry,
             clientToolDefinitions: (sessionId) => this.clientToolBroker.getToolDefinitions(sessionId),
+            modelResolver: bootstrap.modelResolver,
+            resolveSubagentRuntime: createExecutionEnvironmentSubagentRuntimeResolver({
+                executionEnvironment,
+                includeAgentContext: this.sessionOptions.includeAgentContext,
+                now: this.sessionOptions.environment.now,
+            }),
             promptContext: runtimeContext.promptBootstrap.promptContext,
             environment: this.sessionOptions.environment,
             initialPromptComposition: committedSnapshot
@@ -139,7 +125,6 @@ export class LocalSessionHost {
         if (snapshot.settings.serviceTier !== undefined) {
             bootstrap.persona.settings.serviceTier = snapshot.settings.serviceTier;
         }
-        bootstrap.riskLevel = snapshot.settings.riskLevel;
         return bootstrap;
     }
     applyCreateParamsToBootstrap(bootstrap, createParams) {
@@ -154,19 +139,13 @@ export class LocalSessionHost {
         if (createParams.reasoning !== undefined) {
             bootstrap.persona.settings.reasoning = createParams.reasoning;
         }
-        if (createParams.riskLevel !== undefined) {
-            bootstrap.riskLevel = createParams.riskLevel;
-        }
     }
     defaultSessionBootstrap() {
-        return cloneResolvedBootstrap({
-            persona: this.sessionOptions.persona,
-            riskLevel: this.sessionOptions.riskLevel,
-            discoveredSkills: this.sessionOptions.discoveredSkills,
-            personas: this.sessionOptions.personas,
-            prompts: this.sessionOptions.prompts,
-            config: this.sessionOptions.config,
-        });
+        const bootstrap = this.sessionOptions.defaultBootstrap;
+        if (!bootstrap) {
+            throw new Error("local session host has no default session bootstrap");
+        }
+        return cloneResolvedBootstrap(bootstrap);
     }
     async observeSession(sessionId) {
         this.assertHostActive();
@@ -294,9 +273,6 @@ export class LocalSessionHost {
         return false;
     }
 }
-function isPromiseLike(value) {
-    return typeof value.then === "function";
-}
 class LocalHostedSessionHandle {
     runtime;
     promptBootstrap;
@@ -427,13 +403,6 @@ class LocalHostedSessionHandle {
             ...(options.signal !== undefined ? { signal: options.signal } : {}),
         });
     }
-    async setRiskLevel(level) {
-        this.assertActive();
-        this.runtime.setRiskLevel(level);
-        const snapshot = await this.commitSnapshot();
-        this.emitSnapshotReset("configuration", snapshot);
-        return snapshot;
-    }
     async setReasoning(reasoning) {
         this.assertActive();
         const fromRevision = this.committedSnapshot?.revision;
@@ -459,7 +428,7 @@ class LocalHostedSessionHandle {
     }
     async setPersona(personaId) {
         this.assertActive();
-        const runtimeConfig = await this.executionEnvironment.resolveRuntimeConfig();
+        const runtimeConfig = await this.executionEnvironment.resolveRuntimeConfig(this.executionEnvironment.snapshot().cwd);
         const personas = runtimeConfig.personas.map((persona) => this.normalizeReloadedPersona(persona));
         const persona = personas.find((persona) => persona.id.toLowerCase() === personaId.toLowerCase());
         if (!persona) {
@@ -467,21 +436,23 @@ class LocalHostedSessionHandle {
         }
         const selectedPersona = clonePersona(persona);
         const runtimeContext = await this.executionEnvironment.resolveRuntimeContext({
+            cwd: this.executionEnvironment.snapshot().cwd,
             persona: selectedPersona,
             discoveredSkills: runtimeConfig.skills,
             includeAgentContext: this.includeAgentContext,
+            agentContextFiles: runtimeConfig.config.agentContextFiles ?? [],
         });
-        this.runtime.setConfig(runtimeConfig.config);
+        this.runtime.setRuntimeConfig(runtimeConfig.config, runtimeConfig.bootstrap.modelResolver.resolveModel);
         this.runtime.updatePromptContext(runtimeContext.promptBootstrap.promptContext);
         this.runtime.setPersona(selectedPersona, {
             skillsBlock: runtimeContext.promptBootstrap.promptContext.skillsBlock,
         });
         this.bootstrap = {
             persona: clonePersona(selectedPersona),
-            riskLevel: this.runtime.currentRiskLevel,
             discoveredSkills: structuredClone(runtimeConfig.skills),
             personas: personas.map(clonePersona),
             prompts: structuredClone(runtimeConfig.prompts),
+            modelResolver: runtimeConfig.bootstrap.modelResolver.resolveModel,
             config: runtimeConfig.config,
         };
         this.catalog = createContentCatalogSnapshot(this.bootstrap);
@@ -491,7 +462,7 @@ class LocalHostedSessionHandle {
     }
     async reload() {
         this.assertActive();
-        const runtimeConfig = await this.executionEnvironment.resolveRuntimeConfig();
+        const runtimeConfig = await this.executionEnvironment.resolveRuntimeConfig(this.executionEnvironment.snapshot().cwd);
         if (runtimeConfig.personas.length === 0) {
             throw new Error("reload failed: no personas available");
         }
@@ -499,21 +470,23 @@ class LocalHostedSessionHandle {
         const currentPersonaId = this.runtime.persona.id.toLowerCase();
         const nextPersona = personas.find((persona) => persona.id.toLowerCase() === currentPersonaId) ?? personas[0];
         const runtimeContext = await this.executionEnvironment.resolveRuntimeContext({
+            cwd: this.executionEnvironment.snapshot().cwd,
             persona: nextPersona,
             discoveredSkills: runtimeConfig.skills,
             includeAgentContext: this.includeAgentContext,
+            agentContextFiles: runtimeConfig.config.agentContextFiles ?? [],
         });
-        this.runtime.setConfig(runtimeConfig.config);
+        this.runtime.setRuntimeConfig(runtimeConfig.config, runtimeConfig.bootstrap.modelResolver.resolveModel);
         this.runtime.updatePromptContext(runtimeContext.promptBootstrap.promptContext);
         this.runtime.setPersona(nextPersona, {
             skillsBlock: runtimeContext.promptBootstrap.promptContext.skillsBlock,
         });
         this.bootstrap = {
             persona: clonePersona(nextPersona),
-            riskLevel: this.runtime.currentRiskLevel,
             discoveredSkills: structuredClone(runtimeConfig.skills),
             personas: personas.map(clonePersona),
             prompts: structuredClone(runtimeConfig.prompts),
+            modelResolver: runtimeConfig.bootstrap.modelResolver.resolveModel,
             config: runtimeConfig.config,
         };
         this.catalog = createContentCatalogSnapshot(this.bootstrap);
@@ -522,11 +495,7 @@ class LocalHostedSessionHandle {
         this.emitSnapshotReset("configuration", snapshot);
         return {
             snapshot,
-            warnings: [
-                ...runtimeConfig.warnings,
-                ...runtimeContext.promptBootstrap.warnings,
-                ...unknownSkillWarnings,
-            ],
+            warnings: [...runtimeConfig.warnings, ...unknownSkillWarnings],
             counts: {
                 personas: runtimeConfig.personas.length,
                 prompts: runtimeConfig.prompts.length,
@@ -634,12 +603,12 @@ class LocalHostedSessionHandle {
             contextId,
             persona: this.runtime.persona,
             config: this.bootstrap.config ?? {},
+            modelResolver: this.bootstrap.modelResolver,
             discoveredSkills: this.bootstrap.discoveredSkills,
             includeAgentContext: this.includeAgentContext,
             executionEnvironment: this.executionEnvironment,
             instructions: options.instructions,
             tools: options.tools,
-            riskLevel: options.riskLevel,
             emitUpdate: (threadId, update) => {
                 this.emitEphemeral(createSessionProtocolEphemeralMessage({
                     sessionId: this.session.sessionId,
@@ -774,7 +743,6 @@ class LocalHostedSessionHandle {
             costTotal: this.costTotal,
             settings: {
                 personaId: this.runtime.persona.id,
-                riskLevel: this.runtime.currentRiskLevel,
                 ...(this.runtime.persona.settings.reasoning !== undefined
                     ? { reasoning: this.runtime.persona.settings.reasoning }
                     : {}),
@@ -835,7 +803,9 @@ class LocalHostedSessionHandle {
         if (message.id === "system") {
             return false;
         }
-        if (isCoreMessage(message.message) && hasAutoCompactionContinuationMetadata(message.message)) {
+        if (isCoreMessage(message.message) &&
+            (isTauUserMessageHidden(message.message) ||
+                hasAutoCompactionContinuationMetadata(message.message))) {
             return false;
         }
         if (!this.restoredTimelineMessageIds || !this.restoredMessageIds) {
@@ -923,34 +893,37 @@ class LocalHostedSessionHandle {
             }
             case "assistant_partial": {
                 const previousDraft = this.draftAssistantMessage;
+                const message = {
+                    role: "assistant",
+                    content: [
+                        ...(event.snapshot.hasAnyThinking
+                            ? [
+                                {
+                                    type: "thinking",
+                                    thinking: event.snapshot.thinking,
+                                },
+                            ]
+                            : []),
+                        ...(event.snapshot.hasTextStarted
+                            ? [{ type: "text", text: event.snapshot.text }]
+                            : []),
+                        ...event.snapshot.toolCalls,
+                    ],
+                    timestamp: Date.now(),
+                };
                 const nextDraft = {
                     id: event.historyEntryId,
                     state: "draft",
                     modelVisible: false,
-                    message: {
-                        role: "assistant",
-                        content: [
-                            ...(event.snapshot.hasAnyThinking
-                                ? [
-                                    {
-                                        type: "thinking",
-                                        thinking: event.snapshot.thinking,
-                                    },
-                                ]
-                                : []),
-                            ...(event.snapshot.hasTextStarted
-                                ? [{ type: "text", text: event.snapshot.text }]
-                                : []),
-                        ],
-                        timestamp: Date.now(),
-                    },
+                    message,
                 };
                 const changes = this.buildAssistantPartialChanges(previousDraft, nextDraft);
-                if (changes.length === 0) {
+                const toolChanges = this.syncToolRunsFromAssistantMessage(event.historyEntryId, message);
+                if (changes.length === 0 && toolChanges.length === 0) {
                     return;
                 }
                 this.draftAssistantMessage = nextDraft;
-                await this.emitPatch("assistant-stream", changes, {
+                await this.emitPatch("assistant-stream", [...changes, ...toolChanges], {
                     persist: false,
                 });
                 return;
@@ -958,7 +931,7 @@ class LocalHostedSessionHandle {
             case "assistant_final": {
                 this.draftAssistantMessage = undefined;
                 this.messageStates.delete(event.historyEntryId);
-                this.seedToolRunsFromAssistantMessage(event.historyEntryId, event.message);
+                const toolChanges = this.syncToolRunsFromAssistantMessage(event.historyEntryId, event.message);
                 this.costTotal += event.message.usage?.cost?.total ?? 0;
                 await this.emitPatch("assistant-message", [
                     { type: "cost.set", costTotal: this.costTotal },
@@ -971,7 +944,7 @@ class LocalHostedSessionHandle {
                             message: event.message,
                         },
                     },
-                    ...this.toolChangesForAssistantMessage(event.historyEntryId, event.message),
+                    ...toolChanges,
                 ]);
                 return;
             }
@@ -1014,6 +987,34 @@ class LocalHostedSessionHandle {
                 ]);
                 return;
             }
+            case "tool_recovery": {
+                const changes = [
+                    {
+                        type: "message.append",
+                        message: {
+                            id: event.historyEntryId,
+                            state: "committed",
+                            modelVisible: true,
+                            message: event.message,
+                        },
+                    },
+                ];
+                for (const toolResult of event.toolResults) {
+                    const existing = this.tools.get(toolResult.toolCallId);
+                    if (!existing) {
+                        throw new Error(`missing protocol tool run for '${toolResult.toolCallId}'`);
+                    }
+                    const nextTool = {
+                        ...existing,
+                        status: toolResult.isError ? "failed" : "succeeded",
+                        finishedAt: toolResult.timestamp,
+                    };
+                    this.tools.set(nextTool.id, nextTool);
+                    changes.push({ type: "tool.set", tool: structuredClone(nextTool) });
+                }
+                await this.emitPatch("recovery", changes);
+                return;
+            }
             case "notice": {
                 const item = {
                     type: "notice",
@@ -1212,38 +1213,35 @@ class LocalHostedSessionHandle {
             }
         }
     }
-    seedToolRunsFromAssistantMessage(messageId, message) {
+    syncToolRunsFromAssistantMessage(messageId, message) {
+        const changes = [];
         const toolCalls = message.content
             .map((content, index) => ({ content, index }))
             .filter((item) => item.content.type === "toolCall");
         for (const { content, index } of toolCalls) {
-            if (this.tools.has(content.id)) {
-                continue;
-            }
-            this.tools.set(content.id, {
-                id: content.id,
-                toolCallId: content.id,
+            const existing = this.tools.get(content.id);
+            const nextTool = {
+                ...(existing ?? {
+                    id: content.id,
+                    toolCallId: content.id,
+                    status: "queued",
+                    facetIds: [],
+                }),
                 toolName: content.name,
                 call: {
                     messageId,
                     contentIndex: index,
                 },
-                status: "queued",
-                facetIds: [],
-            });
-        }
-    }
-    toolChangesForAssistantMessage(_messageId, message) {
-        return message.content
-            .map((content, index) => ({ content, index }))
-            .filter((item) => item.content.type === "toolCall")
-            .map(({ content }) => {
-            const tool = this.tools.get(content.id);
-            if (!tool) {
-                throw new Error(`missing protocol tool run for tool call '${content.id}'`);
+            };
+            if (existing?.toolName === nextTool.toolName &&
+                existing.call.messageId === nextTool.call.messageId &&
+                existing.call.contentIndex === nextTool.call.contentIndex) {
+                continue;
             }
-            return { type: "tool.set", tool: structuredClone(tool) };
-        });
+            this.tools.set(content.id, nextTool);
+            changes.push({ type: "tool.set", tool: structuredClone(nextTool) });
+        }
+        return changes;
     }
     async interruptDraftAssistantMessage() {
         const draft = this.draftAssistantMessage;
@@ -1284,6 +1282,18 @@ function buildAssistantContentAppendChange(previousDraft, nextDraft) {
         nextDraft.message.role !== "assistant") {
         return undefined;
     }
+    const previousContent = previousDraft.message.content;
+    const nextContent = nextDraft.message.content;
+    const previousStaticContent = previousContent.filter((content) => content.type !== "text" && content.type !== "thinking");
+    const nextStaticContent = nextContent.filter((content) => content.type !== "text" && content.type !== "thinking");
+    if (JSON.stringify(previousStaticContent) !== JSON.stringify(nextStaticContent)) {
+        return undefined;
+    }
+    if (previousStaticContent.length > 0 &&
+        (previousContent.length !== nextContent.length ||
+            previousContent.some((content, index) => content.type !== nextContent[index].type))) {
+        return undefined;
+    }
     const previousText = getAssistantDraftBlockText(previousDraft, "text");
     const nextText = getAssistantDraftBlockText(nextDraft, "text");
     const previousThinking = getAssistantDraftBlockText(previousDraft, "thinking");
@@ -1306,10 +1316,9 @@ function buildAssistantContentAppendChange(previousDraft, nextDraft) {
 }
 function assistantDraftContentEquals(previousDraft, nextDraft) {
     return (previousDraft.id === nextDraft.id &&
-        getAssistantDraftBlockText(previousDraft, "text") ===
-            getAssistantDraftBlockText(nextDraft, "text") &&
-        getAssistantDraftBlockText(previousDraft, "thinking") ===
-            getAssistantDraftBlockText(nextDraft, "thinking"));
+        previousDraft.message.role === "assistant" &&
+        nextDraft.message.role === "assistant" &&
+        JSON.stringify(previousDraft.message.content) === JSON.stringify(nextDraft.message.content));
 }
 function getAssistantDraftBlockText(message, type) {
     if (message.message.role !== "assistant") {
@@ -1474,10 +1483,10 @@ function agentRunFromSubagentEvent(event, originHistoryEntryId, existing) {
 function cloneResolvedBootstrap(bootstrap) {
     return {
         persona: clonePersona(bootstrap.persona),
-        riskLevel: bootstrap.riskLevel,
         discoveredSkills: structuredClone(bootstrap.discoveredSkills),
         personas: bootstrap.personas.map(clonePersona),
         prompts: structuredClone(bootstrap.prompts),
+        modelResolver: bootstrap.modelResolver,
         ...(bootstrap.config !== undefined ? { config: structuredClone(bootstrap.config) } : {}),
     };
 }
@@ -1541,7 +1550,6 @@ function subagentSnapshotsFromConfig(subagents) {
         snapshots[name] = {
             ...(config.description !== undefined ? { description: config.description } : {}),
             ...(config.tools ? { tools: [...config.tools] } : {}),
-            ...(config.riskLevel !== undefined ? { riskLevel: config.riskLevel } : {}),
             ...(config.launchModels ? { launchModels: [...config.launchModels] } : {}),
         };
     }