feat(managed-agents): add Claude Managed Agents workflow block

Author: waleedlatif1

apps/sim/app/api/tools/managed-agent/list/route.ts

@@ -0,0 +1,106 @@
+import { createLogger } from '@sim/logger'
+import { getErrorMessage } from '@sim/utils/errors'
+import { type NextRequest, NextResponse } from 'next/server'
+import {
+  listManagedAgentOptionsContract,
+  MANAGED_AGENT_BYOK_PROVIDER,
+  type ManagedAgentOption,
+  type ManagedAgentResource,
+} from '@/lib/api/contracts/managed-agents'
+import { parseRequest } from '@/lib/api/server'
+import { getBYOKKey } from '@/lib/api-key/byok'
+import { checkSessionOrInternalAuth } from '@/lib/auth/hybrid'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { AGENT_MEMORY_BETA, managedAgentsList } from '@/lib/managed-agents/session-client'
+import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
+
+export const dynamic = 'force-dynamic'
+
+const logger = createLogger('ManagedAgentListAPI')
+
+interface AnthropicListRow {
+  id?: string
+  name?: string | null
+  config?: { type?: 'cloud' | 'self_hosted' }
+}
+
+/**
+ * Anthropic list path + the beta header it requires. Memory-store endpoints
+ * use `agent-memory-2026-07-22`; combining it with the managed-agents beta is
+ * a documented 400, so each resource declares exactly one.
+ */
+const RESOURCE_ENDPOINTS: Record<ManagedAgentResource, { path: string; beta?: string }> = {
+  agents: { path: '/v1/agents' },
+  environments: { path: '/v1/environments' },
+  vaults: { path: '/v1/vaults' },
+  'memory-stores': { path: '/v1/memory_stores', beta: AGENT_MEMORY_BETA },
+}
+
+function toOption(
+  resource: ManagedAgentResource,
+  row: AnthropicListRow
+): ManagedAgentOption | null {
+  if (!row.id) return null
+  const name = row.name?.trim()
+  if (resource === 'environments') {
+    const type = row.config?.type
+    const suffix = type ? ` (${type})` : ''
+    return { id: row.id, label: `${name || row.id}${suffix}` }
+  }
+  if (resource === 'vaults') {
+    return { id: row.id, label: name || row.id }
+  }
+  return { id: row.id, label: name ? `${name} (${row.id})` : row.id }
+}
+
+/**
+ * Resolves Managed Agent dropdown options (agents / environments / vaults /
+ * memory stores) for the block editor. The workspace's Claude Platform BYOK
+ * key is decrypted server-side and never crosses the client boundary — the
+ * browser only ever receives `{ id, label }` options.
+ */
+export const GET = withRouteHandler(async (request: NextRequest) => {
+  const auth = await checkSessionOrInternalAuth(request, { requireWorkflowId: false })
+  if (!auth.success || !auth.userId) {
+    return NextResponse.json({ error: auth.error || 'Unauthorized' }, { status: 401 })
+  }
+
+  const parsed = await parseRequest(listManagedAgentOptionsContract, request, {})
+  if (!parsed.success) return parsed.response
+  const { workspaceId, resource } = parsed.data.query
+
+  const permission = await getUserEntityPermissions(auth.userId, 'workspace', workspaceId)
+  if (!permission) {
+    return NextResponse.json({ error: 'Workspace access denied' }, { status: 403 })
+  }
+
+  const byok = await getBYOKKey(workspaceId, MANAGED_AGENT_BYOK_PROVIDER)
+  if (!byok) {
+    // No Claude Platform key linked yet — return an empty list so the
+    // dropdown renders cleanly rather than erroring.
+    return NextResponse.json({ options: [] })
+  }
+
+  try {
+    const endpoint = RESOURCE_ENDPOINTS[resource]
+    const rows = await managedAgentsList<AnthropicListRow>({
+      apiKey: byok.apiKey,
+      path: endpoint.path,
+      beta: endpoint.beta,
+      signal: request.signal,
+    })
+    const options = rows
+      .map((row) => toOption(resource, row))
+      .filter((option): option is ManagedAgentOption => option !== null)
+    return NextResponse.json({ options })
+  } catch (error) {
+    // Some beta workspaces may not expose every resource (e.g. vaults). Log
+    // and degrade to an empty list rather than breaking the editor.
+    logger.warn('Managed agent list proxy failed', {
+      workspaceId,
+      resource,
+      error: getErrorMessage(error),
+    })
+    return NextResponse.json({ options: [] })
+  }
+})

apps/sim/app/api/tools/managed-agent/run/route.ts

