opencandle 0.8.0 → 0.10.0

package/gui/server/invoke-tool.ts

@@ -8,6 +8,12 @@ import { wrapWithDefaults } from "../../src/runtime/tool-defaults-wrapper.js";
 import { getAllTools } from "../../src/tools/index.js";
 import type { AskUserHandler } from "../../src/types/index.js";
 import { buildToolInvokeAckMessage } from "./tool-invoke-ack.js";
+import {
+  acquireWriterLock,
+  refreshWriterLock,
+  releaseWriterLock,
+  writerLockScopeForSession,
+} from "./writer-lock.js";
 
 export interface InvokeToolResult {
   toolCallId: string;
@@ -20,7 +26,11 @@ interface ToolInvokeClient {
 }
 
 export interface ToolInvokeController {
-  handleToolInvoke(toolName: string, args: Record<string, unknown>): Promise<InvokeToolResult>;
+  handleToolInvoke(
+    toolName: string,
+    args: Record<string, unknown>,
+    sessionId?: string,
+  ): Promise<InvokeToolResult>;
   handleToolInvokeMessage(client: ToolInvokeClient, data: Record<string, unknown>): Promise<void>;
 }
 
@@ -32,6 +42,10 @@ export interface ToolInvokeControllerOptions {
   getTools?: typeof getAllTools;
   invokeTool?: typeof invokeToolFromUi;
   askUserHandler?: AskUserHandler;
+  askUserHandlerForSessionId?: (sessionId: string) => AskUserHandler;
+  resolveSessionManager?: (sessionId: string) => Promise<SessionManager | null>;
+  broadcastSessionSnapshot?: (sessionManager: SessionManager) => void;
+  broadcastSessions?: () => void;
 }
 
 export function createToolInvokeController({
@@ -42,20 +56,63 @@ export function createToolInvokeController({
   getTools = getAllTools,
   invokeTool = invokeToolFromUi,
   askUserHandler,
+  askUserHandlerForSessionId,
+  resolveSessionManager,
+  broadcastSessionSnapshot,
+  broadcastSessions,
 }: ToolInvokeControllerOptions): ToolInvokeController {
   async function handleToolInvoke(
     toolName: string,
     args: Record<string, unknown>,
+    sessionId = "",
   ): Promise<InvokeToolResult> {
     if (role !== "writer") throw new Error("Read-only follower mode");
     const tool = getTools().find((candidate) => candidate.name === toolName);
     if (!tool) throw new Error(`Unknown tool: ${toolName}`);
-    const result = await invokeTool(getSessionManager(), tool, args, "ui", { askUserHandler });
-    if (!result.isError && marketStateToolMapping(toolName) != null) {
-      onMarketStateChanged?.();
+
+    const currentSessionManager = getSessionManager();
+    const runSessionManager = await resolveToolInvokeSessionManager(
+      currentSessionManager,
+      sessionId,
+      resolveSessionManager,
+    );
+    const useCurrentSession = sameSessionStorage(currentSessionManager, runSessionManager);
+    let acquiredLockScope = "";
+    let lockHeartbeat: ReturnType<typeof setInterval> | undefined;
+    if (!useCurrentSession) {
+      const lockScope = writerLockScopeForSession(runSessionManager);
+      const lockResult = await acquireWriterLock(lockScope, "gui");
+      if (lockResult.role !== "writer") {
+        throw new Error(
+          `Session is currently being written by ${lockResult.lock.processKind} (pid ${lockResult.lock.pid}).`,
+        );
+      }
+      acquiredLockScope = lockScope;
+      lockHeartbeat = setInterval(() => refreshWriterLock(lockScope), 5000);
+    }
+
+    try {
+      const runSessionId = safeSessionId(runSessionManager);
+      const result = await invokeTool(runSessionManager, tool, args, "ui", {
+        askUserHandler:
+          runSessionId && askUserHandlerForSessionId
+            ? askUserHandlerForSessionId(runSessionId)
+            : askUserHandler,
+      });
+      if (!result.isError && marketStateToolMapping(toolName) != null) {
+        onMarketStateChanged?.();
+      }
+      if (useCurrentSession) {
+        broadcastState();
+      } else {
+        broadcastSessionSnapshot?.(runSessionManager);
+        broadcastSessions?.();
+      }
+      return result;
+    } finally {
+      if (lockHeartbeat) clearInterval(lockHeartbeat);
+      if (acquiredLockScope) releaseWriterLock(acquiredLockScope);
     }
-    broadcastState();
-    return result;
   }
 
   async function handleToolInvokeMessage(
@@ -64,8 +121,9 @@ export function createToolInvokeController({
   ): Promise<void> {
     const requestId = typeof data.requestId === "string" ? data.requestId : "";
     const toolName = String(data.toolName ?? "");
+    const sessionId = typeof data.sessionId === "string" ? data.sessionId : "";
     try {
-      const result = await handleToolInvoke(toolName, requestArgs(data.args));
+      const result = await handleToolInvoke(toolName, requestArgs(data.args), sessionId);
       if (requestId) {
         client.send(buildToolInvokeAckMessage(requestId, toolName, result));
       }
@@ -88,6 +146,43 @@ export function createToolInvokeController({
   return { handleToolInvoke, handleToolInvokeMessage };
 }
 
+function sameSessionStorage(current: SessionManager, target: SessionManager): boolean {
+  if (current === target) return true;
+  const currentFile = safeSessionFile(current);
+  const targetFile = safeSessionFile(target);
+  return Boolean(currentFile && targetFile && currentFile === targetFile);
+}
+
+function safeSessionFile(sessionManager: SessionManager): string {
+  try {
+    return sessionManager.getSessionFile() ?? "";
+  } catch {
+    return "";
+  }
+}
+
+function safeSessionId(sessionManager: SessionManager): string {
+  try {
+    return sessionManager.getSessionId();
+  } catch {
+    return "";
+  }
+}
+
+async function resolveToolInvokeSessionManager(
+  currentSessionManager: SessionManager,
+  sessionId: string,
+  resolveSessionManager: ((sessionId: string) => Promise<SessionManager | null>) | undefined,
+): Promise<SessionManager> {
+  const targetSessionId = sessionId.trim();
+  if (!targetSessionId || targetSessionId === safeSessionId(currentSessionManager)) {
+    return currentSessionManager;
+  }
+  const resolved = await resolveSessionManager?.(targetSessionId);
+  if (!resolved) throw new Error("Unknown saved session");
+  return resolved;
+}
+
 function requestArgs(value: unknown): Record<string, unknown> {
   return typeof value === "object" && value !== null ? (value as Record<string, unknown>) : {};
 }

package/gui/server/live-chat-event-adapter.ts

@@ -29,15 +29,20 @@ export function createLiveChatEventAdapter(
   let lastAssistantMessageId: string | undefined;
   const completedMessageIds = new Set<string>();
 
-  const emit = (event: Omit<ChatEvent, "seq">) => {
-    options.emit({ ...event, seq: seq++ } as ChatEvent);
+  const emit = (event: Omit<ChatEvent, "seq" | "sessionId">) => {
+    options.emit({ ...event, sessionId: options.sessionId, seq: seq++ } as ChatEvent);
   };
 
   const ensureAssistantMessage = (): string => {
     if (currentAssistantMessageId) return currentAssistantMessageId;
     currentAssistantMessageId = `${options.runId}-assistant-${++assistantCount}`;
     lastAssistantMessageId = currentAssistantMessageId;
-    emit({ type: "message.created", messageId: currentAssistantMessageId, role: "assistant" });
+    emit({
+      type: "message.created",
+      runId: options.runId,
+      messageId: currentAssistantMessageId,
+      role: "assistant",
+    });
     return currentAssistantMessageId;
   };
 
@@ -49,6 +54,7 @@ export function createLiveChatEventAdapter(
     completedMessageIds.add(messageId);
     emit({
       type: "message.completed",
+      runId: options.runId,
       messageId,
       content: contentToChatContent(message.content),
     });
@@ -66,9 +72,10 @@ export function createLiveChatEventAdapter(
               userCount === 1 && options.originalPrompt
                 ? options.originalPrompt
                 : messageText(message.content);
-            emit({ type: "message.created", messageId, role: "user" });
+            emit({ type: "message.created", runId: options.runId, messageId, role: "user" });
             emit({
               type: "message.completed",
+              runId: options.runId,
               messageId,
               content: [{ type: "text", text }],
             });
@@ -85,6 +92,7 @@ export function createLiveChatEventAdapter(
           if (update.type === "text_delta") {
             emit({
               type: "message.delta",
+              runId: options.runId,
               messageId: ensureAssistantMessage(),
               text: update.delta,
             });
@@ -116,6 +124,7 @@ export function createLiveChatEventAdapter(
           const messageId = messageIdForTool();
           emit({
             type: "tool.started",
+            runId: options.runId,
             toolCallId: event.toolCallId,
             messageId,
             name: event.toolName,
@@ -127,6 +136,7 @@ export function createLiveChatEventAdapter(
         case "tool_execution_update":
           emit({
             type: "tool.delta",
+            runId: options.runId,
             toolCallId: event.toolCallId,
             chunk: event.partialResult,
           });
@@ -137,6 +147,7 @@ export function createLiveChatEventAdapter(
           if (event.isError) {
             emit({
               type: "tool.failed",
+              runId: options.runId,
               toolCallId: event.toolCallId,
               error: {
                 message: messageText(output.content),
@@ -146,6 +157,7 @@ export function createLiveChatEventAdapter(
           } else {
             emit({
               type: "tool.completed",
+              runId: options.runId,
               toolCallId: event.toolCallId,
               output,
             });

package/gui/server/server.ts

@@ -23,7 +23,7 @@ import {
   createBackgroundQuotePoller,
 } from "./background-quotes.js";
 import { createInitialGuiSessionManager } from "./gui-session-manager.js";
-import { createHttpRequestHandler } from "./http-routes.js";
+import { createHttpRequestHandler, resolveSessionManagerById } from "./http-routes.js";
 import { createToolInvokeController } from "./invoke-tool.js";
 import { buildMarketStateQuoteSnapshot } from "./market-state-api.js";
 import { createModelSetupController } from "./model-setup.js";
@@ -31,7 +31,12 @@ import { isTrustedPrivateApiRequest } from "./private-api-access.js";
 import { QuoteSnapshotStore } from "./quote-snapshot-store.js";
 import { createSessionActionsController } from "./session-actions.js";
 import { createGracefulShutdown } from "./shutdown.js";
-import { acquireWriterLock, refreshWriterLock, releaseWriterLock } from "./writer-lock.js";
+import {
+  acquireWriterLock,
+  refreshWriterLock,
+  releaseWriterLock,
+  writerLockScopeForSession,
+} from "./writer-lock.js";
 import { createWsHub, type WsHub } from "./ws-hub.js";
 
 assertSupportedNodeVersion();
@@ -54,7 +59,9 @@ const settingsManager = SettingsManager.create(cwd, agentDir);
 const initialSessionManager = createInitialGuiSessionManager(cwd);
 let sessionManager = initialSessionManager;
 const sessionDir = sessionManager.getSessionDir();
-const lockResult = await acquireWriterLock(sessionDir, "gui");
+const initialWriterLockScope = writerLockScopeForSession(sessionManager);
+const lockResult = await acquireWriterLock(initialWriterLockScope, "gui");
+let activeWriterLockScope = initialWriterLockScope;
 let wsHub: WsHub;
 let quotePoller: BackgroundQuotePoller;
 const askUserBridge = createAskUserBridge({
@@ -84,7 +91,7 @@ const runtime = await createAgentSessionRuntime(
   { cwd, agentDir, sessionManager },
 );
 let session = runtime.session;
-const heartbeat = setInterval(() => refreshWriterLock(sessionDir), 5000);
+const heartbeat = setInterval(() => refreshWriterLock(activeWriterLockScope), 5000);
 const backgroundQuoteRefreshes = new BackgroundQuoteRefreshes();
 const quoteSnapshotStore = new QuoteSnapshotStore(() => buildMarketStateQuoteSnapshot());
 quotePoller = createBackgroundQuotePoller({
@@ -108,8 +115,17 @@ const toolInvokeController = createToolInvokeController({
   role: lockResult.role,
   getSessionManager: () => sessionManager,
   broadcastState: () => wsHub.broadcastState(),
+  broadcastSessionSnapshot: (targetSessionManager) =>
+    wsHub.broadcastSessionSnapshot(targetSessionManager),
+  broadcastSessions: () => wsHub.broadcastSessions(),
   onMarketStateChanged: () => quoteSnapshotStore.invalidate(),
   askUserHandler: askUserBridge.ask,
+  askUserHandlerForSessionId: (sessionId) => askUserBridge.askForSession(sessionId),
+  resolveSessionManager: (sessionId) =>
+    resolveSessionManagerById(
+      { cwd, sessionDir, getSessionManager: () => sessionManager },
+      sessionId,
+    ),
 });
 const sessionActionsController = createSessionActionsController({
   role: lockResult.role,
@@ -145,6 +161,17 @@ wsHub = createWsHub({
 
 let unsubscribeSession = wsHub.subscribeToSessionEvents();
 runtime.setRebindSession(async (nextSession) => {
+  const nextWriterLockScope = writerLockScopeForSession(nextSession.sessionManager);
+  if (lockResult.role === "writer" && nextWriterLockScope !== activeWriterLockScope) {
+    const nextLockResult = await acquireWriterLock(nextWriterLockScope, "gui");
+    if (nextLockResult.role !== "writer") {
+      throw new Error(
+        `Session is currently being written by ${nextLockResult.lock.processKind} (pid ${nextLockResult.lock.pid}).`,
+      );
+    }
+    releaseWriterLock(activeWriterLockScope);
+    activeWriterLockScope = nextWriterLockScope;
+  }
   unsubscribeSession();
   session = nextSession;
   sessionManager = nextSession.sessionManager;
@@ -163,6 +190,16 @@ const httpRequestHandler = createHttpRequestHandler({
   allowRemotePrivateApi,
   getSession: () => session,
   getSessionManager: () => sessionManager,
+  createSessionForManager: async (targetSessionManager) =>
+    createOpenCandleSession({
+      cwd,
+      agentDir,
+      authStorage,
+      modelRegistry,
+      settingsManager,
+      sessionManager: targetSessionManager,
+      askUserHandler: askUserBridge.askForSession(targetSessionManager.getSessionId()),
+    }),
   wsHub,
   modelSetupController,
   sessionActionsController,
@@ -197,7 +234,7 @@ const shutdown = createGracefulShutdown({
     localAutomationHeartbeat.stop();
     wsHub.closeClients();
     unsubscribeSession();
-    releaseWriterLock(sessionDir);
+    releaseWriterLock(activeWriterLockScope);
     await runtime.dispose();
   },
   exit: (code) => process.exit(code),

package/gui/server/session-actions.ts

@@ -2,7 +2,11 @@ import { unlink } from "node:fs/promises";
 import { type AgentSession, SessionManager } from "@earendil-works/pi-coding-agent";
 import type { ModelSetupState } from "./model-setup.js";
 import { type PromptObservation, selectReplayPrompt } from "./prompt-observation.js";
-import { waitForNewEntryId, waitForSessionTurnSettlement } from "./session-entry-wait.js";
+import {
+  waitForNewEntryId,
+  waitForResolvedToolCalls,
+  waitForSessionTurnSettlement,
+} from "./session-entry-wait.js";
 
 interface AskUserBridge {
   answer(id: string, answer: string): boolean;
@@ -164,6 +168,7 @@ export async function promptAndSettle(
     () => runSession.sessionManager.getEntries().map((entry) => entry.id),
     beforeIds,
   );
+  await waitForResolvedToolCalls(() => runSession.sessionManager.getEntries());
   await replayObservedWorkflowPromptIfNeeded(runSession, prompt, observation);
 }
 
@@ -184,6 +189,7 @@ export async function replayObservedWorkflowPromptIfNeeded(
     isStreaming: runSession.isStreaming,
     pendingMessageCount: runSession.pendingMessageCount,
   }));
+  await waitForResolvedToolCalls(() => runSession.sessionManager.getEntries());
 }
 
 export async function renameSessionFile(

package/gui/server/session-entry-wait.ts

@@ -1,3 +1,5 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+
 export interface WaitForEntryCountOptions {
   timeoutMs?: number;
   intervalMs?: number;
@@ -12,6 +14,11 @@ export interface SessionRunStatus {
   pendingMessageCount: number;
 }
 
+export interface UnresolvedToolCall {
+  id: string;
+  name: string;
+}
+
 export async function waitForEntryCount(
   getCount: () => number,
   previousCount: number,
@@ -76,6 +83,78 @@ export async function waitForSessionTurnSettlement(
   throw new Error("Timed out waiting for the session turn to settle");
 }
 
+export function findUnresolvedToolCalls(entries: SessionEntry[]): UnresolvedToolCall[] {
+  const latestAssistantIndex = latestAssistantToolUseIndex(entries);
+  if (latestAssistantIndex === -1) return [];
+
+  const assistant = asMessage(entries[latestAssistantIndex]);
+  const calls = toolCallsFromContent(assistant?.content);
+  if (calls.length === 0) return [];
+
+  const resolved = new Set<string>();
+  for (const entry of entries.slice(latestAssistantIndex + 1)) {
+    const message = asMessage(entry);
+    if (message?.role !== "toolResult") continue;
+    const toolCallId = typeof message.toolCallId === "string" ? message.toolCallId : "";
+    if (toolCallId) resolved.add(toolCallId);
+  }
+
+  return calls.filter((call) => !resolved.has(call.id));
+}
+
+export async function waitForResolvedToolCalls(
+  getEntries: () => SessionEntry[],
+  options: WaitForEntryCountOptions = {},
+): Promise<void> {
+  const timeoutMs = options.timeoutMs ?? 120_000;
+  const intervalMs = options.intervalMs ?? 25;
+  const deadline = Date.now() + timeoutMs;
+
+  while (Date.now() < deadline) {
+    if (findUnresolvedToolCalls(getEntries()).length === 0) return;
+    await delay(intervalMs);
+  }
+
+  const unresolved = findUnresolvedToolCalls(getEntries());
+  if (unresolved.length > 0) {
+    throw new Error(
+      `Timed out waiting for tool results: ${unresolved.map((call) => call.name).join(", ")}`,
+    );
+  }
+}
+
 function delay(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+
+function latestAssistantToolUseIndex(entries: SessionEntry[]): number {
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const message = asMessage(entries[index]);
+    if (message?.role === "assistant") {
+      if (toolCallsFromContent(message.content).length > 0) return index;
+      if (message.stopReason === "stop") return -1;
+    }
+    if (message?.role === "user") return -1;
+  }
+  return -1;
+}
+
+function asMessage(entry: SessionEntry | undefined): Record<string, unknown> | undefined {
+  if (entry?.type !== "message") return undefined;
+  const message = (entry as { message?: unknown }).message;
+  return typeof message === "object" && message !== null && !Array.isArray(message)
+    ? (message as Record<string, unknown>)
+    : undefined;
+}
+
+function toolCallsFromContent(content: unknown): UnresolvedToolCall[] {
+  if (!Array.isArray(content)) return [];
+  return content.flatMap((part): UnresolvedToolCall[] => {
+    if (typeof part !== "object" || part === null || Array.isArray(part)) return [];
+    const record = part as Record<string, unknown>;
+    if (record.type !== "toolCall") return [];
+    const id = typeof record.id === "string" ? record.id : "";
+    const name = typeof record.name === "string" ? record.name : "tool";
+    return id ? [{ id, name }] : [];
+  });
+}

package/gui/server/writer-lock.ts

@@ -1,122 +1 @@
-import { mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-export type ProcessKind = "tui" | "gui";
-
-export interface WriterLock {
-  pid: number;
-  processKind: ProcessKind;
-  acquiredAt: string;
-  lastHeartbeat: string;
-}
-
-export interface AcquireOptions {
-  pid?: number;
-  staleGraceMs?: number;
-}
-
-export type AcquireResult =
-  | { role: "writer"; lock: WriterLock }
-  | { role: "follower"; lock: WriterLock };
-
-const DEFAULT_STALE_GRACE_MS = 15_000;
-
-export async function acquireWriterLock(
-  sessionDir: string,
-  processKind: ProcessKind,
-  options: AcquireOptions = {},
-): Promise<AcquireResult> {
-  mkdirSync(sessionDir, { recursive: true });
-  const pid = options.pid ?? process.pid;
-  const staleGraceMs = options.staleGraceMs ?? DEFAULT_STALE_GRACE_MS;
-
-  const created = tryCreate(sessionDir, processKind, pid);
-  if (created) return { role: "writer", lock: created };
-
-  const existing = readWriterLock(sessionDir);
-  if (existing && isLockCurrent(existing, staleGraceMs)) {
-    return { role: "follower", lock: existing };
-  }
-
-  await sleep(staleGraceMs);
-  const afterGrace = readWriterLock(sessionDir);
-  if (afterGrace && isLockCurrent(afterGrace, staleGraceMs)) {
-    return { role: "follower", lock: afterGrace };
-  }
-
-  try {
-    unlinkSync(lockPath(sessionDir));
-  } catch {
-    // Missing or concurrently removed is fine; the next create decides ownership.
-  }
-
-  const recovered = tryCreate(sessionDir, processKind, pid);
-  if (recovered) return { role: "writer", lock: recovered };
-
-  const current = readWriterLock(sessionDir) ?? afterGrace ?? existing;
-  if (!current) throw new Error("Unable to determine active writer lock");
-  return { role: "follower", lock: current };
-}
-
-export function readWriterLock(sessionDir: string): WriterLock | null {
-  try {
-    return JSON.parse(readFileSync(lockPath(sessionDir), "utf8")) as WriterLock;
-  } catch {
-    return null;
-  }
-}
-
-export function refreshWriterLock(sessionDir: string, pid = process.pid): void {
-  const lock = readWriterLock(sessionDir);
-  if (!lock || lock.pid !== pid) return;
-  writeFileSync(
-    lockPath(sessionDir),
-    JSON.stringify({ ...lock, lastHeartbeat: new Date().toISOString() }, null, 2),
-  );
-}
-
-export function releaseWriterLock(sessionDir: string, pid = process.pid): void {
-  const lock = readWriterLock(sessionDir);
-  if (!lock || lock.pid !== pid) return;
-  try {
-    unlinkSync(lockPath(sessionDir));
-  } catch {
-    // Best effort shutdown cleanup.
-  }
-}
-
-function tryCreate(sessionDir: string, processKind: ProcessKind, pid: number): WriterLock | null {
-  const now = new Date().toISOString();
-  const lock: WriterLock = { pid, processKind, acquiredAt: now, lastHeartbeat: now };
-  try {
-    const fd = openSync(lockPath(sessionDir), "wx");
-    writeFileSync(fd, JSON.stringify(lock, null, 2));
-    return lock;
-  } catch {
-    return null;
-  }
-}
-
-function isPidAlive(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function isLockCurrent(lock: WriterLock, staleGraceMs: number): boolean {
-  const heartbeat = Date.parse(lock.lastHeartbeat);
-  return (
-    isPidAlive(lock.pid) && Number.isFinite(heartbeat) && Date.now() - heartbeat <= staleGraceMs
-  );
-}
-
-function lockPath(sessionDir: string): string {
-  return join(sessionDir, "writer.lock");
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
+export * from "../../src/pi/session-writer-lock.js";

package/gui/server/ws-hub.ts

@@ -35,6 +35,7 @@ export interface WsHub {
   broadcast(message: unknown): void;
   broadcastModelSetup(): void;
   broadcastState(): void;
+  broadcastSessionSnapshot(sessionManager: SessionManager): void;
   broadcastSessions(): void;
   buildStateSnapshot(): {
     sessionId: string;
@@ -251,6 +252,13 @@ export function createWsHub({
     });
   }
 
+  function broadcastSessionSnapshot(sessionManager: SessionManager): void {
+    broadcast({
+      type: "session.snapshot",
+      ...buildSnapshotForSession(sessionManager),
+    });
+  }
+
   function buildStateSnapshot() {
     const sessionManager = getSessionManager();
     const sessionId = sessionManager.getSessionId();
@@ -263,11 +271,27 @@ export function createWsHub({
     };
   }
 
+  function buildSnapshotForSession(sessionManager: SessionManager) {
+    const sessionId = sessionManager.getSessionId();
+    const entries = sessionManager.getEntries();
+    return {
+      sessionId,
+      state: projectDashboard(backgroundQuoteRefreshes.withEntries(entries), sessionId),
+      entries,
+      events: sessionEntriesToChatEvents(entries, {
+        sessionId,
+        title: sessionManager.getSessionName(),
+      }),
+    };
+  }
+
   function currentChatEvents(entries = getSessionManager().getEntries()): ChatEvent[] {
     const sessionManager = getSessionManager();
+    const session = getSession();
     return sessionEntriesToChatEvents(entries, {
       sessionId: sessionManager.getSessionId(),
       title: sessionManager.getSessionName(),
+      markUnresolvedToolCalls: !(session.isStreaming || session.pendingMessageCount > 0),
     });
   }
 
@@ -297,6 +321,7 @@ export function createWsHub({
     broadcast,
     broadcastModelSetup,
     broadcastState,
+    broadcastSessionSnapshot,
     broadcastSessions,
     buildStateSnapshot,
     currentChatEvents,