opencandle 0.7.0 → 0.9.0

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,

package/gui/shared/chat-events.ts

@@ -44,37 +44,56 @@ export interface Usage {
   cost?: unknown;
 }
 
+interface ChatEventBase {
+  sessionId: string;
+  seq: number;
+}
+
+interface RunScopedChatEventBase extends ChatEventBase {
+  runId: string;
+}
+
 export type ChatEvent =
-  | { type: "run.started"; runId: string; sessionId: string; seq: number }
-  | { type: "thinking.delta"; runId: string; text: string; seq: number }
-  | { type: "thinking.completed"; runId: string; text?: string; seq: number }
-  | { type: "message.created"; messageId: string; role: ChatRole; seq: number }
-  | { type: "message.delta"; messageId: string; text: string; seq: number }
-  | { type: "message.completed"; messageId: string; content: MessageContent[]; seq: number }
-  | {
+  | ({ type: "run.started" } & RunScopedChatEventBase)
+  | ({ type: "thinking.delta"; text: string } & RunScopedChatEventBase)
+  | ({ type: "thinking.completed"; text?: string } & RunScopedChatEventBase)
+  | ({ type: "message.created"; messageId: string; role: ChatRole; runId?: string } & ChatEventBase)
+  | ({ type: "message.delta"; messageId: string; text: string; runId?: string } & ChatEventBase)
+  | ({
+      type: "message.completed";
+      messageId: string;
+      content: MessageContent[];
+      runId?: string;
+    } & ChatEventBase)
+  | ({
       type: "custom.message";
       messageId: string;
       customType: string;
       content: MessageContent[];
-      seq: number;
-    }
-  | {
+    } & ChatEventBase)
+  | ({
       type: "tool.started";
       toolCallId: string;
       messageId: string;
       name: string;
       input: unknown;
-      seq: number;
-    }
-  | { type: "tool.delta"; toolCallId: string; chunk: unknown; seq: number }
-  | { type: "tool.completed"; toolCallId: string; output: ToolOutput; seq: number }
-  | { type: "tool.failed"; toolCallId: string; error: ToolError; seq: number }
-  | { type: "run.completed"; runId: string; usage?: Usage; seq: number }
-  | { type: "run.failed"; runId: string; error: RunError; seq: number }
-  | { type: "session.updated"; sessionId: string; title?: string; updatedAt: string; seq: number };
+      runId?: string;
+    } & ChatEventBase)
+  | ({ type: "tool.delta"; toolCallId: string; chunk: unknown; runId?: string } & ChatEventBase)
+  | ({
+      type: "tool.completed";
+      toolCallId: string;
+      output: ToolOutput;
+      runId?: string;
+    } & ChatEventBase)
+  | ({ type: "tool.failed"; toolCallId: string; error: ToolError; runId?: string } & ChatEventBase)
+  | ({ type: "run.completed"; usage?: Usage } & RunScopedChatEventBase)
+  | ({ type: "run.failed"; error: RunError } & RunScopedChatEventBase)
+  | ({ type: "session.updated"; title?: string; updatedAt: string } & ChatEventBase);
 
 export interface RenderMessage {
   id: string;
+  sessionId?: string;
   role: ChatRole;
   status: "streaming" | "completed";
   content: MessageContent[];
@@ -84,6 +103,7 @@ export interface RenderMessage {
 
 export interface RenderToolCall {
   id: string;
+  sessionId?: string;
   messageId: string;
   name: string;
   input: unknown;
@@ -95,6 +115,7 @@ export interface RenderToolCall {
 
 export interface RenderThinking {
   runId: string;
+  sessionId?: string;
   status: "streaming" | "completed";
   text: string;
 }
@@ -109,7 +130,8 @@ export interface ChatRunState {
 
 export interface ChatRenderState {
   lastSeq: number;
-  seenSeq: Set<number>;
+  seenSeq: Set<string>;
+  lastSeqBySession: Map<string, number>;
   messages: RenderMessage[];
   messageById: Map<string, RenderMessage>;
   tools: Map<string, RenderToolCall>;
@@ -123,6 +145,7 @@ export function createChatRenderState(): ChatRenderState {
   return {
     lastSeq: 0,
     seenSeq: new Set(),
+    lastSeqBySession: new Map(),
     messages: [],
     messageById: new Map(),
     tools: new Map(),

package/gui/shared/event-reducer.ts

@@ -8,23 +8,26 @@ import {
 
 export function reduceChatEvents(events: ChatEvent[]): ChatRenderState {
   return [...events]
-    .sort((a, b) => a.seq - b.seq)
+    .sort((a, b) => (a.sessionId === b.sessionId ? a.seq - b.seq : 0))
     .reduce((state, event) => applyChatEvent(state, event), createChatRenderState());
 }
 
 export function applyChatEvent(state: ChatRenderState, event: ChatEvent): ChatRenderState {
-  if (state.seenSeq.has(event.seq)) return state;
+  const eventKey = `${event.sessionId}:${event.seq}`;
+  if (state.seenSeq.has(eventKey)) return state;
 
   const next = cloneState(state);
-  if (event.seq > next.lastSeq + 1 && next.lastSeq !== 0) {
-    next.gaps.push({ expected: next.lastSeq + 1, received: event.seq });
+  const sessionLastSeq = next.lastSeqBySession.get(event.sessionId) ?? 0;
+  if (event.seq > sessionLastSeq + 1 && sessionLastSeq !== 0) {
+    next.gaps.push({ expected: sessionLastSeq + 1, received: event.seq });
   }
-  next.seenSeq.add(event.seq);
+  next.seenSeq.add(eventKey);
+  next.lastSeqBySession.set(event.sessionId, Math.max(sessionLastSeq, event.seq));
   next.lastSeq = Math.max(next.lastSeq, event.seq);
 
   switch (event.type) {
     case "run.started":
-      next.runs.set(event.runId, {
+      next.runs.set(scopedId(event.sessionId, event.runId), {
         id: event.runId,
         sessionId: event.sessionId,
         status: "running",
@@ -33,25 +36,25 @@ export function applyChatEvent(state: ChatRenderState, event: ChatEvent): ChatRe
       break;
 
     case "thinking.delta": {
-      const thinking = ensureThinking(next, event.runId);
+      const thinking = ensureThinking(next, event.sessionId, event.runId);
       thinking.status = "streaming";
       thinking.text += event.text;
       break;
     }
 
     case "thinking.completed": {
-      const thinking = ensureThinking(next, event.runId);
+      const thinking = ensureThinking(next, event.sessionId, event.runId);
       thinking.status = "completed";
       if (event.text !== undefined) thinking.text = event.text;
       break;
     }
 
     case "message.created":
-      ensureMessage(next, event.messageId, event.role);
+      ensureMessage(next, event.sessionId, event.messageId, event.role);
       break;
 
     case "message.delta": {
-      const message = ensureMessage(next, event.messageId, "assistant");
+      const message = ensureMessage(next, event.sessionId, event.messageId, "assistant");
       message.status = "streaming";
       message.text += event.text;
       message.content = [{ type: "text", text: message.text }];
@@ -59,7 +62,7 @@ export function applyChatEvent(state: ChatRenderState, event: ChatEvent): ChatRe
     }
 
     case "message.completed": {
-      const message = ensureMessage(next, event.messageId, "assistant");
+      const message = ensureMessage(next, event.sessionId, event.messageId, "assistant");
       message.status = "completed";
       message.content = event.content;
       message.text = contentText(event.content);
@@ -67,7 +70,7 @@ export function applyChatEvent(state: ChatRenderState, event: ChatEvent): ChatRe
     }
 
     case "custom.message": {
-      const message = ensureMessage(next, event.messageId, "assistant");
+      const message = ensureMessage(next, event.sessionId, event.messageId, "assistant");
       message.status = "completed";
       message.content = event.content;
       message.text = contentText(event.content);
@@ -76,9 +79,10 @@ export function applyChatEvent(state: ChatRenderState, event: ChatEvent): ChatRe
     }
 
     case "tool.started":
-      ensureMessage(next, event.messageId, "assistant");
-      next.tools.set(event.toolCallId, {
+      ensureMessage(next, event.sessionId, event.messageId, "assistant");
+      next.tools.set(scopedId(event.sessionId, event.toolCallId), {
         id: event.toolCallId,
+        sessionId: event.sessionId,
         messageId: event.messageId,
         name: event.name,
         input: event.input,
@@ -88,13 +92,13 @@ export function applyChatEvent(state: ChatRenderState, event: ChatEvent): ChatRe
       break;
 
     case "tool.delta": {
-      const tool = next.tools.get(event.toolCallId);
+      const tool = next.tools.get(scopedId(event.sessionId, event.toolCallId));
       if (tool) tool.chunks.push(event.chunk);
       break;
     }
 
     case "tool.completed": {
-      const tool = next.tools.get(event.toolCallId);
+      const tool = next.tools.get(scopedId(event.sessionId, event.toolCallId));
       if (tool) {
         tool.status = event.output.isError ? "failed" : "completed";
         tool.output = event.output;
@@ -103,7 +107,7 @@ export function applyChatEvent(state: ChatRenderState, event: ChatEvent): ChatRe
     }
 
     case "tool.failed": {
-      const tool = next.tools.get(event.toolCallId);
+      const tool = next.tools.get(scopedId(event.sessionId, event.toolCallId));
       if (tool) {
         tool.status = "failed";
         tool.error = event.error;
@@ -112,7 +116,7 @@ export function applyChatEvent(state: ChatRenderState, event: ChatEvent): ChatRe
     }
 
     case "run.completed": {
-      const run = next.runs.get(event.runId);
+      const run = next.runs.get(scopedId(event.sessionId, event.runId));
       if (run) {
         run.status = "completed";
         run.usage = event.usage;
@@ -121,7 +125,7 @@ export function applyChatEvent(state: ChatRenderState, event: ChatEvent): ChatRe
     }
 
     case "run.failed": {
-      const run = next.runs.get(event.runId);
+      const run = next.runs.get(scopedId(event.sessionId, event.runId));
       if (run) {
         run.status = "failed";
         run.error = event.error;
@@ -143,20 +147,23 @@ export function applyChatEvent(state: ChatRenderState, event: ChatEvent): ChatRe
 
 function ensureMessage(
   state: ChatRenderState,
+  sessionId: string,
   id: string,
   role: RenderMessage["role"],
 ): RenderMessage {
-  const existing = state.messageById.get(id);
+  const key = scopedId(sessionId, id);
+  const existing = state.messageById.get(key);
   if (existing) return existing;
 
   const message: RenderMessage = {
     id,
+    sessionId,
     role,
     status: "streaming",
     content: [],
     text: "",
   };
-  state.messageById.set(id, message);
+  state.messageById.set(key, message);
   state.messages.push(message);
   return message;
 }
@@ -166,10 +173,13 @@ function cloneState(state: ChatRenderState): ChatRenderState {
     ...message,
     content: [...message.content],
   }));
-  const messageById = new Map(messages.map((message) => [message.id, message]));
+  const messageById = new Map(
+    messages.map((message) => [scopedId(message.sessionId ?? "", message.id), message]),
+  );
   return {
     ...state,
     seenSeq: new Set(state.seenSeq),
+    lastSeqBySession: new Map(state.lastSeqBySession),
     messages,
     messageById,
     tools: new Map(
@@ -188,14 +198,19 @@ function cloneState(state: ChatRenderState): ChatRenderState {
   };
 }
 
-function ensureThinking(state: ChatRenderState, runId: string) {
-  const existing = state.thinking.get(runId);
+function ensureThinking(state: ChatRenderState, sessionId: string, runId: string) {
+  const key = scopedId(sessionId, runId);
+  const existing = state.thinking.get(key);
   if (existing) return existing;
-  const thinking = { runId, status: "streaming" as const, text: "" };
-  state.thinking.set(runId, thinking);
+  const thinking = { runId, sessionId, status: "streaming" as const, text: "" };
+  state.thinking.set(key, thinking);
   return thinking;
 }
 
+function scopedId(sessionId: string, id: string): string {
+  return `${sessionId ?? ""}::${id}`;
+}
+
 function contentText(content: MessageContent[]): string {
   return content
     .filter((part): part is Extract<MessageContent, { type: "text" }> => part.type === "text")