feat(core): add location-scoped config loading

packages/core/src/agent.ts

@@ -1,147 +0,0 @@
-export * as AgentV2 from "./agent"
-
-import { Context, Effect, HashMap, Layer, Option, Order, pipe, Schema, Array } from "effect"
-import { produce, type Draft } from "immer"
-import { ModelV2 } from "./model"
-import { PermissionV2 } from "./permission"
-import { PluginV2 } from "./plugin"
-import { ProviderV2 } from "./provider"
-
-export const ID = Schema.String.pipe(Schema.brand("AgentV2.ID"))
-export type ID = typeof ID.Type
-
-export const Mode = Schema.Literals(["subagent", "primary", "all"]).annotate({ identifier: "AgentV2.Mode" })
-export type Mode = typeof Mode.Type
-
-export const Info = Schema.Struct({
-  name: ID,
-  description: Schema.optional(Schema.String),
-  mode: Mode,
-  hidden: Schema.Boolean.pipe(Schema.optional),
-  color: Schema.String.pipe(Schema.optional),
-  permission: PermissionV2.Ruleset,
-  model: ModelV2.Ref.pipe(Schema.optional),
-  system: Schema.String.pipe(Schema.optional),
-  options: ProviderV2.Options.pipe(Schema.optional),
-  steps: Schema.Int.pipe(Schema.optional),
-}).annotate({ identifier: "AgentV2.Info" })
-export type Info = typeof Info.Type
-
-export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("AgentV2.NotFound", {
-  agent: ID,
-}) {}
-
-export class InvalidDefaultError extends Schema.TaggedErrorClass<InvalidDefaultError>()("AgentV2.InvalidDefault", {
-  agent: ID,
-  reason: Schema.Literals(["missing", "subagent", "hidden"]),
-}) {}
-
-export class NoDefaultError extends Schema.TaggedErrorClass<NoDefaultError>()("AgentV2.NoDefault", {}) {}
-
-export interface Interface {
-  readonly get: (agent: ID) => Effect.Effect<Info, NotFoundError>
-  readonly list: () => Effect.Effect<Info[]>
-  readonly update: (agent: ID, fn: (agent: Draft<Info>) => void) => Effect.Effect<void>
-  readonly remove: (agent: ID) => Effect.Effect<void>
-  readonly defaultInfo: () => Effect.Effect<Info, InvalidDefaultError | NoDefaultError>
-  readonly defaultAgent: () => Effect.Effect<ID, InvalidDefaultError | NoDefaultError>
-  readonly setDefault: (agent: ID) => Effect.Effect<void, NotFoundError>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Agent") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const plugin = yield* PluginV2.Service
-    let agents = HashMap.empty<ID, Info>()
-    let defaultAgent: ID | undefined
-
-    const result: Interface = {
-      get: Effect.fn("AgentV2.get")(function* (agent) {
-        const match = HashMap.get(agents, agent)
-        if (!match.valueOrUndefined) return yield* new NotFoundError({ agent })
-        return match.value
-      }),
-
-      list: Effect.fn("AgentV2.list")(function* () {
-        return pipe(
-          HashMap.toValues(agents),
-          Array.sortWith((agent) => agent.name, Order.String),
-        )
-      }),
-
-      update: Effect.fnUntraced(function* (agent, fn) {
-        const next = produce(
-          HashMap.get(agents, agent).pipe(
-            Option.getOrElse(
-              () =>
-                ({
-                  name: agent,
-                  mode: "all",
-                  permission: [],
-                  options: {
-                    headers: {},
-                    body: {},
-                    aisdk: {
-                      provider: {},
-                      request: {},
-                    },
-                  },
-                }) satisfies Info,
-            ),
-          ),
-          fn,
-        )
-        const updated = yield* plugin.trigger("agent.update", {}, { agent: next, cancel: false })
-        if (updated.cancel) return
-        agents = HashMap.set(agents, agent, { ...updated.agent, name: agent })
-      }),
-
-      remove: Effect.fn("AgentV2.remove")(function* (agent) {
-        const existing = Option.getOrUndefined(HashMap.get(agents, agent))
-        if (!existing) return
-        if ((yield* plugin.trigger("agent.remove", { agent: existing }, { cancel: false })).cancel) return
-        agents = HashMap.remove(agents, agent)
-        if (defaultAgent === agent) defaultAgent = undefined
-      }),
-
-      defaultInfo: Effect.fn("AgentV2.defaultInfo")(function* () {
-        const updated = yield* plugin.trigger("agent.default", {}, { agent: defaultAgent })
-        const selected = updated.agent
-        if (selected) {
-          const agent = yield* result
-            .get(selected)
-            .pipe(
-              Effect.catchTag("AgentV2.NotFound", () =>
-                Effect.fail(new InvalidDefaultError({ agent: selected, reason: "missing" })),
-              ),
-            )
-          if (agent.mode === "subagent") return yield* new InvalidDefaultError({ agent: selected, reason: "subagent" })
-          if (agent.hidden === true) return yield* new InvalidDefaultError({ agent: selected, reason: "hidden" })
-          return agent
-        }
-
-        const visible = pipe(
-          yield* result.list(),
-          Array.findFirst((agent) => agent.mode !== "subagent" && agent.hidden !== true),
-        )
-        if (Option.isSome(visible)) return visible.value
-        return yield* new NoDefaultError()
-      }),
-
-      defaultAgent: Effect.fn("AgentV2.defaultAgent")(function* () {
-        return (yield* result.defaultInfo()).name
-      }),
-
-      setDefault: Effect.fn("AgentV2.setDefault")(function* (agent) {
-        yield* result.get(agent)
-        defaultAgent = agent
-      }),
-    }
-
-    return Service.of(result)
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(PluginV2.defaultLayer))

