Method interruptWorkspaceTurn

src/node/services/taskService.ts:5763–5834

(
    ownerWorkspaceId: string,
    handleId: string
  )

  }

  async interruptWorkspaceTurn(
    ownerWorkspaceId: string,
    handleId: string
  ): Promise<Result<{ workspaceId: string }, string>> {
    let workspaceId: string | undefined;
    let shouldClearQueuedPrompt = false;
    let shouldStopStream = false;
    let interruptedRecord: WorkspaceTurnTaskHandleRecord | undefined;

    const result = await this.workspaceTurnSettlementLocks.withLock(handleId, async () => {
      const record = await this.taskHandleStore.getWorkspaceTurn(ownerWorkspaceId, handleId);
      if (record == null) {
        return Err("Workspace turn not found or out of scope");
      }
      if (record.status === "completed" || record.status === "error") {
        return Err(`Workspace turn is already ${record.status} and cannot be interrupted.`);
      }

      workspaceId = record.workspaceId;
      shouldClearQueuedPrompt =
        record.status === "queued" &&
        this.workspaceService.hasQueuedWorkspaceTurn(record.workspaceId, record.handleId);
      shouldStopStream = record.status !== "queued";

      const next: WorkspaceTurnTaskHandleRecord = {
        ...record,
        status: "interrupted",
        updatedAt: getIsoNow(),
      };
      await this.taskHandleStore.upsertWorkspaceTurn(next);
      interruptedRecord = next;

      const active = this.activeWorkspaceTurnHandleByWorkspaceId.get(record.workspaceId);
      if (
        active?.handleId === record.handleId &&
        active.ownerWorkspaceId === record.ownerWorkspaceId
      ) {
        this.activeWorkspaceTurnHandleByWorkspaceId.delete(record.workspaceId);
      }
      this.settleWorkspaceTurnWaiters(record.handleId, {
        status: "error",
        error: new Error("Workspace turn interrupted"),
      });
      this.markTaskForegroundRelevant(record.handleId);
      return Ok({ workspaceId: record.workspaceId });
    });

    if (!result.success) {
      return result;
    }

    if (shouldClearQueuedPrompt && workspaceId != null) {
      const clearQueueResult = this.workspaceService.clearQueue(workspaceId, {
        cancelReason: "Workspace turn interrupted",
      });
      if (!clearQueueResult.success) {
        return Err(`Failed to clear queued workspace turn: ${clearQueueResult.error}`);
      }