fix(providers): report attachment limits in the unit vendors publish

The size ceilings are decimal MB — that is how OpenAI, AWS and Fireworks all
write them — but the error messages divided by 1024², so OpenAI's 50 MB cap
was reported to the user as "48MB". Someone shrinking a 49 MB file to get
under it was chasing a limit that does not exist.

One formatter, used by all three messages, so the file size and the ceiling in
the same sentence are always in the same unit.

Author: waleedlatif1

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

@@ -52,7 +52,11 @@ import { buildAPIUrl, buildAuthHeaders } from '@/executor/utils/http'
 import { stringifyJSON } from '@/executor/utils/json'
 import { resolveVertexCredential } from '@/executor/utils/vertex-credential'
 import { executeProviderRequest } from '@/providers'
-import { shouldUseLargeFilePath, supportsFileAttachments } from '@/providers/attachments'
+import {
+  formatAttachmentBytes,
+  shouldUseLargeFilePath,
+  supportsFileAttachments,
+} from '@/providers/attachments'
 import {
   canUseProviderLargeFilePath,
   getInlineHydrationMaxBytes,
@@ -974,11 +978,11 @@ export class AgentBlockHandler implements BlockHandler {
           !(canUseProviderLargeFilePath(providerId) && shouldUseLargeFilePath(file, providerId))
       )
       if (missingFile) {
-        const inlineMB = (inlineMaxBytes / (1024 * 1024)).toFixed(0)
+        const inlineMB = formatAttachmentBytes(inlineMaxBytes)
         const oversized = Number.isFinite(missingFile.size) && missingFile.size > inlineMaxBytes
         throw new Error(
           oversized
-            ? `File "${missingFile.name}" (${(missingFile.size / (1024 * 1024)).toFixed(2)}MB) exceeds the ${inlineMB}MB inline attachment limit, and provider "${providerId}" has no large-file upload path for it.`
+            ? `File "${missingFile.name}" (${formatAttachmentBytes(missingFile.size)}MB) exceeds the ${inlineMB}MB inline attachment limit, and provider "${providerId}" has no large-file upload path for it.`
             : `File "${missingFile.name}" could not be read for provider "${providerId}". The file may no longer be accessible.`
         )
       }

apps/sim/providers/attachments.test.ts

@@ -11,6 +11,7 @@ import {
   buildOpenAICompatibleChatContent,
   buildOpenAIMessageContent,
   buildOpenRouterMessageContent,
+  formatAttachmentBytes,
   formatMessagesForProvider,
   getProviderAttachmentMaxBytes,
   getProviderFileStrategy,
@@ -287,6 +288,15 @@ describe('provider attachments', () => {
   })
 })
 
+describe('attachment limit formatting', () => {
+  /** Guards the report of OpenAI's decimal 50 MB ceiling as "48MB" when divided by 1024². */
+  it('reports a decimal-MB ceiling as the vendor publishes it', () => {
+    expect(formatAttachmentBytes(50_000_000)).toBe('50')
+    expect(formatAttachmentBytes(10 * 1024 * 1024)).toBe('10')
+    expect(formatAttachmentBytes(9_591_617)).toBe('9.59')
+  })
+})
+
 describe('provider large-file capability', () => {
   /**
    * Guards the regression where every 6-10 MB attachment died with "Execution memory limit

apps/sim/providers/attachments.ts

@@ -213,6 +213,18 @@ export function getProviderAttachmentMaxBytes(providerId: ProviderId | string):
   return getProviderFileAttachment(providerId).maxBytes
 }
 
+/**
+ * Renders a byte count for a user-facing limit message.
+ *
+ * Decimal MB, because that is the unit the vendors publish and therefore the number a user is
+ * comparing against. Dividing by 1024² instead reported OpenAI's 50 MB ceiling as "48MB", so a
+ * user shrinking a 49 MB file to get under it was chasing a limit that did not exist.
+ */
+export function formatAttachmentBytes(bytes: number): string {
+  const megabytes = bytes / 1_000_000
+  return megabytes < 10 ? megabytes.toFixed(2).replace(/\.?0+$/, '') : megabytes.toFixed(0)
+}
+
 export function inferAttachmentMimeType(file: UserFile): string {
   const explicitType = file.type?.trim().toLowerCase()
   return resolveFileType({
@@ -400,8 +412,8 @@ export function prepareProviderAttachments(
 
     const maxBytes = getProviderAttachmentMaxBytes(providerId)
     if (Number.isFinite(file.size) && file.size > maxBytes) {
-      const sizeMB = (file.size / (1024 * 1024)).toFixed(2)
-      const maxMB = (maxBytes / (1024 * 1024)).toFixed(0)
+      const sizeMB = formatAttachmentBytes(file.size)
+      const maxMB = formatAttachmentBytes(maxBytes)
       throw new Error(
         `File "${file.name}" (${sizeMB}MB) exceeds the ${maxMB}MB agent attachment limit for provider "${providerId}"`
       )

apps/sim/providers/file-attachments.server.ts

@@ -8,6 +8,7 @@ import { downloadServableFileFromStorage } from '@/lib/uploads/utils/file-utils.
 import { verifyFileAccess } from '@/app/api/files/authorization'
 import type { UserFile } from '@/executor/types'
 import {
+  formatAttachmentBytes,
   getProviderAttachmentMaxBytes,
   getProviderFileStrategy,
   INLINE_ATTACHMENT_THRESHOLD_BYTES,
@@ -88,8 +89,8 @@ export async function attachLargeFileRemoteUrls(
     if (!file.key || !shouldUseLargeFilePath(file, providerId)) continue
 
     if (Number.isFinite(file.size) && file.size > maxBytes) {
-      const sizeMB = (file.size / (1024 * 1024)).toFixed(2)
-      const maxMB = (maxBytes / (1024 * 1024)).toFixed(0)
+      const sizeMB = formatAttachmentBytes(file.size)
+      const maxMB = formatAttachmentBytes(maxBytes)
       throw new Error(
         `File "${file.name}" (${sizeMB}MB) exceeds the ${maxMB}MB agent attachment limit for provider "${providerId}"`
       )