packages/core/src/config/config.ts

@@ -0,0 +1,89 @@
+export * as Config from "./config"
+
+import path from "path"
+import { type ParseError, parse } from "jsonc-parser"
+import { Context, Effect, Layer, Option, Schema } from "effect"
+import { AppFileSystem } from "../filesystem"
+import { Global } from "../global"
+import { Location } from "../location"
+import { AbsolutePath } from "../schema"
+import { ConfigV2 } from "./schema"
+
+export interface Interface {
+  /** Returns supplemental config directories from lowest to highest priority. */
+  readonly directories: () => Effect.Effect<AbsolutePath[]>
+  /** Loads location config files from lowest to highest priority. */
+  readonly get: () => Effect.Effect<ConfigV2.Loaded[]>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Config") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const fs = yield* AppFileSystem.Service
+    const global = yield* Global.Service
+    const location = yield* Location.Service
+    const names = ["config.json", "opencode.json", "opencode.jsonc"]
+
+    const loadFile = Effect.fnUntraced(function* (filepath: string) {
+      const text = yield* fs.readFileStringSafe(filepath)
+      if (!text) return
+
+      const errors: ParseError[] = []
+      const input: unknown = parse(text, errors, { allowTrailingComma: true })
+      if (errors.length) return
+
+      const info = Option.getOrUndefined(Schema.decodeUnknownOption(ConfigV2.Info)(input, { errors: "all" }))
+      if (!info) return
+      return new ConfigV2.Loaded({ source: new ConfigV2.FileSource({ type: "file", path: filepath }), info })
+    })
+
+    const loadDirectory = Effect.fnUntraced(function* (directory: AbsolutePath) {
+      return yield* Effect.forEach(names, (file) => loadFile(path.join(directory, file))).pipe(
+        Effect.map((configs) => configs.filter((config): config is ConfigV2.Loaded => config !== undefined)),
+      )
+    })
+
+    const globalDirectory = AbsolutePath.make(global.config)
+    const locationIsGlobal = path.resolve(location.directory) === path.resolve(global.config)
+    // Read configuration once when this location opens. Later calls reuse these
+    // values until the location is reopened.
+    const directories = locationIsGlobal
+      ? [globalDirectory]
+      : [
+          globalDirectory,
+          ...(yield* fs
+            .up({ targets: [".opencode"], start: location.directory, stop: location.project.directory })
+            .pipe(Effect.orDie))
+            .toReversed()
+            .map((directory) => AbsolutePath.make(directory)),
+        ]
+    // A config closer to the opened directory should win over one higher up.
+    // Search starts nearby, so reverse the results before applying them.
+    const directPaths = locationIsGlobal
+      ? []
+      : (yield* fs
+          .up({ targets: names.toReversed(), start: location.directory, stop: location.project.directory })
+          .pipe(Effect.orDie)).toReversed()
+    const direct = yield* Effect.forEach(directPaths, loadFile).pipe(
+      Effect.orDie,
+      Effect.map((configs) => configs.filter((config): config is ConfigV2.Loaded => config !== undefined)),
+    )
+    const supplementary = yield* Effect.forEach(directories, loadDirectory).pipe(Effect.orDie)
+    // Apply general settings first and more specific settings last:
+    // global config, project files, then `.opencode` files.
+    const configs = [...(supplementary[0] ?? []), ...direct, ...supplementary.slice(1).flat()]
+
+    return Service.of({
+      directories: Effect.fn("Config.directories")(function* () {
+        return directories
+      }),
+      get: Effect.fn("Config.get")(function* () {
+        return configs
+      }),
+    })
+  }),
+)
+
+export const defaultLayer = layer.pipe(Layer.provide(AppFileSystem.defaultLayer), Layer.provide(Global.defaultLayer))

