fix: avoid resumeStream on empty history

Change-Id: I5363d2c940e341f3c6b0623603564388eb777c83
Signed-off-by: Thomas Kosiewski <tk@coder.com>

Author: ThomasK33

src/node/services/agentSession.resumeStreamEmptyHistory.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, test, mock } from "bun:test";
+
+import { AgentSession } from "./agentSession";
+import type { Config } from "@/node/config";
+import type { HistoryService } from "./historyService";
+import type { PartialService } from "./partialService";
+import type { AIService } from "./aiService";
+import type { InitStateManager } from "./initStateManager";
+import type { BackgroundProcessManager } from "./backgroundProcessManager";
+import type { Result } from "@/common/types/result";
+import { Ok } from "@/common/types/result";
+
+describe("AgentSession.resumeStream", () => {
+  test("returns an error when history is empty", async () => {
+    const streamMessage = mock(() => Promise.resolve(Ok(undefined)));
+
+    const aiService: AIService = {
+      on: mock(() => aiService),
+      off: mock(() => aiService),
+      stopStream: mock(() => Promise.resolve(Ok(undefined))),
+      isStreaming: mock(() => false),
+      streamMessage,
+    } as unknown as AIService;
+
+    const historyService: HistoryService = {
+      getHistory: mock(() => Promise.resolve(Ok([]))),
+    } as unknown as HistoryService;
+
+    const partialService: PartialService = {
+      commitToHistory: mock((): Promise<Result<void>> => Promise.resolve(Ok(undefined))),
+    } as unknown as PartialService;
+
+    const initStateManager: InitStateManager = {
+      on: mock(() => initStateManager),
+      off: mock(() => initStateManager),
+    } as unknown as InitStateManager;
+
+    const backgroundProcessManager: BackgroundProcessManager = {
+      cleanup: mock(() => Promise.resolve()),
+      setMessageQueued: mock(() => undefined),
+    } as unknown as BackgroundProcessManager;
+
+    const config: Config = { srcDir: "/tmp" } as unknown as Config;
+
+    const session = new AgentSession({
+      workspaceId: "ws",
+      config,
+      historyService,
+      partialService,
+      aiService,
+      initStateManager,
+      backgroundProcessManager,
+    });
+
+    const result = await session.resumeStream({ model: "anthropic:claude-sonnet-4-5" });
+    expect(result.success).toBe(false);
+    if (result.success) return;
+    expect(result.error.type).toBe("unknown");
+    if (result.error.type !== "unknown") {
+      throw new Error(`Expected unknown error, got ${result.error.type}`);
+    }
+    expect(result.error.raw).toContain("history is empty");
+    expect(streamMessage).toHaveBeenCalledTimes(0);
+  });
+});

src/node/services/agentSession.ts

@@ -613,6 +613,13 @@ export class AgentSession {
     if (!historyResult.success) {
       return Err(createUnknownSendMessageError(historyResult.error));
     }
+    if (historyResult.data.length === 0) {
+      return Err(
+        createUnknownSendMessageError(
+          "Cannot resume stream: workspace history is empty. Send a new message instead."
+        )
+      );
+    }
 
     // Check for external file edits (timestamp-based polling)
     const changedFileAttachments = await this.getChangedFileAttachments();

src/node/services/taskService.ts

@@ -185,6 +185,8 @@ export class TaskService {
     this.aiService.on("tool-call-end", (payload: unknown) => {
       if (!isToolCallEndEvent(payload)) return;
       if (payload.toolName !== "agent_report") return;
+      // Ignore failed agent_report attempts (e.g. tool rejected due to active descendants).
+      if (!isSuccessfulToolResult(payload.result)) return;
       void this.handleAgentReport(payload).catch((error: unknown) => {
         log.error("TaskService.handleAgentReport failed", { error });
       });
@@ -1721,7 +1723,14 @@ export class TaskService {
     const childEntry = this.findWorkspaceEntry(cfgAfterReport, childWorkspaceId);
     const parentWorkspaceId = childEntry?.workspace.parentWorkspaceId;
     if (!parentWorkspaceId) {
-      log.error("agent_report called from non-task workspace", { childWorkspaceId });
+      const reason = childEntry ? "missing parentWorkspaceId" : "workspace not found in config";
+      log.debug("Ignoring agent_report: workspace is not an agent task", {
+        childWorkspaceId,
+        reason,
+      });
+      // Best-effort: resolve any foreground waiters even if we can't deliver to a parent.
+      this.resolveWaiters(childWorkspaceId, reportArgs);
+      void this.maybeStartQueuedTasks();
       return;
     }
 
@@ -1738,6 +1747,10 @@ export class TaskService {
 
     // Auto-resume any parent stream that was waiting on a task tool call (restart-safe).
     const postCfg = this.config.loadConfigOrDefault();
+    if (!this.findWorkspaceEntry(postCfg, parentWorkspaceId)) {
+      // Parent may have been cleaned up (e.g. it already reported and this was its last descendant).
+      return;
+    }
     const hasActiveDescendants = this.hasActiveDescendantAgentTasks(postCfg, parentWorkspaceId);
     if (!hasActiveDescendants && !this.aiService.isStreaming(parentWorkspaceId)) {
       const resumeResult = await this.workspaceService.resumeStream(parentWorkspaceId, {

src/node/services/workspaceService.ts

@@ -633,6 +633,21 @@ export class WorkspaceService extends EventEmitter {
   async remove(workspaceId: string, force = false): Promise<Result<void>> {
     // Try to remove from runtime (filesystem)
     try {
+      // Stop any active stream before deleting metadata/config to avoid tool calls racing with removal.
+      try {
+        if (this.aiService.isStreaming(workspaceId)) {
+          const stopResult = await this.aiService.stopStream(workspaceId, { abandonPartial: true });
+          if (!stopResult.success) {
+            log.debug("Failed to stop stream during workspace removal", {
+              workspaceId,
+              error: stopResult.error,
+            });
+          }
+        }
+      } catch (error: unknown) {
+        log.debug("Failed to stop stream during workspace removal (threw)", { workspaceId, error });
+      }
+
       const metadataResult = await this.aiService.getWorkspaceMetadata(workspaceId);
       if (metadataResult.success) {
         const metadata = metadataResult.data;
@@ -1314,6 +1329,14 @@ export class WorkspaceService extends EventEmitter {
         });
       }
 
+      // Guard: avoid creating sessions for workspaces that don't exist anymore.
+      if (!this.config.findWorkspace(workspaceId)) {
+        return Err({
+          type: "unknown",
+          raw: "Workspace not found. It may have been deleted.",
+        });
+      }
+
       // Guard: queued agent tasks must not be resumed by generic UI/API calls.
       // TaskService is responsible for dequeuing and starting them.
       if (!internal?.allowQueuedAgentTask) {