added utils files for each provider, consolidated gemini utils, added dynamic verbosity and reasoning fetcher

Author: waleedlatif1

apps/docs/package.json

@@ -4,7 +4,7 @@
   "private": true,
   "license": "Apache-2.0",
   "scripts": {
-    "dev": "next dev --port 3001",
+    "dev": "next dev --port 7322",
     "build": "fumadocs-mdx && NODE_OPTIONS='--max-old-space-size=8192' next build",
     "start": "next start",
     "postinstall": "fumadocs-mdx",

apps/sim/blocks/blocks/agent.ts

@@ -8,6 +8,8 @@ import {
   getHostedModels,
   getMaxTemperature,
   getProviderIcon,
+  getReasoningEffortValuesForModel,
+  getVerbosityValuesForModel,
   MODELS_WITH_REASONING_EFFORT,
   MODELS_WITH_VERBOSITY,
   providers,
@@ -114,12 +116,47 @@ export const AgentBlock: BlockConfig<AgentResponse> = {
       type: 'dropdown',
       placeholder: 'Select reasoning effort...',
       options: [
-        { label: 'none', id: 'none' },
-        { label: 'minimal', id: 'minimal' },
         { label: 'low', id: 'low' },
         { label: 'medium', id: 'medium' },
         { label: 'high', id: 'high' },
       ],
+      dependsOn: ['model'],
+      fetchOptions: async (blockId: string) => {
+        const { useSubBlockStore } = await import('@/stores/workflows/subblock/store')
+        const { useWorkflowRegistry } = await import('@/stores/workflows/registry/store')
+
+        const activeWorkflowId = useWorkflowRegistry.getState().activeWorkflowId
+        if (!activeWorkflowId) {
+          return [
+            { label: 'low', id: 'low' },
+            { label: 'medium', id: 'medium' },
+            { label: 'high', id: 'high' },
+          ]
+        }
+
+        const workflowValues = useSubBlockStore.getState().workflowValues[activeWorkflowId]
+        const blockValues = workflowValues?.[blockId]
+        const modelValue = blockValues?.model as string
+
+        if (!modelValue) {
+          return [
+            { label: 'low', id: 'low' },
+            { label: 'medium', id: 'medium' },
+            { label: 'high', id: 'high' },
+          ]
+        }
+
+        const validOptions = getReasoningEffortValuesForModel(modelValue)
+        if (!validOptions) {
+          return [
+            { label: 'low', id: 'low' },
+            { label: 'medium', id: 'medium' },
+            { label: 'high', id: 'high' },
+          ]
+        }
+
+        return validOptions.map((opt) => ({ label: opt, id: opt }))
+      },
       value: () => 'medium',
       condition: {
         field: 'model',
@@ -136,6 +173,43 @@ export const AgentBlock: BlockConfig<AgentResponse> = {
         { label: 'medium', id: 'medium' },
         { label: 'high', id: 'high' },
       ],
+      dependsOn: ['model'],
+      fetchOptions: async (blockId: string) => {
+        const { useSubBlockStore } = await import('@/stores/workflows/subblock/store')
+        const { useWorkflowRegistry } = await import('@/stores/workflows/registry/store')
+
+        const activeWorkflowId = useWorkflowRegistry.getState().activeWorkflowId
+        if (!activeWorkflowId) {
+          return [
+            { label: 'low', id: 'low' },
+            { label: 'medium', id: 'medium' },
+            { label: 'high', id: 'high' },
+          ]
+        }
+
+        const workflowValues = useSubBlockStore.getState().workflowValues[activeWorkflowId]
+        const blockValues = workflowValues?.[blockId]
+        const modelValue = blockValues?.model as string
+
+        if (!modelValue) {
+          return [
+            { label: 'low', id: 'low' },
+            { label: 'medium', id: 'medium' },
+            { label: 'high', id: 'high' },
+          ]
+        }
+
+        const validOptions = getVerbosityValuesForModel(modelValue)
+        if (!validOptions) {
+          return [
+            { label: 'low', id: 'low' },
+            { label: 'medium', id: 'medium' },
+            { label: 'high', id: 'high' },
+          ]
+        }
+
+        return validOptions.map((opt) => ({ label: opt, id: opt }))
+      },
       value: () => 'medium',
       condition: {
         field: 'model',

apps/sim/package.json

@@ -8,7 +8,7 @@
     "node": ">=20.0.0"
   },
   "scripts": {
-    "dev": "next dev --port 3000",
+    "dev": "next dev --port 7321",
     "dev:webpack": "next dev --webpack",
     "dev:sockets": "bun run socket-server/index.ts",
     "dev:full": "concurrently -n \"App,Realtime\" -c \"cyan,magenta\" \"bun run dev\" \"bun run dev:sockets\"",

apps/sim/providers/anthropic/index.ts

@@ -2,35 +2,23 @@ import Anthropic from '@anthropic-ai/sdk'
 import { createLogger } from '@/lib/logs/console/logger'
 import type { StreamingExecution } from '@/executor/types'
 import { MAX_TOOL_ITERATIONS } from '@/providers'
+import {
+  checkForForcedToolUsage,
+  createReadableStreamFromAnthropicStream,
+  generateToolUseId,
+} from '@/providers/anthropic/utils'
+import { getProviderDefaultModel, getProviderModels } from '@/providers/models'
+import type {
+  ProviderConfig,
+  ProviderRequest,
+  ProviderResponse,
+  TimeSegment,
+} from '@/providers/types'
+import { prepareToolExecution, prepareToolsWithUsageControl } from '@/providers/utils'
 import { executeTool } from '@/tools'
-import { getProviderDefaultModel, getProviderModels } from '../models'
-import type { ProviderConfig, ProviderRequest, ProviderResponse, TimeSegment } from '../types'
-import { prepareToolExecution, prepareToolsWithUsageControl, trackForcedToolUsage } from '../utils'
 
 const logger = createLogger('AnthropicProvider')
 
-/**
- * Helper to wrap Anthropic streaming into a browser-friendly ReadableStream
- */
-function createReadableStreamFromAnthropicStream(
-  anthropicStream: AsyncIterable<any>
-): ReadableStream {
-  return new ReadableStream({
-    async start(controller) {
-      try {
-        for await (const event of anthropicStream) {
-          if (event.type === 'content_block_delta' && event.delta?.text) {
-            controller.enqueue(new TextEncoder().encode(event.delta.text))
-          }
-        }
-        controller.close()
-      } catch (err) {
-        controller.error(err)
-      }
-    },
-  })
-}
-
 export const anthropicProvider: ProviderConfig = {
   id: 'anthropic',
   name: 'Anthropic',
@@ -48,11 +36,6 @@ export const anthropicProvider: ProviderConfig = {
 
     const anthropic = new Anthropic({ apiKey: request.apiKey })
 
-    // Helper function to generate a simple unique ID for tool uses
-    const generateToolUseId = (toolName: string) => {
-      return `${toolName}-${Date.now()}-${Math.random().toString(36).substring(2, 7)}`
-    }
-
     // Transform messages to Anthropic format
     const messages: any[] = []
 
@@ -393,44 +376,17 @@ ${fieldDescriptions}
           },
         ]
 
-        // Helper function to check for forced tool usage in Anthropic responses
-        const checkForForcedToolUsage = (response: any, toolChoice: any) => {
-          if (
-            typeof toolChoice === 'object' &&
-            toolChoice !== null &&
-            Array.isArray(response.content)
-          ) {
-            const toolUses = response.content.filter((item: any) => item.type === 'tool_use')
-
-            if (toolUses.length > 0) {
-              // Convert Anthropic tool_use format to a format trackForcedToolUsage can understand
-              const adaptedToolCalls = toolUses.map((tool: any) => ({
-                name: tool.name,
-              }))
-
-              // Convert Anthropic tool_choice format to match OpenAI format for tracking
-              const adaptedToolChoice =
-                toolChoice.type === 'tool' ? { function: { name: toolChoice.name } } : toolChoice
-
-              const result = trackForcedToolUsage(
-                adaptedToolCalls,
-                adaptedToolChoice,
-                logger,
-                'anthropic',
-                forcedTools,
-                usedForcedTools
-              )
-              // Make the behavior consistent with the initial check
-              hasUsedForcedTool = result.hasUsedForcedTool
-              usedForcedTools = result.usedForcedTools
-              return result
-            }
-          }
-          return null
-        }
-
         // Check if a forced tool was used in the first response
-        checkForForcedToolUsage(currentResponse, originalToolChoice)
+        const firstCheckResult = checkForForcedToolUsage(
+          currentResponse,
+          originalToolChoice,
+          forcedTools,
+          usedForcedTools
+        )
+        if (firstCheckResult) {
+          hasUsedForcedTool = firstCheckResult.hasUsedForcedTool
+          usedForcedTools = firstCheckResult.usedForcedTools
+        }
 
         try {
           while (iterationCount < MAX_TOOL_ITERATIONS) {
@@ -576,7 +532,16 @@ ${fieldDescriptions}
             currentResponse = await anthropic.messages.create(nextPayload)
 
             // Check if any forced tools were used in this response
-            checkForForcedToolUsage(currentResponse, nextPayload.tool_choice)
+            const nextCheckResult = checkForForcedToolUsage(
+              currentResponse,
+              nextPayload.tool_choice,
+              forcedTools,
+              usedForcedTools
+            )
+            if (nextCheckResult) {
+              hasUsedForcedTool = nextCheckResult.hasUsedForcedTool
+              usedForcedTools = nextCheckResult.usedForcedTools
+            }
 
             const nextModelEndTime = Date.now()
             const thisModelTime = nextModelEndTime - nextModelStartTime
@@ -746,44 +711,17 @@ ${fieldDescriptions}
         },
       ]
 
-      // Helper function to check for forced tool usage in Anthropic responses
-      const checkForForcedToolUsage = (response: any, toolChoice: any) => {
-        if (
-          typeof toolChoice === 'object' &&
-          toolChoice !== null &&
-          Array.isArray(response.content)
-        ) {
-          const toolUses = response.content.filter((item: any) => item.type === 'tool_use')
-
-          if (toolUses.length > 0) {
-            // Convert Anthropic tool_use format to a format trackForcedToolUsage can understand
-            const adaptedToolCalls = toolUses.map((tool: any) => ({
-              name: tool.name,
-            }))
-
-            // Convert Anthropic tool_choice format to match OpenAI format for tracking
-            const adaptedToolChoice =
-              toolChoice.type === 'tool' ? { function: { name: toolChoice.name } } : toolChoice
-
-            const result = trackForcedToolUsage(
-              adaptedToolCalls,
-              adaptedToolChoice,
-              logger,
-              'anthropic',
-              forcedTools,
-              usedForcedTools
-            )
-            // Make the behavior consistent with the initial check
-            hasUsedForcedTool = result.hasUsedForcedTool
-            usedForcedTools = result.usedForcedTools
-            return result
-          }
-        }
-        return null
-      }
-
       // Check if a forced tool was used in the first response
-      checkForForcedToolUsage(currentResponse, originalToolChoice)
+      const firstCheckResult = checkForForcedToolUsage(
+        currentResponse,
+        originalToolChoice,
+        forcedTools,
+        usedForcedTools
+      )
+      if (firstCheckResult) {
+        hasUsedForcedTool = firstCheckResult.hasUsedForcedTool
+        usedForcedTools = firstCheckResult.usedForcedTools
+      }
 
       try {
         while (iterationCount < MAX_TOOL_ITERATIONS) {
@@ -925,7 +863,16 @@ ${fieldDescriptions}
           currentResponse = await anthropic.messages.create(nextPayload)
 
           // Check if any forced tools were used in this response
-          checkForForcedToolUsage(currentResponse, nextPayload.tool_choice)
+          const nextCheckResult = checkForForcedToolUsage(
+            currentResponse,
+            nextPayload.tool_choice,
+            forcedTools,
+            usedForcedTools
+          )
+          if (nextCheckResult) {
+            hasUsedForcedTool = nextCheckResult.hasUsedForcedTool
+            usedForcedTools = nextCheckResult.usedForcedTools
+          }
 
           const nextModelEndTime = Date.now()
           const thisModelTime = nextModelEndTime - nextModelStartTime

apps/sim/providers/anthropic/utils.ts

@@ -0,0 +1,70 @@
+import { createLogger } from '@/lib/logs/console/logger'
+import { trackForcedToolUsage } from '@/providers/utils'
+
+const logger = createLogger('AnthropicUtils')
+
+/**
+ * Helper to wrap Anthropic streaming into a browser-friendly ReadableStream
+ */
+export function createReadableStreamFromAnthropicStream(
+  anthropicStream: AsyncIterable<any>
+): ReadableStream {
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const event of anthropicStream) {
+          if (event.type === 'content_block_delta' && event.delta?.text) {
+            controller.enqueue(new TextEncoder().encode(event.delta.text))
+          }
+        }
+        controller.close()
+      } catch (err) {
+        controller.error(err)
+      }
+    },
+  })
+}
+
+/**
+ * Helper function to generate a simple unique ID for tool uses
+ */
+export function generateToolUseId(toolName: string): string {
+  return `${toolName}-${Date.now()}-${Math.random().toString(36).substring(2, 7)}`
+}
+
+/**
+ * Helper function to check for forced tool usage in Anthropic responses
+ */
+export function checkForForcedToolUsage(
+  response: any,
+  toolChoice: any,
+  forcedTools: string[],
+  usedForcedTools: string[]
+): { hasUsedForcedTool: boolean; usedForcedTools: string[] } | null {
+  if (typeof toolChoice === 'object' && toolChoice !== null && Array.isArray(response.content)) {
+    const toolUses = response.content.filter((item: any) => item.type === 'tool_use')
+
+    if (toolUses.length > 0) {
+      // Convert Anthropic tool_use format to a format trackForcedToolUsage can understand
+      const adaptedToolCalls = toolUses.map((tool: any) => ({
+        name: tool.name,
+      }))
+
+      // Convert Anthropic tool_choice format to match OpenAI format for tracking
+      const adaptedToolChoice =
+        toolChoice.type === 'tool' ? { function: { name: toolChoice.name } } : toolChoice
+
+      const result = trackForcedToolUsage(
+        adaptedToolCalls,
+        adaptedToolChoice,
+        logger,
+        'anthropic',
+        forcedTools,
+        usedForcedTools
+      )
+
+      return result
+    }
+  }
+  return null
+}