skills/workflow/SKILL.md 359:# Cancel a running workflow 360:npx workflow cancel 361:npx workflow cancel --backend vercel --project --team pnpm-lock.yaml 12935: p-cancelable@3.0.0: 26677: p-cancelable: 3.0.0 29557: p-cancelable@3.0.0: {} packages/world/src/steps.ts 16: 'cancelled', packages/world/src/runs.ts 15: 'cancelled', 53: // Cancelled state 55: status: z.literal('cancelled'), 109:export interface CancelWorkflowRunParams { packages/world/src/interfaces.ts 65: * - run_cancelled event for run cancellation 69: * reaches a terminal state (run_completed, run_failed, run_cancelled). This releases packages/world/src/events.ts 12: 'run_cancelled', 205: * Event created when a workflow run is cancelled. 206: * Updates the run entity to status 'cancelled'. 208:const RunCancelledEventSchema = BaseEventSchema.extend({ 209: eventType: z.literal('run_cancelled'), 220: RunCancelledEventSchema, 244: RunCancelledEventSchema, packages/world/CHANGELOG.md 53: - `run_cancelled`: skip event storage, directly update run 58: - Remove `cancel`, `pause`, `resume` from `runs` 60: - Add run lifecycle events: `run_created`, `run_started`, `run_completed`, `run_failed`, `run_cancelled` packages/world-vercel/src/runs.ts 3: type CancelWorkflowRunParams, 206:export async function cancelWorkflowRunV1( 208: params: CancelWorkflowRunParams & { resolveData: 'none' }, 211:export async function cancelWorkflowRunV1( 213: params?: CancelWorkflowRunParams & { resolveData?: 'all' }, 216:export async function cancelWorkflowRunV1( 218: params?: CancelWorkflowRunParams, 221:export async function cancelWorkflowRunV1( 223: params?: CancelWorkflowRunParams, 233: const endpoint = `/v1/runs/${id}/cancel${queryString ? `?${queryString}` : ''}`; packages/world-vercel/src/events.ts 17:import { cancelWorkflowRunV1, createWorkflowRunV1 } from './runs.js'; 123: if (data.eventType === 'run_cancelled' && id) { 124: const run = await cancelWorkflowRunV1(id, params, config); packages/world-vercel/CHANGELOG.md 72: - Remove `cancel`, `pause`, `resume` from `runs` 74: - Add run lifecycle events: `run_created`, `run_started`, `run_completed`, `run_failed`, `run_cancelled` 85:- [#894](https://github.com/vercel/workflow/pull/894) [`a2b688d`](https://github.com/vercel/workflow/commit/a2b688d0623ebbae117877a696c5b9b288d628fd) Thanks [@VaguelySerious](https://github.com/VaguelySerious)! - Fix resuming v1 hooks and cancelling/re-running v1 runs from a v2 UI or runtime 102: - Remove `cancel`, `pause`, `resume` from storage interface packages/world-testing/CHANGELOG.md 90: - Remove `cancel`, `pause`, `resume` from `runs` 92: - Add run lifecycle events: `run_created`, `run_started`, `run_completed`, `run_failed`, `run_cancelled` packages/world-postgres/test/storage.test.ts 1349: it('should reject run_cancelled on completed run', async () => { 1360: events.create(run.runId, { eventType: 'run_cancelled' }) 1394: it('should reject run_cancelled on failed run', async () => { 1403: events.create(run.runId, { eventType: 'run_cancelled' }) 1408: describe('cancelled run', () => { 1409: it('should reject run_started on cancelled run', async () => { 1415: await events.create(run.runId, { eventType: 'run_cancelled' }); 1422: it('should reject run_completed on cancelled run', async () => { 1428: await events.create(run.runId, { eventType: 'run_cancelled' }); 1437: it('should reject run_failed on cancelled run', async () => { 1443: await events.create(run.runId, { eventType: 'run_cancelled' }); 1631: it('should reject step_created on cancelled run', async () => { 1637: await events.create(run.runId, { eventType: 'run_cancelled' }); 1641: stepId: 'new_step_cancelled', 1664: it('should reject hook_created on cancelled run', async () => { 1670: await events.create(run.runId, { eventType: 'run_cancelled' }); 1674: hookId: 'new_hook_cancelled', 1675: token: 'new-token-cancelled', 1682: it('should allow run_cancelled on already cancelled run (idempotent)', async () => { 1688: await events.create(run.runId, { eventType: 'run_cancelled' }); 1692: eventType: 'run_cancelled', 1694: expect(result.run?.status).toBe('cancelled'); 1810: describe('run cancellation with in-flight entities', () => { 1811: it('should allow in-progress step to complete after run cancelled', async () => { 1826: // Cancel the run 1827: await events.create(run.runId, { eventType: 'run_cancelled' }); 1840: it('should reject step_created after run cancelled', async () => { 1846: await events.create(run.runId, { eventType: 'run_cancelled' }); 1850: stepId: 'new_step_after_cancel', 1857: it('should reject step_started for pending step after run cancelled', async () => { 1866: stepId: 'pending_after_cancel', 1871: // Cancel the run 1872: await events.create(run.runId, { eventType: 'run_cancelled' }); 1874: // Should reject - cannot start a pending step on a cancelled run 1876: updateStep(events, run.runId, 'pending_after_cancel', 'step_started') 1971: it('should handle run_cancelled on legacy run with specVersion=1', async () => { 1976: eventType: 'run_cancelled', 1980: expect(result.run?.status).toBe('cancelled'); 1984: it('should handle run_cancelled on legacy run with specVersion=null', async () => { 1989: eventType: 'run_cancelled', 1993: expect(result.run?.status).toBe('cancelled'); 2057: it('should delete hooks when legacy run is cancelled', async () => { 2072: // Cancel the legacy run 2073: await events.create(runId, { eventType: 'run_cancelled' }); packages/world-postgres/src/streamer.ts 255: cancel() { packages/world-postgres/src/storage.ts 162: * - run_cancelled: Skip event storage, directly update run 178: case 'run_cancelled': { 179: // Legacy: Skip event storage, directly update run to cancelled 182: // Update run status to cancelled 186: status: 'cancelled', 325: ['completed', 'failed', 'cancelled'].includes(status); 388: // Idempotent operation: run_cancelled on already cancelled run is allowed 390: data.eventType === 'run_cancelled' && 391: currentRun.status === 'cancelled' 425: data.eventType === 'run_cancelled' 626: // Handle run_cancelled event: update run status and cleanup hooks 627: if (data.eventType === 'run_cancelled') { 631: status: 'cancelled', packages/world-postgres/src/drizzle/migrations/meta/0005_snapshot.json 555: "values": ["pending", "running", "completed", "failed", "cancelled"] 560: "values": ["pending", "running", "completed", "failed", "cancelled"] packages/world-postgres/src/drizzle/migrations/meta/0003_snapshot.json 549: "values": ["pending", "running", "completed", "failed", "cancelled"] 560: "cancelled" packages/world-postgres/src/drizzle/migrations/meta/0002_snapshot.json 527: "values": ["pending", "running", "completed", "failed", "cancelled"] 538: "cancelled" packages/world-postgres/src/drizzle/migrations/meta/0001_snapshot.json 521: "values": ["pending", "running", "completed", "failed", "cancelled"] 532: "cancelled" packages/world-postgres/src/drizzle/migrations/meta/0000_snapshot.json 476: "values": ["pending", "running", "completed", "failed", "cancelled"] 487: "cancelled" packages/world-postgres/src/drizzle/migrations/0005_add_spec_version.sql 3:CREATE TYPE "public"."status" AS ENUM('pending', 'running', 'completed', 'failed', 'cancelled');--> statement-breakpoint packages/world-postgres/src/drizzle/migrations/0004_remove_run_pause_status.sql 1:-- Update any paused runs to cancelled 2:UPDATE "workflow"."workflow_runs" SET "status" = 'cancelled' WHERE "status" = 'paused'; 5:CREATE TYPE "public"."status_new" AS ENUM('pending', 'running', 'completed', 'failed', 'cancelled'); packages/world-postgres/src/drizzle/migrations/0000_cultured_the_anarchist.sql 4: CREATE TYPE "public"."step_status" AS ENUM('pending', 'running', 'completed', 'failed', 'cancelled'); 10: CREATE TYPE "public"."status" AS ENUM('pending', 'running', 'completed', 'failed', 'paused', 'cancelled'); packages/world-postgres/CHANGELOG.md 76: - Remove `cancel`, `pause`, `resume` from `runs` 78: - Add run lifecycle events: `run_created`, `run_started`, `run_completed`, `run_failed`, `run_cancelled` 89: - `run_cancelled`: skip event storage, directly update run packages/world-local/src/streamer.ts 301: // Ignore if controller is already closed (e.g., from cancel() or EOF) 384: cancel() { packages/world-local/src/streamer.test.ts 417: it('should handle stream resumption with startIndex after cancellation (reproduces vibe platform bug)', async () => { 441: // Cancel the first stream (simulating connection loss / timeout) 442: await reader1.cancel(); packages/world-local/src/storage/legacy.ts 13: * - run_cancelled: Skip event storage, directly update run 28: case 'run_cancelled': { 29: // Legacy: Skip event storage, directly update run to cancelled 41: status: 'cancelled', packages/world-local/src/storage/events-storage.ts 80: ['completed', 'failed', 'cancelled'].includes(status); 138: // Idempotent operation: run_cancelled on already cancelled run is allowed 140: data.eventType === 'run_cancelled' && 141: currentRun.status === 'cancelled' 169: data.eventType === 'run_cancelled' 380: } else if (data.eventType === 'run_cancelled') { 394: status: 'cancelled', packages/world-local/src/storage.test.ts 1731: it('should reject run_cancelled on completed run', async () => { 1742: storage.events.create(run.runId, { eventType: 'run_cancelled' }) 1776: it('should reject run_cancelled on failed run', async () => { 1785: storage.events.create(run.runId, { eventType: 'run_cancelled' }) 1790: describe('cancelled run', () => { 1791: it('should reject run_started on cancelled run', async () => { 1797: await storage.events.create(run.runId, { eventType: 'run_cancelled' }); 1804: it('should reject run_completed on cancelled run', async () => { 1810: await storage.events.create(run.runId, { eventType: 'run_cancelled' }); 1819: it('should reject run_failed on cancelled run', async () => { 1825: await storage.events.create(run.runId, { eventType: 'run_cancelled' }); 2013: it('should reject step_created on cancelled run', async () => { 2019: await storage.events.create(run.runId, { eventType: 'run_cancelled' }); 2023: stepId: 'new_step_cancelled', 2046: it('should reject hook_created on cancelled run', async () => { 2052: await storage.events.create(run.runId, { eventType: 'run_cancelled' }); 2056: hookId: 'new_hook_cancelled', 2057: token: 'new-token-cancelled', 2064: it('should allow run_cancelled on already cancelled run (idempotent)', async () => { 2070: await storage.events.create(run.runId, { eventType: 'run_cancelled' }); 2074: eventType: 'run_cancelled', 2076: expect(result.run?.status).toBe('cancelled'); 2192: describe('run cancellation with in-flight entities', () => { 2193: it('should allow in-progress step to complete after run cancelled', async () => { 2208: // Cancel the run 2209: await storage.events.create(run.runId, { eventType: 'run_cancelled' }); 2222: it('should reject step_created after run cancelled', async () => { 2228: await storage.events.create(run.runId, { eventType: 'run_cancelled' }); 2232: stepId: 'new_step_after_cancel', 2239: it('should reject step_started for pending step after run cancelled', async () => { 2248: stepId: 'pending_after_cancel', 2253: // Cancel the run 2254: await storage.events.create(run.runId, { eventType: 'run_cancelled' }); 2256: // Should reject - cannot start a pending step on a cancelled run 2258: updateStep(storage, run.runId, 'pending_after_cancel', 'step_started') 2365: it('should handle run_cancelled on legacy run with specVersion=1', async () => { 2370: eventType: 'run_cancelled', 2374: expect(result.run?.status).toBe('cancelled'); 2378: it('should handle run_cancelled on legacy run with specVersion=undefined', async () => { 2383: eventType: 'run_cancelled', 2387: expect(result.run?.status).toBe('cancelled'); 2451: it('should delete hooks when legacy run is cancelled', async () => { 2475: // Cancel the legacy run 2476: await storage.events.create(runId, { eventType: 'run_cancelled' }); packages/world-local/CHANGELOG.md 85: - Remove `cancel`, `pause`, `resume` from `runs` 87: - Add run lifecycle events: `run_created`, `run_started`, `run_completed`, `run_failed`, `run_cancelled` 98: - `run_cancelled`: skip event storage, directly update run packages/workflow/src/internal/errors.ts 4: WorkflowRunCancelledError, packages/workflow/CHANGELOG.md 162: - Remove `cancel`, `pause`, `resume` from `runs` 164: - Add run lifecycle events: `run_created`, `run_started`, `run_completed`, `run_failed`, `run_cancelled` packages/web/app/server/workflow-server-actions.server.ts 821: * Cancel a workflow run 823:export async function cancelRun( 829: await workflowRunHelpers.cancelRun(world, runId); packages/web/app/routes/api.rpc.tsx 11: cancelRun, 49: cancelRun: (p: any) => cancelRun(p.worldEnv ?? {}, p.runId), packages/web/app/lib/workflow-api-client.ts 27: cancelRun, packages/web/app/lib/rpc-client.ts 153:export async function cancelRun( 157: return rpc('cancelRun', { worldEnv, runId }); packages/web/app/lib/flow-graph/workflow-graph-types.ts 109: | 'cancelled'; 127: status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled'; packages/web/app/lib/flow-graph/graph-execution-mapper.ts 36: * Handles all step statuses: pending, running, completed, failed, cancelled 57: case 'cancelled': 58: status = 'cancelled'; 332: * Handles all run statuses: pending, running, completed, failed, cancelled 354: case 'cancelled': 355: endNodeStatus = 'cancelled'; 781: case 'cancelled': 782: status = 'cancelled'; packages/web/app/lib/client/workflow-actions.ts 2: cancelRun as cancelRunServerAction, 16:/** Cancel a workflow run */ 17:export async function cancelRun(env: EnvMap, runId: string): Promise { 18: await unwrapOrThrow(cancelRunServerAction(env, runId)); packages/web/app/lib/client/workflow-actions.test.ts 3: cancelRun, 11: cancelRun: vi.fn(), 42:describe('cancelRun', () => { 43: it('throws with the server error message when cancellation fails', async () => { 44: vi.mocked(rpc.cancelRun).mockReturnValue(fail('cancel failed')); 45: await expect(cancelRun(env, 'run-1')).rejects.toThrow('cancel failed'); packages/web/app/components/ui/sonner.tsx 18: cancelButton: packages/web/app/components/ui/alert-dialog.tsx 143:function AlertDialogCancel({ 146:}: React.ComponentProps) { 148: { 477: const hasCancellableSelection = cancellableSelectedRuns.length > 0; 479: const handleBulkCancel = useCallback(async () => { 480: if (isBulkCancelling || cancellableSelectedRuns.length === 0) return; 482: setIsBulkCancelling(true); 485: cancellableSelectedRuns.map((run) => cancelRun(env, run.runId)) 493: `Cancelled ${succeeded} run${succeeded !== 1 ? 's' : ''}` 496: toast.error(`Failed to cancel ${failed} run${failed !== 1 ? 's' : ''}`); 499: `Cancelled ${succeeded} run${succeeded !== 1 ? 's' : ''}, ${failed} failed` 506: toast.error('Failed to cancel runs', { 510: setIsBulkCancelling(false); 512: }, [env, cancellableSelectedRuns, isBulkCancelling, selection, onReload]); 807: {hasCancellableSelection && ( 812: onClick={handleBulkCancel} 813: disabled={isBulkCancelling} 815: {isBulkCancelling ? ( 820: Cancel{' '} 821: {cancellableSelectedRuns.length !== selection.selectionCount 822: ? `${cancellableSelectedRuns.length} ` 824: {isBulkCancelling ? 'cancelling...' : ''} packages/web/app/components/run-detail-view.tsx 25: AlertDialogCancel, 52: cancelRun, 186: 'run_cancelled', 197: const [cancelling, setCancelling] = useState(false); 199: const [showCancelDialog, setShowCancelDialog] = useState(false); 404: const handleCancelClick = () => { 405: setShowCancelDialog(true); 408: const handleConfirmCancel = async () => { 409: if (cancelling) return; 412: setCancelling(true); 413: setShowCancelDialog(false); 414: await cancelRun(env, runId); 417: toast.success('Run cancelled successfully'); 419: console.error('Failed to cancel run:', err); 420: toast.error('Failed to cancel run', { 425: setCancelling(false); 477: {/* Cancel Confirmation Dialog */} 478: 481: Cancel Workflow Run? 485: you sure you want to cancel the run? 489: Keep Running 491: onClick={handleConfirmCancel} 494: Cancel Run 511: Cancel 562: onCancelClick={handleCancelClick} packages/web/app/components/run-actions.tsx 24: cancelRun, 72: const [cancelling, setCancelling] = useState(false); 125: toast.success('Active sleeps cancelled', { 126: description: `Cancelled ${result.stoppedCount} active sleep${result.stoppedCount > 1 ? 's' : ''} and resumed the run.`, 130: description: 'There were no active sleep calls to cancel.', 135: toast.error('Failed to cancel sleeps', { 143: const handleCancel = useCallback(async () => { 144: if (cancelling) return; 148: toast.error('Cannot cancel', { 149: description: 'Only active runs can be cancelled', 155: setCancelling(true); 156: await cancelRun(env, runId); 157: toast.success('Run cancelled'); 160: toast.error('Failed to cancel', { 164: setCancelling(false); 166: }, [env, runId, runStatus, cancelling, callbacks]); 173: cancelling, 179: handleCancel, 187:function CancelSleepsTooltipContent({ 193: return <>No active sleep calls to cancel.; 197: Cancel any active sleep calls and resume the run immediately. 233: cancelling, 238: handleCancel, 251: const onCancelSleeps = (e: React.MouseEvent) => { 256: const onCancel = (e: React.MouseEvent) => { 258: handleCancel(); 286: {/* Cancel Active Sleeps - disabled if no active sleeps */} 290: onClick={onCancelSleeps} 294: {wakingUp ? 'Cancelling sleeps...' : 'Cancel Active Sleeps'} 298: 303: onClick={onCancel} 304: disabled={!isRunActive || cancelling} 307: {cancelling ? 'Cancelling...' : 'Cancel'} 319: /** Called when cancel button is clicked - typically shows a confirmation dialog */ 320: onCancelClick?: () => void; 333: onCancelClick, 345: const canCancel = isRunActive; 355: // Cancel button logic 356: const cancelDisabledReason = 361: : runStatus === 'cancelled' 362: ? 'Run has already been cancelled' 395: {/* Cancel Button */} 402: onClick={onCancelClick} 403: disabled={!canCancel} 406: Cancel 411: {cancelDisabledReason ? ( 412:

