feat(core): flatten image config to experimental.image_model

Author: rekram1-node

packages/client/src/promise/generated/types.ts

@@ -495,14 +495,14 @@ function normalizeExperimental(
         )
         if (value !== undefined) result.media_blob = value
       }
-      if (own(experimental, "image_generation")) {
+      if (own(experimental, "image_model")) {
         const value = decodeEncoded(
-          ConfigExperimental.Info.fields.image_generation,
-          experimental.image_generation,
-          ["experimental", "image_generation"],
+          ConfigExperimental.Info.fields.image_model,
+          experimental.image_model,
+          ["experimental", "image_model"],
           diagnostics,
         )
-        if (value !== undefined) result.image_generation = value
+        if (value !== undefined) result.image_model = value
       }
       if (own(experimental, "schedules")) {
         const value = decodeEncoded(

packages/core/src/config/normalize.ts

@@ -84,8 +84,7 @@ export const Plugin = {
       const available = yield* models.available(["image"])
       if (!input) {
         // A configured default is a preference: when it can't serve this call, pick automatically and say so.
-        const settings = settingsFrom(yield* config.entries())
-        const configured = settings ? settings.model : undefined
+        const configured = configuredModel(yield* config.entries())
         const preferred = configured
           ? available.find((model) => model.providerID === configured.providerID && model.id === configured.model)
           : undefined
@@ -224,11 +223,9 @@ export const Plugin = {
         Effect.catchTag("Environment.NotFound", () => Effect.succeed(false)),
       )
 
-    // Registered only while an image model is available and config doesn't turn the tool off, re-evaluated
-    // whenever either changes. Subscribing before the first read keeps a change in between from being missed.
-    const wanted = Effect.all([config.entries(), models.available(["image"])]).pipe(
-      Effect.map(([entries, available]) => settingsFrom(entries) !== false && available.length > 0),
-    )
+    // Registered only while an image model is available, re-evaluated whenever the catalog changes.
+    // Subscribing before the first read keeps a change in between from being missed.
+    const wanted = models.available(["image"]).pipe(Effect.map((available) => available.length > 0))
     let enabled = false
     const refresh = wanted.pipe(
       Effect.flatMap((next) => {
@@ -237,7 +234,7 @@ export const Plugin = {
         return ctx.tool.reload()
       }),
     )
-    yield* ctx.event.subscribe({ types: ["model.updated", "config.updated"] }).pipe(
+    yield* ctx.event.subscribe({ types: ["model.updated"] }).pipe(
       Stream.runForEach(() => refresh),
       Effect.forkScoped({ startImmediately: true }),
     )
@@ -379,10 +376,10 @@ export function defaultModel(
 }
 
 // Read per field so a later config that sets other experimental options doesn't hide this one.
-function settingsFrom(entries: readonly Entry[]) {
+function configuredModel(entries: readonly Entry[]) {
   return entries.findLast(
-    (entry): entry is Document => entry.type === "document" && entry.info.experimental?.image_generation !== undefined,
-  )?.info.experimental?.image_generation
+    (entry): entry is Document => entry.type === "document" && entry.info.experimental?.image_model !== undefined,
+  )?.info.experimental?.image_model
 }
 
 function acceptsImages(model: Model.Info) {

packages/core/src/tool/plugin/image-generate.ts

@@ -545,7 +545,7 @@ describe("ConfigNormalize", () => {
           todo: true,
           background_compaction: true,
           media_blob: true,
-          image_generation: { model: "openai/gpt-image-2" },
+          image_model: "openai/gpt-image-2",
           subagent_depth: 0,
           location_idle_timeout: "2 hours",
           policies: [{ action: "provider.use", resource: "custom", effect: "allow" }],
@@ -557,7 +557,7 @@ describe("ConfigNormalize", () => {
         todo: true,
         background_compaction: true,
         media_blob: true,
-        image_generation: { model: { providerID: "openai", model: "gpt-image-2" } },
+        image_model: { providerID: "openai", model: "gpt-image-2" },
         subagent_depth: 0,
         location_idle_timeout: "7200000 millis",
       },
@@ -571,18 +571,15 @@ describe("ConfigNormalize", () => {
     })
   })
 
-  test("normalizes the image generation setting", () => {
-    expect(normalized({ experimental: { image_generation: false } }).encoded.experimental).toEqual({
-      image_generation: false,
+  test("normalizes the image model setting", () => {
+    expect(normalized({ experimental: { image_model: "openai/gpt-image-2#hd" } }).encoded.experimental).toEqual({
+      image_model: { providerID: "openai", model: "gpt-image-2", variant: "hd" },
     })
-    expect(normalized({ experimental: { image_generation: {} } }).encoded.experimental).toEqual({
-      image_generation: {},
-    })
-    for (const value of [true, { model: "no-slash" }, { model: 1 }, "openai/gpt-image-2"]) {
-      const result = normalized({ experimental: { image_generation: value } })
+    for (const value of [false, true, "no-slash", 1, { model: "openai/gpt-image-2" }]) {
+      const result = normalized({ experimental: { image_model: value } })
       expect(result.encoded.experimental).toBeUndefined()
       expect(result.diagnostics.map((item) => [item.kind, item.path])).toEqual([
-        ["invalid", ["experimental", "image_generation"]],
+        ["invalid", ["experimental", "image_model"]],
       ])
     }
   })

packages/core/test/config/normalization.test.ts

@@ -128,21 +128,22 @@ const setup = (providerID = "test") =>
     return { session, run, notice, directory: location.directory }
   })
 
-const configure = (image_generation: ConfigExperimental.Info["image_generation"]) =>
+const configure = (image_model: ConfigExperimental.Info["image_model"]) =>
   Effect.gen(function* () {
     const config = yield* Config.Test
     yield* config.setEntries([
       new Document({
         type: "document",
-        info: new Info({ experimental: new ConfigExperimental.Info({ image_generation }) }),
+        info: new Info({ experimental: new ConfigExperimental.Info({ image_model }) }),
       }),
     ])
     const bus = yield* Bus.Service
     yield* bus.publish(Event.Updated, {})
   })
 
 const configuredModel = (providerID: string, model: string) => ({
-  model: { providerID: Provider.ID.make(providerID), model: Model.ID.make(model) },
+  providerID: Provider.ID.make(providerID),
+  model: Model.ID.make(model),
 })
 
 const registered = Tool.Service.use((registry) => toolDefinitions(registry)).pipe(
@@ -172,19 +173,6 @@ describe("image_generate", () => {
     }),
   )
 
-  it.live("is not registered while config turns it off", () =>
-    Effect.gen(function* () {
-      yield* imageModel("test", "painter")
-      yield* configure(false)
-      yield* setup()
-      expect(yield* registered).toBe(false)
-      yield* configure({})
-      expect(yield* until(true)).toBe(true)
-      yield* configure(false)
-      expect(yield* until(false)).toBe(false)
-    }),
-  )
-
   it.live("uses the configured model unless the agent picks one, and falls back with a note", () =>
     Effect.gen(function* () {
       yield* imageModel("test", "painter", (model) => {
@@ -386,23 +374,19 @@ describe("image_generate", () => {
       )
 
       yield* configure({
-        model: {
-          providerID: Provider.ID.make("test"),
-          model: Model.ID.make("painter"),
-          variant: Model.VariantID.make("hd"),
-        },
+        providerID: Provider.ID.make("test"),
+        model: Model.ID.make("painter"),
+        variant: Model.VariantID.make("hd"),
       })
       const configured = yield* run({ prompt: "x" })
       expect(configured.output).toMatchObject({ model: "test/painter#hd" })
       yield* notice(configured)
       expect(fixture.requests.at(-1)?.model.variant).toBe(Model.VariantID.make("hd"))
 
       yield* configure({
-        model: {
-          providerID: Provider.ID.make("test"),
-          model: Model.ID.make("painter"),
-          variant: Model.VariantID.make("bogus"),
-        },
+        providerID: Provider.ID.make("test"),
+        model: Model.ID.make("painter"),
+        variant: Model.VariantID.make("bogus"),
       })
       const fallback = yield* run({ prompt: "x" })
       expect(text(fallback)).toContain('test/painter#bogus has no variant "bogus"; used ')

packages/core/test/tool-image-generate.test.ts

@@ -20,15 +20,10 @@ export class Info extends Schema.Class<Info>("ConfigExperimental.Info")({
     description:
       "Store new session media once in a deduplicated blob table instead of inline in every message row. Defaults to false.",
   }),
-  image_generation: Schema.Union([
-    Schema.Literal(false),
-    Schema.Struct({ model: ConfigModel.Selection.pipe(optional) }),
-  ])
-    .pipe(optional)
-    .annotate({
-      description:
-        "Image generation tool settings. `model` sets the default image model (providerID/modelID) used when the agent doesn't choose one; set to false to disable the image_generate tool.",
-    }),
+  image_model: ConfigModel.Selection.pipe(optional).annotate({
+    description:
+      "Default model for the image_generate tool when the agent doesn't choose one, as providerID/modelID. Falls back to automatic selection when it isn't available.",
+  }),
   schedules: Schema.Boolean.pipe(optional).annotate({
     description: "Enable experimental scheduled tasks that wake a session with a prompt. Defaults to false.",
   }),