@@ -0,0 +1,119 @@
+import { db } from '@sim/db'
+import { workflow } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { eq } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import {
+  MANAGED_AGENT_BYOK_PROVIDER,
+  runManagedAgentContract,
+} from '@/lib/api/contracts/managed-agents'
+import { parseRequest } from '@/lib/api/server'
+import { getBYOKKey } from '@/lib/api-key/byok'
+import { checkInternalAuth } from '@/lib/auth/hybrid'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { runManagedAgentSession } from '@/lib/managed-agents/run-session'
+
+export const dynamic = 'force-dynamic'
+/** Sessions can run for several minutes; bound generously above the run loop's own caps. */
+export const maxDuration = 800
+
+const logger = createLogger('ManagedAgentRunAPI')
+
+/**
+ * Internal route that runs one Managed Agent session. Executor-only
+ * (server-to-server internal auth) — the browser never invokes it. The
+ * workspace Claude Platform key is resolved server-side from the workflow's
+ * workspace and never leaves the server.
+ */
+export const POST = withRouteHandler(async (request: NextRequest) => {
+  const auth = await checkInternalAuth(request, { requireWorkflowId: false })
+  if (!auth.success) {
+    return NextResponse.json(
+      { success: false, error: auth.error || 'Unauthorized' },
+      { status: 401 }
+    )
+  }
+
+  const parsed = await parseRequest(runManagedAgentContract, request, {})
+  if (!parsed.success) return parsed.response
+  const { body, query } = parsed.data
+
+  const workflowId = query.workflowId
+  if (!workflowId) {
+    return NextResponse.json(
+      { success: false, error: 'Missing workflowId — is this tool running inside a workflow?' },
+      { status: 400 }
+    )
+  }
+
+  const [row] = await db
+    .select({ workspaceId: workflow.workspaceId, name: workflow.name })
+    .from(workflow)
+    .where(eq(workflow.id, workflowId))
+    .limit(1)
+  const workspaceId = row?.workspaceId
+  if (!workspaceId) {
+    return NextResponse.json(
+      { success: false, error: 'Workflow is not associated with a workspace.' },
+      { status: 400 }
+    )
+  }
+
+  // Vault authorization ack — enforced here because the block's condition
+  // engine cannot test array-non-empty. Fails closed: attaching a vault
+  // requires explicit confirmation, since the session assumes its identity.
+  if (body.vaults && body.vaults.length > 0 && !body.vaultsAck) {
+    return NextResponse.json(
+      {
+        success: false,
+        error:
+          'Vault authorization is required — check the "I am authorized to use these vaults" acknowledgement on the block, or remove the selected vault(s).',
+      },
+      { status: 400 }
+    )
+  }
+
+  const byok = await getBYOKKey(workspaceId, MANAGED_AGENT_BYOK_PROVIDER)
+  if (!byok) {
+    return NextResponse.json(
+      {
+        success: false,
+        error:
+          'No Claude Platform API key is configured for this workspace. Add one under Settings → API Keys (Claude Platform).',
+      },
+      { status: 400 }
+    )
+  }
+
+  const result = await runManagedAgentSession({
+    apiKey: byok.apiKey,
+    agentId: body.agent,
+    environmentId: body.environment,
+    userMessage: body.userMessage,
+    title: row?.name ? `Sim - ${row.name}` : undefined,
+    vaultIds: body.vaults,
+    memoryStoreId: body.memoryStoreId,
+    memoryAccess: body.memoryAccess,
+    fileIds: body.fileIds,
+    sessionParameters: body.sessionParameters,
+    signal: request.signal,
+  })
+
+  if (!result.ok) {
+    logger.warn('Managed agent session failed', {
+      workspaceId,
+      workflowId,
+      sessionId: result.sessionId,
+      error: result.error,
+    })
+    return NextResponse.json(
+      { success: false, error: result.error ?? 'Managed Agent session failed' },
+      { status: 502 }
+    )
+  }
+
+  return NextResponse.json({
+    success: true,
+    output: { content: result.content, sessionId: result.sessionId ?? '' },
+  })
+})

apps/sim/app/workspace/[workspaceId]/settings/components/byok/byok.tsx

