auto model

Author: Sg312

apps/desktop/build/generated-icon.icon/Assets/border.svg

@@ -0,0 +1,33 @@
+{
+  "fill": {
+    "solid": "srgb:1.00000,1.00000,1.00000,1.00000"
+  },
+  "groups": [
+    {
+      "layers": [
+        {
+          "image-name": "logo.png",
+          "is-glass": false,
+          "name": "Sim"
+        },
+        {
+          "image-name": "border.svg",
+          "is-glass": false,
+          "name": "Dev Border"
+        }
+      ],
+      "shadow": {
+        "kind": "neutral",
+        "opacity": 0
+      },
+      "specular": false,
+      "translucency": {
+        "enabled": false,
+        "value": 0
+      }
+    }
+  ],
+  "supported-platforms": {
+    "squares": ["macOS"]
+  }
+}

apps/desktop/build/generated-icon.icon/Assets/logo.png

@@ -63,7 +63,11 @@ API_ENCRYPTION_KEY=your_api_encryption_key # Use `openssl rand -hex 32` to gener
 # VLLM_API_KEY=                          # Optional bearer token if your vLLM instance requires auth
 # LITELLM_BASE_URL=http://localhost:4000 # Base URL for your LiteLLM proxy (OpenAI-compatible)
 # LITELLM_API_KEY=                       # Optional bearer token if your LiteLLM proxy requires auth
-# FIREWORKS_API_KEY=                     # Optional Fireworks AI API key for model listing
+# NEXT_PUBLIC_FORCE_HOSTED=true          # Dev only: treat this instance as hosted Sim (sim-auto pool, platform keys); ignored in production builds
+# FIREWORKS_API_KEY=                     # Optional Fireworks AI API key for model listing and inference
+# FIREWORKS_API_KEY_1=                   # Optional Fireworks API key for rotation (hosted deployments)
+# FIREWORKS_API_KEY_2=                   # Additional Fireworks API key for load balancing
+# FIREWORKS_API_KEY_3=                   # Additional Fireworks API key for load balancing
 # NEXT_PUBLIC_BEDROCK_DEFAULT_CREDENTIALS=true  # Set when using AWS default credential chain (IAM roles, ECS task roles, IRSA). Hides credential fields in Agent block UI.
 # AZURE_OPENAI_ENDPOINT=                        # Azure OpenAI endpoint (hides field in UI when set alongside NEXT_PUBLIC_AZURE_CONFIGURED)
 # AZURE_OPENAI_API_KEY=                         # Azure OpenAI API key

apps/desktop/build/generated-icon.icon/icon.json

@@ -10,6 +10,7 @@ import { validationErrorResponse } from '@/lib/api/server'
 import { getBYOKKey } from '@/lib/api-key/byok'
 import { getSession } from '@/lib/auth'
 import { env } from '@/lib/core/config/env'
+import { isHosted } from '@/lib/core/config/env-flags'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
 import { filterBlacklistedModels, isProviderBlacklisted } from '@/providers/utils'
@@ -54,7 +55,13 @@ export const GET = withRouteHandler(async (request: NextRequest) => {
     }
   }
 
