feat(core): add location-scoped config loading (#29625)

packages/core/src/config/agent.ts

@@ -0,0 +1,25 @@
+export * as ConfigAgent from "./agent"
+
+import { Schema } from "effect"
+import { PermissionV2 } from "../permission"
+import { ConfigProvider } from "./provider"
+import { PositiveInt } from "../schema"
+
+export const Color = Schema.Union([
+  Schema.String.check(Schema.isPattern(/^#[0-9a-fA-F]{6}$/)),
+  Schema.Literals(["primary", "secondary", "accent", "success", "warning", "error", "info"]),
+])
+
+export class Info extends Schema.Class<Info>("ConfigV2.Agent")({
+  model: Schema.String.pipe(Schema.optional),
+  variant: Schema.String.pipe(Schema.optional),
+  options: ConfigProvider.Options.pipe(Schema.optional),
+  system: Schema.String.pipe(Schema.optional),
+  description: Schema.String.pipe(Schema.optional),
+  mode: Schema.Literals(["subagent", "primary", "all"]).pipe(Schema.optional),
+  hidden: Schema.Boolean.pipe(Schema.optional),
+  color: Color.pipe(Schema.optional),
+  steps: PositiveInt.pipe(Schema.optional),
+  disabled: Schema.Boolean.pipe(Schema.optional),
+  permissions: PermissionV2.Ruleset.pipe(Schema.optional),
+}) {}

packages/core/src/config/attachments.ts

@@ -0,0 +1,15 @@
+export * as ConfigAttachments from "./attachments"
+
+import { Schema } from "effect"
+import { PositiveInt } from "../schema"
+
+export class Image extends Schema.Class<Image>("ConfigV2.Attachments.Image")({
+  auto_resize: Schema.Boolean.pipe(Schema.optional),
+  max_width: PositiveInt.pipe(Schema.optional),
+  max_height: PositiveInt.pipe(Schema.optional),
+  max_base64_bytes: PositiveInt.pipe(Schema.optional),
+}) {}
+
+export class Info extends Schema.Class<Info>("ConfigV2.Attachments")({
+  image: Image.pipe(Schema.optional),
+}) {}

packages/core/src/config/compaction.ts

@@ -0,0 +1,16 @@
+export * as ConfigCompaction from "./compaction"
+
+import { Schema } from "effect"
+import { NonNegativeInt } from "../schema"
+
+export class Keep extends Schema.Class<Keep>("ConfigV2.Compaction.Keep")({
+  turns: NonNegativeInt.pipe(Schema.optional),
+  tokens: NonNegativeInt.pipe(Schema.optional),
+}) {}
+
+export class Info extends Schema.Class<Info>("ConfigV2.Compaction")({
+  auto: Schema.Boolean.pipe(Schema.optional),
+  prune: Schema.Boolean.pipe(Schema.optional),
+  keep: Keep.pipe(Schema.optional),
+  buffer: NonNegativeInt.pipe(Schema.optional),
+}) {}

packages/core/src/config/experimental.ts

@@ -0,0 +1,18 @@
+export * as ConfigExperimental from "./experimental"
+
+import { Schema } from "effect"
+import { Catalog } from "../catalog"
+import { Policy as PolicyV2 } from "../policy"
+
+// Each core domain exports the policy actions it supports. Adding an action to
+// this union makes it valid in authored config while keeping Policy generic.
+export const PolicyAction = Schema.Union([Catalog.PolicyActions])
+
+export class Policy extends Schema.Class<Policy>("ConfigV2.Experimental.Policy")({
+  ...PolicyV2.Info.fields,
+  action: PolicyAction,
+}) {}
+
+export class Experimental extends Schema.Class<Experimental>("ConfigV2.Experimental")({
+  policies: Policy.pipe(Schema.Array, Schema.optional),
+}) {}

packages/core/src/config/formatter.ts

@@ -0,0 +1,12 @@
+export * as ConfigFormatter from "./formatter"
+
+import { Schema } from "effect"
+
+export class Entry extends Schema.Class<Entry>("ConfigV2.Formatter.Entry")({
+  disabled: Schema.Boolean.pipe(Schema.optional),
+  command: Schema.String.pipe(Schema.Array, Schema.optional),
+  environment: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
+  extensions: Schema.String.pipe(Schema.Array, Schema.optional),
+}) {}
+
+export const Info = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry)])

packages/core/src/config/lsp.ts

@@ -0,0 +1,18 @@
+export * as ConfigLSP from "./lsp"
+
+import { Schema } from "effect"
+
+export const Disabled = Schema.Struct({
+  disabled: Schema.Literal(true),
+})
+
+export class Server extends Schema.Class<Server>("ConfigV2.LSP.Server")({
+  command: Schema.String.pipe(Schema.Array),
+  extensions: Schema.String.pipe(Schema.Array, Schema.optional),
+  disabled: Schema.Boolean.pipe(Schema.optional),
+  env: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
+  initialization: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
+}) {}
+
+export const Entry = Schema.Union([Disabled, Server])
+export const Info = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry)])

