271 lines
10 KiB
TypeScript
271 lines
10 KiB
TypeScript
export * as SessionRunnerModel from "./model"
|
|
|
|
import { makeLocationNode } from "../../effect/app-node"
|
|
import { type Model } from "@opencode-ai/llm"
|
|
import * as AnthropicMessages from "@opencode-ai/llm/protocols/anthropic-messages"
|
|
import * as OpenAICompatibleChat from "@opencode-ai/llm/protocols/openai-compatible-chat"
|
|
import * as OpenAIResponses from "@opencode-ai/llm/protocols/openai-responses"
|
|
import { Auth, type AnyRoute } from "@opencode-ai/llm/route"
|
|
import { Context, Effect, Layer, Schema } from "effect"
|
|
import { produce } from "immer"
|
|
import { Catalog } from "../../catalog"
|
|
import { Credential } from "../../credential"
|
|
import { Integration } from "../../integration"
|
|
import { ModelV2 } from "../../model"
|
|
import { OpenAICodex } from "../../plugin/provider/openai-codex"
|
|
import { ProviderV2 } from "../../provider"
|
|
import { SessionSchema } from "../schema"
|
|
|
|
export class ModelNotSelectedError extends Schema.TaggedErrorClass<ModelNotSelectedError>()(
|
|
"SessionRunnerModel.ModelNotSelectedError",
|
|
{
|
|
sessionID: SessionSchema.ID,
|
|
},
|
|
) {
|
|
override get message() {
|
|
return `No model is available for session ${this.sessionID}`
|
|
}
|
|
}
|
|
|
|
export class ModelUnavailableError extends Schema.TaggedErrorClass<ModelUnavailableError>()(
|
|
"SessionRunnerModel.ModelUnavailableError",
|
|
{
|
|
providerID: ProviderV2.ID,
|
|
modelID: ModelV2.ID,
|
|
},
|
|
) {
|
|
override get message() {
|
|
return `Model unavailable: ${this.providerID}/${this.modelID}`
|
|
}
|
|
}
|
|
|
|
export class VariantUnavailableError extends Schema.TaggedErrorClass<VariantUnavailableError>()(
|
|
"SessionRunnerModel.VariantUnavailableError",
|
|
{
|
|
providerID: ProviderV2.ID,
|
|
modelID: ModelV2.ID,
|
|
variant: ModelV2.VariantID,
|
|
},
|
|
) {
|
|
override get message() {
|
|
return `Variant unavailable for ${this.providerID}/${this.modelID}: ${this.variant}`
|
|
}
|
|
}
|
|
|
|
export class UnsupportedApiError extends Schema.TaggedErrorClass<UnsupportedApiError>()(
|
|
"SessionRunnerModel.UnsupportedApiError",
|
|
{
|
|
providerID: ProviderV2.ID,
|
|
modelID: ModelV2.ID,
|
|
api: Schema.String,
|
|
},
|
|
) {
|
|
override get message() {
|
|
return `Unsupported API for ${this.providerID}/${this.modelID}: ${this.api}`
|
|
}
|
|
}
|
|
|
|
export type Error =
|
|
| ModelNotSelectedError
|
|
| ModelUnavailableError
|
|
| VariantUnavailableError
|
|
| UnsupportedApiError
|
|
| Integration.AuthorizationError
|
|
|
|
export interface Resolved {
|
|
/** Route-level model for provider requests; its id is the provider API model id, which may differ from the catalog id. */
|
|
readonly model: Model
|
|
/** Selected catalog identity. Durable records and displays must use this, never the API model id. */
|
|
readonly ref: ModelV2.Ref
|
|
}
|
|
|
|
export interface Interface {
|
|
readonly resolve: (session: SessionSchema.Info) => Effect.Effect<Resolved, Error>
|
|
}
|
|
|
|
export class Service extends Context.Service<Service, Interface>()("@opencode/v2/SessionRunnerModel") {}
|
|
|
|
/** Test or embedding seam for supplying a model resolver directly. */
|
|
export const layerWith = (resolve: Interface["resolve"]) => Layer.succeed(Service, Service.of({ resolve }))
|
|
|
|
/** Builds a Resolved whose catalog identity mirrors the route model. Test or embedding seam. */
|
|
export const resolved = (model: Model, variant?: ModelV2.VariantID): Resolved => ({
|
|
model,
|
|
ref: ModelV2.Ref.make({
|
|
id: ModelV2.ID.make(model.id),
|
|
providerID: ProviderV2.ID.make(model.provider),
|
|
...(variant === undefined ? {} : { variant }),
|
|
}),
|
|
})
|
|
|
|
const apiKey = (model: ModelV2.Info, credential?: Credential.Value) => {
|
|
if (credential?.type === "key") return Auth.value(credential.key)
|
|
if (credential?.type === "oauth") return Auth.value(credential.access)
|
|
const value = model.request.body.apiKey ?? model.api.settings?.apiKey
|
|
if (typeof value === "string") return Auth.value(value)
|
|
}
|
|
|
|
const withDefaults = (model: ModelV2.Info, route: AnyRoute) => {
|
|
const body = model.request.body
|
|
const httpBody = Object.hasOwn(body, "apiKey")
|
|
? Object.fromEntries(Object.entries(body).filter(([key]) => key !== "apiKey"))
|
|
: body
|
|
return route.with({
|
|
provider: model.providerID,
|
|
endpoint: model.api.url === undefined ? undefined : { baseURL: model.api.url },
|
|
headers: model.request.headers,
|
|
providerOptions: providerOptions(model),
|
|
http: { body: httpBody },
|
|
limits: { context: model.limit.context, output: model.limit.output },
|
|
})
|
|
}
|
|
|
|
const providerOptions = (
|
|
model: ModelV2.Info,
|
|
): { readonly [key: string]: { readonly [key: string]: unknown } } | undefined => {
|
|
if (Object.keys(model.request.settings).length === 0) return undefined
|
|
if (model.api.type !== "aisdk") return undefined
|
|
if (model.api.package === "@ai-sdk/openai") return { openai: model.request.settings }
|
|
if (model.api.package === "@ai-sdk/anthropic") return { anthropic: model.request.settings }
|
|
if (model.api.package === "@ai-sdk/openai-compatible") return { openai: model.request.settings }
|
|
}
|
|
|
|
export const withVariant = (
|
|
model: ModelV2.Info,
|
|
variantID: ModelV2.VariantID | undefined,
|
|
): Effect.Effect<ModelV2.Info, VariantUnavailableError> => {
|
|
const id = variantID === "default" || variantID === undefined ? model.request.variant : variantID
|
|
const variant = model.variants.find((item) => item.id === id)
|
|
if (!variant && variantID !== undefined && variantID !== "default")
|
|
return Effect.fail(
|
|
new VariantUnavailableError({
|
|
providerID: model.providerID,
|
|
modelID: model.id,
|
|
variant: variantID,
|
|
}),
|
|
)
|
|
return Effect.succeed(
|
|
variant
|
|
? produce(model, (draft) => {
|
|
Object.assign(draft.request.settings, variant.settings)
|
|
Object.assign(draft.request.headers, variant.headers)
|
|
Object.assign(draft.request.body, variant.body)
|
|
})
|
|
: model,
|
|
)
|
|
}
|
|
|
|
const apiName = (model: ModelV2.Info) =>
|
|
model.api.type === "aisdk" ? `${model.api.type}:${model.api.package}` : model.api.type
|
|
|
|
export const fromCatalogModel = (
|
|
model: ModelV2.Info,
|
|
credential?: Credential.Value,
|
|
): Effect.Effect<Model, UnsupportedApiError> => {
|
|
const resolved =
|
|
credential?.type !== "key" || credential.metadata === undefined
|
|
? model
|
|
: produce(model, (draft) => {
|
|
Object.assign(draft.request.body, credential.metadata)
|
|
})
|
|
const key = apiKey(resolved, credential)
|
|
if (resolved.api.type === "aisdk" && resolved.api.package === "@ai-sdk/openai") {
|
|
// ChatGPT-plan OAuth tokens are not API-key credentials: the public API rejects
|
|
// them, so requests must target the codex backend with the account header.
|
|
if (OpenAICodex.isChatGPT(credential)) {
|
|
const account = OpenAICodex.accountID(credential)
|
|
return Effect.succeed(
|
|
withDefaults(resolved, OpenAIResponses.route)
|
|
.with({
|
|
endpoint: { baseURL: OpenAICodex.baseURL },
|
|
auth: (key === undefined ? Auth.none : Auth.bearer(key)).andThen(
|
|
account === undefined ? Auth.none : Auth.headers({ "chatgpt-account-id": account }),
|
|
),
|
|
})
|
|
.model({ id: resolved.api.id }),
|
|
)
|
|
}
|
|
return Effect.succeed(
|
|
withDefaults(resolved, OpenAIResponses.route)
|
|
.with({ auth: key === undefined ? Auth.none : Auth.bearer(key) })
|
|
.model({ id: resolved.api.id }),
|
|
)
|
|
}
|
|
if (resolved.api.type === "aisdk" && resolved.api.package === "@ai-sdk/anthropic") {
|
|
return Effect.succeed(
|
|
withDefaults(resolved, AnthropicMessages.route)
|
|
.with({ auth: key === undefined ? Auth.none : Auth.header("x-api-key", key) })
|
|
.model({ id: resolved.api.id }),
|
|
)
|
|
}
|
|
if (resolved.api.type === "aisdk" && resolved.api.package === "@ai-sdk/openai-compatible" && resolved.api.url) {
|
|
return Effect.succeed(
|
|
withDefaults(resolved, OpenAICompatibleChat.route)
|
|
.with({ auth: key === undefined ? Auth.none : Auth.bearer(key) })
|
|
.model({ id: resolved.api.id }),
|
|
)
|
|
}
|
|
return Effect.fail(
|
|
new UnsupportedApiError({
|
|
providerID: resolved.providerID,
|
|
modelID: resolved.id,
|
|
api: apiName(resolved),
|
|
}),
|
|
)
|
|
}
|
|
|
|
export const resolve = (session: SessionSchema.Info, model: ModelV2.Info, credential?: Credential.Value) =>
|
|
withVariant(model, session.model?.variant).pipe(Effect.flatMap((model) => fromCatalogModel(model, credential)))
|
|
|
|
export const supported = (model: ModelV2.Info) =>
|
|
model.api.type === "aisdk" &&
|
|
(model.api.package === "@ai-sdk/openai" ||
|
|
model.api.package === "@ai-sdk/anthropic" ||
|
|
(model.api.package === "@ai-sdk/openai-compatible" && model.api.url !== undefined))
|
|
|
|
/** Resolves models from the catalog belonging to the current Location runtime. */
|
|
const layer = Layer.effect(
|
|
Service,
|
|
Effect.gen(function* () {
|
|
const catalog = yield* Catalog.Service
|
|
const integrations = yield* Integration.Service
|
|
return Service.of({
|
|
resolve: Effect.fn("SessionRunnerModel.resolve")(function* (session) {
|
|
// Location plugins populate and filter the catalog asynchronously during layer startup.
|
|
const defaultModel = session.model ? undefined : yield* catalog.model.default()
|
|
const selected = session.model
|
|
? (yield* catalog.model.available()).find(
|
|
(model) => model.providerID === session.model?.providerID && model.id === session.model.id,
|
|
)
|
|
: defaultModel && supported(defaultModel)
|
|
? defaultModel
|
|
: (yield* catalog.model.available()).find(supported)
|
|
if (!selected && session.model)
|
|
return yield* new ModelUnavailableError({
|
|
providerID: session.model.providerID,
|
|
modelID: session.model.id,
|
|
})
|
|
if (!selected) return yield* new ModelNotSelectedError({ sessionID: session.id })
|
|
const provider = yield* catalog.provider.get(selected.providerID)
|
|
const connection = yield* integrations.connection.active(
|
|
provider?.integrationID ?? Integration.ID.make(selected.providerID),
|
|
)
|
|
const model = yield* resolve(
|
|
session,
|
|
selected,
|
|
connection ? yield* integrations.connection.resolve(connection) : undefined,
|
|
)
|
|
return {
|
|
model,
|
|
ref: ModelV2.Ref.make({
|
|
id: selected.id,
|
|
providerID: selected.providerID,
|
|
...(session.model?.variant === undefined ? {} : { variant: session.model.variant }),
|
|
}),
|
|
}
|
|
}),
|
|
})
|
|
}),
|
|
)
|
|
|
|
export const node = makeLocationNode({ service: Service, layer, deps: [Catalog.node, Integration.node] })
|