-  if (!apiKey) {
+  /**
+   * On hosted Sim the platform key is the sim-auto pool's inference key, not a
+   * workspace credential: enumerating the whole Fireworks catalog from it would
+   * offer every serverless model as selectable when no key can actually run it
+   * (`getApiKeyWithBYOK` serves the platform key to catalog models only).
+   */
+  if (!apiKey && !isHosted) {
     apiKey = env.FIREWORKS_API_KEY
   }
 

apps/sim/.env.example

@@ -1,6 +1,5 @@
 import { createLogger } from '@sim/logger'
 import { AgentIcon } from '@/components/icons'
-import { isHosted } from '@/lib/core/config/env-flags'
 import type { BlockConfig } from '@/blocks/types'
 import { AuthMode, IntegrationType } from '@/blocks/types'
 import {
@@ -22,7 +21,6 @@ import {
   getThinkingLevelsForModel,
   getVerbosityValuesForModel,
   isAutoModel,
-  SIM_AUTO_MODEL_ID,
   supportsTemperature,
 } from '@/providers/models'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
@@ -135,9 +133,7 @@ Return ONLY the JSON array.`,
       type: 'combobox',
       placeholder: 'Type or select a model...',
       required: true,
-      // Hosted Sim defaults new agent blocks to the automatic model; the
-      // runtime fallback for blocks with no model set stays AGENT.DEFAULT_MODEL.
-      defaultValue: isHosted ? SIM_AUTO_MODEL_ID : 'claude-sonnet-5',
+      defaultValue: 'claude-sonnet-5',
       options: getModelOptions,
       commandSearchable: true,
     },

apps/sim/app/api/providers/fireworks/models/route.ts

@@ -85,8 +85,11 @@ export function getModelOptions() {
       return { label: model, id: model, ...(icon && { icon }) }
     })
 
+  // Hosted-only automatic model. Deliberately LAST in the list (limited
+  // visibility for the initial release): available to anyone who scrolls or
+  // searches for it, but never the first thing the dropdown offers.
   if (isHosted) {
-    options.unshift({ label: 'Auto', id: SIM_AUTO_MODEL_ID, icon: SimAutoIcon })
+    options.push({ label: 'Auto', id: SIM_AUTO_MODEL_ID, icon: SimAutoIcon })
   }
 
   return options
@@ -192,8 +195,10 @@ function shouldRequireApiKeyForModel(model: string): boolean {
   const normalizedModel = model.trim().toLowerCase()
   if (!normalizedModel) return false
 
-  // The auto pseudo-model resolves server-side to a hosted pool model.
-  if (isAutoModel(normalizedModel)) return false
+  // On hosted Sim the auto pseudo-model resolves server-side to a hosted pool
+  // model. On self-hosted it exists only via imported workflows and always
+  // falls back to the default Anthropic model, so the key field must show.
+  if (isAutoModel(normalizedModel)) return !isHosted
 
   if (isHosted) {
     const hostedModels = getHostedModels()

apps/sim/blocks/blocks/agent.ts

@@ -17,10 +17,11 @@ import {
   vi,
 } from 'vitest'
 import { getAllBlocks } from '@/blocks'
-import { BlockType, isMcpTool } from '@/executor/constants'
+import { AGENT, BlockType, isMcpTool } from '@/executor/constants'
 import { AgentBlockHandler } from '@/executor/handlers/agent/agent-handler'
 import type { ExecutionContext, StreamingExecution } from '@/executor/types'
 import { executeProviderRequest } from '@/providers'
+import { SIM_AUTO_MODEL_ID } from '@/providers/models'
 import { getProviderFromModel, transformBlockTool } from '@/providers/utils'
 import type { SerializedBlock, SerializedWorkflow } from '@/serializer/types'
 import { executeTool } from '@/tools'
@@ -275,6 +276,88 @@ describe('AgentBlockHandler', () => {
       expect(result).toEqual(expectedOutput)
     })
 
+    it('reports a sim-auto run under the sim-auto identity, not the model that served it', async () => {
+      mockExecuteProviderRequest.mockResolvedValue({
+        content: 'Mocked response content',
+        model: AGENT.DEFAULT_MODEL,
+        tokens: { input: 10, output: 20, total: 30 },
+        toolCalls: [],
+        cost: { input: 0.001, output: 0.002, total: 0.003 },
+        timing: {
+          total: 100,
+          timeSegments: [
+            { type: 'model', name: AGENT.DEFAULT_MODEL, provider: 'anthropic', duration: 100 },
+          ],
+        },
+      })
+
+      const result = (await handler.execute(mockContext, mockBlock, {
+        model: SIM_AUTO_MODEL_ID,
+        userPrompt: 'Hello!',
+      })) as {
+        model: string
+        cost: unknown
+        tokens: unknown
+        providerTiming: { timeSegments: Array<{ name?: string; provider?: string }> }
+      }
+
+      expect(result.model).toBe(SIM_AUTO_MODEL_ID)
+      expect(result.providerTiming.timeSegments[0].name).toBe(SIM_AUTO_MODEL_ID)
+      expect(result.providerTiming.timeSegments[0].provider).toBeUndefined()
+      // Only the label changes: tokens and the already-priced cost are untouched.
+      expect(result.tokens).toEqual({ input: 10, output: 20, total: 30 })
+      expect(result.cost).toEqual({ input: 0.001, output: 0.002, total: 0.003 })
+    })
+
+    /** Reaches the private signal builder; routing depends on nothing else. */
+    const buildAutoRoutingSignalsFor = (inputs: Record<string, unknown>) =>
+      (
+        handler as unknown as {
+          buildAutoRoutingSignals: (i: unknown, rf: unknown) => { mediaKind: string }
+        }
+      ).buildAutoRoutingSignals(inputs, undefined)
+
+    const png = { id: 'f1', type: 'image/png' }
+    const pdf = { id: 'f2', type: 'application/pdf' }
+
+    it('reports no media when neither the files input nor any message carries one', async () => {
+      const signals = buildAutoRoutingSignalsFor({
+        messages: [{ role: 'user' as const, content: 'Summarize this text' }],
+      })
+
+      expect(signals.mediaKind).toBe('none')
+    })
+
+    it('detects media carried on inbound messages, not just the files input', async () => {
+      const signals = buildAutoRoutingSignalsFor({
+        messages: [{ role: 'user' as const, content: 'What is in this image?', files: [png] }],
+      })
+
+      expect(signals.mediaKind).toBe('image')
+    })
+
+    it('classifies an all-image attachment set as image', async () => {
+      expect(buildAutoRoutingSignalsFor({ files: [png, png] }).mediaKind).toBe('image')
+    })
+
+    it('classifies a mixed image + document set as file', async () => {
+      expect(buildAutoRoutingSignalsFor({ files: [png, pdf] }).mediaKind).toBe('file')
+    })
+
+    it('treats an unknown MIME type as file rather than assuming it is an image', async () => {
+      expect(buildAutoRoutingSignalsFor({ files: [{ id: 'f3' }] }).mediaKind).toBe('file')
+    })
+
+    it('leaves the reported model alone for an explicitly selected model', async () => {
+      const result = (await handler.execute(mockContext, mockBlock, {
+        model: 'gpt-4o',
+        userPrompt: 'Hello!',
+        apiKey: 'test-api-key',
+      })) as { model: string }
+
+      expect(result.model).toBe('mock-model')
+    })
+
     it('should attach files to the last user message only', async () => {
       const inputs = {
         model: 'gpt-4o',

apps/sim/blocks/utils.ts

@@ -8,12 +8,17 @@ import { and, eq, inArray, isNull } from 'drizzle-orm'
 import { normalizeStringRecord, normalizeWorkflowVariables } from '@/lib/core/utils/records'
 import { createMcpToolId } from '@/lib/mcp/utils'
 import {
+  type AutoMediaKind,
   type AutoRoutingResult,
   type AutoRoutingSignals,
   resolveAutoModel,
   SIM_AUTO_SYSTEM_PREAMBLE,
 } from '@/lib/model-router/resolve'
-import { processFilesToUserFiles, type RawFileInput } from '@/lib/uploads/utils/file-utils'
+import {
+  MODEL_SUPPORTED_IMAGE_MIME_TYPES,
+  processFilesToUserFiles,
+  type RawFileInput,
+} from '@/lib/uploads/utils/file-utils'
 import { hydrateUserFilesWithBase64 } from '@/lib/uploads/utils/user-file-base64.server'
 import { resolveCustomBlockToolBinding } from '@/lib/workflows/custom-blocks/operations'
 import { getCustomToolById } from '@/lib/workflows/custom-tools/operations'
@@ -52,7 +57,7 @@ import {
   shouldUseLargeFilePath,
   supportsFileAttachments,
 } from '@/providers/attachments'
-import { isAutoModel } from '@/providers/models'
+import { isAutoModel, SIM_AUTO_MODEL_ID } from '@/providers/models'
 import { getProviderFromModel, transformBlockTool } from '@/providers/utils'
 import type { SerializedBlock } from '@/serializer/types'
 import { filterSchemaForLLM, type ToolSchema } from '@/tools/params'
@@ -166,6 +171,10 @@ export class AgentBlockHandler implements BlockHandler {
       this.applyRoutingCost(result as BlockOutput, autoRouting.billableRoutingCost)
     }
 
+    if (autoRouting) {
+      this.applyAutoModelLabel(result, model)
+    }
+
     if (this.isStreamingExecution(result)) {
       if (filteredInputs.memoryType && filteredInputs.memoryType !== 'none') {
         return this.wrapStreamForMemoryPersistence(
@@ -208,14 +217,77 @@ export class AgentBlockHandler implements BlockHandler {
       lastMessage,
       messageCount: (inputs.messages?.length ?? 0) + (inputs.userPrompt ? 1 : 0),
       toolNames: (inputs.tools ?? []).map((t) => t.title || t.type || 'tool'),
-      hasAttachments: Array.isArray(normalizedFiles)
-        ? normalizedFiles.length > 0
-        : Boolean(normalizedFiles),
+      mediaKind: this.resolveMediaKind(inputs, normalizedFiles),
       hasResponseFormat: Boolean(responseFormat),
       approxInputTokens: Math.ceil(approxChars / 4),
     }
   }
 
+  /**
+   * Classifies what the block attaches, which decides the sim-auto pool column.
+   *
+   * Media reaches the provider by two routes — the block's `files` input and
+   * files already carried on inbound messages (chat deployments, memory, an
+   * upstream block feeding `messages`) — and both count. A file whose MIME type
+   * is missing or unrecognized counts as `file`, the column served by the
+   * providers that accept the most input types, because the alternative is
+   * handing a document to a model whose API models no such content part.
+   */
+  private resolveMediaKind(inputs: AgentInputs, normalizedFiles: unknown): AutoMediaKind {
+    const attached: Array<{ type?: string }> = [
+      ...(Array.isArray(normalizedFiles) ? (normalizedFiles as Array<{ type?: string }>) : []),
+      ...(inputs.messages ?? []).flatMap((message) => message.files ?? []),
+    ]
+
+    if (attached.length === 0) return 'none'
+
+    return attached.every((file) =>
+      MODEL_SUPPORTED_IMAGE_MIME_TYPES.has((file.type ?? '').toLowerCase())
+    )
+      ? 'image'
+      : 'file'
+  }
+
+  /**
+   * Reports a completed auto run under the `sim-auto` identity everywhere the
+   * run is observed — the block output, the trace span, and the usage-ledger
+   * row keyed on the model name — so the pool model that served the request
+   * stays an implementation detail (matching the block's configured model and
+   * the hidden identity preamble the models themselves run under).
+   *
+   * Runs after `executeProviderRequest`, whose billability gate and pricing
+   * key on the concrete pool model: tokens and cost are already settled here,
+   * only the label changes.
+   */
+  private applyAutoModelLabel(
+    result: BlockOutput | StreamingExecution,
+    resolvedModel: string
+  ): void {
+    const output = this.isStreamingExecution(result)
+      ? (result as StreamingExecution).execution?.output
+      : (result as BlockOutput)
+    if (!output || typeof output !== 'object') return
+
+    const target = output as {
+      model?: string
+      providerTiming?: {
+        timeSegments?: Array<{ type?: string; name?: string; provider?: string }>
+      }
+    }
+    target.model = SIM_AUTO_MODEL_ID
+
+    // Model segments name themselves after the model (every provider does) and
+    // carry the serving provider, which the log detail renders as that
+    // provider's icon — the same leak by two other routes.
+    for (const segment of target.providerTiming?.timeSegments ?? []) {
+      if (segment.type !== 'model') continue
+      if (segment.name?.toLowerCase() === resolvedModel.toLowerCase()) {
+        segment.name = SIM_AUTO_MODEL_ID
+      }
+      segment.provider = undefined
+    }
+  }
+
   /**
    * Adds the billable sim-auto routing charge to a non-streaming output's
    * cost breakdown as a distinct `routing` component.