opencode-discord-bot 0.0.1

package/src/Opencode/EventMapping.test.ts

@@ -0,0 +1,188 @@
+import { describe, expect, test } from "bun:test"
+import { Effect, Stream } from "effect"
+import { decodeOpencodeEvent, opencodeEventStream } from "./EventMapping.ts"
+
+describe("opencode event mapping", () => {
+  test("maps lifecycle, text delta, snapshot, tool, changed-file, and error events", async () => {
+    const events = await Effect.runPromise(
+      opencodeEventStream(
+        Stream.fromIterable([
+          { id: "e1", type: "session.idle", properties: { sessionID: "s1" } },
+          { id: "e2", type: "session.next.reasoning.delta", properties: { delta: "thinking" } },
+          { id: "e3", type: "session.next.text.delta", properties: { delta: "hello" } },
+          { id: "e4", type: "session.next.text.ended", properties: { text: "snapshot" } },
+          {
+            id: "e5-role",
+            type: "message.updated",
+            properties: { sessionID: "s1", info: { id: "assistant-message", role: "assistant" } }
+          },
+          {
+            id: "e5",
+            type: "message.part.delta",
+            properties: { messageID: "assistant-message", part: { messageID: "assistant-message", type: "text" }, delta: " fallback" }
+          },
+          {
+            id: "e6",
+            type: "message.part.updated",
+            properties: { part: { messageID: "assistant-message", type: "text", text: "updated" } }
+          },
+          { id: "e7", type: "session.next.tool.called", properties: { tool: "Running tests" } },
+          { id: "e8", type: "session.next.tool.success", properties: {} },
+          { id: "e9", type: "session.next.tool.failed", properties: { error: { message: "tool failed" } } },
+          { id: "e10", type: "session.next.step.started", properties: { step: { type: "tool", title: "Editing file" } } },
+          { id: "e11", type: "session.next.step.ended", properties: {} },
+          { id: "e12", type: "session.diff", properties: { diff: [{ path: "a.ts" }, { path: "b.ts" }] } },
+          { id: "e13", type: "session.error", properties: { error: { message: "boom" } } }
+        ])
+      ).pipe(Stream.runCollect)
+    )
+
+    expect(events).toEqual([
+      { type: "idle" },
+      { type: "text-delta", text: "hello" },
+      { type: "text-snapshot", text: "snapshot" },
+      { type: "text-delta", text: " fallback" },
+      { type: "text-snapshot", text: "updated" },
+      { type: "tool-start", title: "Running tests" },
+      { type: "tool-end" },
+      { type: "error", message: "tool failed" },
+      { type: "tool-start", title: "Editing file" },
+      { type: "tool-end" },
+      { type: "changed-files", files: 2, insertions: 0, deletions: 0 },
+      { type: "error", message: "boom" }
+    ])
+  })
+
+  test("ignores unknown or non-text event payloads", () => {
+    expect(decodeOpencodeEvent({ type: "unknown" })).toBeUndefined()
+    expect(decodeOpencodeEvent({ type: "session.next.reasoning.delta", properties: { delta: "hidden" } })).toBeUndefined()
+    expect(decodeOpencodeEvent({ type: "message.part.delta", part: { type: "reasoning" }, delta: "hidden" })).toBeUndefined()
+  })
+
+  test("maps wrapped SDK events and delta-bearing part updates", () => {
+    expect(
+      decodeOpencodeEvent({
+        directory: "/repo",
+        payload: { id: "e1", type: "session.next.text.delta", properties: { sessionID: "s1", delta: "wrapped" } }
+      })
+    ).toEqual({ type: "text-delta", text: "wrapped" })
+    expect(
+      decodeOpencodeEvent({
+        type: "message.part.updated",
+        properties: { sessionID: "s1", part: { type: "text", text: "hello" }, delta: "lo" }
+      })
+    ).toBeUndefined()
+    expect(
+      decodeOpencodeEvent(
+        {
+          type: "message.part.updated",
+          properties: { sessionID: "s1", part: { type: "text", text: "hello" }, delta: "lo" }
+        },
+        { includeGenericMessageParts: true }
+      )
+    ).toEqual({ type: "text-delta", text: "lo" })
+    expect(
+      decodeOpencodeEvent({ type: "message.part.delta", properties: { sessionID: "s1", field: "reasoning", delta: "hidden" } })
+    ).toBeUndefined()
+    expect(
+      decodeOpencodeEvent(
+        { type: "message.part.delta", properties: { sessionID: "s1", field: "text", delta: "ambiguous" } },
+        { includeGenericMessageParts: true }
+      )
+    ).toBeUndefined()
+  })
+
+  test("does not render reasoning part text deltas as assistant output", async () => {
+    const events = await Effect.runPromise(
+      opencodeEventStream(
+        Stream.fromIterable([
+          {
+            type: "message.updated",
+            properties: { sessionID: "s1", info: { id: "assistant-message", role: "assistant" } }
+          },
+          {
+            type: "message.part.updated",
+            properties: {
+              sessionID: "s1",
+              part: { id: "reasoning-part", sessionID: "s1", messageID: "assistant-message", type: "reasoning", text: "thinking" }
+            }
+          },
+          {
+            type: "message.part.delta",
+            properties: { sessionID: "s1", messageID: "assistant-message", partID: "reasoning-part", field: "text", delta: " hidden" }
+          },
+          { type: "session.next.text.delta", properties: { sessionID: "s1", delta: "answer" } },
+          { type: "session.idle", properties: { sessionID: "s1" } }
+        ])
+      ).pipe(Stream.runCollect)
+    )
+
+    expect(events).toEqual([{ type: "text-delta", text: "answer" }, { type: "idle" }])
+  })
+
+  test("maps numeric diff and legacy failed-step event shapes", () => {
+    expect(
+      decodeOpencodeEvent({
+        type: "session.diff",
+        properties: {
+          diff: [
+            { additions: 2, deletions: 1 },
+            { additions: 3, deletions: 0 }
+          ]
+        }
+      })
+    ).toEqual({
+      type: "changed-files",
+      files: 2,
+      insertions: 5,
+      deletions: 1
+    })
+    expect(decodeOpencodeEvent({ type: "session.diff", properties: { diff: [] } })).toBeUndefined()
+    expect(decodeOpencodeEvent({ type: "session.diff", properties: { files: 0, insertions: 0, deletions: 0 } })).toBeUndefined()
+    expect(decodeOpencodeEvent({ type: "session.diff", properties: { files: 2, insertions: 5, deletions: 1 } })).toEqual({
+      type: "changed-files",
+      files: 2,
+      insertions: 5,
+      deletions: 1
+    })
+    expect(decodeOpencodeEvent({ type: "session.next.step.finished" })).toEqual({ type: "tool-end" })
+    expect(decodeOpencodeEvent({ type: "session.step.failed", message: "legacy failed" })).toEqual({
+      type: "error",
+      message: "legacy failed"
+    })
+    expect(decodeOpencodeEvent(undefined)).toBeUndefined()
+    expect(decodeOpencodeEvent({ type: "session.diff", files: 1, insertions: 2, deletions: 3 })).toEqual({
+      type: "changed-files",
+      files: 1,
+      insertions: 2,
+      deletions: 3
+    })
+  })
+
+  test("does not render user prompt message parts as assistant output", async () => {
+    const events = await Effect.runPromise(
+      opencodeEventStream(
+        Stream.fromIterable([
+          {
+            type: "message.updated",
+            properties: { sessionID: "s1", info: { id: "user-message", role: "user" } }
+          },
+          {
+            type: "message.part.updated",
+            properties: {
+              sessionID: "s1",
+              part: { id: "user-text", sessionID: "s1", messageID: "user-message", type: "text", text: "Discord bridge context" }
+            }
+          },
+          {
+            type: "session.next.text.ended",
+            properties: { sessionID: "s1", assistantMessageID: "assistant-message", textID: "assistant-text", text: "Normal answer" }
+          },
+          { type: "session.idle", properties: { sessionID: "s1" } }
+        ])
+      ).pipe(Stream.runCollect)
+    )
+
+    expect(events).toEqual([{ type: "text-snapshot", text: "Normal answer" }, { type: "idle" }])
+  })
+})

