clanka 0.5.2 → 0.6.0

package/src/Agent.ts

@@ -12,9 +12,12 @@ import type * as HttpClient from "effect/unstable/http/HttpClient"
 import type {
   CurrentDirectory,
   DirectoryChanger,
+  ImageAttacher,
+  ImageAttachment,
   SubagentExecutor,
   TaskCompleter,
 } from "./AgentTools.ts"
+import * as Image from "./Image.ts"
 import type * as FileSystem from "effect/FileSystem"
 import * as Prompt from "effect/unstable/ai/Prompt"
 import * as Effect from "effect/Effect"
@@ -197,6 +200,13 @@ ${content}
     // `inputTokens.total` from the most recent finish part; undefined until
     // the first response and after every compaction.
     let lastContextTokens: number | undefined = undefined
+    // Images stay in the Prompt; this only decides whether they are sent.
+    // Starts false for models known not to take images, and flips to false
+    // after a provider rejects image input once.
+    let sendImages = modelConfig.supportsImages !== false
+    // Images attached by `readFile` during the current script, spliced onto
+    // the Prompt as a user message once the tool result has been recorded.
+    const pendingImages: Array<ImageAttachment> = []
 
     const output = yield* Queue.make<Output, AgentFinished | AiError.AiError>()
     let inputTokens = 0
@@ -386,6 +396,10 @@ ${content}
             Effect.sync(() => {
               finalSummary = Option.some(summary)
             }),
+          onImage: (image) =>
+            Effect.sync(() => {
+              pendingImages.push(image)
+            }),
         }),
         Stream.mkString,
       )
@@ -454,12 +468,21 @@ ${content}
 
         // oxlint-disable-next-line typescript/no-explicit-any
         let response = Array.empty<Response.StreamPart<any>>()
+        const discardAttempt = () => {
+          response = []
+          pendingImages.length = 0
+        }
         let reasoningStarted = false
         let hadReasoningDelta = false
         let hadToolCall = false
         const runModel = pipe(
           Stream.suspend(() =>
-            ai.streamText({ prompt: prompt.current, toolkit: singleTool }),
+            ai.streamText({
+              prompt: sendImages
+                ? prompt.current
+                : Image.stripImages(prompt.current),
+              toolkit: singleTool,
+            }),
           ),
           Stream.takeUntil((part) => {
             if (
@@ -555,7 +578,7 @@ ${content}
                     }),
                   }),
                 })
-                response = []
+                discardAttempt()
                 return true
               }
               // Never retry a context-length error as is: the overflow
@@ -575,21 +598,37 @@ ${content}
                   }
                 }
               }
-              response = []
+              discardAttempt()
               return err.isRetryable
             },
             schedule: retryPolicy,
           }),
           Effect.catchTag("TimeoutError", Effect.die),
         )
+        // Unsupported images: drop them from the request and retry once.
+        // The images stay in the Prompt with an omitted note in their place.
+        const attemptWithImageFallback = attempt.pipe(
+          Effect.catchIf(
+            (err): err is AiError.AiError =>
+              sendImages &&
+              Image.hasImages(prompt.current) &&
+              Image.isUnsupportedImageError(err),
+            (err) => {
+              sendImages = false
+              discardAttempt()
+              maybeSend({ agentId, part: new ErrorRetry({ error: err }) })
+              return attempt
+            },
+          ),
+        )
         // Overflow: compact once, retry the attempt once, then fail.
