@@ -7,12 +7,22 @@ import type { ExecutionContext } from '@/lib/copilot/request/types'
 const { mocks } = vi.hoisted(() => ({
   mocks: {
     apiKey: vi.fn(),
+    cancelWorkflowExecutionRoute: vi.fn(),
     executeWorkflowUseCase: vi.fn(),
+    generateInternalToken: vi.fn(),
     hasExecutionResult: vi.fn(),
     readAttemptedExecutionId: vi.fn(),
   },
 }))
 
+vi.mock('@/app/api/workflows/[id]/executions/[executionId]/cancel/route', () => ({
+  POST: mocks.cancelWorkflowExecutionRoute,
+}))
+
+vi.mock('@/lib/auth/internal', () => ({
+  generateInternalToken: mocks.generateInternalToken,
+}))
+
 vi.mock('@/lib/copilot/application/execute-workflow-use-case', () => ({
   executeCopilotWorkflowUseCase: mocks.executeWorkflowUseCase,
   messageForCopilotWorkflowError: (_error: unknown, fallback = 'Workflow operation failed') =>
@@ -53,12 +63,14 @@ const context = {
   workspaceId: 'workspace-1',
   workflowId: 'workflow-1',
   toolCallId: 'tool-call-1',
+  copilotToolExecution: true,
   billingAttribution: { workspaceId: 'workspace-1' },
 } as ExecutionContext
 
 describe('workflow mutation Copilot adapters', () => {
   beforeEach(() => {
     vi.clearAllMocks()
+    mocks.generateInternalToken.mockResolvedValue('internal-token')
     mocks.hasExecutionResult.mockReturnValue(false)
     mocks.readAttemptedExecutionId.mockReturnValue(undefined)
   })
@@ -162,18 +174,18 @@ describe('workflow mutation Copilot adapters', () => {
     )
   })
 
-  it('cancels a workflow run through the registered application command', async () => {
-    mocks.executeWorkflowUseCase.mockResolvedValue({
-      success: true,
-      executionId: 'execution-1',
-      redisAvailable: true,
-      durablyRecorded: true,
-      locallyAborted: false,
-      pausedCancelled: false,
-      reason: 'recorded',
-      workflowId: 'workflow-1',
-      workspaceId: 'workspace-1',
-    })
+  it('cancels a workflow run through the same route as the logs UI', async () => {
+    mocks.cancelWorkflowExecutionRoute.mockResolvedValue(
+      Response.json({
+        success: true,
+        executionId: 'execution-1',
+        redisAvailable: true,
+        durablyRecorded: true,
+        locallyAborted: false,
+        pausedCancelled: false,
+        reason: 'recorded',
+      })
+    )
 
     const result = await executeCancelWorkflowRun(
       { workflowId: 'workflow-1', executionId: 'execution-1' },
@@ -191,19 +203,40 @@ describe('workflow mutation Copilot adapters', () => {
         reason: 'recorded',
       },
     })
-    expect(mocks.executeWorkflowUseCase).toHaveBeenCalledWith(
-      context,
-      expect.objectContaining({
-        operation: expect.objectContaining({ id: 'workflows.runs.cancel' }),
-      }),
-      { workflowId: 'workflow-1', runId: 'execution-1' }
+    expect(mocks.generateInternalToken).toHaveBeenCalledWith('user-1')
+    expect(mocks.cancelWorkflowExecutionRoute).toHaveBeenCalledOnce()
+    const [request, routeContext] = mocks.cancelWorkflowExecutionRoute.mock.calls[0]
+    expect(request.method).toBe('POST')
+    expect(request.headers.get('authorization')).toBe('Bearer internal-token')
+    expect(request.nextUrl.pathname).toBe('/api/workflows/workflow-1/executions/execution-1/cancel')
+    await expect(routeContext.params).resolves.toEqual({
+      id: 'workflow-1',
+      executionId: 'execution-1',
+    })
+    expect(mocks.executeWorkflowUseCase).not.toHaveBeenCalled()
+  })
+
+  it('returns the cancellation route error to the Run agent', async () => {
+    mocks.cancelWorkflowExecutionRoute.mockResolvedValue(
+      Response.json({ error: 'Execution cannot be cancelled while completed' }, { status: 409 })
+    )
+
+    const result = await executeCancelWorkflowRun(
+      { workflowId: 'workflow-1', executionId: 'execution-1' },
+      context
     )
+
+    expect(result).toEqual({
+      success: false,
+      error: 'Execution cannot be cancelled while completed',
+    })
   })
 
   it('requires an execution ID before attempting workflow-run cancellation', async () => {
     const result = await executeCancelWorkflowRun({ workflowId: 'workflow-1' }, context)
 
     expect(result).toEqual({ success: false, error: 'executionId is required' })
+    expect(mocks.cancelWorkflowExecutionRoute).not.toHaveBeenCalled()
     expect(mocks.executeWorkflowUseCase).not.toHaveBeenCalled()
   })
 
 
@@ -1,11 +1,15 @@
 import { createLogger } from '@sim/logger'
+import { NextRequest } from 'next/server'
+import { cancelWorkflowExecutionContract } from '@/lib/api/contracts/workflows'
 import { createCopilotWorkspaceApiKey } from '@/lib/api-key/application/create-api-key'
+import { generateInternalToken } from '@/lib/auth/internal'
 import { messageForCopilotApplicationError } from '@/lib/copilot/application/error'
 import { executeCopilotApiKeyUseCase } from '@/lib/copilot/application/execute-api-key-use-case'
 import {
   executeCopilotWorkflowUseCase,
   messageForCopilotWorkflowError,
 } from '@/lib/copilot/application/execute-workflow-use-case'
+import { requireTrustedCopilotExecutionContext } from '@/lib/copilot/auth/application-delegation'
 import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
 import {
   TOOL_EFFECT_PHASE,
@@ -15,7 +19,6 @@ import {
 import { requireCopilotWorkspace } from '@/lib/copilot/tools/server/workspace-scope'
 import { decodeVfsPathSegments, encodeVfsPathSegments } from '@/lib/copilot/vfs/path-utils'
 import { PlatformEvents } from '@/lib/core/telemetry'
-import { cancelWorkflowRun } from '@/lib/workflows/application/cancel-run'
 import { createWorkflow } from '@/lib/workflows/application/create-workflow'
 import { moveWorkflowsBulk } from '@/lib/workflows/application/move-workflows-bulk'
 import {
@@ -153,6 +156,12 @@ function resolveInputFromExecutionId(value: unknown): string | undefined {
   return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined
 }
 
+function readCancellationRouteError(body: unknown): string | undefined {
+  if (!body || typeof body !== 'object' || !('error' in body)) return undefined
+  const error = body.error
+  return typeof error === 'string' && error.trim() ? error : undefined
+}
+
 function copilotRunLifecycle(context: ExecutionContext) {
   return {
     billingAttribution: context.billingAttribution,
@@ -302,15 +311,36 @@ export async function executeCancelWorkflowRun(
       context,
       'Request aborted before workflow run cancellation could be applied.'
     )
-    const result = await executeCopilotWorkflowUseCase(context, cancelWorkflowRun, {
-      workflowId,
-      runId: executionId,
-    })
+    const trustedContext = requireTrustedCopilotExecutionContext(context)
+    const internalToken = await generateInternalToken(trustedContext.userId)
+    const { POST: cancelWorkflowExecution } = await import(
+      '@/app/api/workflows/[id]/executions/[executionId]/cancel/route'
+    )
+    const response = await cancelWorkflowExecution(
+      new NextRequest(
+        `http://localhost/api/workflows/${encodeURIComponent(workflowId)}/executions/${encodeURIComponent(executionId)}/cancel`,
+        {
+          method: 'POST',
+          headers: { authorization: `Bearer ${internalToken}` },
+        }
+      ),
+      { params: Promise.resolve({ id: workflowId, executionId }) }
+    )
+    const responseBody: unknown = await response.json()
+    if (!response.ok) {
+      return {
+        success: false,
+        error:
+          readCancellationRouteError(responseBody) ||
+          `Failed to cancel workflow run (${response.status})`,
+      }
+    }
+    const result = cancelWorkflowExecutionContract.response.schema.parse(responseBody)
 
     return {
       success: result.success,
       output: {
-        workflowId: result.workflowId,
+        workflowId,
         executionId: result.executionId,
         durablyRecorded: result.durablyRecorded,
         locallyAborted: result.locallyAborted,