@@ -6,6 +6,7 @@ import {
   AnthropicIcon,
   BasetenIcon,
   BrandfetchIcon,
+  ClaudeIcon,
   ContextDevIcon,
   DatagmaIcon,
   DropcontactIcon,
@@ -66,6 +67,13 @@ const PROVIDERS: (BYOKManagerProvider & { id: BYOKProviderId })[] = [
     description: 'LLM calls',
     placeholder: 'sk-ant-...',
   },
+  {
+    id: 'claude-platform',
+    name: 'Claude Platform',
+    icon: ClaudeIcon,
+    description: 'Managed Agents block',
+    placeholder: 'sk-ant-...',
+  },
   {
     id: 'google',
     name: 'Google',
@@ -303,6 +311,7 @@ const PROVIDER_SECTIONS: BYOKProviderSection[] = [
     ids: [
       'openai',
       'anthropic',
+      'claude-platform',
       'google',
       'mistral',
       'xai',

apps/sim/app/workspace/[workspaceId]/w/components/sidebar/hooks/use-drag-drop.test.tsx

@@ -0,0 +1,124 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { act } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('next/navigation', () => ({
+  useParams: () => ({ workspaceId: 'ws-1' }),
+}))
+
+vi.mock('@/hooks/queries/folders', () => ({
+  useReorderFolders: () => ({ mutateAsync: vi.fn() }),
+}))
+
+vi.mock('@/hooks/queries/workflows', () => ({
+  useReorderWorkflows: () => ({ mutateAsync: vi.fn() }),
+}))
+
+vi.mock('@/hooks/queries/utils/folder-cache', () => ({
+  getFolderMap: () => ({}),
+}))
+
+vi.mock('@/hooks/queries/utils/workflow-cache', () => ({
+  getWorkflows: () => [],
+}))
+
+vi.mock('@/lib/folders/tree', () => ({
+  getFolderPath: () => [],
+}))
+
+const { mockUseFolderStore } = vi.hoisted(() => {
+  const folderState = { setExpanded: () => {}, expandedFolders: new Set<string>() }
+  const store = Object.assign(
+    (selector: (state: typeof folderState) => unknown) => selector(folderState),
+    { getState: () => folderState }
+  )
+  return { mockUseFolderStore: store }
+})
+vi.mock('@/stores/folders/store', () => ({ useFolderStore: mockUseFolderStore }))
+
+import { useDragDrop } from '@/app/workspace/[workspaceId]/w/components/sidebar/hooks/use-drag-drop'
+
+type DragDropApi = ReturnType<typeof useDragDrop>
+
+let latest: DragDropApi
+
+function Harness() {
+  latest = useDragDrop()
+  return null
+}
+
+/** Minimal stand-in for the dragOver event `initDragOver` consumes. */
+function fakeDragOverEvent(): unknown {
+  const node = {}
+  return {
+    preventDefault: () => {},
+    stopPropagation: () => {},
+    clientY: 0,
+    // target !== currentTarget so the root drop zone skips indicator math (getBoundingClientRect)
+    target: node,
+    currentTarget: {},
+  }
+}
+
+let container: HTMLDivElement
+let root: Root
+
+describe('useDragDrop stranded-drag reset', () => {
+  beforeEach(() => {
+    // Prevent the auto-scroll rAF loop from spinning in jsdom.
+    vi.stubGlobal(
+      'requestAnimationFrame',
+      () => 0 as unknown as ReturnType<typeof requestAnimationFrame>
+    )
+    vi.stubGlobal('cancelAnimationFrame', () => {})
+    container = document.createElement('div')
+    document.body.appendChild(container)
+    root = createRoot(container)
+    act(() => {
+      root.render(<Harness />)
+    })
+    // The reset listeners only attach once a scroll container is registered.
+    act(() => {
+      latest.setScrollContainer(document.createElement('div'))
+    })
+  })
+
+  afterEach(() => {
+    act(() => {
+      root.unmount()
+    })
+    container.remove()
+    vi.unstubAllGlobals()
+    vi.clearAllMocks()
+  })
+
+  it('clears isDragging on a window dragend when no drop fired', () => {
+    // A drag entering the list flips isDragging on via initDragOver.
+    act(() => {
+      latest.createRootDropZone().onDragOver(fakeDragOverEvent() as never)
+    })
+    expect(latest.isDragging).toBe(true)
+
+    // The drag is cancelled/dropped outside the list: only `dragend` fires, no `drop`.
+    act(() => {
+      window.dispatchEvent(new Event('dragend'))
+    })
+    expect(latest.isDragging).toBe(false)
+  })
+
+  it('keeps isDragging active across dragOver updates until the drag ends', () => {
+    act(() => {
+      latest.createRootDropZone().onDragOver(fakeDragOverEvent() as never)
+    })
+    expect(latest.isDragging).toBe(true)
+
+    // A subsequent dragOver must not tear down the active drag.
+    act(() => {
+      latest.createRootDropZone().onDragOver(fakeDragOverEvent() as never)
+    })
+    expect(latest.isDragging).toBe(true)
+  })
+})