fix(providers): cover the option payload, drop the unused discovery constant

Author: waleedlatif1

apps/sim/providers/transport.test.ts

@@ -1,42 +1,65 @@
 /**
  * @vitest-environment node
  *
- * These pin transport policy against the vendored SDK rather than against a number
- * typed from memory: if an `openai` bump moves `DEFAULT_TIMEOUT` or the retry default,
- * this fails and the divergence is a decision rather than a surprise.
+ * Pinned against the vendored SDKs rather than against numbers typed from memory: if an
+ * SDK bump moves a default, these fail and the divergence becomes a decision instead of
+ * a surprise.
  */
+import Cerebras from '@cerebras/cerebras_cloud_sdk'
+import Groq from 'groq-sdk'
+import OpenAI from 'openai'
 import { describe, expect, it } from 'vitest'
 import {
   openAICompatTransport,
-  PROVIDER_DISCOVERY_TIMEOUT_MS,
   PROVIDER_HEADERS_TIMEOUT_MS,
   PROVIDER_MAX_RETRIES,
 } from '@/providers/transport'
 
 describe('provider transport policy', () => {
-  it('pins the headers budget to the vendored OpenAI client default', async () => {
-    const { default: OpenAI } = await import('openai')
-    expect(PROVIDER_HEADERS_TIMEOUT_MS).toBe(
-      (OpenAI as unknown as { DEFAULT_TIMEOUT: number }).DEFAULT_TIMEOUT
-    )
-    expect(PROVIDER_HEADERS_TIMEOUT_MS).toBe(600_000)
+  it('pins the headers budget to the vendored OpenAI client default', () => {
+    expect(PROVIDER_HEADERS_TIMEOUT_MS).toBe(OpenAI.DEFAULT_TIMEOUT)
   })
 
   /**
-   * Not lowered to 0 on purpose. A chat completion is non-idempotent and carries no
-   * idempotency key, and on the non-streaming path the response exists only once the
-   * generation is already billed — so a replay re-bills completed work.
+   * Not lowered to 0 in favour of a hand-rolled loop: a chat completion is
+   * non-idempotent and carries no idempotency key, and on the non-streaming path the
+   * response exists only once the generation is already billed, so a replay re-bills
+   * completed work.
    */
   it('keeps the vendor retry default rather than hand-rolling one', () => {
-    expect(PROVIDER_MAX_RETRIES).toBe(2)
+    expect(PROVIDER_MAX_RETRIES).toBe(OpenAI.DEFAULT_MAX_RETRIES ?? 2)
   })
 
-  it('stamps only constructor-safe options, since clients are memoised', () => {
-    expect(openAICompatTransport()).toEqual({ timeout: 600_000, maxRetries: 2 })
+  /**
+   * The assertion that matters: object spread gets no excess-property checking, so a
+   * renamed option in either SDK would become a silent no-op with a green typecheck.
+   * These read the value back off a constructed client.
+   */
+  it('actually reaches the Groq client, which defaults to 60s', () => {
+    const client = new Groq({ apiKey: 'test', ...openAICompatTransport() })
+    expect(client.timeout).toBe(PROVIDER_HEADERS_TIMEOUT_MS)
+    expect(client.maxRetries).toBe(PROVIDER_MAX_RETRIES)
+  })
+
+  it('actually reaches the Cerebras client, which defaults to 60s', () => {
+    const client = new Cerebras({ apiKey: 'test', ...openAICompatTransport() })
+    expect(client.timeout).toBe(PROVIDER_HEADERS_TIMEOUT_MS)
+    expect(client.maxRetries).toBe(PROVIDER_MAX_RETRIES)
+  })
+
+  it('actually reaches an OpenAI-compatible client', () => {
+    const client = new OpenAI({
+      apiKey: 'test',
+      baseURL: 'https://example.invalid',
+      ...openAICompatTransport(),
+    })
+    expect(client.timeout).toBe(PROVIDER_HEADERS_TIMEOUT_MS)
+    expect(client.maxRetries).toBe(PROVIDER_MAX_RETRIES)
   })
 
-  /** A catalog probe must not inherit a generation-sized budget. */
-  it('bounds discovery far below a generation', () => {
-    expect(PROVIDER_DISCOVERY_TIMEOUT_MS).toBeLessThan(PROVIDER_HEADERS_TIMEOUT_MS / 10)
+  /** Stamping a `fetch` wrapper here would convert a header-only timer into a total
+   * deadline that truncates live streams, so the shape is pinned too. */
+  it('stamps only constructor-safe options', () => {
+    expect(Object.keys(openAICompatTransport()).sort()).toEqual(['maxRetries', 'timeout'])
   })
 })

apps/sim/providers/transport.ts

@@ -1,21 +1,27 @@
 /**
  * Transport policy for provider requests, in one place.
  *
- * The values here mostly *pin* what the vendor SDKs already default to, so an SDK
- * bump cannot silently move production behaviour. Two are deliberate divergences,
- * marked below.
+ * These pin what the vendor SDKs already default to, so an SDK bump cannot silently
+ * move production behaviour. For 16 of 18 providers this is a no-op. Groq and Cerebras
+ * are the exception and are marked at {@link PROVIDER_HEADERS_TIMEOUT_MS}.
  *
- * What these deliberately do NOT do: bound a stalled stream. Under Bun a `fetch`
- * carries a socket-scoped idle wall (~300s, reduced by however long a pooled socket
- * sat idle before reuse) that no SDK, undici `Agent`, or `RequestInit` option can
- * reach. Raising a timeout number therefore cannot rescue a long silent generation —
- * only keeping bytes on the socket can. That work belongs in the stream pump.
+ * What these deliberately do NOT do: bound a stalled stream. Bun's `fetch` is native
+ * and appears to impose a socket-scoped idle wall of roughly 300s, reduced by however
+ * long a pooled socket sat idle before reuse. That figure is observed, not documented,
+ * and is not something these constants can override — raising a number above it changes
+ * nothing. Only keeping bytes on the socket can rescue a long silent generation, and
+ * that work belongs in the stream pump.
  */
 
 /**
  * Time-to-headers budget for a single attempt, matching `openai@7`'s own
- * `DEFAULT_TIMEOUT` so this is behaviour-preserving for every provider already on
- * that client.
+ * `DEFAULT_TIMEOUT`.
+ *
+ * Behaviour-preserving for the 16 providers already on that client. It is a deliberate
+ * divergence for **Groq and Cerebras**, whose SDKs default to 60s: on a non-streaming
+ * call headers do not arrive until the generation completes, so 60s caps every
+ * generation at a minute and then retries it twice, re-billing. The cost of the raise is
+ * that a genuinely hung call now fails slower — see the PR for the worst-case numbers.
  *
  * It must stay generous: `deepseek-reasoner`, `kimi-k3`, `grok-4.5-reasoning` and
  * every dynamic-catalog provider can legitimately generate for minutes with zero
@@ -34,9 +40,6 @@ export const PROVIDER_HEADERS_TIMEOUT_MS = 600_000
  */
 export const PROVIDER_MAX_RETRIES = 2
 
-/** Liveness probe for model catalogs, never a generation. Failure degrades gracefully. */
-export const PROVIDER_DISCOVERY_TIMEOUT_MS = 15_000
-
 export interface OpenAICompatTransport {
   timeout: number
   maxRetries: number