package/src/Opencode/EventMapping.ts

@@ -0,0 +1,232 @@
+import { Stream } from "effect"
+import type { OpencodeEvent } from "../Schema.ts"
+import {
+  type DecodeOptions,
+  includeGenericMessageParts,
+  includeGenericPartDeltas,
+  initialDecodeState,
+  updateDecodeState
+} from "./EventMappingState.ts"
+import type { OpencodeError } from "./OpencodePort.ts"
+
+const isRecord = (value: unknown): value is Readonly<Record<string, unknown>> =>
+  typeof value === "object" && value !== null && !Array.isArray(value)
+
+const stringField = (record: Readonly<Record<string, unknown>>, key: string): string | undefined => {
+  const value = record[key]
+  return typeof value === "string" ? value : undefined
+}
+
+const numberField = (record: Readonly<Record<string, unknown>>, key: string): number | undefined => {
+  const value = record[key]
+  return typeof value === "number" ? value : undefined
+}
+
+const payloadProperties = (record: Readonly<Record<string, unknown>>): Readonly<Record<string, unknown>> => {
+  const properties = record.properties
+  return isRecord(properties) ? properties : record
+}
+
+const eventPayload = (value: unknown): Readonly<Record<string, unknown>> | undefined => {
+  if (!isRecord(value)) return undefined
+  const payload = value.payload
+  return isRecord(payload) && stringField(payload, "type") !== undefined ? payload : value
+}
+
+const textPart = (value: unknown): Readonly<Record<string, unknown>> | undefined => {
+  if (!isRecord(value)) return undefined
+  return stringField(value, "type") === "text" ? value : undefined
+}
+
+const errorMessage = (value: unknown): string => {
+  if (!isRecord(value)) return "Unknown opencode error"
+  const properties = payloadProperties(value)
+  const nested = properties.error
+  if (isRecord(nested)) {
+    const data = nested.data
+    if (isRecord(data)) return stringField(data, "message") ?? stringField(nested, "message") ?? "Unknown opencode error"
+    return stringField(nested, "message") ?? "Unknown opencode error"
+  }
+  return stringField(properties, "message") ?? stringField(value, "message") ?? "Unknown opencode error"
+}
+
+const toolTitle = (value: unknown): string | undefined => {
+  if (!isRecord(value)) return undefined
+  const properties = payloadProperties(value)
+  const step = properties.step
+  if (!isRecord(step)) return undefined
+  return stringField(step, "type") === "tool" ? stringField(step, "title") : undefined
+}
+
+const toolName = (value: unknown): string | undefined => {
+  if (!isRecord(value)) return undefined
+  const properties = payloadProperties(value)
+  return stringField(properties, "tool") ?? stringField(properties, "title")
+}
+
+const changedFilesFromCounts = (files: number, insertions: number, deletions: number): OpencodeEvent | undefined => {
+  if (files <= 0 && insertions <= 0 && deletions <= 0) return undefined
+  return { type: "changed-files", files, insertions, deletions }
+}
+
+const changedFiles = (value: unknown): OpencodeEvent | undefined => {
+  if (!isRecord(value)) return undefined
+  const properties = payloadProperties(value)
+  const diff = properties.diff
+  if (Array.isArray(diff)) {
+    let insertions = 0
+    let deletions = 0
+    for (const item of diff) {
+      if (!isRecord(item)) continue
+      insertions += numberField(item, "additions") ?? numberField(item, "insertions") ?? 0
+      deletions += numberField(item, "deletions") ?? 0
+    }
+    return changedFilesFromCounts(diff.length, insertions, deletions)
+  }
+  return changedFilesFromCounts(
+    numberField(properties, "files") ?? numberField(value, "files") ?? 0,
+    numberField(properties, "insertions") ?? numberField(properties, "additions") ?? numberField(value, "insertions") ?? 0,
+    numberField(properties, "deletions") ?? numberField(value, "deletions") ?? 0
+  )
+}
+
+const decodeLifecycle = (payload: Readonly<Record<string, unknown>>, type: string | undefined): OpencodeEvent | undefined => {
+  switch (type) {
+    case "session.idle":
+      return { type: "idle" }
+    case "session.error":
+      return { type: "error", message: errorMessage(payload) }
+    case "session.diff":
+      return changedFiles(payload)
+    default:
+      return undefined
+  }
+}
+
+const decodeText = (properties: Readonly<Record<string, unknown>>, type: string | undefined): OpencodeEvent | undefined => {
+  switch (type) {
+    case "session.next.text.delta": {
+      const delta = stringField(properties, "delta")
+      return delta === undefined ? undefined : { type: "text-delta", text: delta }
+    }
+    case "session.next.text.ended": {
+      const text = stringField(properties, "text")
+      return text === undefined ? undefined : { type: "text-snapshot", text }
+    }
+    default:
+      return undefined
+  }
+}
+
+const textDelta = (
+  payload: Readonly<Record<string, unknown>>,
+  properties: Readonly<Record<string, unknown>>
+): OpencodeEvent | undefined => {
+  const delta = stringField(properties, "delta") ?? stringField(payload, "delta")
+  return delta === undefined ? undefined : { type: "text-delta", text: delta }
+}
+
+const decodePartDelta = (
+  payload: Readonly<Record<string, unknown>>,
+  properties: Readonly<Record<string, unknown>>,
+  options: DecodeOptions
+): OpencodeEvent | undefined => {
+  const part = properties.part ?? payload.part
+  if (part !== undefined) return textPart(part) === undefined ? undefined : textDelta(payload, properties)
+  if (options.includeGenericPartDeltas !== true) return undefined
+  return stringField(properties, "field") === "text" ? textDelta(payload, properties) : undefined
+}
+
+const decodePartUpdated = (
+  payload: Readonly<Record<string, unknown>>,
+  properties: Readonly<Record<string, unknown>>
+): OpencodeEvent | undefined => {
+  const part = textPart(properties.part ?? payload.part)
+  if (part === undefined) return undefined
+  const delta = textDelta(payload, properties)
+  if (delta !== undefined) return delta
+  const text = stringField(part, "text")
+  return text === undefined ? undefined : { type: "text-snapshot", text }
+}
+
+const decodePart = (
+  payload: Readonly<Record<string, unknown>>,
+  properties: Readonly<Record<string, unknown>>,
+  type: string | undefined,
+  options: DecodeOptions
+): OpencodeEvent | undefined => {
+  switch (type) {
+    case "message.part.delta": {
+      if (options.includeGenericMessageParts !== true) return undefined
+      return decodePartDelta(payload, properties, options)
+    }
+    case "session.next.message.part.delta":
+      return decodePartDelta(payload, properties, { ...options, includeGenericPartDeltas: true })
+    case "message.part.updated": {
+      if (options.includeGenericMessageParts !== true) return undefined
+      return decodePartUpdated(payload, properties)
+    }
+    case "session.next.message.part.updated":
+      return decodePartUpdated(payload, properties)
+    default:
+      return undefined
+  }
+}
+
+const decodeTool = (payload: Readonly<Record<string, unknown>>, type: string | undefined): OpencodeEvent | undefined => {
+  switch (type) {
+    case "session.next.tool.called": {
+      const title = toolName(payload)
+      return title === undefined ? undefined : { type: "tool-start", title }
+    }
+    case "session.next.tool.success":
+      return { type: "tool-end" }
+    case "session.next.tool.failed":
+      return { type: "error", message: errorMessage(payload) }
+    default:
+      return undefined
+  }
+}
+
+const decodeStep = (payload: Readonly<Record<string, unknown>>, type: string | undefined): OpencodeEvent | undefined => {
+  switch (type) {
+    case "session.next.step.started": {
+      const title = toolTitle(payload)
+      return title === undefined ? undefined : { type: "tool-start", title }
+    }
+    case "session.next.step.finished":
+    case "session.next.step.ended":
+      return { type: "tool-end" }
+    case "session.step.failed":
+    case "session.next.step.failed":
+      return { type: "error", message: errorMessage(payload) }
+    default:
+      return undefined
+  }
+}
+
+export const decodeOpencodeEvent = (payload: unknown, options: DecodeOptions = {}): OpencodeEvent | undefined => {
+  const event = eventPayload(payload)
+  if (event === undefined) return undefined
+  const type = stringField(event, "type")
+  const properties = payloadProperties(event)
+  return (
+    decodeLifecycle(event, type) ??
+    decodeText(properties, type) ??
+    decodePart(event, properties, type, options) ??
+    decodeTool(event, type) ??
+    decodeStep(event, type)
+  )
+}
+
+export const opencodeEventStream = (events: Stream.Stream<unknown, OpencodeError>) =>
+  events.pipe(
+    Stream.mapAccum(initialDecodeState, (state, event) => {
+      const nextState = updateDecodeState(state, event)
+      const decoded = decodeOpencodeEvent(event, {
+        includeGenericMessageParts: includeGenericMessageParts(nextState, event),
+        includeGenericPartDeltas: includeGenericPartDeltas(nextState, event)
+      })
+      return [nextState, decoded === undefined ? [] : [decoded]]
+    })
+  )

