fix: apply apiRequestTimeout consistently across providers (#567)

* fix(api): apply apiRequestTimeout consistently across OpenAI/Anthropic SDK providers

Wire getApiRequestTimeout() into every provider that instantiates an OpenAI
or Anthropic SDK client so the user-configured apiRequestTimeout setting
applies uniformly. Previously only openai/lm-studio and providers extending
BaseOpenAiCompatibleProvider honored it.

OpenAI SDK: openai-native, openai-codex, openrouter, router-provider
(lite-llm, zoo-gateway, opencode-go, vercel-ai-gateway), requesty, unbound,
xai, qwen-code.

Anthropic SDK: anthropic, minimax, anthropic-vertex.

* docs(i18n): list providers where apiRequestTimeout has no effect

Append the list of unsupported providers (Amazon Bedrock, Google Gemini,
GCP Vertex AI, Mistral, Ollama, VS Code LM API, Poe) to the
apiRequestTimeout setting description across all package.nls locales so
users can see at a glance which providers ignore the value.

* test(api): align provider tests with apiRequestTimeout wiring

Assert SDK clients receive a timeout option in providers updated by
4c82de4 (anthropic-vertex, openrouter, requesty, vercel-ai-gateway,
zoo-gateway), and stub vscode.workspace.getConfiguration in tests that
mock vscode as an empty object so getApiRequestTimeout() can run during
provider construction.

* docs(i18n): drop provider examples from apiRequestTimeout recommendation

The previous description recommended raising the timeout for "local
providers like LM Studio and Ollama" while also listing Ollama among
the providers where the setting has no effect. Drop the provider
examples from the recommendation so the two parts no longer
contradict; the unsupported list still spells out where the setting
has no effect.

* chore: fix typo in Turkish apiRequestTimeout description

* fix(api): round timeout ms and restrict apiRequestTimeout to 1-3600s

- Math.round() prevents float ms from Anthropic SDK validatePositiveInteger throw
- minimum changed from 0 to 1; removed unreachable <= 0 branch in getApiRequestTimeout
- return type narrowed from number | undefined to number

* docs(i18n): remove '0 = no timeout', scope GCP Vertex AI, add Moonshot to unsupported list

- removed '0 = no timeout' from all locales; minimum is now 1
- scoped GCP Vertex AI to '(Gemini models)' since Claude models on Vertex are supported
- added Moonshot to unsupported providers (uses Vercel AI SDK, no client-level timeout)

* docs(i18n): tighten apiRequestTimeout description across all locales

Restructured into 3 concise sentences: timeout info, local provider
recommendation, and alphabetized unsupported providers list. Fixed
Korean phrasing and unified Japanese fullwidth punctuation.

* refactor(api): extract timeout constants and validate range bounds

Pull the timeout bounds (1-3600s) and default (600s) into named
constants and a small isValidTimeout type-guard, so out-of-range
values fall back to the default just like NaN/non-number inputs.
Tests updated to cover the new boundary and out-of-range fallback
cases.

* test(api): cover timeout passthrough for Vertex auth variants

Add cases verifying timeout is forwarded to AnthropicVertex when
constructing with vertexJsonCredentials or vertexKeyFile, and mock
GoogleAuth so the auth-bound paths are exercised.

* test(api): make GoogleAuth mock newable in Vertex tests

Arrow functions cannot be invoked with `new`, so the mock threw
TypeError when the handler did `new GoogleAuth(...)`. Switch to a
regular function expression to match the AnthropicVertex mock.

* Add changeset for API request timeout

* refactor: standardize API request timeout handling across providers

- Refactor timeout handling logic in multiple API providers
- Improve consistency in timeout configuration and error handling
- Reduce code duplication across provider implementations

* refactor: use class field initialization for timeoutMs in BaseProvider

- Replace constructor-based initialization with class field initialization
- Removes unnecessary constructor when only initializing properties
- Follows modern TypeScript/JavaScript conventions for cleaner code

* fix(tests): add getConfiguration mock to vscode provider tests

Add workspace.getConfiguration mock to vertex.spec.ts and vscode-lm.spec.ts to fix test failures

* chore(i18n): update apiRequestTimeout description for Google Gemini clarification

- Update translation files to clarify that Google Gemini is not supported
  either directly or through the Vertex AI platform

* test: add timeout config mock to provider tests

- Mock timeout-config module in anthropic-vertex, openai, openrouter, requesty, and zoo-gateway tests
- Add MOCK_TIMEOUT_MS constant for consistent timeout assertions
- Replace expect.any(Number) with explicit MOCK_TIMEOUT_MS value in timeout assertions

---------

Co-authored-by: Oh Daewoong <dw.oh@samsung.com>
Co-authored-by: Naved  Merchant <naved.merchant@gmail.com>

Author: 3 people

.changeset/api-request-timeout.md

@@ -0,0 +1,5 @@
+---
+"zoo-code": patch
+---
+
+Updated `apiRequestTimeout` validation. Values must be integers between 1 and 3600 seconds; invalid or out-of-range values, including `0`, now fall back to 600 seconds. This aligns with the SDK's default timeout value.

src/api/providers/__tests__/anthropic-vertex.spec.ts

@@ -2,13 +2,26 @@
 
 import { Anthropic } from "@anthropic-ai/sdk"
 import { AnthropicVertex } from "@anthropic-ai/vertex-sdk"
+import { GoogleAuth } from "google-auth-library"
 
 import { VERTEX_1M_CONTEXT_MODEL_IDS } from "@roo-code/types"
 
 import { ApiStreamChunk } from "../../transform/stream"
 
 import { AnthropicVertexHandler } from "../anthropic-vertex"
 
+vitest.mock("../utils/timeout-config", () => ({
+	getApiRequestTimeout: vitest.fn().mockReturnValue(300_000),
+}))
+
+const MOCK_TIMEOUT_MS = 300_000
+
+vitest.mock("google-auth-library", () => ({
+	GoogleAuth: vitest.fn().mockImplementation(function (opts) {
+		return { __googleAuthOptions: opts }
+	}),
+}))
+
 vitest.mock("@anthropic-ai/vertex-sdk", () => ({
 	AnthropicVertex: vitest.fn().mockImplementation(function () {
 		return {
@@ -56,6 +69,11 @@ describe("VertexHandler", () => {
 	let handler: AnthropicVertexHandler
 
 	describe("constructor", () => {
+		beforeEach(() => {
+			;(AnthropicVertex as any).mockClear()
+			;(GoogleAuth as any).mockClear()
+		})
+
 		it("should initialize with provided config for Claude", () => {
 			handler = new AnthropicVertexHandler({
 				apiModelId: "claude-3-5-sonnet-v2@20241022",
@@ -66,7 +84,58 @@ describe("VertexHandler", () => {
 			expect(AnthropicVertex).toHaveBeenCalledWith({
 				projectId: "test-project",
 				region: "us-central1",
+				timeout: MOCK_TIMEOUT_MS,
+			})
+		})
+
+		it("should pass timeout when initializing with vertexJsonCredentials", () => {
+			const credentials = {
+				type: "service_account",
+				client_email: "test@test-project.iam.gserviceaccount.com",
+				private_key: "-----BEGIN PRIVATE KEY-----\nfake\n-----END PRIVATE KEY-----\n",
+			}
+
+			handler = new AnthropicVertexHandler({
+				apiModelId: "claude-3-5-sonnet-v2@20241022",
+				vertexProjectId: "test-project",
+				vertexRegion: "us-central1",
+				vertexJsonCredentials: JSON.stringify(credentials),
 			})
+
+			expect(GoogleAuth).toHaveBeenCalledWith({
+				scopes: ["https://www.googleapis.com/auth/cloud-platform"],
+				credentials,
+			})
+			expect(AnthropicVertex).toHaveBeenCalledWith(
+				expect.objectContaining({
+					projectId: "test-project",
+					region: "us-central1",
+					googleAuth: expect.any(Object),
+					timeout: MOCK_TIMEOUT_MS,
+				}),
+			)
+		})
+
+		it("should pass timeout when initializing with vertexKeyFile", () => {
+			handler = new AnthropicVertexHandler({
+				apiModelId: "claude-3-5-sonnet-v2@20241022",
+				vertexProjectId: "test-project",
+				vertexRegion: "us-central1",
+				vertexKeyFile: "/tmp/sa-key.json",
+			})
+
+			expect(GoogleAuth).toHaveBeenCalledWith({
+				scopes: ["https://www.googleapis.com/auth/cloud-platform"],
+				keyFile: "/tmp/sa-key.json",
+			})
+			expect(AnthropicVertex).toHaveBeenCalledWith(
+				expect.objectContaining({
+					projectId: "test-project",
+					region: "us-central1",
+					googleAuth: expect.any(Object),
+					timeout: MOCK_TIMEOUT_MS,
+				}),
+			)
 		})
 	})
 

src/api/providers/__tests__/lite-llm.spec.ts

@@ -6,7 +6,13 @@ import { ApiHandlerOptions } from "../../../shared/api"
 import { litellmDefaultModelId, litellmDefaultModelInfo } from "@roo-code/types"
 
 // Mock vscode first to avoid import errors
-vi.mock("vscode", () => ({}))
+vi.mock("vscode", () => ({
+	workspace: {
+		getConfiguration: () => ({
+			get: (_key: string, defaultValue?: unknown) => defaultValue,
+		}),
+	},
+}))
 
 // Mock OpenAI
 const mockCreate = vi.fn()

src/api/providers/__tests__/openai.spec.ts

@@ -8,6 +8,12 @@ import { openAiModelInfoSaneDefaults, DEEP_SEEK_DEFAULT_TEMPERATURE } from "@roo
 import { Package } from "../../../shared/package"
 import axios from "axios"
 
+vitest.mock("../utils/timeout-config", () => ({
+	getApiRequestTimeout: vitest.fn().mockReturnValue(300_000),
+}))
+
+const MOCK_TIMEOUT_MS = 300_000
+
 const mockCreate = vitest.fn()
 
 vitest.mock("openai", () => {
@@ -117,7 +123,7 @@ describe("OpenAiHandler", () => {
 					"X-Title": "Zoo Code",
 					"User-Agent": `ZooCode/${Package.version}`,
 				},
-				timeout: expect.any(Number),
+				timeout: MOCK_TIMEOUT_MS,
 			})
 		})
 	})

src/api/providers/__tests__/opencode-go.spec.ts

@@ -1,7 +1,13 @@
 // npx vitest run src/api/providers/__tests__/opencode-go.spec.ts
 
 // Mock vscode first to avoid import errors
-vitest.mock("vscode", () => ({}))
+vitest.mock("vscode", () => ({
+	workspace: {
+		getConfiguration: () => ({
+			get: (_key: string, defaultValue?: unknown) => defaultValue,
+		}),
+	},
+}))
 
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"

src/api/providers/__tests__/openrouter.spec.ts

@@ -1,6 +1,18 @@
 // pnpm --filter roo-cline test api/providers/__tests__/openrouter.spec.ts
 
-vitest.mock("vscode", () => ({}))
+vitest.mock("vscode", () => ({
+	workspace: {
+		getConfiguration: () => ({
+			get: (_key: string, defaultValue?: unknown) => defaultValue,
+		}),
+	},
+}))
+
+vitest.mock("../utils/timeout-config", () => ({
+	getApiRequestTimeout: vitest.fn().mockReturnValue(300_000),
+}))
+
+const MOCK_TIMEOUT_MS = 300_000
 
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
@@ -108,6 +120,7 @@ describe("OpenRouterHandler", () => {
 				"X-Title": "Zoo Code",
 				"User-Agent": `ZooCode/${Package.version}`,
 			},
+			timeout: MOCK_TIMEOUT_MS,
 		})
 	})
 

src/api/providers/__tests__/requesty.spec.ts

@@ -1,5 +1,11 @@
 // npx vitest run api/providers/__tests__/requesty.spec.ts
 
+vitest.mock("../utils/timeout-config", () => ({
+	getApiRequestTimeout: vitest.fn().mockReturnValue(300_000),
+}))
+
+const MOCK_TIMEOUT_MS = 300_000
+
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
 
@@ -82,6 +88,7 @@ describe("RequestyHandler", () => {
 				"X-Title": "Zoo Code",
 				"User-Agent": `ZooCode/${Package.version}`,
 			},
+			timeout: MOCK_TIMEOUT_MS,
 		})
 	})
 
@@ -97,6 +104,7 @@ describe("RequestyHandler", () => {
 				"X-Title": "Zoo Code",
 				"User-Agent": `ZooCode/${Package.version}`,
 			},
+			timeout: MOCK_TIMEOUT_MS,
 		})
 	})
 

src/api/providers/__tests__/vercel-ai-gateway.spec.ts

@@ -1,7 +1,13 @@
 // npx vitest run src/api/providers/__tests__/vercel-ai-gateway.spec.ts
 
 // Mock vscode first to avoid import errors
-vitest.mock("vscode", () => ({}))
+vitest.mock("vscode", () => ({
+	workspace: {
+		getConfiguration: () => ({
+			get: (_key: string, defaultValue?: unknown) => defaultValue,
+		}),
+	},
+}))
 
 import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
@@ -118,6 +124,7 @@ describe("VercelAiGatewayHandler", () => {
 				"X-Title": "Zoo Code",
 				"User-Agent": expect.stringContaining("ZooCode/"),
 			}),
+			timeout: expect.any(Number),
 		})
 	})
 

src/api/providers/__tests__/vertex-credentials.spec.ts

@@ -2,7 +2,13 @@
 
 // Mock vscode first to avoid import errors when the provider stack pulls
 // transitive vscode-dependent modules during construction.
-vitest.mock("vscode", () => ({}))
+vitest.mock("vscode", () => ({
+	workspace: {
+		getConfiguration: () => ({
+			get: (_key: string, defaultValue?: unknown) => defaultValue,
+		}),
+	},
+}))
 
 vitest.mock("@roo-code/telemetry", () => ({
 	TelemetryService: {

src/api/providers/__tests__/vertex.spec.ts

@@ -1,7 +1,13 @@
 // npx vitest run src/api/providers/__tests__/vertex.spec.ts
 
 // Mock vscode first to avoid import errors
-vitest.mock("vscode", () => ({}))
+vitest.mock("vscode", () => ({
+	workspace: {
+		getConfiguration: vitest.fn(() => ({
+			get: vitest.fn((key: string, defaultValue: any) => defaultValue),
+		})),
+	},
+}))
 
 const mockCaptureException = vitest.fn()