ceos/opencode
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix(llm): port provider retry classification (#36887)

Browse source
This commit is contained in:
Shoubhit Dash 2026-07-14 22:09:50 +05:30 • committed by GitHub
commit 40fedf086e
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
12 changed files with 340 additions and 182 deletions
Download patch file Download diff file Expand all files Collapse all files

33
packages/llm/test/executor.test.ts
View file

@ -107,6 +107,39 @@ describe("RequestExecutor", () => {
}).pipe(Effect.provide(responsesLayer([new Response("invalid parameter", { status: 400 })]))),
)
it.effect("classifies provider rate limits hidden behind HTTP 400", () =>
Effect.gen(function* () {
const classify = (body: string) =>
Effect.gen(function* () {
const executor = yield* RequestExecutor.Service
const error = yield* executor.execute(request).pipe(Effect.flip)
expectLLMError(error)
expect(error.reason).toMatchObject({ _tag: "RateLimit" })
}).pipe(Effect.provide(responsesLayer([new Response(body, { status: 400 })])))
yield* classify("Request rate increased too quickly")
yield* classify('{"type":"error","error":{"type":"too_many_requests"}}')
yield* classify('{"type":"error","error":{"code":"rate_limit_exceeded"}}')
}),
)
it.effect("classifies provider overloads hidden behind HTTP 400", () =>
Effect.gen(function* () {
const classify = (body: string) =>
Effect.gen(function* () {
const executor = yield* RequestExecutor.Service
const error = yield* executor.execute(request).pipe(Effect.flip)
expectLLMError(error)
expect(error.reason).toMatchObject({ _tag: "ProviderInternal" })
}).pipe(Effect.provide(responsesLayer([new Response(body, { status: 400 })])))
yield* classify('{"code":"resource_exhausted"}')
yield* classify('{"code":"service_unavailable"}')
}),
)
it.effect("returns redacted diagnostics for rate limits", () =>
Effect.gen(function* () {
const executor = yield* RequestExecutor.Service

46
packages/llm/test/provider-error.test.ts
View file

@ -1,8 +1,54 @@
import { describe, expect, test } from "bun:test"
import { isContextOverflow } from "../src"
import { classifyProviderFailure } from "../src/provider-error"
describe("provider error classification", () => {
test("classifies Z.AI GLM token limit messages as context overflow", () => {
expect(isContextOverflow("tokens in request more than max tokens allowed")).toBe(true)
})
test("classifies V1 plain-text rate limit fallbacks", () => {
expect(
[
"Request rate increased too quickly",
"Rate limit exceeded, please try again later",
"Too many requests, please slow down",
].map((message) => classifyProviderFailure({ message })._tag),
).toEqual(["RateLimit", "RateLimit", "RateLimit"])
})
test("classifies V1 JSON rate limit fallbacks", () => {
expect(
[
'{"type":"error","error":{"type":"too_many_requests"}}',
'{"type":"error","error":{"code":"rate_limit_exceeded"}}',
'{"code":"bad_request","error":{"code":"rate_limit_exceeded"}}',
'{"type":"error","error":{"code":"unknown","type":"too_many_requests"}}',
].map((message) => classifyProviderFailure({ message })._tag),
).toEqual(["RateLimit", "RateLimit", "RateLimit", "RateLimit"])
})
test("classifies V1 overloaded provider codes", () => {
expect(
['{"code":"resource_exhausted"}', '{"code":"service_unavailable"}'].map(
(message) => classifyProviderFailure({ message })._tag,
),
).toEqual(["ProviderInternal", "ProviderInternal"])
})
test("classifies nested provider codes when a top-level code is also present", () => {
expect(
[
'{"code":"bad_request","error":{"code":"usage_not_included"}}',
'{"code":"bad_request","error":{"code":"server_error"}}',
'{"code":"bad_request","error":{"type":"invalid_request_error"}}',
].map((message) => classifyProviderFailure({ message })._tag),
).toEqual(["QuotaExceeded", "ProviderInternal", "InvalidRequest"])
})
test("keeps unknown and malformed provider payloads non-retryable", () => {
expect(classifyProviderFailure({ message: '{"error":{"message":"no_kv_space"}}' })._tag).toBe("UnknownProvider")
expect(classifyProviderFailure({ message: '{"type":"error","error":{"code":123}}' })._tag).toBe("UnknownProvider")
expect(classifyProviderFailure({ message: "not-json" })._tag).toBe("UnknownProvider")
})
})

34
packages/llm/test/provider/anthropic-messages.test.ts
View file

@ -484,23 +484,22 @@ describe("Anthropic Messages route", () => {
}),
)
it.effect("emits provider-error events for mid-stream provider errors", () =>
it.effect("fails with a typed provider error for stream error frames", () =>
Effect.gen(function* () {
const response = yield* LLMClient.generate(request).pipe(
const error = yield* LLMClient.generate(request).pipe(
Effect.provide(
fixedResponse(sseEvents({ type: "error", error: { type: "overloaded_error", message: "Overloaded" } })),
),
Effect.flip,
)
// Prefix the error type so consumers can distinguish overloads, rate
// limits, and quota errors without parsing the message string.
expect(response.events).toEqual([{ type: "provider-error", message: "overloaded_error: Overloaded" }])
expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "overloaded_error: Overloaded" })
}),
)
it.effect("classifies prompt-too-long provider errors", () =>
Effect.gen(function* () {
const response = yield* LLMClient.generate(request).pipe(
const error = yield* LLMClient.generate(request).pipe(
Effect.provide(
fixedResponse(
sseEvents({
@ -509,35 +508,36 @@ describe("Anthropic Messages route", () => {
}),
),
),
Effect.flip,
)
expect(response.events).toEqual([
{
type: "provider-error",
message: "invalid_request_error: prompt is too long: 210000 tokens",
classification: "context-overflow",
},
])
expect(error.reason).toMatchObject({
_tag: "InvalidRequest",
message: "invalid_request_error: prompt is too long: 210000 tokens",
classification: "context-overflow",
})
}),
)
it.effect("falls back to error type when no message is present", () =>
Effect.gen(function* () {
const response = yield* LLMClient.generate(request).pipe(
const error = yield* LLMClient.generate(request).pipe(
Effect.provide(fixedResponse(sseEvents({ type: "error", error: { type: "overloaded_error", message: "" } }))),
Effect.flip,
)
expect(response.events).toEqual([{ type: "provider-error", message: "overloaded_error" }])
expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "overloaded_error" })
}),
)
it.effect("falls back to a stable default when error payload is absent", () =>
Effect.gen(function* () {
const response = yield* LLMClient.generate(request).pipe(
const error = yield* LLMClient.generate(request).pipe(
Effect.provide(fixedResponse(sseEvents({ type: "error" }))),
Effect.flip,
)
expect(response.events).toEqual([{ type: "provider-error", message: "Anthropic Messages stream error" }])
expect(error.reason).toMatchObject({ _tag: "UnknownProvider", message: "Anthropic Messages stream error" })
}),
)

16
packages/llm/test/provider/bedrock-converse.test.ts
View file

@ -355,31 +355,29 @@ describe("Bedrock Converse route", () => {
}),
)
it.effect("emits provider-error for throttlingException", () =>
it.effect("classifies throttlingException as a rate limit", () =>
Effect.gen(function* () {
const body = eventStreamBody(
["messageStart", { role: "assistant" }],
["throttlingException", { message: "Slow down" }],
)
const response = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)))
const error = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)), Effect.flip)
expect(response.events.find((event) => event.type === "provider-error")).toEqual({
type: "provider-error",
message: "Slow down",
})
expect(error.reason).toMatchObject({ _tag: "RateLimit", message: "Slow down" })
}),
)
it.effect("classifies input-too-long validation exceptions", () =>
Effect.gen(function* () {
const response = yield* LLMClient.generate(baseRequest).pipe(
const error = yield* LLMClient.generate(baseRequest).pipe(
Effect.provide(
fixedBytes(eventStreamBody(["validationException", { message: "Input is too long for requested model" }])),
),
Effect.flip,
)
expect(response.events.find((event) => event.type === "provider-error")).toEqual({
type: "provider-error",
expect(error.reason).toMatchObject({
_tag: "InvalidRequest",
message: "Input is too long for requested model",
classification: "context-overflow",
})

85
packages/llm/test/provider/openai-responses.test.ts
View file

@ -1368,37 +1368,37 @@ describe("OpenAI Responses route", () => {
}),
)
it.effect("emits provider-error events for mid-stream provider errors", () =>
it.effect("fails with a typed rate limit for provider error frames", () =>
Effect.gen(function* () {
const response = yield* LLMClient.generate(request).pipe(
const error = yield* LLMClient.generate(request).pipe(
Effect.provide(fixedResponse(sseEvents({ type: "error", code: "rate_limit_exceeded", message: "Slow down" }))),
Effect.flip,
)
// Prefix the code so consumers see the failure mode, not just the
// sometimes-generic provider message. The bare message alone meant
// production errors like rate limits were indistinguishable from
// unrelated stream failures.
expect(response.events).toEqual([{ type: "provider-error", message: "rate_limit_exceeded: Slow down" }])
expect(error).toBeInstanceOf(LLMError)
expect(error.reason).toMatchObject({ _tag: "RateLimit", message: "rate_limit_exceeded: Slow down" })
}),
)
it.effect("falls back to error code when no message is present", () =>
Effect.gen(function* () {
const response = yield* LLMClient.generate(request).pipe(
const error = yield* LLMClient.generate(request).pipe(
Effect.provide(fixedResponse(sseEvents({ type: "error", code: "internal_error" }))),
Effect.flip,
)
expect(response.events).toEqual([{ type: "provider-error", message: "internal_error" }])
expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "internal_error" })
}),
)
it.effect("falls back to error code when message is empty", () =>
Effect.gen(function* () {
const response = yield* LLMClient.generate(request).pipe(
const error = yield* LLMClient.generate(request).pipe(
Effect.provide(fixedResponse(sseEvents({ type: "error", code: "internal_error", message: "" }))),
Effect.flip,
)
expect(response.events).toEqual([{ type: "provider-error", message: "internal_error" }])
expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "internal_error" })
}),
)
@ -1408,7 +1408,7 @@ describe("OpenAI Responses route", () => {
// "OpenAI Responses response failed" string, hiding the real cause.
it.effect("surfaces response.failed details from response.error", () =>
Effect.gen(function* () {
const response = yield* LLMClient.generate(request).pipe(
const error = yield* LLMClient.generate(request).pipe(
Effect.provide(
fixedResponse(
sseEvents({
@ -1420,15 +1420,19 @@ describe("OpenAI Responses route", () => {
}),
),
),
Effect.flip,
)
expect(response.events).toEqual([{ type: "provider-error", message: "server_error: Upstream model unavailable" }])
expect(error.reason).toMatchObject({
_tag: "ProviderInternal",
message: "server_error: Upstream model unavailable",
})
}),
)
it.effect("surfaces response.failed code when no nested message is present", () =>
Effect.gen(function* () {
const response = yield* LLMClient.generate(request).pipe(
const error = yield* LLMClient.generate(request).pipe(
Effect.provide(
fixedResponse(
sseEvents({
@ -1437,9 +1441,10 @@ describe("OpenAI Responses route", () => {
}),
),
),
Effect.flip,
)
expect(response.events).toEqual([{ type: "provider-error", message: "invalid_prompt" }])
expect(error.reason).toMatchObject({ _tag: "InvalidRequest", message: "invalid_prompt" })
}),
)
@ -1450,7 +1455,7 @@ describe("OpenAI Responses route", () => {
// when they bubble up an HTTP error as an SSE `error` event. Honour
// both shapes so the user still sees the underlying cause instead
// of the catch-all string.
const response = yield* LLMClient.generate(request).pipe(
const error = yield* LLMClient.generate(request).pipe(
Effect.provide(
fixedResponse(
sseEvents({
@ -1459,21 +1464,20 @@ describe("OpenAI Responses route", () => {
}),
),
),
Effect.flip,
)
expect(response.events).toEqual([
{
type: "provider-error",
message: "context_length_exceeded: prompt too long",
classification: "context-overflow",
},
])
expect(error.reason).toMatchObject({
_tag: "InvalidRequest",
message: "context_length_exceeded: prompt too long",
classification: "context-overflow",
})
}),
)
it.effect("surfaces error event details nested under error", () =>
Effect.gen(function* () {
const response = yield* LLMClient.generate(request).pipe(
const error = yield* LLMClient.generate(request).pipe(
Effect.provide(
fixedResponse(
sseEvents({
@ -1488,21 +1492,20 @@ describe("OpenAI Responses route", () => {
}),
),
),
Effect.flip,
)
expect(response.events).toEqual([
{
type: "provider-error",
message: "context_length_exceeded: prompt too long",
classification: "context-overflow",
},
])
expect(error.reason).toMatchObject({
_tag: "InvalidRequest",
message: "context_length_exceeded: prompt too long",
classification: "context-overflow",
})
}),
)
it.effect("accepts nullable fields in spec-compliant error events", () =>
Effect.gen(function* () {
const response = yield* LLMClient.generate(request).pipe(
const error = yield* LLMClient.generate(request).pipe(
Effect.provide(
fixedResponse(
sseEvents({
@ -1514,39 +1517,43 @@ describe("OpenAI Responses route", () => {
}),
),
),
Effect.flip,
)
expect(response.events).toEqual([{ type: "provider-error", message: "Something went wrong" }])
expect(error.reason).toMatchObject({ _tag: "UnknownProvider", message: "Something went wrong" })
}),
)
it.effect("falls back to a stable default when error is null", () =>
Effect.gen(function* () {
const response = yield* LLMClient.generate(request).pipe(
const error = yield* LLMClient.generate(request).pipe(
Effect.provide(fixedResponse(sseEvents({ type: "error", error: null }))),
Effect.flip,
)
expect(response.events).toEqual([{ type: "provider-error", message: "OpenAI Responses stream error" }])
expect(error.reason).toMatchObject({ _tag: "UnknownProvider", message: "OpenAI Responses stream error" })
}),
)
it.effect("falls back to a stable default when both error and response are absent", () =>
Effect.gen(function* () {
const response = yield* LLMClient.generate(request).pipe(
const error = yield* LLMClient.generate(request).pipe(
Effect.provide(fixedResponse(sseEvents({ type: "error" }))),
Effect.flip,
)
expect(response.events).toEqual([{ type: "provider-error", message: "OpenAI Responses stream error" }])
expect(error.reason).toMatchObject({ _tag: "UnknownProvider", message: "OpenAI Responses stream error" })
}),
)
it.effect("falls back to a stable default when response.failed has no error payload", () =>
Effect.gen(function* () {
const response = yield* LLMClient.generate(request).pipe(
const error = yield* LLMClient.generate(request).pipe(
Effect.provide(fixedResponse(sseEvents({ type: "response.failed", response: { id: "resp_failed_3" } }))),
Effect.flip,
)
expect(response.events).toEqual([{ type: "provider-error", message: "OpenAI Responses response failed" }])
expect(error.reason).toMatchObject({ _tag: "UnknownProvider", message: "OpenAI Responses response failed" })
}),
)