package/src/Opencode/EventMappingState.ts

@@ -0,0 +1,97 @@
+type MessageRole = "assistant" | "user"
+
+export type DecodeOptions = {
+  readonly includeGenericMessageParts?: boolean
+  readonly includeGenericPartDeltas?: boolean
+}
+
+type DecodeState = {
+  readonly assistantMessageIds: Set<string>
+  readonly textPartIds: Set<string>
+}
+
+const isRecord = (value: unknown): value is Readonly<Record<string, unknown>> =>
+  typeof value === "object" && value !== null && !Array.isArray(value)
+
+const stringField = (record: Readonly<Record<string, unknown>>, key: string): string | undefined => {
+  const value = record[key]
+  return typeof value === "string" ? value : undefined
+}
+
+const eventPayload = (value: unknown): Readonly<Record<string, unknown>> | undefined => {
+  if (!isRecord(value)) return undefined
+  const payload = value.payload
+  return isRecord(payload) && stringField(payload, "type") !== undefined ? payload : value
+}
+
+const payloadProperties = (record: Readonly<Record<string, unknown>>): Readonly<Record<string, unknown>> => {
+  const properties = record.properties
+  return isRecord(properties) ? properties : record
+}
+
+const genericMessagePartType = (type: string | undefined): boolean => type === "message.part.delta" || type === "message.part.updated"
+
+const messagePart = (value: unknown): Readonly<Record<string, unknown>> | undefined => {
+  const event = eventPayload(value)
+  if (event === undefined || !genericMessagePartType(stringField(event, "type"))) return undefined
+  const properties = payloadProperties(event)
+  const part = properties.part ?? event.part
+  return isRecord(part) ? part : undefined
+}
+
+const partId = (part: Readonly<Record<string, unknown>> | undefined): string | undefined =>
+  part === undefined ? undefined : (stringField(part, "id") ?? stringField(part, "partID") ?? stringField(part, "partId"))
+
+const messagePartField = (value: unknown, primary: string, secondary: string): string | undefined => {
+  const event = eventPayload(value)
+  if (event === undefined || !genericMessagePartType(stringField(event, "type"))) return undefined
+  const properties = payloadProperties(event)
+  const part = properties.part ?? event.part
+  if (isRecord(part)) {
+    const partValue = stringField(part, primary) ?? stringField(part, secondary)
+    if (partValue !== undefined) return partValue
+  }
+  return stringField(properties, primary) ?? stringField(properties, secondary)
+}
+
+const messagePartPartId = (value: unknown): string | undefined => partId(messagePart(value)) ?? messagePartField(value, "partID", "partId")
+
+const messagePartMessageId = (value: unknown): string | undefined => messagePartField(value, "messageID", "messageId")
+
+const messageRole = (value: unknown): MessageRole | undefined => (value === "assistant" || value === "user" ? value : undefined)
+
+const messageRoleUpdate = (value: unknown): { readonly id: string; readonly role: MessageRole } | undefined => {
+  const event = eventPayload(value)
+  if (event === undefined || stringField(event, "type") !== "message.updated") return undefined
+  const info = payloadProperties(event).info
+  if (!isRecord(info)) return undefined
+  const id = stringField(info, "id")
+  const role = messageRole(info.role)
+  return id === undefined || role === undefined ? undefined : { id, role }
+}
+
+export const initialDecodeState = (): DecodeState => ({ assistantMessageIds: new Set(), textPartIds: new Set() })
+
+export const updateDecodeState = (state: DecodeState, value: unknown): DecodeState => {
+  const update = messageRoleUpdate(value)
+  if (update !== undefined) state.assistantMessageIds[update.role === "assistant" ? "add" : "delete"](update.id)
+
+  const part = messagePart(value)
+  const id = partId(part)
+  if (part !== undefined && id !== undefined) state.textPartIds[stringField(part, "type") === "text" ? "add" : "delete"](id)
+  return state
+}
+
+export const includeGenericMessageParts = (state: DecodeState, value: unknown): boolean => {
+  const messageId = messagePartMessageId(value)
+  return messageId !== undefined && state.assistantMessageIds.has(messageId)
+}
+
+export const includeGenericPartDeltas = (state: DecodeState, value: unknown): boolean => {
+  const event = eventPayload(value)
+  if (event === undefined || stringField(event, "type") !== "message.part.delta") return false
+  const part = messagePart(value)
+  if (part !== undefined) return stringField(part, "type") === "text"
+  const id = messagePartPartId(value)
+  return id !== undefined && state.textPartIds.has(id)
+}

