openAgent

1export * as Catalog from "./catalog"
2 
3import { makeLocationNode } from "./effect/app-node"
4import { Array, Context, Effect, Layer, Option, Order, pipe, Schema } from "effect"
5import { Catalog } from "@opencode-ai/schema/catalog"
6import { ModelV2 } from "./model"
7import { ProviderV2 } from "./provider"
8import { EventV2 } from "./event"
9import { Policy } from "./policy"
10import { State } from "./state"
11import { Integration } from "./integration"
12 
13export type ProviderRecord = {
14  provider: ProviderV2.MutableInfo
15  models: Map<ModelV2.ID, ModelV2.MutableInfo>
16}
17 
18export type DefaultModel = { providerID: ProviderV2.ID; modelID: ModelV2.ID }
19 
20export const PolicyActions = Schema.Literals(["provider.use"])
21 
22export const Event = Catalog.Event
23 
24type Data = {
25  providers: Map<ProviderV2.ID, ProviderRecord>
26  defaultModel?: DefaultModel
27}
28 
29export type Draft = {
30  provider: {
31    list: () => readonly ProviderRecord[]
32    get: (providerID: ProviderV2.ID) => ProviderRecord | undefined
33    update: (providerID: ProviderV2.ID, fn: (provider: ProviderV2.MutableInfo) => void) => void
34    remove: (providerID: ProviderV2.ID) => void
35  }
36  model: {
37    get: (providerID: ProviderV2.ID, modelID: ModelV2.ID) => ModelV2.Info | undefined
38    update: (providerID: ProviderV2.ID, modelID: ModelV2.ID, fn: (model: ModelV2.MutableInfo) => void) => void
39    remove: (providerID: ProviderV2.ID, modelID: ModelV2.ID) => void
40    default: {
41      get: () => DefaultModel | undefined
42      set: (providerID: ProviderV2.ID, modelID: ModelV2.ID) => void
43    }
44  }
45}
46 
47export interface Interface extends State.Transformable<Draft> {
48  readonly provider: {
49    readonly get: (providerID: ProviderV2.ID) => Effect.Effect<ProviderV2.Info | undefined>
50    readonly all: () => Effect.Effect<ProviderV2.Info[]>
51    readonly available: () => Effect.Effect<ProviderV2.Info[]>
52  }
53  readonly model: {
54    readonly get: (providerID: ProviderV2.ID, modelID: ModelV2.ID) => Effect.Effect<ModelV2.Info | undefined>
55    readonly all: () => Effect.Effect<ModelV2.Info[]>
56    readonly available: () => Effect.Effect<ModelV2.Info[]>
57    readonly default: () => Effect.Effect<ModelV2.Info | undefined>
58    readonly small: (providerID: ProviderV2.ID) => Effect.Effect<ModelV2.Info | undefined>
59  }
60}
61 
62export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Catalog") {}
63 
64const layer = Layer.effect(
65  Service,
66  Effect.gen(function* () {
67    const events = yield* EventV2.Service
68    const policy = yield* Policy.Service
69    const integrations = yield* Integration.Service
70 
71    const available = (provider: ProviderV2.Info, integration: Integration.Info | undefined) => {
72      if (provider.disabled) return false
73      if (typeof provider.request.body.apiKey === "string") return true
74      if (integration?.connections.length) return true
75      return provider.integrationID === undefined && !integration
76    }
77 
78    const projectModel = (model: ModelV2.Info, provider: ProviderV2.Info) => {
79      const api =
80        model.api.type === "native" && !model.api.url && Object.keys(model.api.settings).length === 0
81          ? { ...provider.api, id: model.api.id }
82          : model.api.type === "aisdk" && provider.api.type === "aisdk" && !model.api.url
83            ? { ...model.api, url: provider.api.url, settings: { ...provider.api.settings, ...model.api.settings } }
84            : model.api.type === "aisdk" && provider.api.type === "aisdk"
85              ? { ...model.api, settings: { ...provider.api.settings, ...model.api.settings } }
86              : model.api
87      const request = {
88        headers: { ...provider.request.headers, ...model.request.headers },
89        body: { ...provider.request.body, ...model.request.body },
90        variant: model.request.variant,
91      }
92      return ModelV2.Info.make({
93        ...model,
94        api,
95        request,
96      })
97    }
98 
99    const normalizeApi = (item: ProviderV2.MutableInfo | ModelV2.MutableInfo) => {
100      if (typeof item.request.body.baseURL !== "string") return
101      item.api.url = item.request.body.baseURL
102      delete item.request.body.baseURL
103    }
104 
105    const state = State.create<Data, Draft>({
106      initial: () => ({ providers: new Map() }),
107      draft: (draft) => {
108        const result: Draft = {
109          provider: {
110            list: () => Array.fromIterable(draft.providers.values()) as ProviderRecord[],
111            get: (providerID) => draft.providers.get(providerID),
112            update: (providerID, fn) => {
113              let current = draft.providers.get(providerID)
114              if (!current) {
115                current = {
116                  provider: ProviderV2.Info.empty(providerID) as ProviderV2.MutableInfo,
117                  models: new Map<ModelV2.ID, ModelV2.MutableInfo>(),
118                }
119                draft.providers.set(providerID, current)
120              }
121              fn(current.provider)
122              normalizeApi(current.provider)
123            },
124            remove: (providerID) => {
125              draft.providers.delete(providerID)
126            },
127          },
128          model: {
129            get: (providerID, modelID) => draft.providers.get(providerID)?.models.get(modelID),
130            update: (providerID, modelID, fn) => {
131              let record = draft.providers.get(providerID)
132              if (!record) {
133                record = {
134                  provider: ProviderV2.Info.empty(providerID) as ProviderV2.MutableInfo,
135                  models: new Map<ModelV2.ID, ModelV2.MutableInfo>(),
136                }
137                draft.providers.set(providerID, record)
138              }
139              const model =
140                record.models.get(modelID) ?? (ModelV2.Info.empty(providerID, modelID) as ModelV2.MutableInfo)
141              if (!record.models.has(modelID)) record.models.set(modelID, model)
142              fn(model)
143              model.id = modelID
144              model.providerID = providerID
145              normalizeApi(model)
146            },
147            remove: (providerID, modelID) => {
148              draft.providers.get(providerID)?.models.delete(modelID)
149            },
150            default: {
151              get: () => draft.defaultModel,
152              set: (providerID, modelID) => {
153                draft.defaultModel = { providerID, modelID }
154              },
155            },
156          },
157        }
158        return result
159      },
160      finalize: Effect.fn("CatalogV2.finalize")(function* (catalog) {
161        if (policy.hasStatements()) {
162          for (const record of [...catalog.provider.list()]) {
163            if ((yield* policy.evaluate("provider.use", record.provider.id, "allow")) === "deny") {
164              catalog.provider.remove(record.provider.id)
165            }
166          }
167        }
168        yield* events.publish(Event.Updated, {})
169      }),
170    })
171    const result: Interface = {
172      transform: state.transform,
173      reload: state.reload,
174 
175      provider: {
176        get: Effect.fn("CatalogV2.provider.get")(function* (providerID) {
177          return state.get().providers.get(providerID)?.provider
178        }),
179 
180        all: Effect.fn("CatalogV2.provider.all")(function* () {
181          return Array.fromIterable(state.get().providers.values()).map((record) => record.provider)
182        }),
183 
184        available: Effect.fn("CatalogV2.provider.available")(function* () {
185          const active = new Map((yield* integrations.list()).map((integration) => [integration.id, integration]))
186          return (yield* result.provider.all()).filter((provider) =>
187            available(provider, active.get(provider.integrationID ?? Integration.ID.make(provider.id))),
188          )
189        }),
190      },
191 
192      model: {
193        get: Effect.fn("CatalogV2.model.get")(function* (providerID, modelID) {
194          const record = state.get().providers.get(providerID)
195          if (!record) return
196          const model = record.models.get(modelID)
197          return model && projectModel(model, record.provider)
198        }),
199 
200        all: Effect.fn("CatalogV2.model.all")(function* () {
201          return pipe(
202            Array.fromIterable(state.get().providers.values()),
203            Array.flatMap((record) => {
204              return Array.fromIterable(record.models.values()).map((model) => projectModel(model, record.provider))
205            }),
206            Array.sortWith((item) => item.time.released, Order.flip(Order.Number)),
207          )
208        }),
209 
210        available: Effect.fn("CatalogV2.model.available")(function* () {
211          const providers = new Set((yield* result.provider.available()).map((provider) => provider.id))
212          return (yield* result.model.all()).filter((model) => providers.has(model.providerID) && model.enabled)
213        }),
214 
215        default: Effect.fn("CatalogV2.model.default")(function* () {
216          const defaultModel = state.get().defaultModel
217          if (defaultModel) {
218            const provider = yield* result.provider.get(defaultModel.providerID)
219            if (provider && (yield* result.provider.available()).some((item) => item.id === provider.id)) {
220              const model = yield* result.model.get(defaultModel.providerID, defaultModel.modelID)
221              if (model?.enabled) return model
222            }
223          }
224 
225          return Option.getOrUndefined(
226            pipe(
227              yield* result.model.available(),
228              Array.sortWith((item) => item.time.released, Order.flip(Order.Number)),
229              Array.head,
230            ),
231          )
232        }),
233 
234        small: Effect.fn("CatalogV2.model.small")(function* (providerID) {
235          const record = state.get().providers.get(providerID)
236          if (!record) return
237          const provider = record.provider
238 
239          // TODO: Remove these provider-specific assumptions once model syncing reliably reports available deployments.
240          if (providerID === ProviderV2.ID.azure || providerID === ProviderV2.ID.make("azure-cognitive-services")) {
241            return
242          }
243 
244          if (providerID === ProviderV2.ID.opencode) {
245            const gpt5Nano = record.models.get(ModelV2.ID.make("gpt-5-nano"))
246            if (gpt5Nano?.enabled && gpt5Nano.status === "active") return projectModel(gpt5Nano, provider)
247          }
248 
249          const candidates = pipe(
250            Array.fromIterable(record.models.values()),
251            Array.filter(
252              (model) =>
253                model.providerID === providerID &&
254                model.enabled &&
255                model.status === "active" &&
256                model.capabilities.input.some((item) => item.startsWith("text")) &&
257                model.capabilities.output.some((item) => item.startsWith("text")),
258            ),
259            Array.map((model) => ({
260              model,
261              cost: model.cost[0] ? model.cost[0].input + model.cost[0].output : 999,
262              age: (Date.now() - model.time.released) / (1000 * 60 * 60 * 24 * 30),
263              small: SMALL_MODEL_RE.test(`${model.id} ${model.family ?? ""} ${model.name}`.toLowerCase()),
264            })),
265            Array.filter((item) => item.cost > 0 && item.age <= 18),
266          )
267 
268          const pick = (items: typeof candidates) => {
269            const maxCost = Math.max(...items.map((item) => item.cost), 0.01)
270            const maxAge = Math.max(...items.map((item) => item.age), 0.01)
271            return pipe(
272              items,
273              Array.sortWith((item) => (item.cost / maxCost) * 0.8 + (item.age / maxAge) * 0.2, Order.Number),
274              Array.map((item) => projectModel(item.model, provider)),
275              Array.head,
276            )
277          }
278 
279          return Option.getOrUndefined(
280            pipe(
281              candidates,
282              Array.filter((item) => item.small),
283              (items) => (items.length > 0 ? pick(items) : pick(candidates)),
284            ),
285          )
286        }),
287      },
288    }
289 
290    return Service.of(result)
291  }),
292)
293 
294const SMALL_MODEL_RE = /\b(nano|flash|lite|mini|haiku|small|fast)\b/
295 
296export const locationLayer = layer.pipe(
297  Layer.provideMerge(Integration.locationLayer),
298  Layer.provideMerge(Policy.locationLayer),
299)
300 
301export const node = makeLocationNode({ service: Service, layer, deps: [EventV2.node, Policy.node, Integration.node] })
302