Combine superagent into copilkot

simstudioai · Sg312 · Dec 5, 2025 · Nov 18, 2025 · Nov 20, 2025 · Nov 20, 2025
commit 114a2246b96322d2c7b0c4321ed22a10afdc1103
diff --git a/apps/sim/app/api/copilot/chat/route.ts b/apps/sim/app/api/copilot/chat/route.ts
@@ -14,11 +14,13 @@ import {
   createRequestTracker,
   createUnauthorizedResponse,
 } from '@/lib/copilot/request-helpers'
+import { getCredentialsServerTool } from '@/lib/copilot/tools/server/user/get-credentials'
 import type { CopilotProviderConfig } from '@/lib/copilot/types'
 import { env } from '@/lib/core/config/env'
 import { createLogger } from '@/lib/logs/console/logger'
 import { CopilotFiles } from '@/lib/uploads'
 import { createFileContent } from '@/lib/uploads/utils/file-utils'
+import { tools } from '@/tools/registry'
 
 const logger = createLogger('CopilotChatAPI')
 
@@ -313,6 +315,94 @@ export async function POST(req: NextRequest) {
     const effectiveConversationId =
       (currentChat?.conversationId as string | undefined) || conversationId
 
+    // For agent/build mode, fetch credentials and build tool definitions
+    let integrationTools: any[] = []
+    let credentials: {
+      oauth: Record<string, { accessToken: string; accountId: string; name: string; expiresAt?: string }>
+      apiKeys: string[]
+      metadata?: {
+        connectedOAuth: Array<{ provider: string; name: string; scopes?: string[] }>
+        configuredApiKeys: string[]
+      }
+    } | null = null
+
+    if (mode === 'agent') {
+      // Fetch user credentials (OAuth + API keys)
+      try {
+        const rawCredentials = await getCredentialsServerTool.execute(
+          { userId: authenticatedUserId },
+          { userId: authenticatedUserId }
+        )
+
+        // Transform OAuth credentials to map format: { [provider]: { accessToken, accountId, ... } }
+        const oauthMap: Record<
+          string,
+          { accessToken: string; accountId: string; name: string; expiresAt?: string }
+        > = {}
+        const connectedOAuth: Array<{ provider: string; name: string; scopes?: string[] }> = []
+        for (const cred of rawCredentials?.oauth?.credentials || []) {
+          if (cred.accessToken) {
+            oauthMap[cred.provider] = {
+              accessToken: cred.accessToken,
+              accountId: cred.id,
+              name: cred.name,
+            }
+            connectedOAuth.push({
+              provider: cred.provider,
+              name: cred.name,
+            })
+          }
+        }
+
+        credentials = {
+          oauth: oauthMap,
+          apiKeys: rawCredentials?.environment?.variableNames || [],
+          metadata: {
+            connectedOAuth,
+            configuredApiKeys: rawCredentials?.environment?.variableNames || [],
+          },
+        }
+
+        logger.info(`[${tracker.requestId}] Fetched credentials for build mode`, {
+          oauthProviders: Object.keys(oauthMap),
+          apiKeyCount: credentials.apiKeys.length,
+        })
+      } catch (error) {
+        logger.warn(`[${tracker.requestId}] Failed to fetch credentials`, {
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+
+      // Build tool definitions (schemas only)
+      try {
+        const { createUserToolSchema } = await import('@/tools/params')
+
+        integrationTools = Object.entries(tools).map(([toolId, toolConfig]) => {
+          const userSchema = createUserToolSchema(toolConfig)
+          return {
+            name: toolId,
+            description: toolConfig.description || toolConfig.name || toolId,
+            input_schema: userSchema,
+            defer_loading: true, // Anthropic Advanced Tool Use
+            ...(toolConfig.oauth?.required && {
+              oauth: {
+                required: true,
+                provider: toolConfig.oauth.provider,
+              },
+            }),
+          }
+        })
+
+        logger.info(`[${tracker.requestId}] Built tool definitions for build mode`, {
+          integrationToolCount: integrationTools.length,
+        })
+      } catch (error) {
+        logger.warn(`[${tracker.requestId}] Failed to build tool definitions`, {
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+    }
+
     const requestPayload = {
       message: message, // Just send the current user message text
       workflowId,
@@ -330,6 +420,11 @@ export async function POST(req: NextRequest) {
       ...(agentContexts.length > 0 && { context: agentContexts }),
       ...(actualChatId ? { chatId: actualChatId } : {}),
       ...(processedFileContents.length > 0 && { fileAttachments: processedFileContents }),
+      // For build/agent mode, include tools and credentials
+      ...(integrationTools.length > 0 && { tools: integrationTools }),
+      ...(credentials && { credentials }),
+      // Anthropic beta features for advanced tool use
+      ...(mode === 'agent' && { betas: ['advanced-tool-use-2025-11-20'] }),
     }
 
     try {

diff --git a/.../app/api/superagent/execute-tool/route.ts → ...sim/app/api/copilot/execute-tool/route.ts b/.../app/api/superagent/execute-tool/route.ts → ...sim/app/api/copilot/execute-tool/route.ts
@@ -17,13 +17,13 @@ import { createLogger } from '@/lib/logs/console/logger'
 import { executeTool } from '@/tools'
 import { getTool } from '@/tools/utils'
 
-const logger = createLogger('SuperagentExecuteToolAPI')
+const logger = createLogger('CopilotExecuteToolAPI')
 
 const ExecuteToolSchema = z.object({
   toolCallId: z.string(),
   toolName: z.string(),
   arguments: z.record(z.any()).optional().default({}),
-  workspaceId: z.string(),
+  workflowId: z.string().optional(),
 })
 
 /**
@@ -49,11 +49,7 @@ function mapEnvVarsToToolParams(
   const toolPrefix = toolId.split('_')[0]?.toUpperCase()
 
   // Common API key environment variable patterns to check
-  const envKeyPatterns = [
-    `${toolPrefix}_API_KEY`,
-    `${toolPrefix}AI_API_KEY`,
-    `${toolPrefix}_KEY`,
-  ]
+  const envKeyPatterns = [`${toolPrefix}_API_KEY`, `${toolPrefix}AI_API_KEY`, `${toolPrefix}_KEY`]
 
   // Special mappings for tools with non-standard naming
   const specialMappings: Record<string, string[]> = {
@@ -93,8 +89,9 @@ function mapEnvVarsToToolParams(
 }
 
 /**
- * POST /api/superagent/execute-tool
+ * POST /api/copilot/execute-tool
  * Execute an integration tool with resolved credentials
+ * Called by the sim-agent service when it needs to execute a tool
  */
 export async function POST(req: NextRequest) {
   const tracker = createRequestTracker()
@@ -113,12 +110,12 @@ export async function POST(req: NextRequest) {
       logger.debug(`[${tracker.requestId}] Incoming execute-tool request`, { preview })
     } catch {}
 
-    const { toolCallId, toolName, arguments: toolArgs, workspaceId } = ExecuteToolSchema.parse(body)
+    const { toolCallId, toolName, arguments: toolArgs, workflowId } = ExecuteToolSchema.parse(body)
 
     logger.info(`[${tracker.requestId}] Executing tool`, {
       toolCallId,
       toolName,
-      workspaceId,
+      workflowId,
       hasArgs: Object.keys(toolArgs).length > 0,
     })
 
@@ -128,12 +125,12 @@ export async function POST(req: NextRequest) {
       // Find similar tool names to help debug
       const { tools: allTools } = await import('@/tools/registry')
       const allToolNames = Object.keys(allTools)
-      const prefix = toolName.split('_').slice(0, 2).join('_') // e.g., "linear_list"
-      const similarTools = allToolNames.filter((name) => 
-        name.startsWith(prefix.split('_')[0] + '_') // Same provider prefix
-      ).slice(0, 10)
-      
-      logger.warn(`[${tracker.requestId}] Tool not found in registry`, { 
+      const prefix = toolName.split('_').slice(0, 2).join('_')
+      const similarTools = allToolNames
+        .filter((name) => name.startsWith(prefix.split('_')[0] + '_'))
+        .slice(0, 10)
+
+      logger.warn(`[${tracker.requestId}] Tool not found in registry`, {
         toolName,
         prefix,
         similarTools,
@@ -216,32 +213,34 @@ export async function POST(req: NextRequest) {
     const llmProvidedApiKey = executionParams.apiKey as string | undefined
 
     if (needsApiKey || llmProvidedApiKey) {
-      logger.info(`[${tracker.requestId}] Resolving API key for tool`, { 
-        toolName, 
+      logger.info(`[${tracker.requestId}] Resolving API key for tool`, {
+        toolName,
         needsApiKey,
         hasLlmProvidedKey: !!llmProvidedApiKey,
-        llmProvidedKeyPreview: llmProvidedApiKey ? `${llmProvidedApiKey.substring(0, 20)}...` : null,
+        llmProvidedKeyPreview: llmProvidedApiKey
+          ? `${llmProvidedApiKey.substring(0, 20)}...`
+          : null,
       })
 
       try {
-        const decryptedEnvVars = await getEffectiveDecryptedEnv(userId, workspaceId)
-        
+        const decryptedEnvVars = await getEffectiveDecryptedEnv(userId, workflowId)
+
         // Case 1: LLM provided an API key name (e.g., "EXA_API_KEY") - resolve it
         if (llmProvidedApiKey) {
           // Check if it looks like an env var name (uppercase with underscores, ends with _KEY or _API_KEY)
           const looksLikeEnvVar = /^[A-Z][A-Z0-9_]*(_KEY|_API_KEY)$/.test(llmProvidedApiKey)
-          
+
           if (looksLikeEnvVar && decryptedEnvVars[llmProvidedApiKey]) {
             // Resolve the env var name to its actual value
             executionParams.apiKey = decryptedEnvVars[llmProvidedApiKey]
-            logger.info(`[${tracker.requestId}] Resolved API key from LLM-provided name`, { 
-              toolName, 
+            logger.info(`[${tracker.requestId}] Resolved API key from LLM-provided name`, {
+              toolName,
               envVarName: llmProvidedApiKey,
             })
           } else if (looksLikeEnvVar) {
             // LLM provided an env var name but it's not configured
-            logger.warn(`[${tracker.requestId}] LLM provided API key name not found in env vars`, { 
-              toolName, 
+            logger.warn(`[${tracker.requestId}] LLM provided API key name not found in env vars`, {
+              toolName,
               envVarName: llmProvidedApiKey,
               availableKeys: Object.keys(decryptedEnvVars),
             })
@@ -256,7 +255,7 @@ export async function POST(req: NextRequest) {
           }
           // else: LLM provided what looks like an actual API key value, keep it as-is
         }
-        
+
         // Case 2: No API key yet but tool requires one - resolve from tool prefix convention
         if (!executionParams.apiKey && needsApiKey) {
           const apiKeyParams = mapEnvVarsToToolParams(toolName, toolConfig, decryptedEnvVars)
@@ -294,7 +293,7 @@ export async function POST(req: NextRequest) {
 
     // Add execution context
     executionParams._context = {
-      workspaceId,
+      workflowId,
       userId,
     }