package/src/Opencode/MemoryOpencode.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, test } from "bun:test"
+import { Effect, Stream } from "effect"
+import type { DiscordScope } from "../Schema.ts"
+import { makeMemoryOpencode } from "./MemoryOpencode.ts"
+
+const scope: DiscordScope = { guildId: "g1", channelId: "c1", threadId: "t1" }
+
+describe("makeMemoryOpencode", () => {
+  test("records prompts and aborts by Discord scope", async () => {
+    const opencode = makeMemoryOpencode([{ type: "text-delta", text: "ok" }, { type: "idle" }])
+    const events = await Effect.runPromise(opencode.runPrompt({ prompt: "hello", projectDir: "/repo", scope }).pipe(Stream.runCollect))
+    await Effect.runPromise(opencode.abort(scope).pipe(Stream.runCollect))
+
+    expect(events).toEqual([{ type: "text-delta", text: "ok" }, { type: "idle" }])
+    expect(opencode.prompts.map((item) => item.prompt)).toEqual(["hello"])
+    expect(opencode.aborted).toEqual(["t1"])
+  })
+})

package/src/Opencode/MemoryOpencode.ts

@@ -0,0 +1,29 @@
+import { Stream } from "effect"
+import type { OpencodeEvent } from "../Schema.ts"
+import type { OpencodePrompt, OpencodeService } from "./OpencodePort.ts"
+
+export type MemoryOpencode = OpencodeService & {
+  readonly prompts: Array<OpencodePrompt>
+  readonly aborted: Array<string>
+}
+
+const scopeKey = (scope: OpencodePrompt["scope"]) => scope.threadId ?? scope.channelId
+
+export const makeMemoryOpencode = (events: ReadonlyArray<OpencodeEvent>): MemoryOpencode => {
+  const prompts: Array<OpencodePrompt> = []
+  const aborted: Array<string> = []
+
+  return {
+    prompts,
+    aborted,
+    checkHealth: Stream.runDrain(Stream.empty),
+    runPrompt: (input) => {
+      prompts.push(input)
+      return Stream.fromIterable(events)
+    },
+    abort: (scope) => {
+      aborted.push(scopeKey(scope))
+      return Stream.empty
+    }
+  }
+}

