diff --git a/packages/core/src/generate.ts b/packages/core/src/generate.ts index e3f558fd790..bd2149d5d35 100644 --- a/packages/core/src/generate.ts +++ b/packages/core/src/generate.ts @@ -41,6 +41,8 @@ export const layer = Layer.effect( [ "SessionRunnerModel.VariantUnavailableError", "SessionRunnerModel.UnsupportedPackageError", + "SessionRunnerModel.ModelConfigurationError", + "SessionRunnerModel.ModelInitializationError", "SessionRunnerModel.UnresolvedProviderVariablesError", "SessionRunnerModel.UnsupportedCompactionError", ], diff --git a/packages/core/src/model-resolver.ts b/packages/core/src/model-resolver.ts index 9a134a5296a..8a075cd76c6 100644 --- a/packages/core/src/model-resolver.ts +++ b/packages/core/src/model-resolver.ts @@ -1,7 +1,7 @@ export * as ModelResolver from "./model-resolver.js" import { makeLocationNode } from "@opencode/util/effect/app-node" -import { LanguageModel } from "@opencode/ai" +import { LanguageModel, ProviderConfigurationError } from "@opencode/ai" import { Auth } from "@opencode/ai/route" import { Context, Effect, Layer, Schema, Struct } from "effect" import { AISDK } from "./aisdk.js" @@ -39,6 +39,40 @@ export class UnsupportedPackageError extends Schema.TaggedError()( + "SessionRunnerModel.ModelConfigurationError", + { + providerID: Provider.ID, + modelID: ID, + package: Schema.String, + detail: Schema.String, + }, +) { + override get message() { + return `Cannot initialize ${this.providerID}/${this.modelID}: ${this.detail}` + } +} + +/** A supported package failed unexpectedly while loading or constructing the model. */ +export class ModelInitializationError extends Schema.TaggedError()( + "SessionRunnerModel.ModelInitializationError", + { + providerID: Provider.ID, + modelID: ID, + package: Schema.String, + phase: InitializationPhase, + detail: Schema.String, + }, +) { + override get message() { + return `Cannot initialize ${this.providerID}/${this.modelID}: ${this.detail}` + } +} + export class UnresolvedProviderVariablesError extends Schema.TaggedError()( "SessionRunnerModel.UnresolvedProviderVariablesError", { @@ -68,6 +102,8 @@ export class UnsupportedCompactionError extends Schema.TaggedError => resolveCatalogModel(model, credential, dependencies).pipe( Effect.flatMap((resolved) => validateProviderVariables(model, resolved)), @@ -178,14 +218,16 @@ const resolveCatalogModel = Effect.fn("ModelResolver.resolveCatalogModel")(funct ...configuration, }) ?? {}, ) - return yield* loadAISDK({ ...resolved, settings }).pipe(Effect.mapError(() => unsupported(resolved))) + return yield* loadAISDK({ ...resolved, settings }).pipe( + Effect.mapError((error) => initialization(resolved, "init", error.cause)), + ) } if (!native) return yield* unsupported(resolved) const specifier = native const mapped = yield* prepareProviderSettings(resolved, mapping?.settings ?? configured) const module = yield* (dependencies?.loadPackage ?? Provider.loadPackage)(specifier).pipe( - Effect.mapError(() => unsupported(resolved)), + Effect.mapError((error) => initialization(resolved, "load", error.cause)), ) const settings = { ...(credential ? Struct.omit(mapped, ["accessToken", "apiKey", "authToken"]) : mapped), @@ -204,7 +246,15 @@ const resolveCatalogModel = Effect.fn("ModelResolver.resolveCatalogModel")(funct : runtime.compatibility, }) }, - catch: () => unsupported(resolved), + catch: (cause) => + cause instanceof ProviderConfigurationError + ? new ModelConfigurationError({ + providerID: resolved.providerID, + modelID: resolved.id, + package: resolved.package ?? "unknown", + detail: cause.message, + }) + : initialization(resolved, "construct", cause), }) }) @@ -277,6 +327,24 @@ const unsupported = (model: Info) => package: model.package ?? "unknown", }) +const initialization = (model: Info, phase: InitializationPhase, cause: unknown) => + new ModelInitializationError({ + providerID: model.providerID, + modelID: model.id, + package: model.package ?? "unknown", + phase, + detail: causeMessage(cause) ?? `${phase} failed for ${model.package ?? "unknown"}`, + }) + +// Unexpected throws still carry the most useful diagnosis in their message; a stack or an unknown value does not. +const causeMessage = (cause: unknown): string | undefined => { + if (typeof cause === "string") return cause.trim() || undefined + if (!(cause instanceof globalThis.Error)) return undefined + const message = cause.message.trim() + if (message) return message + return causeMessage(cause.cause) +} + export const resolveModel = ( model: Info, variant: VariantID | undefined, diff --git a/packages/core/src/session/runner/model.ts b/packages/core/src/session/runner/model.ts index c8414150793..80e7bc91a55 100644 --- a/packages/core/src/session/runner/model.ts +++ b/packages/core/src/session/runner/model.ts @@ -33,6 +33,10 @@ export const VariantUnavailableError = ModelResolver.VariantUnavailableError export type VariantUnavailableError = ModelResolver.VariantUnavailableError export const UnsupportedPackageError = ModelResolver.UnsupportedPackageError export type UnsupportedPackageError = ModelResolver.UnsupportedPackageError +export const ModelConfigurationError = ModelResolver.ModelConfigurationError +export type ModelConfigurationError = ModelResolver.ModelConfigurationError +export const ModelInitializationError = ModelResolver.ModelInitializationError +export type ModelInitializationError = ModelResolver.ModelInitializationError export const UnresolvedProviderVariablesError = ModelResolver.UnresolvedProviderVariablesError export type UnresolvedProviderVariablesError = ModelResolver.UnresolvedProviderVariablesError export const UnsupportedCompactionError = ModelResolver.UnsupportedCompactionError diff --git a/packages/core/src/session/to-session-error.ts b/packages/core/src/session/to-session-error.ts index e9306f9491d..2d436c288ce 100644 --- a/packages/core/src/session/to-session-error.ts +++ b/packages/core/src/session/to-session-error.ts @@ -55,6 +55,8 @@ export function toSessionError(cause: unknown): SessionError.Error { cause instanceof SessionRunnerModel.ModelUnavailableError || cause instanceof SessionRunnerModel.VariantUnavailableError || cause instanceof SessionRunnerModel.UnsupportedPackageError || + cause instanceof SessionRunnerModel.ModelConfigurationError || + cause instanceof SessionRunnerModel.ModelInitializationError || cause instanceof SessionRunnerModel.UnresolvedProviderVariablesError ) return { type: "provider.no-route", message: cause.message } diff --git a/packages/core/test/model-resolver.test.ts b/packages/core/test/model-resolver.test.ts index 7a2b284a9d0..d0be9288417 100644 --- a/packages/core/test/model-resolver.test.ts +++ b/packages/core/test/model-resolver.test.ts @@ -1395,6 +1395,81 @@ describe("ModelResolver", () => { }), ) + it.effect("reports provider configuration errors from supported packages", () => + Effect.gen(function* () { + const failure = yield* ModelResolver.fromCatalogModel( + model(Provider.aisdk("@ai-sdk/azure"), { + providerID: Provider.ID.azure, + modelID: "gpt-5.4-nano", + }), + Credential.OAuth.make({ + type: "oauth", + methodID: Integration.MethodID.make("oauth"), + access: "oauth-token", + refresh: "refresh", + expires: Date.now() + 60_000, + }), + ).pipe(Effect.flip) + + expect(failure).toMatchObject({ + _tag: "SessionRunnerModel.ModelConfigurationError", + providerID: "azure", + modelID: "test-model", + package: "aisdk:@ai-sdk/azure", + detail: "Azure requires resourceName or baseURL", + }) + expect(failure.message).toBe("Cannot initialize azure/test-model: Azure requires resourceName or baseURL") + }), + ) + + it.effect("distinguishes unexpected constructor failures from configuration errors", () => + Effect.gen(function* () { + const failure = yield* ModelResolver.fromCatalogModel(model("@opencode/ai/providers/custom"), undefined, { + loadPackage: () => + Effect.succeed({ + model: () => { + throw new Error("custom provider crashed") + }, + }), + }).pipe(Effect.flip) + + expect(failure).toMatchObject({ + _tag: "SessionRunnerModel.ModelInitializationError", + phase: "construct", + detail: "custom provider crashed", + }) + }), + ) + + it.effect("reports package load and AISDK initialization failures with their causes", () => + Effect.gen(function* () { + const load = yield* ModelResolver.fromCatalogModel(model("@opencode/ai/providers/custom"), undefined, { + loadPackage: (specifier) => + Effect.fail( + new Provider.LoadError({ package: specifier, cause: new Error(`Provider package ${specifier} is broken`) }), + ), + }).pipe(Effect.flip) + expect(load).toMatchObject({ + _tag: "SessionRunnerModel.ModelInitializationError", + phase: "load", + detail: "Provider package @opencode/ai/providers/custom is broken", + }) + + const init = yield* ModelResolver.fromCatalogModel(model(Provider.aisdk("@ai-sdk/cohere")), undefined, { + loadAISDK: (runtime) => + Effect.fail( + new AISDK.InitError({ providerID: runtime.providerID, cause: new Error("Cohere plugin failed") }), + ), + }).pipe(Effect.flip) + expect(init).toMatchObject({ + _tag: "SessionRunnerModel.ModelInitializationError", + phase: "init", + detail: "Cohere plugin failed", + }) + expect(init.message).toBe("Cannot initialize test-provider/test-model: Cohere plugin failed") + }), + ) + it.effect("drops an empty API key before loading an AISDK package", () => Effect.gen(function* () { const native = yield* ModelResolver.fromCatalogModel( diff --git a/packages/core/test/session-error.test.ts b/packages/core/test/session-error.test.ts index d491c28707f..858e8f48599 100644 --- a/packages/core/test/session-error.test.ts +++ b/packages/core/test/session-error.test.ts @@ -140,6 +140,30 @@ describe("toSessionError", () => { }) }) + test("preserves provider configuration and initialization errors", () => { + const configuration = new ModelResolver.ModelConfigurationError({ + providerID: Provider.ID.make("azure"), + modelID: ID.make("gpt-5.4-nano"), + package: "aisdk:@ai-sdk/azure", + detail: "Azure requires resourceName or baseURL", + }) + expect(toSessionError(configuration)).toEqual({ + type: "provider.no-route", + message: "Cannot initialize azure/gpt-5.4-nano: Azure requires resourceName or baseURL", + }) + const initialization = new ModelResolver.ModelInitializationError({ + providerID: Provider.ID.make("custom"), + modelID: ID.make("model"), + package: "@opencode/ai/providers/custom", + phase: "load", + detail: "Provider package @opencode/ai/providers/custom is broken", + }) + expect(toSessionError(initialization)).toEqual({ + type: "provider.no-route", + message: "Cannot initialize custom/model: Provider package @opencode/ai/providers/custom is broken", + }) + }) + test("retries rate limits, provider-internal, transport, and unrecognized failures", () => { const eligible = [ llm(new RateLimitError({ message: "rate" })),