Switch back to inline imports

Author: Theodore Li

apps/sim/executor/handlers/agent/agent-handler.ts

@@ -3,7 +3,6 @@ import { mcpServers } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
 import { and, eq, inArray, isNull } from 'drizzle-orm'
 import { createMcpToolId } from '@/lib/mcp/utils'
-import { getCustomToolById } from '@/lib/workflows/custom-tools/operations'
 import { getAllBlocks } from '@/blocks'
 import type { BlockOutput } from '@/blocks/types'
 import {
@@ -284,6 +283,7 @@ export class AgentBlockHandler implements BlockHandler {
     }
 
     try {
+      const { getCustomToolById } = await import('@/lib/workflows/custom-tools/operations')
       const tool = await getCustomToolById({
         toolId: customToolId,
         userId: ctx.userId,

apps/sim/tools/utils.server.ts

@@ -1,10 +1,8 @@
 import { createLogger } from '@sim/logger'
-import { generateInternalToken } from '@/lib/auth/internal'
 import {
   secureFetchWithPinnedIP,
   validateUrlWithDNS,
 } from '@/lib/core/security/input-validation.server'
-import { getInternalApiBaseUrl } from '@/lib/core/utils/urls'
 import { isCustomTool } from '@/executor/constants'
 import type { CustomToolDefinition } from '@/hooks/queries/custom-tools'
 import { extractErrorMessage } from '@/tools/error-extractors'
@@ -97,67 +95,42 @@ export async function getToolAsync(
   if (builtInTool) return builtInTool
 
   if (isCustomTool(toolId)) {
-    return fetchCustomToolFromAPI(toolId, context)
+    return fetchCustomToolFromDB(toolId, context)
   }
 
   return undefined
 }
 
-async function fetchCustomToolFromAPI(
+async function fetchCustomToolFromDB(
   customToolId: string,
   context: GetToolAsyncContext
 ): Promise<ToolConfig | undefined> {
   const { workflowId, userId, workspaceId } = context
   const identifier = customToolId.replace('custom_', '')
 
   try {
-    const baseUrl = getInternalApiBaseUrl()
-    const url = new URL('/api/tools/custom', baseUrl)
-
-    if (workflowId) {
-      url.searchParams.append('workflowId', workflowId)
-    }
-    if (userId) {
-      url.searchParams.append('userId', userId)
-    }
-    if (workspaceId) {
-      url.searchParams.append('workspaceId', workspaceId)
-    }
-
-    const headers: Record<string, string> = {}
-
-    try {
-      const internalToken = await generateInternalToken(userId)
-      headers.Authorization = `Bearer ${internalToken}`
-    } catch (error) {
-      logger.warn('Failed to generate internal token for custom tools fetch', { error })
-    }
-
-    const response = await fetch(url.toString(), { headers })
-
-    if (!response.ok) {
-      await response.text().catch(() => {})
-      logger.error(`Failed to fetch custom tools: ${response.statusText}`)
+    if (!userId) {
+      logger.error(`Cannot fetch custom tool without userId: ${identifier}`)
       return undefined
     }
 
-    const result = await response.json()
-
-    if (!result.data || !Array.isArray(result.data)) {
-      logger.error(`Invalid response when fetching custom tools: ${JSON.stringify(result)}`)
-      return undefined
-    }
+    const { getCustomToolById, listCustomTools } = await import(
+      '@/lib/workflows/custom-tools/operations'
+    )
 
-    const customTool = result.data.find(
-      (tool: CustomToolDefinition) => tool.id === identifier || tool.title === identifier
-    ) as CustomToolDefinition | undefined
+    // Try to find by ID first, fall back to searching by title
+    const customTool =
+      (await getCustomToolById({ toolId: identifier, userId, workspaceId })) ??
+      (await listCustomTools({ userId, workspaceId })).find(
+        (t: { title: string }) => t.title === identifier
+      )
 
     if (!customTool) {
       logger.error(`Custom tool not found: ${identifier}`)
       return undefined
     }
 
-    const toolConfig = createToolConfig(customTool, customToolId)
+    const toolConfig = createToolConfig(customTool as unknown as CustomToolDefinition, customToolId)
 
     return {
       ...toolConfig,
@@ -168,7 +141,7 @@ async function fetchCustomToolFromAPI(
       },
     }
   } catch (error) {
-    logger.error(`Error fetching custom tool ${identifier} from API:`, error)
+    logger.error(`Error fetching custom tool ${identifier} from DB:`, error)
     return undefined
   }
 }

apps/sim/tools/utils.ts

@@ -1,6 +1,5 @@
 import { createLogger } from '@sim/logger'
 import { getMaxExecutionTimeout } from '@/lib/core/execution-limits'
-import { getCustomToolById, listCustomTools } from '@/lib/workflows/custom-tools/operations'
 import { AGENT, isCustomTool } from '@/executor/constants'
 import type { CustomToolDefinition } from '@/hooks/queries/custom-tools'
 import { useEnvironmentStore } from '@/stores/settings/environment'
@@ -295,24 +294,6 @@ export function getTool(toolId: string, _workspaceId?: string): ToolConfig | und
   return undefined
 }
 
-// Get a tool by its ID asynchronously (supports server-side)
-export async function getToolAsync(
-  toolId: string,
-  workflowId?: string,
-  userId?: string
-): Promise<ToolConfig | undefined> {
-  // Check for built-in tools
-  const builtInTool = tools[toolId]
-  if (builtInTool) return builtInTool
-
-  // Check if it's a custom tool
-  if (isCustomTool(toolId)) {
-    return fetchCustomToolFromDB(toolId, workflowId, userId)
-  }
-
-  return undefined
-}
-
 // Helper function to create a tool config from a custom tool
 export function createToolConfig(
   customTool: CustomToolDefinition,
@@ -354,69 +335,4 @@ export function createToolConfig(
   }
 }
 
-// Create a tool config from a custom tool definition by querying the database directly
-async function fetchCustomToolFromDB(
-  customToolId: string,
-  workflowId?: string,
-  userId?: string
-): Promise<ToolConfig | undefined> {
-  const identifier = customToolId.replace('custom_', '')
-
-  try {
-    if (!userId) {
-      logger.error(`Cannot fetch custom tool without userId: ${identifier}`)
-      return undefined
-    }
-
-    // Try to find by ID first, fall back to searching by title
-    const customTool =
-      (await getCustomToolById({ toolId: identifier, userId })) ??
-      (await listCustomTools({ userId })).find((t) => t.title === identifier)
-
-    if (!customTool) {
-      logger.error(`Custom tool not found: ${identifier}`)
-      return undefined
-    }
-
-    const schema = customTool.schema as Record<string, any>
-
-    // Create a parameter schema
-    const params = createParamSchema(customTool)
-
-    // Create a tool config for the custom tool
-    return {
-      id: customToolId,
-      name: customTool.title,
-      description: schema.function?.description || '',
-      version: '1.0.0',
-      params,
-
-      // Request configuration - for custom tools we'll use the execute endpoint
-      request: {
-        url: '/api/function/execute',
-        method: 'POST',
-        headers: () => ({ 'Content-Type': 'application/json' }),
-        body: createCustomToolRequestBody(customTool, false, workflowId),
-      },
-
-      // Same response handling as client-side
-      transformResponse: async (response: Response) => {
-        const data = await response.json()
-
-        if (!data.success) {
-          throw new Error(data.error || 'Custom tool execution failed')
-        }
-
-        return {
-          success: true,
-          output: data.output.result || data.output,
-          error: undefined,
-        }
-      },
-    }
-  } catch (error) {
-    logger.error(`Error fetching custom tool ${identifier} from DB:`, error)
-    return undefined
-  }
-}