-        yield* attempt.pipe(
+        yield* attemptWithImageFallback.pipe(
           Effect.catchIf(
             (err): err is AiError.AiError =>
               Compaction.isContextLengthError(err),
             (err) =>
               Effect.gen(function* () {
-                response = []
+                discardAttempt()
                 const compacted = yield* compactWithEvents(
                   "overflow",
                   Compaction.compact({
@@ -605,7 +644,9 @@ ${content}
                     Effect.catchTag("TimeoutError", Effect.die),
                   ),
                 )
-                return Option.isSome(compacted) ? yield* attempt : yield* err
+                return Option.isSome(compacted)
+                  ? yield* attemptWithImageFallback
+                  : yield* err
               }),
           ),
         )
@@ -613,6 +654,16 @@ ${content}
           prompt,
           Prompt.concat(Prompt.fromResponseParts(response)),
         )
+        if (pendingImages.length > 0) {
+          // After the tool result, so call / result pairing stays intact.
+          MutableRef.update(
+            prompt,
+            Prompt.concat(
+              Prompt.fromMessages([Image.userMessage(pendingImages)]),
+            ),
+          )
+          pendingImages.length = 0
+        }
         if (conversationMode && !hadToolCall && pendingMessages.size === 0) {
           finalSummary = Option.some(responseToSummary(response))
         }
@@ -793,7 +844,11 @@ export const layerLocal = <Toolkit extends Toolkit.Any = never>(options: {
       Toolkit extends Toolkit.Toolkit<infer T>
         ? Tool.HandlersFor<T> | Tool.HandlerServices<T[keyof T]>
         : never,
-      CurrentDirectory | DirectoryChanger | SubagentExecutor | TaskCompleter
+      | CurrentDirectory
+      | DirectoryChanger
+      | SubagentExecutor
+      | TaskCompleter
+      | ImageAttacher
     >
 > => layer.pipe(Layer.provide(AgentExecutor.layerLocal(options)))
 
@@ -870,6 +925,13 @@ export class AgentModelConfig extends Context.Reference<{
         effect: Effect.Effect<A, E, R>,
       ) => Effect.Effect<A, E, R>)
     | undefined
+  /**
+   * `false` for models known not to take image input: image parts are
+   * stripped before every request. Leave unset when unknown; the Agent then
+   * sends images and retries once without them if the provider rejects
+   * them.
+   */
+  readonly supportsImages?: boolean | undefined
 }>("clanka/Agent/SystemPromptTransform", {
   defaultValue: () => ({}),
 }) {

package/src/AgentExecutor.ts

@@ -11,9 +11,12 @@ import {
   AgentToolsWithSearch,
   CurrentDirectory,
   DirectoryChanger,
+  ImageAttacher,
+  type ImageAttachment,
   SubagentExecutor,
   TaskCompleter,
 } from "./AgentTools.ts"
+import * as Image from "./Image.ts"
 import { ToolkitRenderer } from "./ToolkitRenderer.ts"
 import * as AgentSkills from "./AgentSkills.ts"
 import type * as ChildProcessSpawner from "effect/unstable/process/ChildProcessSpawner"
@@ -56,6 +59,10 @@ export class AgentExecutor extends Context.Service<
       readonly script: string
       readonly onTaskComplete: (summary: string) => Effect.Effect<void>
       readonly onSubagent: (message: string) => Effect.Effect<string>
+      /**
+       * Receives every image `readFile` attached while the script ran.
+       */
+      readonly onImage: (image: ImageAttachment) => Effect.Effect<void>
     }): Stream.Stream<string>
     executeUnsafe<Tool extends keyof typeof AgentTools.tools>(options: {
       readonly tool: Tool
@@ -101,7 +108,11 @@ export const makeLocal = Effect.fnUntraced(function* <
       Toolkit extends Toolkit.Toolkit<infer T>
         ? Tool.HandlersFor<T> | Tool.HandlerServices<T[keyof T]>
         : never,
-      CurrentDirectory | DirectoryChanger | SubagentExecutor | TaskCompleter
+      | CurrentDirectory
+      | DirectoryChanger
+      | SubagentExecutor
+      | TaskCompleter
+      | ImageAttacher
     >
 > {
   const fs = yield* FileSystem.FileSystem
@@ -145,6 +156,7 @@ export const makeLocal = Effect.fnUntraced(function* <
     readonly script: string
     readonly onTaskComplete: (summary: string) => Effect.Effect<void>
     readonly onSubagent: (message: string) => Effect.Effect<string>
+    readonly onImage: (image: ImageAttachment) => Effect.Effect<void>
   }) {
     const output = yield* Queue.unbounded<string, Cause.Done>()
     const console = yield* makeConsole(output)
@@ -155,6 +167,7 @@ export const makeLocal = Effect.fnUntraced(function* <
       Context.add(TaskCompleter, opts.onTaskComplete),
       Context.add(DirectoryChanger, changeDirectory),
       Context.add(SubagentExecutor, opts.onSubagent),
+      Context.add(ImageAttacher, opts.onImage),
       Context.add(Console.Console, console),
       Context.add(References.CurrentLogAnnotations, {}),
       Option.isSome(search)
@@ -254,6 +267,8 @@ export const makeLocal = Effect.fnUntraced(function* <
           Context.add(CurrentDirectory, currentDirectory),
           Context.add(DirectoryChanger, changeDirectory),
           Context.add(SubagentExecutor, () => Effect.succeed("")),
+          // Direct tool calls have no model turn to attach images to.
+          Context.add(ImageAttacher, () => Effect.void),
           Context.add(References.CurrentLogAnnotations, {}),
           Option.isSome(search)
             ? Context.add(SemanticSearch, search.value)
@@ -305,6 +320,13 @@ export const makeRpc = Effect.gen(function* () {
                   Effect.forkIn(scope),
                 )
               }
+              case "Image": {
+                return opts.onImage({
+                  fileName: part.fileName,
+                  mediaType: part.mediaType,
+                  data: part.data,
+                })
+              }
             }
           }),
           Stream.orDie,
@@ -337,7 +359,11 @@ export const layerLocal = <Toolkit extends Toolkit.Any = never>(options: {
       Toolkit extends Toolkit.Toolkit<infer T>
         ? Tool.HandlersFor<T> | Tool.HandlerServices<T[keyof T]>
         : never,
-      CurrentDirectory | DirectoryChanger | SubagentExecutor | TaskCompleter
+      | CurrentDirectory
+      | DirectoryChanger
+      | SubagentExecutor
+      | TaskCompleter
+      | ImageAttacher
     >
 > =>
   Layer.effect(AgentExecutor, makeLocal(options)).pipe(
@@ -377,7 +403,11 @@ export const layerRpcServer = <Toolkit extends Toolkit.Any = never>(options: {
       Toolkit extends Toolkit.Toolkit<infer T>
         ? Tool.HandlersFor<T> | Tool.HandlerServices<T[keyof T]>
         : never,
-      CurrentDirectory | DirectoryChanger | SubagentExecutor | TaskCompleter
+      | CurrentDirectory
+      | DirectoryChanger
+      | SubagentExecutor
+      | TaskCompleter
+      | ImageAttacher
     >
 > =>
   RpcServer.layer(Rpcs, {
@@ -433,6 +463,14 @@ export const layerRpcServer = <Toolkit extends Toolkit.Any = never>(options: {
                       })
                     })
                   },
+                  onImage(image) {
+                    return Queue.offer(queue, {
+                      _tag: "Image",
+                      fileName: image.fileName,
+                      mediaType: image.mediaType,
+                      data: image.data,
+                    })
+                  },
                 }),
                 Stream.runForEachArray((parts) => {
                   for (const part of parts) {
@@ -443,6 +481,11 @@ export const layerRpcServer = <Toolkit extends Toolkit.Any = never>(options: {
                   }
                   return Effect.void
                 }),
+                Effect.onExit((exit) =>
+                  Exit.isSuccess(exit)
+                    ? Queue.end(queue)
+                    : Queue.failCause(queue, exit.cause),
+                ),
                 Effect.forkScoped,
               )
 
@@ -466,6 +509,11 @@ export const ExecuteOutput = Schema.TaggedUnion({
   Text: { text: Schema.String },
   TaskComplete: { summary: Schema.String },
   Subagent: { id: Schema.Finite, prompt: Schema.String },
+  Image: {
+    fileName: Schema.String,
+    mediaType: Image.ImageMediaType,
+    data: Schema.Uint8Array,
+  },
 })
 
 /**

package/src/AgentExecutorImage.test.ts

@@ -0,0 +1,103 @@
+import { assert, describe, it } from "@effect/vitest"
+import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer"
+import * as NodeServices from "@effect/platform-node/NodeServices"
+import * as Effect from "effect/Effect"
+import * as Encoding from "effect/Encoding"
+import * as FileSystem from "effect/FileSystem"
+import * as Layer from "effect/Layer"
+import * as Path from "effect/Path"
+import * as Stream from "effect/Stream"
+import * as HttpServer from "effect/unstable/http/HttpServer"
+import * as RpcClient from "effect/unstable/rpc/RpcClient"
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization"
+import * as RpcServer from "effect/unstable/rpc/RpcServer"
+import * as AgentExecutor from "./AgentExecutor.ts"
+import type { ImageAttachment } from "./AgentTools.ts"
+import { equalBytes, supportedImages } from "./fixtures/TestImages.ts"
+
+// Real HTTP transport and NDJSON serialization, not RpcTest's no-codec path.
+const withRpc = <A, E, R>(
+  f: (
+    executor: AgentExecutor.AgentExecutor["Service"],
+  ) => Effect.Effect<A, E, R>,
+) =>
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const path = yield* Path.Path
+    const directory = yield* fs.makeTempDirectoryScoped()
+    for (const [name, data] of fixtures) {
+      yield* fs.writeFile(path.join(directory, name), data)
+    }
+    const { protocol, httpEffect } =
+      yield* RpcServer.makeProtocolWithHttpEffect()
+    yield* Layer.build(
+      AgentExecutor.layerRpcServer({ directory }).pipe(
+        Layer.provide(Layer.succeed(RpcServer.Protocol, protocol)),
+      ),
+    )
+    yield* HttpServer.serveEffect(httpEffect)
+    return yield* Effect.gen(function* () {
+      const executor = yield* AgentExecutor.AgentExecutor
+      return yield* f(executor)
+    }).pipe(
+      Effect.provide(
+        AgentExecutor.layerRpc.pipe(
+          Layer.provide(RpcClient.layerProtocolHttp({ url: "" })),
+        ),
+      ),
+    )
+  }).pipe(
+    Effect.provide(
+      Layer.mergeAll(
+        RpcSerialization.layerNdjson,
+        NodeHttpServer.layerTest,
+        NodeServices.layer,
+      ),
+    ),
+    Effect.scoped,
+  )
+
+const fixtures = supportedImages.map(
+  ({ fileName, data, mediaType }) => [fileName, data, mediaType] as const,
+)
+
+describe("RPC image executor", () => {
+  it.live(
+    "delivers supported images and markers, then completes the RPC stream",
+    () =>
+      withRpc((executor) =>
+        Effect.gen(function* () {
+          const images: Array<ImageAttachment> = []
+          const output = yield* executor
+            .execute({
+              script: fixtures
+                .map(
+                  ([name]) =>
+                    "console.log(await readFile({ path: " +
+                    JSON.stringify(name) +
+                    " }))",
+                )
+                .join(";"),
+              onImage: (image) =>
+                Effect.sync(() => {
+                  images.push(image)
+                }),
+              onTaskComplete: () => Effect.void,
+              onSubagent: () => Effect.succeed(""),
+            })
+            .pipe(Stream.runCollect, Effect.timeout("5 seconds"))
+          assert.strictEqual(images.length, fixtures.length)
+          for (const [index, [name, bytes, mediaType]] of fixtures.entries()) {
+            const image = images[index]!
+            assert.strictEqual(image.fileName, name)
+            assert.strictEqual(image.mediaType, mediaType)
+            assert.instanceOf(image.data, Uint8Array)
+            assert.isTrue(equalBytes(image.data, bytes))
+            assert.include(output.join(""), "Image attached: " + name)
+            assert.notInclude(output.join(""), Encoding.encodeBase64(bytes))
+          }
+          assert.notInclude(output.join(""), "data:image/")
+        }),
+      ),
+  )
+})

package/src/AgentImage.test.ts

@@ -0,0 +1,295 @@
+import { assert, describe, it } from "@effect/vitest"
+import * as Duration from "effect/Duration"
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as Stream from "effect/Stream"
+import * as AiError from "effect/unstable/ai/AiError"
+import * as LanguageModel from "effect/unstable/ai/LanguageModel"
+import * as Model from "effect/unstable/ai/Model"
+import type * as Prompt from "effect/unstable/ai/Prompt"
+import type * as Response from "effect/unstable/ai/Response"
+import * as Agent from "./Agent.ts"
+import * as AgentExecutor from "./AgentExecutor.ts"
+import { tinyPng } from "./fixtures/TestImages.ts"
+
+const capabilities = new AgentExecutor.Capabilities({
+  toolsDts: "",
+  agentsMd: Option.none(),
+  supportsSearch: false,
+  skills: [],
+})
+
+const makeExecutor = (
+  execute: AgentExecutor.AgentExecutor["Service"]["execute"] = () =>
+    Stream.empty,
+) =>
+  AgentExecutor.AgentExecutor.of({
+    capabilities: Effect.succeed(capabilities),
+    execute,
+    executeUnsafe: () => Effect.die("executeUnsafe not implemented"),
+  })
+
+interface RecordedCall {
+  readonly prompt: Prompt.Prompt
+}
+
+const runAgent = (options: {
+  readonly prompt: Prompt.RawInput
+  readonly executor?: AgentExecutor.AgentExecutor["Service"] | undefined
+  readonly modelConfig?: typeof Agent.AgentModelConfig.Service | undefined
+  readonly respond: (
+    call: RecordedCall,
+    index: number,
+  ) => Stream.Stream<Response.StreamPartEncoded, AiError.AiError>
+}) =>
+  Effect.gen(function* () {
+    const calls: Array<RecordedCall> = []
+    const languageModel = yield* LanguageModel.make({
+      generateText: () => Effect.succeed([]),
+      streamText: (providerOptions) => {
+        const call = { prompt: providerOptions.prompt }
+        const index = calls.push(call) - 1
+        return options.respond(call, index)
+      },
+    })
+    const modelLayer = Layer.mergeAll(
+      Layer.succeed(LanguageModel.LanguageModel, languageModel),
+      Layer.succeed(Model.ProviderName, "test-provider"),
+      Layer.succeed(Model.ModelName, "test-model"),
+    )
+    const agent = yield* Agent.make.pipe(
+      Effect.provideService(
+        AgentExecutor.AgentExecutor,
+        options.executor ?? makeExecutor(),
+      ),
+    )
+    const exit = yield* agent.send({ prompt: options.prompt }).pipe(
+      Effect.flatMap((stream) =>
+        stream.pipe(
+          Stream.runDrain,
+          Effect.as(""),
+          Effect.catchTag("AgentFinished", (finished) =>
+            Effect.succeed(finished.summary),
+          ),
+        ),
+      ),
+      Effect.provide(
+        Layer.mergeAll(
+          modelLayer,
+          Agent.ConversationMode.layer(true),
+          Agent.layerSubagentModel(modelLayer),
+          Agent.AgentModelConfig.layer(options.modelConfig ?? {}),
+          Layer.succeed(Agent.TurnTimeout, Duration.minutes(5)),
+        ),
+      ),
+      Effect.exit,
+    )
+    return { exit, calls, history: agent.history.current }
+  }).pipe(Effect.scoped)
+
+const text = (content: string): Array<Response.StreamPartEncoded> => [
+  { type: "text-start", id: "t" },
+  { type: "text-delta", id: "t", delta: content },
+  { type: "text-end", id: "t" },
+]
+
+const toolCall = (id: string, script: string): Response.StreamPartEncoded => ({
+  type: "tool-call",
+  id,
+  name: "execute",
+  params: { script },
+})
+
+/** A user turn with a caption and a screenshot, as ACP ingest would build. */
+const imagePrompt: Prompt.RawInput = [
+  {
+    role: "user",
+    content: [
+      { type: "text", text: "what is in this screenshot?" },
+      {
+        type: "file",
+        mediaType: "image/png",
+        fileName: "shot.png",
+        data: tinyPng,
+      },
+    ],
+  },
+]
+
+const fileParts = (prompt: Prompt.Prompt): Array<Prompt.FilePart> =>
+  prompt.content.flatMap((message) =>
+    message.role === "user"
+      ? message.content.filter((part) => part.type === "file")
+      : [],
+  )
+
+const userText = (prompt: Prompt.Prompt): string =>
+  prompt.content
+    .flatMap((message) =>
+      message.role === "user"
+        ? message.content.flatMap((part) =>
+            part.type === "text" ? [part.text] : [],
+          )
+        : [],
+    )
+    .join("\n")
+
+const omittedNote = /\[image: shot\.png omitted\]/
+
+/** Mirrors the OpenAI rejection for image input on a text-only model. */
+const unsupportedImageError = AiError.make({
+  module: "OpenAiLanguageModel",
+  method: "streamText",
+  reason: new AiError.InvalidRequestError({
+    description:
+      "Invalid content type. image_url is only supported by certain models. (POST https://api.openai.com/v1/responses) [code: invalid_value]",
+  }),
+})
+
+const unrelatedError = AiError.make({
+  module: "OpenAiLanguageModel",
+  method: "streamText",
+  reason: new AiError.InvalidRequestError({
+    description:
+      "Unsupported parameter: 'temperature' is not supported with this model. (POST https://api.openai.com/v1/responses)",
+  }),
+})
+
+describe("Agent images", () => {
+  it.effect(
+    "strips images and leaves an omitted note for a model known not to take images",
+    () =>
+      Effect.gen(function* () {
+        const { exit, calls } = yield* runAgent({
+          prompt: imagePrompt,
+          modelConfig: { supportsImages: false },
+          respond: () => Stream.fromIterable(text("I cannot see images.")),
+        })
+        assert.isTrue(Exit.isSuccess(exit))
+        assert.strictEqual(calls.length, 1)
+        assert.strictEqual(fileParts(calls[0]!.prompt).length, 0)
+        const prompt = userText(calls[0]!.prompt)
+        assert.include(prompt, "what is in this screenshot?")
+        assert.match(prompt, omittedNote)
+      }),
+  )
+
+  it.effect(
+    "retries without images and discards attachments from the failed attempt",
+    () =>
+      Effect.gen(function* () {
+        const attached = yield* Deferred.make<void>()
+        let executions = 0
+        const executor = makeExecutor(({ onImage }) =>
+          Stream.fromEffect(
+            Effect.gen(function* () {
+              executions++
+              yield* onImage({
+                data: tinyPng,
+                mediaType: "image/png",
+                fileName: executions === 1 ? "discarded.png" : "shot.png",
+              })
+              yield* Deferred.succeed(attached, undefined)
+              return "Image attached"
+            }),
+          ),
+        )
+        const { exit, calls, history } = yield* runAgent({
+          prompt: imagePrompt,
+          executor,
+          respond: (_, index) =>
+            index === 0
+              ? Stream.make(
+                  toolCall("discarded", 'await readFile({ path: "shot.png" })'),
+                ).pipe(
+                  // Advance past the tool-call chunk so its handler starts.
+                  Stream.concat(
+                    Stream.make({ type: "text-start", id: "failed" } as const),
+                  ),
+                  Stream.concat(
+                    Stream.fromEffect(
+                      Deferred.await(attached).pipe(
+                        Effect.andThen(Effect.fail(unsupportedImageError)),
+                      ),
+                    ),
+                  ),
+                )
+              : index === 1
+                ? Stream.make(
+                    toolCall("retried", 'await readFile({ path: "shot.png" })'),
+                  )
+                : Stream.fromIterable(text("Text only, but I tried.")),
+        })
+        assert.isTrue(Exit.isSuccess(exit))
+        assert.strictEqual(calls.length, 3)
+        assert.strictEqual(executions, 2)
+        assert.deepStrictEqual(
+          fileParts(history).map((part) => part.fileName),
+          ["shot.png", "shot.png"],
+        )
+        assert.strictEqual(fileParts(calls[0]!.prompt).length, 1)
+        assert.strictEqual(fileParts(calls[1]!.prompt).length, 0)
+        const retried = userText(calls[1]!.prompt)
+        assert.include(retried, "what is in this screenshot?")
+        assert.match(retried, omittedNote)
+      }),
+  )
+
+  it.effect("does not retry when the provider rejects it a second time", () =>
+    Effect.gen(function* () {
+      const { exit, calls } = yield* runAgent({
+        prompt: imagePrompt,
+        respond: () => Stream.fail(unsupportedImageError),
+      })
+      assert.isTrue(Exit.isFailure(exit))
+      assert.strictEqual(calls.length, 2)
+    }),
+  )
+
+  it.effect(
+    "does not treat other invalid-request errors as image rejections",
+    () =>
+      Effect.gen(function* () {
+        const { exit, calls } = yield* runAgent({
+          prompt: imagePrompt,
+          respond: () => Stream.fail(unrelatedError),
+        })
+        assert.isTrue(Exit.isFailure(exit))
+        assert.strictEqual(calls.length, 1)
+      }),
+  )
+
+  it.effect("does not copy image bytes into a delegate prompt", () =>
+    Effect.gen(function* () {
+      const executor = makeExecutor(({ onSubagent }) =>
+        Stream.fromEffect(onSubagent("child task: describe the layout")),
+      )
+      const { exit, calls } = yield* runAgent({
+        prompt: imagePrompt,
+        executor,
+        respond: (call, index) => {
+          if (index === 0) {
+            return Stream.make(
+              toolCall("call-1", 'await delegate("describe the layout")'),
+            )
+          }
+          const isChild = userText(call.prompt).includes("child task")
+          return Stream.fromIterable(
+            text(isChild ? "child done" : "parent done"),
+          )
+        },
+      })
+      assert.isTrue(Exit.isSuccess(exit))
+      const child = calls.find((call) =>
+        userText(call.prompt).includes("child task"),
+      )
+      assert.isDefined(child, "the delegate call reached the model")
+      assert.strictEqual(fileParts(child!.prompt).length, 0)
+      // The parent still has its image.
+      assert.strictEqual(fileParts(calls[0]!.prompt).length, 1)
+    }),
+  )
+})