packages/core/src/config/provider.ts

@@ -0,0 +1,121 @@
+export * as ConfigProvider from "./provider"
+
+import { Effect, Schema } from "effect"
+import { Catalog } from "../catalog"
+import { Config } from "./config"
+import { ProviderV2 } from "../provider"
+import { ModelV2 } from "../model"
+import { PluginV2 } from "../plugin"
+
+class Model extends Schema.Class<Model>("ConfigV2.Model")({
+  apiID: ModelV2.ID.pipe(Schema.optional),
+  family: ModelV2.Family.pipe(Schema.optional),
+  name: Schema.String.pipe(Schema.optional),
+  endpoint: ProviderV2.Endpoint.pipe(Schema.optional),
+  capabilities: ModelV2.Capabilities.pipe(Schema.optional),
+  options: Schema.Struct({
+    ...ProviderV2.Options.fields,
+    variant: Schema.String.pipe(Schema.optional),
+  }).pipe(Schema.optional),
+  variants: Schema.Struct({
+    id: ModelV2.VariantID,
+    ...ProviderV2.Options.fields,
+  }).pipe(Schema.Array, Schema.optional),
+  cost: ModelV2.Cost.pipe(Schema.Array).pipe(Schema.optional),
+  enabled: Schema.Boolean.pipe(Schema.optional),
+  limit: Schema.Struct({
+    context: Schema.Int,
+    input: Schema.Int.pipe(Schema.optional),
+    output: Schema.Int,
+  }).pipe(Schema.optional),
+}) {}
+
+export class Info extends Schema.Class<Info>("ConfigV2.Provider")({
+  name: Schema.String.pipe(Schema.optional),
+  endpoint: ProviderV2.Endpoint.pipe(Schema.optional),
+  options: ProviderV2.Options.pipe(Schema.optional),
+  models: Schema.Record(Schema.String, Model).pipe(Schema.optional),
+}) {}
+
+export const Plugin = PluginV2.define({
+  id: PluginV2.ID.make("config-provider"),
+  effect: Effect.gen(function* () {
+    const catalog = yield* Catalog.Service
+    const config = yield* Config.Service
+    const load = yield* catalog.loader()
+    const files = yield* config.get()
+
+    yield* load((catalog) => {
+      for (const file of files) {
+        for (const [id, item] of Object.entries(file.info.providers ?? {})) {
+          const providerID = ProviderV2.ID.make(id)
+          catalog.provider.update(providerID, (provider) => {
+            if (item.name !== undefined) provider.name = item.name
+            provider.enabled = { via: "custom", data: {} }
+            if (item.endpoint !== undefined) provider.endpoint = { ...item.endpoint }
+            if (item.options !== undefined) {
+              Object.assign(provider.options.headers, item.options.headers)
+              Object.assign(provider.options.body, item.options.body)
+              Object.assign(provider.options.aisdk.provider, item.options.aisdk.provider)
+              Object.assign(provider.options.aisdk.request, item.options.aisdk.request)
+            }
+          })
+
+          for (const [id, config] of Object.entries(item.models ?? {})) {
+            catalog.model.update(providerID, ModelV2.ID.make(id), (model) => {
+              if (config.apiID !== undefined) model.apiID = config.apiID
+              if (config.family !== undefined) model.family = config.family
+              if (config.name !== undefined) model.name = config.name
+              if (config.endpoint !== undefined) model.endpoint = { ...config.endpoint }
+              if (config.capabilities !== undefined) {
+                model.capabilities = {
+                  tools: config.capabilities.tools,
+                  input: [...config.capabilities.input],
+                  output: [...config.capabilities.output],
+                }
+              }
+              if (config.options !== undefined) {
+                Object.assign(model.options.headers, config.options.headers)
+                Object.assign(model.options.body, config.options.body)
+                Object.assign(model.options.aisdk.provider, config.options.aisdk.provider)
+                Object.assign(model.options.aisdk.request, config.options.aisdk.request)
+                if (config.options.variant !== undefined) model.options.variant = config.options.variant
+              }
+              if (config.variants !== undefined) {
+                for (const variant of config.variants) {
+                  let existing = model.variants.find((item) => item.id === variant.id)
+                  if (!existing) {
+                    existing = {
+                      id: variant.id,
+                      headers: {},
+                      body: {},
+                      aisdk: {
+                        provider: {},
+                        request: {},
+                      },
+                    }
+                    model.variants.push(existing)
+                  }
+                  Object.assign(existing.headers, variant.headers)
+                  Object.assign(existing.body, variant.body)
+                  Object.assign(existing.aisdk.provider, variant.aisdk.provider)
+                  Object.assign(existing.aisdk.request, variant.aisdk.request)
+                }
+              }
+              if (config.cost !== undefined) {
+                model.cost = config.cost.map((cost) => ({
+                  tier: cost.tier && { ...cost.tier },
+                  input: cost.input,
+                  output: cost.output,
+                  cache: { ...cost.cache },
+                }))
+              }
+              if (config.enabled !== undefined) model.enabled = config.enabled
+              if (config.limit !== undefined) model.limit = { ...config.limit }
+            })
+          }
+        }
+      }
+    })
+  }),
+})

