fix(providers): stop an over-limit size rendering as the limit itself

Deriving the unit from the ceiling fixed the 5% error but left the precision
fixed at two decimals, so a file one byte over a 20 MiB cap still printed
"(20.00MB) exceeds the 20MB agent attachment limit" — the same self-contradicting
sentence, now in a ~5 KB band above every ceiling in the registry. The size
rounds up and the ceiling rounds down, so the two can no longer collide.

The test that was supposed to guard this asserted a file 0.03MB over and an
OpenAI file that was under the limit — neither anywhere near the band — so it
passed while the bug was live. It now walks `limit + 1` for every ceiling, and
goes red against the old rounding.

The reason clause added last commit also claimed a deployment had no cloud file
storage whenever the strategy was not inline. A generated document on a
remote-url provider reaches that same error with storage fully configured,
because a signed URL points at the generation source rather than the rendered
artifact — so it was told something false about its own deployment. That case
now names itself.

Author: waleedlatif1

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

@@ -15,6 +15,7 @@ import {
   SIM_AUTO_SYSTEM_PREAMBLE,
 } from '@/lib/model-router/resolve'
 import {
+  isGeneratedDocumentSourceType,
   MODEL_SUPPORTED_IMAGE_MIME_TYPES,
   processFilesToUserFiles,
   type RawFileInput,
@@ -984,8 +985,9 @@ export class AgentBlockHandler implements BlockHandler {
           inlineMaxBytes
         )
         const oversized = Number.isFinite(missingFile.size) && missingFile.size > inlineMaxBytes
-        const reason =
-          getProviderFileStrategy(providerId) === 'inline'
+        const reason = isGeneratedDocumentSourceType(missingFile.type)
+          ? `a generated document cannot use the large-file path for provider "${providerId}"`
+          : getProviderFileStrategy(providerId) === 'inline'
             ? `provider "${providerId}" has no large-file upload path`
             : 'this deployment has no cloud file storage for the large-file upload path'
         throw new Error(

apps/sim/providers/attachments.test.ts

@@ -302,15 +302,31 @@ describe('attachment limit formatting', () => {
     expect(formatAttachmentSizes(0, 10 * 1024 * 1024).limit).toBe('10')
   })
 
-  /** The size and the ceiling share a unit, so the sentence can never contradict itself. */
+  /**
+   * Exercises `limit + 1` for every ceiling in the registry, which is the only input that can
+   * expose this: rounding both figures to the nearest hundredth rendered a file one byte over a
+   * 20 MiB cap as "20.00MB exceeds the 20MB limit". The previous version of this test asserted
+   * a file 0.03MB over and an openai file *under* the limit, so it passed while that was live.
+   */
   it('never renders an over-limit file as equal to the limit', () => {
+    const ceilings = [
+      50 * 1024 * 1024,
+      25 * 1024 * 1024,
+      20 * 1024 * 1024,
+      10 * 1024 * 1024,
+      6 * 1024 * 1024,
+      50_000_000,
+    ]
+    for (const limit of ceilings) {
+      const justOver = formatAttachmentSizes(limit + 1, limit)
+      expect(justOver.size).not.toBe(justOver.limit)
+    }
+  })
+
+  it('keeps a comfortably over-limit size readable', () => {
     const groq = formatAttachmentSizes(21_000_000, 20 * 1024 * 1024)
     expect(groq.limit).toBe('20')
     expect(groq.size).toBe('20.03')
-
-    const openai = formatAttachmentSizes(9_591_617, 50_000_000)
-    expect(openai.limit).toBe('50')
-    expect(openai.size).toBe('9.59')
   })
 })
 

apps/sim/providers/attachments.ts

@@ -237,11 +237,17 @@ export function formatAttachmentSizes(
   limitBytes: number
 ): { size: string; limit: string } {
   const divisor = limitBytes % MEBIBYTE === 0 ? MEBIBYTE : 1_000_000
-  const render = (value: number) => {
-    const scaled = value / divisor
+  /**
+   * The size rounds up and the ceiling rounds down, so an over-limit file can never render as
+   * the same number as the limit it broke. Rounding both to the nearest hundredth instead let a
+   * file one byte over a 20 MiB cap print as "20.00MB exceeds the 20MB limit" — a sentence that
+   * tells the user to shrink to a size they are already under.
+   */
+  const render = (value: number, round: (n: number) => number) => {
+    const scaled = round((value / divisor) * 100) / 100
     return Number.isInteger(scaled) ? String(scaled) : scaled.toFixed(2)
   }
-  return { size: render(bytes), limit: render(limitBytes) }
+  return { size: render(bytes, Math.ceil), limit: render(limitBytes, Math.floor) }
 }
 
 export function inferAttachmentMimeType(file: UserFile): string {