packages/core/src/config/mcp.ts

@@ -0,0 +1,36 @@
+export * as ConfigMCP from "./mcp"
+
+import { Schema } from "effect"
+import { PositiveInt } from "../schema"
+
+export class Local extends Schema.Class<Local>("ConfigV2.MCP.Local")({
+  type: Schema.Literal("local"),
+  command: Schema.String.pipe(Schema.Array),
+  environment: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
+  disabled: Schema.Boolean.pipe(Schema.optional),
+  timeout: PositiveInt.pipe(Schema.optional),
+}) {}
+
+export class OAuth extends Schema.Class<OAuth>("ConfigV2.MCP.OAuth")({
+  client_id: Schema.String.pipe(Schema.optional),
+  client_secret: Schema.String.pipe(Schema.optional),
+  scope: Schema.String.pipe(Schema.optional),
+  callback_port: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65535 })).pipe(Schema.optional),
+  redirect_uri: Schema.String.pipe(Schema.optional),
+}) {}
+
+export class Remote extends Schema.Class<Remote>("ConfigV2.MCP.Remote")({
+  type: Schema.Literal("remote"),
+  url: Schema.String,
+  headers: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
+  oauth: Schema.Union([OAuth, Schema.Literal(false)]).pipe(Schema.optional),
+  disabled: Schema.Boolean.pipe(Schema.optional),
+  timeout: PositiveInt.pipe(Schema.optional),
+}) {}
+
+export const Server = Schema.Union([Local, Remote]).pipe(Schema.toTaggedUnion("type"))
+
+export class Info extends Schema.Class<Info>("ConfigV2.MCP")({
+  timeout: PositiveInt.pipe(Schema.optional),
+  servers: Schema.Record(Schema.String, Server).pipe(Schema.optional),
+}) {}

packages/core/src/config/plugin.ts

@@ -0,0 +1,13 @@
+export * as ConfigPlugin from "./plugin"
+
+import { Schema } from "effect"
+
+export class Entry extends Schema.Class<Entry>("ConfigV2.Plugin.Entry")({
+  package: Schema.String,
+  options: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
+}) {}
+
+export const Plugin = Schema.Union([Schema.String, Entry])
+export type Plugin = typeof Plugin.Type
+
+export const Plugins = Plugin.pipe(Schema.Array)

packages/core/src/config/plugin/agent.ts

@@ -0,0 +1,66 @@
+export * as ConfigAgentPlugin from "./agent"
+
+import { Effect } from "effect"
+import { AgentV2 } from "../../agent"
+import { Config } from "../../config"
+import { ModelV2 } from "../../model"
+import { PermissionV2 } from "../../permission"
+import { PluginV2 } from "../../plugin"
+
+export const Plugin = PluginV2.define({
+  id: PluginV2.ID.make("config-agent"),
+  effect: Effect.gen(function* () {
+    const agent = yield* AgentV2.Service
+    const config = yield* Config.Service
+    const transform = yield* agent.transform()
+    const files = yield* config.get()
+
+    yield* transform((editor) => {
+      const permissions = new Map<AgentV2.ID, PermissionV2.Ruleset>()
+
+      for (const file of files) {
+        for (const [id, item] of Object.entries(file.info.agents ?? {})) {
+          const agentID = AgentV2.ID.make(id)
+          if (item.disabled) {
+            editor.remove(agentID)
+            permissions.delete(agentID)
+            continue
+          }
+
+          editor.update(agentID, (agent) => {
+            if (item.model !== undefined) {
+              const model = ModelV2.parse(item.model)
+              agent.model = { id: model.modelID, providerID: model.providerID, variant: agent.model?.variant }
+            }
+            if (item.variant !== undefined && agent.model !== undefined) {
+              agent.model.variant = ModelV2.VariantID.make(item.variant)
+            }
+            if (item.options !== undefined) {
+              Object.assign(agent.options.headers, item.options.headers ?? {})
+              Object.assign(agent.options.body, item.options.body ?? {})
+              Object.assign(agent.options.aisdk.provider, item.options.aisdk?.provider ?? {})
+              Object.assign(agent.options.aisdk.request, item.options.aisdk?.request ?? {})
+            }
+            if (item.system !== undefined) agent.system = item.system
+            if (item.description !== undefined) agent.description = item.description
+            if (item.mode !== undefined) agent.mode = item.mode
+            if (item.hidden !== undefined) agent.hidden = item.hidden
+            if (item.color !== undefined) agent.color = item.color
+            if (item.steps !== undefined) agent.steps = item.steps
+          })
+
+          if (item.permissions !== undefined) {
+            permissions.set(agentID, [...(permissions.get(agentID) ?? []), ...item.permissions])
+          }
+        }
+      }
+
+      const global = files.flatMap((file) => file.info.permissions ?? [])
+      for (const current of editor.list()) {
+        editor.update(current.id, (agent) => {
+          agent.permissions.push(...global, ...(permissions.get(current.id) ?? []))
+        })
+      }
+    })
+  }),
+})

packages/core/src/config/plugin/provider.ts