packages/core/src/config/schema.ts

@@ -0,0 +1,28 @@
+export * as ConfigV2 from "./schema"
+
+import { Schema } from "effect"
+import { ConfigProvider } from "./provider"
+
+export class Info extends Schema.Class<Info>("ConfigV2.Info")({
+  $schema: Schema.optional(Schema.String).annotate({
+    description: "JSON schema reference for configuration validation",
+  }),
+  providers: Schema.Record(Schema.String, ConfigProvider.Info).pipe(Schema.optional),
+}) {}
+
+export class FileSource extends Schema.Class<FileSource>("ConfigV2.FileSource")({
+  type: Schema.Literal("file"),
+  path: Schema.String,
+}) {}
+
+export class MemorySource extends Schema.Class<MemorySource>("ConfigV2.MemorySource")({
+  type: Schema.Literal("memory"),
+}) {}
+
+export const Source = Schema.Union([FileSource, MemorySource]).pipe(Schema.toTaggedUnion("type"))
+export type Source = typeof Source.Type
+
+export class Loaded extends Schema.Class<Loaded>("ConfigV2.Loaded")({
+  source: Source,
+  info: Info,
+}) {}

packages/core/src/event.ts

@@ -128,7 +128,7 @@ export const layer = Layer.effect(
           ...(options?.metadata ? { metadata: options.metadata } : {}),
           type: definition.type,
           ...(definition.version === undefined ? {} : { version: definition.version }),
-          ...(location ? { location } : {}),
+          ...(location ? { location: { directory: location.directory, workspaceID: location.workspaceID } } : {}),
           data,
         } as Payload<D>
         return yield* publishEvent(event)