package/src/Opencode/OpencodePort.ts

@@ -0,0 +1,30 @@
+import { Context, Data, type Effect, type Stream } from "effect"
+import type { DiscordScope, OpencodeEvent } from "../Schema.ts"
+
+export class OpencodeError extends Data.TaggedError("OpencodeError")<{
+  readonly message: string
+}> {}
+
+export type OpencodePrompt = {
+  readonly prompt: string
+  readonly parts?: ReadonlyArray<OpencodePromptFilePart>
+  readonly projectDir: string
+  readonly scope: DiscordScope
+  readonly model?: string
+  readonly agent?: string
+}
+
+export type OpencodePromptFilePart = {
+  readonly type: "file"
+  readonly mime: string
+  readonly filename?: string
+  readonly url: string
+}
+
+export type OpencodeService = {
+  readonly runPrompt: (input: OpencodePrompt) => Stream.Stream<OpencodeEvent, OpencodeError>
+  readonly abort: (scope: DiscordScope) => Stream.Stream<never, OpencodeError>
+  readonly checkHealth: Effect.Effect<void, OpencodeError>
+}
+
+export const Opencode = Context.Service<OpencodeService>("opencode-discord-bot/Opencode")

package/src/Opencode/PromptParts.ts

@@ -0,0 +1,47 @@
+import { Buffer } from "node:buffer"
+import { Data, Effect } from "effect"
+import type { OpencodePromptFilePart } from "./OpencodePort.ts"
+
+class PromptPartError extends Data.TaggedError("PromptPartError")<{
+  readonly message: string
+}> {}
+
+const causeText = (value: unknown): string => {
+  if (value instanceof Error) return value.message.length === 0 ? causeText(value.cause) : value.message
+  return typeof value === "string" && value.length > 0 ? value : "unknown error"
+}
+
+const isBase64DataUrl = (value: string): boolean => value.startsWith("data:") && /;base64,/i.test(value)
+
+const partLabel = (part: OpencodePromptFilePart): string => part.filename ?? part.url
+
+const imageError = (action: "fetch" | "read", part: OpencodePromptFilePart, detail: string) =>
+  new PromptPartError({ message: `failed to ${action} image attachment ${partLabel(part)}: ${detail}` })
+
+const fetchImagePart = Effect.fn("fetchImagePartDataUrl")(function* (part: OpencodePromptFilePart) {
+  if (!part.mime.startsWith("image/") || isBase64DataUrl(part.url)) return part
+
+  const response = yield* Effect.tryPromise({
+    try: () => fetch(part.url),
+    catch: (cause) => imageError("fetch", part, causeText(cause))
+  })
+  if (!response.ok) {
+    const statusText = response.statusText.length === 0 ? "" : ` ${response.statusText}`
+    return yield* Effect.fail(imageError("fetch", part, `${response.status}${statusText}`))
+  }
+  const buffer = yield* Effect.tryPromise({
+    try: () => response.arrayBuffer(),
+    catch: (cause) => imageError("read", part, causeText(cause))
+  })
+  return { ...part, url: `data:${part.mime};base64,${Buffer.from(buffer).toString("base64")}` }
+})
+
+export const preparePromptParts = Effect.fn("prepareOpencodePromptParts")(function* (
+  parts: ReadonlyArray<OpencodePromptFilePart> | undefined
+) {
+  const prepared: Array<OpencodePromptFilePart> = []
+  for (const part of parts ?? []) {
+    prepared.push(yield* fetchImagePart(part))
+  }
+  return prepared
+})