@@ -0,0 +1,95 @@
+export * as ConfigProviderPlugin from "./provider"
+
+import { Effect } from "effect"
+import { Catalog } from "../../catalog"
+import { Config } from "../../config"
+import { ModelV2 } from "../../model"
+import { PluginV2 } from "../../plugin"
+import { ProviderV2 } from "../../provider"
+
+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 transform = yield* catalog.transform()
+    const files = yield* config.get()
+
+    yield* transform((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
+            if (item.env !== undefined) provider.env = [...item.env]
+            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.api_id !== undefined) model.apiID = config.api_id
+              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 = (Array.isArray(config.cost) ? config.cost : [config.cost]).map((cost) => ({
+                  tier: cost.tier && { ...cost.tier },
+                  input: cost.input,
+                  output: cost.output,
+                  cache: {
+                    read: cost.cache?.read ?? 0,
+                    write: cost.cache?.write ?? 0,
+                  },
+                }))
+              }
+              if (config.disabled !== undefined) model.enabled = !config.disabled
+              if (config.limit !== undefined) model.limit = { ...model.limit, ...config.limit }
+            })
+          }
+        }
+      }
+    })
+  }),
+})

packages/core/src/config/provider.ts

@@ -0,0 +1,62 @@
+export * as ConfigProvider from "./provider"
+
+import { Schema } from "effect"
+import { ProviderV2 } from "../provider"
+import { ModelV2 } from "../model"
+
+export class Options extends Schema.Class<Options>("ConfigV2.Provider.Options")({
+  headers: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
+  body: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
+  aisdk: Schema.Struct({
+    provider: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
+    request: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
+  }).pipe(Schema.optional),
+}) {}
+
+class Cache extends Schema.Class<Cache>("ConfigV2.Model.Cost.Cache")({
+  read: Schema.Finite.pipe(Schema.optional),
+  write: Schema.Finite.pipe(Schema.optional),
+}) {}
+
+class Cost extends Schema.Class<Cost>("ConfigV2.Model.Cost")({
+  tier: Schema.Struct({
+    type: Schema.Literal("context"),
+    size: Schema.Int,
+  }).pipe(Schema.optional),
+  input: Schema.Finite,
+  output: Schema.Finite,
+  cache: Cache.pipe(Schema.optional),
+}) {}
+
+class Limit extends Schema.Class<Limit>("ConfigV2.Model.Limit")({
+  context: Schema.Int.pipe(Schema.optional),
+  input: Schema.Int.pipe(Schema.optional),
+  output: Schema.Int.pipe(Schema.optional),
+}) {}
+
+class Model extends Schema.Class<Model>("ConfigV2.Model")({
+  api_id: 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({
+    ...Options.fields,
+    variant: Schema.String.pipe(Schema.optional),
+  }).pipe(Schema.optional),
+  variants: Schema.Struct({
+    id: ModelV2.VariantID,
+    ...Options.fields,
+  }).pipe(Schema.Array, Schema.optional),
+  cost: Schema.Union([Cost, Cost.pipe(Schema.Array)]).pipe(Schema.optional),
+  disabled: Schema.Boolean.pipe(Schema.optional),
+  limit: Limit.pipe(Schema.optional),
+}) {}
+
+export class Info extends Schema.Class<Info>("ConfigV2.Provider")({
+  name: Schema.String.pipe(Schema.optional),
+  env: Schema.String.pipe(Schema.Array, Schema.optional),
+  endpoint: ProviderV2.Endpoint.pipe(Schema.optional),
+  options: Options.pipe(Schema.optional),
+  models: Schema.Record(Schema.String, Model).pipe(Schema.optional),
+}) {}

packages/core/src/config/reference.ts

@@ -0,0 +1,17 @@
+export * as ConfigReference from "./reference"
+
+import { Schema } from "effect"
+
+export class Git extends Schema.Class<Git>("ConfigV2.Reference.Git")({
+  repository: Schema.String,
+  branch: Schema.String.pipe(Schema.optional),
+}) {}
+
+export class Local extends Schema.Class<Local>("ConfigV2.Reference.Local")({
+  path: Schema.String,
+}) {}
+
+export const Entry = Schema.Union([Schema.String, Git, Local])
+export type Entry = typeof Entry.Type
+
+export const Info = Schema.Record(Schema.String, Entry)

packages/core/src/config/tool-output.ts

@@ -0,0 +1,9 @@
+export * as ConfigToolOutput from "./tool-output"
+
+import { Schema } from "effect"
+import { PositiveInt } from "../schema"
+
+export class Info extends Schema.Class<Info>("ConfigV2.ToolOutput")({
+  max_lines: PositiveInt.pipe(Schema.optional),
+  max_bytes: PositiveInt.pipe(Schema.optional),
+}) {}

packages/core/src/config/watcher.ts

@@ -0,0 +1,7 @@
+export * as ConfigWatcher from "./watcher"
+
+import { Schema } from "effect"
+
+export class Info extends Schema.Class<Info>("ConfigV2.Watcher")({
+  ignore: Schema.String.pipe(Schema.Array, Schema.optional),
+}) {}