packages/core/src/location-layer.ts

@@ -4,10 +4,12 @@ import { Catalog } from "./catalog"
 import { PluginBoot } from "./plugin/boot"
 
 export class LocationServiceMap extends LayerMap.Service<LocationServiceMap>()("@opencode/example/LocationServiceMap", {
-  lookup: (ref: Location.Ref) =>
-    Layer.mergeAll(Catalog.defaultLayer, PluginBoot.defaultLayer).pipe(
-      Layer.provide([Layer.succeed(Location.Service, Location.Service.of(ref))]),
-    ),
+  lookup: (ref: Location.Ref) => {
+    const result = Layer.mergeAll(Catalog.defaultLayer, PluginBoot.defaultLayer).pipe(
+      Layer.provideMerge(Location.defaultLayer(ref)),
+    )
+    return result
+  },
   idleTimeToLive: "5 minutes",
   dependencies: [],
 }) {}

packages/core/src/location.ts

@@ -1,11 +1,40 @@
-import { Context, Schema } from "effect"
+import { Context, Effect, Layer, Schema } from "effect"
+import { Project } from "./project"
+import { AbsolutePath } from "./schema"
 
 export * as Location from "./location"
 
 export const Ref = Schema.Struct({
-  directory: Schema.String,
+  directory: AbsolutePath,
   workspaceID: Schema.optional(Schema.String),
 }).annotate({ identifier: "Location.Ref" })
 export type Ref = typeof Ref.Type
 
-export class Service extends Context.Service<Service, Ref>()("@opencode/Location") {}
+export interface Interface {
+  readonly directory: AbsolutePath
+  readonly workspaceID?: string
+  readonly project: {
+    readonly id: Project.ID
+    readonly directory: AbsolutePath
+  }
+  readonly vcs?: Project.Vcs
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/Location") {}
+
+export const layer = (ref: Ref) =>
+  Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const project = yield* Project.Service
+      const resolved = yield* project.resolve(ref.directory)
+      return Service.of({
+        directory: ref.directory,
+        workspaceID: ref.workspaceID,
+        project: { id: resolved.id, directory: resolved.directory },
+        vcs: resolved.vcs,
+      })
+    }),
+  )
+
+export const defaultLayer = (ref: Ref) => layer(ref).pipe(Layer.provide(Project.defaultLayer))

packages/core/src/plugin.ts

@@ -4,7 +4,6 @@ import { createDraft, finishDraft, type Draft } from "immer"
 import type { LanguageModelV3 } from "@ai-sdk/provider"
 import { Context, Effect, Exit, Layer, PubSub, Schema, Scope, Stream } from "effect"
 import type { ModelV2 } from "./model"
-import type { AgentV2 } from "./agent"
 import type { Catalog } from "./catalog"
 
 export const ID = Schema.String.pipe(Schema.brand("Plugin.ID"))
@@ -43,27 +42,6 @@ type HookSpec = {
       sdk?: any
     }
   }