{cancelDisabledReason}

414:

Cancel the workflow run

448: {/* Cancel Active Sleeps - disabled if no active sleeps */} 458: {wakingUp ? 'Cancelling sleeps...' : 'Cancel Active Sleeps'} 462: 486: let cancelled = false; 491: if (!cancelled) { 500: if (!cancelled) { 506: cancelled = true; packages/web/app/components/flow-graph/workflow-graph-execution-viewer.tsx 71: | 'cancelled'; 287: case 'cancelled': 1039: Cancelled 1063: : execution.status === 'cancelled' packages/web/app/components/display-utils/status-badge.tsx 34: case 'cancelled': packages/web/CHANGELOG.md 36: - Remove `cancel`, `pause`, `resume` from `runs` 38: - Add run lifecycle events: `run_created`, `run_started`, `run_completed`, `run_failed`, `run_cancelled` 95:- [#716](https://github.com/vercel/workflow/pull/716) [`0da8e54`](https://github.com/vercel/workflow/commit/0da8e543742ad160dedc28f998cfe16fe1e3fd84) Thanks [@VaguelySerious](https://github.com/VaguelySerious)! - Allow selecting and cancelling multiple runs from table view workbench/nextjs-turbopack/app/page.tsx 45: reader.cancel(); packages/web-shared/src/lib/event-analysis.ts 138: * Check if a workflow run status is terminal (completed, failed, or cancelled) 144: status === 'completed' || status === 'failed' || status === 'cancelled' packages/web-shared/src/components/workflow-traces/trace-colors.ts 27: case 'cancelled': 28: return styles.spanCancelled; packages/web-shared/src/components/workflow-trace-view.tsx 96: cancelAnimationFrame(rafId); 97: cancelAnimationFrame(scaleRafId); 279: onCancelRun, 294: onCancelRun?: (runId: string) => Promise; 520: // Run-specific: Cancel (only on active runs) 521: if (menu.resourceType === 'run' && isRunActive && onCancelRun) { 523: label: 'Cancel Run', 527: onCancelRun(run.runId).catch((err: unknown) => { 528: toast.error('Failed to cancel run', { 583: onCancelRun, 889: onCancelRun, 915: /** Callback to cancel the current run */ 916: onCancelRun?: (runId: string) => Promise; 1096: onCancelRun={onCancelRun} packages/serde/CHANGELOG.md 9: - Remove `cancel`, `pause`, `resume` from `runs` 11: - Add run lifecycle events: `run_created`, `run_started`, `run_completed`, `run_failed`, `run_cancelled` packages/web-shared/src/components/trace-viewer/util/use-trackpad-zoom.tsx 40: cancelAnimationFrame(nextFrame); 48: cancelAnimationFrame(nextFrame); packages/web-shared/src/components/trace-viewer/util/use-streaming-spans.ts 346: cancelAnimationFrame(nextFrame); 352: cancelAnimationFrame(nextFrame); 421: cancelAnimationFrame(nextFrame); packages/web-shared/src/components/trace-viewer/trace-viewer.tsx 380: if (event?.cancelable) { packages/web-shared/src/components/trace-viewer/trace-viewer.module.css 1055: &::-webkit-search-cancel-button, 1211:.spanCancelled { packages/web-shared/src/components/trace-viewer/components/span-detail-panel.tsx 631: cancelAnimationFrame(nextFrame); packages/web-shared/src/components/trace-viewer/components/node.tsx 60: name === 'run_cancelled' 197: // to be explicitly live to avoid completed/cancelled traces continuing to 294: return () => cancelAnimationFrame(rafId); packages/web-shared/src/components/trace-viewer/components/markers.tsx 412: cancelAnimationFrame(nextFrame); 496: cancelAnimationFrame(nextFrame); 501: cancelAnimationFrame(nextFrame); 536: cancelAnimationFrame(nextFrame); packages/web-shared/src/components/trace-viewer/components/map.tsx 84: cancelAnimationFrame(nextFrame); 102: if (event.cancelable) { 108: if (event.cancelable) { 127: cancelAnimationFrame(nextFrame); 164: return () => cancelAnimationFrame(nextFrame); 184: cancelAnimationFrame(nextFrame); 190: cancelAnimationFrame(nextFrame); packages/web-shared/src/components/sidebar/resolve-hook-modal.tsx 342: Cancel packages/web-shared/src/components/sidebar/entity-detail-panel.tsx 157: const terminalStates = ['completed', 'failed', 'cancelled']; 177: const terminalStates = ['completed', 'failed', 'cancelled']; packages/web-shared/src/components/run-trace-view.tsx 27: onCancelRun?: (runId: string) => Promise; 47: onCancelRun, 78: onCancelRun={onCancelRun} packages/web-shared/src/components/event-list-view.tsx 60: // Cancelled → amber 61: if (eventType === 'run_cancelled') { 123: /** Time from started → completed/failed/cancelled (ms) */ 129: * created ↔ started (queued) and started ↔ completed/failed/cancelled (ran). 172: type === 'run_cancelled' || 196: eventType === 'run_cancelled' || packages/web-shared/CHANGELOG.md 101: - Remove `cancel`, `pause`, `resume` from `runs` 103: - Add run lifecycle events: `run_created`, `run_started`, `run_completed`, `run_failed`, `run_cancelled` 110:- [#894](https://github.com/vercel/workflow/pull/894) [`a2b688d`](https://github.com/vercel/workflow/commit/a2b688d0623ebbae117877a696c5b9b288d628fd) Thanks [@VaguelySerious](https://github.com/VaguelySerious)! - Fix resuming v1 hooks and cancelling/re-running v1 runs from a v2 UI or runtime 126:- [#856](https://github.com/vercel/workflow/pull/856) [`f64b776`](https://github.com/vercel/workflow/commit/f64b7761657c46978bcb0df80e0bfc768f2b8a10) Thanks [@karthikscale3](https://github.com/karthikscale3)! - Style the resolve hook modal for theme tokens and align the cancel action with secondary button styling. packages/utils/CHANGELOG.md 15: - Remove `cancel`, `pause`, `resume` from `runs` 17: - Add run lifecycle events: `run_created`, `run_started`, `run_completed`, `run_failed`, `run_cancelled` packages/errors/src/index.ts 231:export class WorkflowRunCancelledError extends WorkflowError { 235: super(`Workflow run "${runId}" cancelled`, {}); 236: this.name = 'WorkflowRunCancelledError'; 240: static is(value: unknown): value is WorkflowRunCancelledError { 241: return isError(value) && value.name === 'WorkflowRunCancelledError'; packages/errors/CHANGELOG.md 23: - Remove `cancel`, `pause`, `resume` from `runs` 25: - Add run lifecycle events: `run_created`, `run_started`, `run_completed`, `run_failed`, `run_cancelled` 36: - `run_cancelled`: skip event storage, directly update run packages/core/src/workflow.ts 544: cancel(): any { packages/swc-plugin-workflow/CHANGELOG.md 46: - Remove `cancel`, `pause`, `resume` from `runs` 48: - Add run lifecycle events: `run_created`, `run_started`, `run_completed`, `run_failed`, `run_cancelled` packages/core/e2e/utils.ts 196: * Executes the `workflow cancel` CLI command for a given run ID. 199:export const cliCancel = async (runId: string) => { 203: const command = `node ./node_modules/workflow/bin/run.js cancel`; packages/core/e2e/e2e.test.ts 2: WorkflowRunCancelledError, 18: cliCancel, 1652: // ==================== CANCEL TESTS ==================== 1654: 'cancelRun - cancelling a running workflow', 1658: // window for the cancel to arrive while the workflow is still running. 1664: // Cancel the run using the core runtime cancelRun function. 1665: // This exercises the same cancelRun code path that the CLI uses 1667: const { cancelRun } = await import('../src/runtime'); 1668: await cancelRun(getWorld(), run.runId); 1670: // Verify the run was cancelled - returnValue should throw WorkflowRunCancelledError 1672: expect(WorkflowRunCancelledError.is(error)).toBe(true); 1674: // Verify the run status is 'cancelled' via CLI inspect 1676: expect(runData.status).toBe('cancelled'); 1681: 'cancelRun via CLI - cancelling a running workflow', 1685: // window for the cancel to arrive while the workflow is still running. 1691: // Cancel the run via the CLI command. This tests the full CLI code path 1693: await cliCancel(run.runId); 1695: // Verify the run was cancelled - returnValue should throw WorkflowRunCancelledError 1697: expect(WorkflowRunCancelledError.is(error)).toBe(true); 1699: // Verify the run status is 'cancelled' via CLI inspect 1701: expect(runData.status).toBe('cancelled'); packages/core/CHANGELOG.md 164: - Remove `cancel`, `pause`, `resume` from `runs` 166: - Add run lifecycle events: `run_created`, `run_started`, `run_completed`, `run_failed`, `run_cancelled` 178:- [#894](https://github.com/vercel/workflow/pull/894) [`a2b688d`](https://github.com/vercel/workflow/commit/a2b688d0623ebbae117877a696c5b9b288d628fd) Thanks [@VaguelySerious](https://github.com/VaguelySerious)! - Fix resuming v1 hooks and cancelling/re-running v1 runs from a v2 UI or runtime packages/cli/src/lib/inspect/terminal-utils.ts 131: cancelled: 'X', packages/cli/src/lib/inspect/stream.ts 52: await reader.cancel(); 54: // Ignore cancellation errors during cleanup packages/cli/src/lib/inspect/output.ts 116: cancelled: chalk.strikethrough.yellow, 130: 'cancelled', packages/cli/src/commands/cancel.ts 2:import { cancelRun } from '@workflow/core/runtime'; 8:export default class Cancel extends BaseCommand { 9: static description = 'Cancel a workflow'; 13: static examples = ['$ workflow cancel ', '$ wf cancel ']; 24: description: 'ID of the run to cancel.', 32: const { flags, args } = await this.parse(Cancel); 41: await cancelRun(world, args.runId); packages/cli/CHANGELOG.md 39:- [#1078](https://github.com/vercel/workflow/pull/1078) [`262ef3a`](https://github.com/vercel/workflow/commit/262ef3a21a223ea0047c5b2840228d3216afb2df) Thanks [@TooTallNate](https://github.com/TooTallNate)! - Fix CLI missing `specVersion` in "run_cancelled" event payload 130: - Remove `cancel`, `pause`, `resume` from `runs` 132: - Add run lifecycle events: `run_created`, `run_started`, `run_completed`, `run_failed`, `run_cancelled` 139:- [#621](https://github.com/vercel/workflow/pull/621) [`4966b72`](https://github.com/vercel/workflow/commit/4966b728a8c8ac339fd98ed91af222f406479fae) Thanks [@pranaygp](https://github.com/pranaygp)! - Use `events.create()` for run cancellation 141:- [#894](https://github.com/vercel/workflow/pull/894) [`a2b688d`](https://github.com/vercel/workflow/commit/a2b688d0623ebbae117877a696c5b9b288d628fd) Thanks [@VaguelySerious](https://github.com/VaguelySerious)! - Fix resuming v1 hooks and cancelling/re-running v1 runs from a v2 UI or runtime packages/core/src/runtime/step-handler.ts 158: // 409 Conflict: Step in terminal state (completed/failed/cancelled) packages/core/src/runtime/runs.ts 86: * Cancel a workflow run. 88:export async function cancelRun(world: World, runId: string): Promise { 94: eventType: 'run_cancelled' as const, 100: `Failed to cancel run ${runId}: ${err instanceof Error ? err.message : String(err)}`, packages/core/src/runtime/run.ts 2: WorkflowRunCancelledError, 67: * Cancels the workflow run. 69: async cancel(): Promise { 71: eventType: 'run_cancelled', 166: if (run.status === 'cancelled') { 167: throw new WorkflowRunCancelledError(this.runId); packages/core/src/runtime/resume-hook.ts 274: reader.cancel(); packages/core/src/runtime/helpers.ts 234: reader.cancel(); 236: // Ignore cancel errors packages/ai/src/workflow-chat-transport.ts 154: * @param options.abortSignal - Optional AbortSignal to cancel the request packages/ai/src/stream-iterator.ts 4: * @param signal - Optional AbortSignal to cancel the stream 49: async cancel(_reason) { packages/core/src/runtime.ts 56: cancelRun, 182: // TODO: for `cancel`, we actually want to propagate a WorkflowCancelled event 184: // TODO: furthermore, there should be a timeout or a way to force cancel SIGKILL packages/ai/src/agent/durable-agent.ts 195: * Abort signal for cancelling the operation. packages/core/src/events-consumer.ts 55: // Cancel any pending unconsumed check since a new callback may consume the event packages/core/src/events-consumer.test.ts 378: it('should cancel pending unconsumed check when a new callback subscribes', async () => { docs/content/docs/how-it-works/event-sourcing.mdx 56: C -->|"run_cancelled"| F["cancelled"] 57: B -->|"run_cancelled"| F 70:- `cancelled`: Explicitly cancelled by the user or system 94:- `cancelled`: Reserved for future use (not currently emitted) 132:When a hook is disposed (either explicitly or when its workflow completes), the token is released and can be claimed by future workflows. Hooks are automatically disposed when a workflow reaches a terminal state (`completed`, `failed`, or `cancelled`). The `hook_disposed` event is only needed for explicit disposal before workflow completion. 174:| `run_cancelled` | Transitions the run to `cancelled` state. Can be triggered from `pending` or `running` states. | 210:- `cancelled`: Workflow was explicitly cancelled docs/content/docs/errors/hook-conflict.mdx 104:- The workflow run is **cancelled** docs/content/docs/deploying/building-a-world.mdx 95:**Automatic Hook Disposal:** When a workflow reaches a terminal state (`completed`, `failed`, or `cancelled`), automatically dispose of all associated hooks to release tokens for reuse. docs/content/docs/api-reference/workflow-api/get-world.mdx 66:### Cancel a Workflow Run 68:Cancel a running workflow: 82: const run = await world.runs.cancel(runId); // [!code highlight] 87: { error: "Failed to cancel workflow run" }, docs/app/[lang]/(home)/components/intro/workflow.tsx 46: let cancelled = false; 55: if (cancelled) return; 66: if (cancelled) return; 86: if (cancelled) return; 97: if (cancelled) return; 107: if (cancelled) return; 118: if (cancelled) return; 128: if (cancelled) return; 139: if (cancelled) return; 148: cancelled = true; docs/app/[lang]/(home)/components/intro/non-workflow.tsx 42: let cancelled = false; 57: if (cancelled) return; 68: if (cancelled) return; 78: if (cancelled) return; 90: cancelled = true; docs/components/ui/alert-dialog.tsx 132:function AlertDialogCancel({ 135:}: React.ComponentProps) { 137: