v0

simstudioai · Sg312 · Feb 10, 2026 · Jan 30, 2026 · Jan 30, 2026 · Jan 31, 2026
commit 06fbc29eaaf23d5377e5f846ebf29d412e7c36bb
diff --git a/apps/sim/app/api/copilot/chat/route.ts b/apps/sim/app/api/copilot/chat/route.ts
diff --git a/apps/sim/app/api/v1/copilot/chat/route.ts b/apps/sim/app/api/v1/copilot/chat/route.ts
@@ -0,0 +1,81 @@
+import { createLogger } from '@sim/logger'
+import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import { authenticateV1Request } from '@/app/api/v1/auth'
+import { getCopilotModel } from '@/lib/copilot/config'
+import { SIM_AGENT_VERSION } from '@/lib/copilot/constants'
+import { orchestrateCopilotStream } from '@/lib/copilot/orchestrator'
+
+const logger = createLogger('CopilotHeadlessAPI')
+
+const RequestSchema = z.object({
+  message: z.string().min(1, 'message is required'),
+  workflowId: z.string().min(1, 'workflowId is required'),
+  chatId: z.string().optional(),
+  mode: z.enum(['agent', 'ask', 'plan']).optional().default('agent'),
+  model: z.string().optional(),
+  autoExecuteTools: z.boolean().optional().default(true),
+  timeout: z.number().optional().default(300000),
+})
+
+/**
+ * POST /api/v1/copilot/chat
+ * Headless copilot endpoint for server-side orchestration.
+ */
+export async function POST(req: NextRequest) {
+  const auth = await authenticateV1Request(req)
+  if (!auth.authenticated || !auth.userId) {
+    return NextResponse.json({ success: false, error: auth.error || 'Unauthorized' }, { status: 401 })
+  }
+
+  try {
+    const body = await req.json()
+    const parsed = RequestSchema.parse(body)
+    const defaults = getCopilotModel('chat')
+    const selectedModel = parsed.model || defaults.model
+
+    const requestPayload = {
+      message: parsed.message,
+      workflowId: parsed.workflowId,
+      userId: auth.userId,
+      stream: true,
+      streamToolCalls: true,
+      model: selectedModel,
+      mode: parsed.mode,
+      messageId: crypto.randomUUID(),
+      version: SIM_AGENT_VERSION,
+      ...(parsed.chatId ? { chatId: parsed.chatId } : {}),
+    }
+
+    const result = await orchestrateCopilotStream(requestPayload, {
+      userId: auth.userId,
+      workflowId: parsed.workflowId,
+      chatId: parsed.chatId,
+      autoExecuteTools: parsed.autoExecuteTools,
+      timeout: parsed.timeout,
+      interactive: false,
+    })
+
+    return NextResponse.json({
+      success: result.success,
+      content: result.content,
+      toolCalls: result.toolCalls,
+      chatId: result.chatId,
+      conversationId: result.conversationId,
+      error: result.error,
+    })
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json(
+        { success: false, error: 'Invalid request', details: error.errors },
+        { status: 400 }
+      )
+    }
+
+    logger.error('Headless copilot request failed', {
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return NextResponse.json({ success: false, error: 'Internal server error' }, { status: 500 })
+  }
+}
+
diff --git a/...Id]/w/[workflowId]/components/panel/components/copilot/components/tool-call/tool-call.tsx b/...Id]/w/[workflowId]/components/panel/components/copilot/components/tool-call/tool-call.tsx
@@ -1,5 +1,6 @@
 'use client'
 
+import { createLogger } from '@sim/logger'
 import { memo, useEffect, useMemo, useRef, useState } from 'react'
 import clsx from 'clsx'
 import { ChevronUp, LayoutList } from 'lucide-react'
@@ -26,6 +27,7 @@ import { getBlock } from '@/blocks/registry'
 import type { CopilotToolCall } from '@/stores/panel'
 import { useCopilotStore } from '@/stores/panel'
 import { CLASS_TOOL_METADATA } from '@/stores/panel/copilot/store'
+import { COPILOT_SERVER_ORCHESTRATED } from '@/lib/copilot/orchestrator/config'
 import type { SubAgentContentBlock } from '@/stores/panel/copilot/types'
 import { useWorkflowStore } from '@/stores/workflows/workflow/store'
 
@@ -1257,12 +1259,36 @@ function shouldShowRunSkipButtons(toolCall: CopilotToolCall): boolean {
   return false
 }
 
+const toolCallLogger = createLogger('CopilotToolCall')
+
+async function sendToolDecision(toolCallId: string, status: 'accepted' | 'rejected') {
+  try {
+    await fetch('/api/copilot/confirm', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ toolCallId, status }),
+    })
+  } catch (error) {
+    toolCallLogger.warn('Failed to send tool decision', {
+      toolCallId,
+      status,
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+}
+
 async function handleRun(
   toolCall: CopilotToolCall,
   setToolCallState: any,
   onStateChange?: any,
   editedParams?: any
 ) {
+  if (COPILOT_SERVER_ORCHESTRATED) {
+    setToolCallState(toolCall, 'executing')
+    onStateChange?.('executing')
+    await sendToolDecision(toolCall.id, 'accepted')
+    return
+  }
   const instance = getClientTool(toolCall.id)
 
   if (!instance && isIntegrationTool(toolCall.name)) {
@@ -1307,6 +1333,12 @@ async function handleRun(
 }
 
 async function handleSkip(toolCall: CopilotToolCall, setToolCallState: any, onStateChange?: any) {
+  if (COPILOT_SERVER_ORCHESTRATED) {
+    setToolCallState(toolCall, 'rejected')
+    onStateChange?.('rejected')
+    await sendToolDecision(toolCall.id, 'rejected')
+    return
+  }
   const instance = getClientTool(toolCall.id)
 
   if (!instance && isIntegrationTool(toolCall.name)) {

diff --git a/apps/sim/lib/copilot/orchestrator/config.ts b/apps/sim/lib/copilot/orchestrator/config.ts
@@ -0,0 +1,23 @@
+/**
+ * Feature flag for server-side copilot orchestration.
+ */
+export const COPILOT_SERVER_ORCHESTRATED = true
+
+export const INTERRUPT_TOOL_NAMES = [
+  'set_global_workflow_variables',
+  'run_workflow',
+  'manage_mcp_tool',
+  'manage_custom_tool',
+  'deploy_mcp',
+  'deploy_chat',
+  'deploy_api',
+  'create_workspace_mcp_server',
+  'set_environment_variables',
+  'make_api_request',
+  'oauth_request_access',
+  'navigate_ui',
+  'knowledge_base',
+] as const
+
+export const INTERRUPT_TOOL_SET = new Set<string>(INTERRUPT_TOOL_NAMES)
+
diff --git a/apps/sim/lib/copilot/orchestrator/index.ts b/apps/sim/lib/copilot/orchestrator/index.ts
@@ -0,0 +1,181 @@
+import { createLogger } from '@sim/logger'
+import { SIM_AGENT_API_URL_DEFAULT } from '@/lib/copilot/constants'
+import { env } from '@/lib/core/config/env'
+import { parseSSEStream } from '@/lib/copilot/orchestrator/sse-parser'
+import {
+  handleSubagentRouting,
+  sseHandlers,
+  subAgentHandlers,
+} from '@/lib/copilot/orchestrator/sse-handlers'
+import { prepareExecutionContext } from '@/lib/copilot/orchestrator/tool-executor'
+import type {
+  ExecutionContext,
+  OrchestratorOptions,
+  OrchestratorResult,
+  SSEEvent,
+  StreamingContext,
+  ToolCallSummary,
+} from '@/lib/copilot/orchestrator/types'
+
+const logger = createLogger('CopilotOrchestrator')
+const SIM_AGENT_API_URL = env.SIM_AGENT_API_URL || SIM_AGENT_API_URL_DEFAULT
+
+export interface OrchestrateStreamOptions extends OrchestratorOptions {
+  userId: string
+  workflowId: string
+  chatId?: string
+}
+
+/**
+ * Orchestrate a copilot SSE stream and execute tool calls server-side.
+ */
+export async function orchestrateCopilotStream(
+  requestPayload: Record<string, any>,
+  options: OrchestrateStreamOptions
+): Promise<OrchestratorResult> {
+  const { userId, workflowId, chatId, timeout = 300000, abortSignal } = options
+  const execContext = await prepareExecutionContext(userId, workflowId)
+
+  const context: StreamingContext = {
+    chatId,
+    conversationId: undefined,
+    messageId: requestPayload?.messageId || crypto.randomUUID(),
+    accumulatedContent: '',
+    contentBlocks: [],
+    toolCalls: new Map(),
+    currentThinkingBlock: null,
+    isInThinkingBlock: false,
+    subAgentParentToolCallId: undefined,
+    subAgentContent: {},
+    subAgentToolCalls: {},
+    pendingContent: '',
+    streamComplete: false,
+    wasAborted: false,
+    errors: [],
+  }
+
+  try {
+    const response = await fetch(`${SIM_AGENT_API_URL}/api/chat-completion-streaming`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(env.COPILOT_API_KEY ? { 'x-api-key': env.COPILOT_API_KEY } : {}),
+      },
+      body: JSON.stringify(requestPayload),
+      signal: abortSignal,
+    })
+
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => '')
+      throw new Error(`Copilot backend error (${response.status}): ${errorText || response.statusText}`)
+    }
+
+    if (!response.body) {
+      throw new Error('Copilot backend response missing body')
+    }
+
+    const reader = response.body.getReader()
+    const decoder = new TextDecoder()
+
+    const timeoutId = setTimeout(() => {
+      context.errors.push('Request timed out')
+      context.streamComplete = true
+      reader.cancel().catch(() => {})
+    }, timeout)
+
+    try {
+      for await (const event of parseSSEStream(reader, decoder, abortSignal)) {
+        if (abortSignal?.aborted) {
+          context.wasAborted = true
+          break
+        }
+
+        await forwardEvent(event, options)
+
+        if (event.type === 'subagent_start') {
+          const toolCallId = event.data?.tool_call_id
+          if (toolCallId) {
+            context.subAgentParentToolCallId = toolCallId
+            context.subAgentContent[toolCallId] = ''
+            context.subAgentToolCalls[toolCallId] = []
+          }
+          continue
+        }
+
+        if (event.type === 'subagent_end') {
+          context.subAgentParentToolCallId = undefined
+          continue
+        }
+
+        if (handleSubagentRouting(event, context)) {
+          const handler = subAgentHandlers[event.type]
+          if (handler) {
+            await handler(event, context, execContext, options)
+          }
+          if (context.streamComplete) break
+          continue
+        }
+
+        const handler = sseHandlers[event.type]
+        if (handler) {
+          await handler(event, context, execContext, options)
+        }
+        if (context.streamComplete) break
+      }
+    } finally {
+      clearTimeout(timeoutId)
+    }
+
+    const result = buildResult(context)
+    await options.onComplete?.(result)
+    return result
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error('Copilot orchestration failed')
+    logger.error('Copilot orchestration failed', { error: err.message })
+    await options.onError?.(err)
+    return {
+      success: false,
+      content: '',
+      contentBlocks: [],
+      toolCalls: [],
+      chatId: context.chatId,
+      conversationId: context.conversationId,
+      error: err.message,
+    }
+  }
+}
+
+async function forwardEvent(event: SSEEvent, options: OrchestratorOptions): Promise<void> {
+  try {
+    await options.onEvent?.(event)
+  } catch (error) {
+    logger.warn('Failed to forward SSE event', {
+      type: event.type,
+      error: error instanceof Error ? error.message : String(error),
+    })
+  }
+}
+
+function buildResult(context: StreamingContext): OrchestratorResult {
+  const toolCalls: ToolCallSummary[] = Array.from(context.toolCalls.values()).map((toolCall) => ({
+    id: toolCall.id,
+    name: toolCall.name,
+    status: toolCall.status,
+    params: toolCall.params,
+    result: toolCall.result?.output,
+    error: toolCall.error,
+    durationMs:
+      toolCall.endTime && toolCall.startTime ? toolCall.endTime - toolCall.startTime : undefined,
+  }))
+
+  return {
+    success: context.errors.length === 0,
+    content: context.accumulatedContent,
+    contentBlocks: context.contentBlocks,
+    toolCalls,
+    chatId: context.chatId,
+    conversationId: context.conversationId,
+    errors: context.errors.length ? context.errors : undefined,
+  }
+}
+