-  "agent.update": {
-    input: {}
-    output: {
-      agent: AgentV2.Info
-      cancel: boolean
-    }
-  }
-  "agent.remove": {
-    input: {
-      agent: AgentV2.Info
-    }
-    output: {
-      cancel: boolean
-    }
-  }
-  "agent.default": {
-    input: {}
-    output: {
-      agent?: AgentV2.ID
-    }
-  }
 }
 
 export type Hooks = {

packages/core/src/plugin/boot.ts

@@ -2,8 +2,9 @@ export * as PluginBoot from "./boot"
 
 import { Context, Deferred, Effect, Layer } from "effect"
 import { AccountV2 } from "../account"
-import { AgentV2 } from "../agent"
 import { Catalog } from "../catalog"
+import { Config } from "../config/config"
+import { ConfigProvider } from "../config/provider"
 import { EventV2 } from "../event"
 import { Npm } from "../npm"
 import { PluginV2 } from "../plugin"
@@ -15,7 +16,7 @@ import { ProviderPlugins } from "./provider"
 type Plugin = {
   id: PluginV2.ID
   effect: PluginV2.Effect<
-    Catalog.Service | AgentV2.Service | AccountV2.Service | Npm.Service | EventV2.Service | PluginV2.Service
+    Catalog.Service | AccountV2.Service | Npm.Service | EventV2.Service | PluginV2.Service | Config.Service
   >
 }
 
@@ -28,10 +29,10 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/v2
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
-    const agent = yield* AgentV2.Service
     const catalog = yield* Catalog.Service
     const plugin = yield* PluginV2.Service
     const accounts = yield* AccountV2.Service
+    const config = yield* Config.Service
     const npm = yield* Npm.Service
     const events = yield* EventV2.Service
     const done = yield* Deferred.make<void>()
@@ -41,8 +42,8 @@ export const layer = Layer.effect(
         id: input.id,
         effect: input.effect.pipe(
           Effect.provideService(Catalog.Service, catalog),
-          Effect.provideService(AgentV2.Service, agent),
           Effect.provideService(AccountV2.Service, accounts),
+          Effect.provideService(Config.Service, config),
           Effect.provideService(Npm.Service, npm),
           Effect.provideService(EventV2.Service, events),
           Effect.provideService(PluginV2.Service, plugin),
@@ -57,6 +58,7 @@ export const layer = Layer.effect(
         yield* add(item)
       }
       yield* add(ModelsDevPlugin)
+      yield* add(ConfigProvider.Plugin)
     }).pipe(Effect.withSpan("PluginBoot.boot"))
 
     yield* boot.pipe(
@@ -72,10 +74,10 @@ export const layer = Layer.effect(
 )
 
 export const defaultLayer = layer.pipe(
-  Layer.provide(AgentV2.defaultLayer),
   Layer.provide(Catalog.defaultLayer),
   Layer.provide(EventV2.defaultLayer),
   Layer.provide(PluginV2.defaultLayer),
   Layer.provide(AccountV2.defaultLayer),
+  Layer.provide(Config.defaultLayer),
   Layer.provide(Npm.defaultLayer),
 )

packages/core/src/project.ts

@@ -25,7 +25,6 @@ export type Vcs = typeof Vcs.Type
 
 export class Info extends Schema.Class<Info>("Project.Info")({
   id: ID,
-  vcs: Schema.optional(Vcs),
 }) {}
 
 export interface Interface {
@@ -105,7 +104,7 @@ export const layer = Layer.effect(
 
     const resolve = Effect.fn("Project.resolve")(function* (input: AbsolutePath) {
       const repo = yield* git.find(input)
-      if (!repo) return { id: ID.global, directory: input, vcs: undefined }
+      if (!repo) return { id: ID.global, directory: AbsolutePath.make(path.parse(input).root), vcs: undefined }
 
       const previous = yield* cached(repo.store)
       const id = (yield* remote(repo)) ?? previous ?? (yield* root(repo))