opencode/packages/core/test/session-runner-message.test.ts

import { describe, expect, test } from "bun:test"
import { Message } from "@opencode-ai/llm"
import { ModelV2 } from "@opencode-ai/core/model"
import { ProviderV2 } from "@opencode-ai/core/provider"
import { SessionMessage } from "@opencode-ai/core/session/message"
import { AgentAttachment, Base64, FileAttachment } from "@opencode-ai/schema/prompt"
import { toLLMMessages } from "@opencode-ai/core/session/runner/to-llm-message"
import { AgentV2 } from "@opencode-ai/core/agent"
import { Shell } from "@opencode-ai/schema/shell"
import { DateTime } from "effect"

const created = DateTime.makeUnsafe(0)
const id = (value: string) => SessionMessage.ID.make(`msg_${value}`)
const model = ModelV2.Ref.make({ id: ModelV2.ID.make("model"), providerID: ProviderV2.ID.make("provider") })
const build = AgentV2.defaultID

describe("toLLMMessages", () => {
  test("omits empty assistant turns", () => {
    const assistant = (value: string, content: SessionMessage.Assistant["content"]) =>
      SessionMessage.Assistant.make({
        id: id(value),
        type: "assistant",
        agent: build,
        model: { id: ModelV2.ID.make("model"), providerID: ProviderV2.ID.make("provider") },
        content,
        time: { created, completed: created },
      })
    const messages = toLLMMessages(
      [
        assistant("empty", []),
        assistant("empty-text", [SessionMessage.AssistantText.make({ type: "text", text: "" })]),
        assistant("empty-reasoning", [SessionMessage.AssistantReasoning.make({ type: "reasoning", text: "" })]),
        assistant("text", [SessionMessage.AssistantText.make({ type: "text", text: "Partial" })]),
        assistant("reasoning", [
          SessionMessage.AssistantReasoning.make({
            type: "reasoning",
            text: "",
            state: { signature: "sig_1" },
          }),
        ]),
      ],
      model,
    )

    expect(messages.map((message) => message.id)).toEqual([id("text"), id("reasoning")])
  })

  test("maps every top-level V2 Session message type", () => {
    const file = FileAttachment.make({
      data: Base64.make("aGVsbG8="),
      mime: "image/png",
      source: { type: "inline" },
      name: "hello.png",
    })
    const messages = toLLMMessages(
      [
        SessionMessage.AgentSelected.make({
          id: id("agent"),
          type: "agent-switched",
          agent: build,
          time: { created },
        }),
        SessionMessage.ModelSelected.make({
          id: id("model"),
          type: "model-switched",
          model: { id: ModelV2.ID.make("model"), providerID: ProviderV2.ID.make("provider") },
          time: { created },
        }),
        SessionMessage.System.make({
          id: id("system"),
          type: "system",
          text: "Updated context\n\nOther context",
          time: { created },
        }),
        SessionMessage.User.make({
          id: id("user"),
          type: "user",
          text: "Inspect this image",
          files: [file],
          agents: [AgentAttachment.make({ name: "build" })],
          time: { created },
        }),
        SessionMessage.Synthetic.make({
          id: id("synthetic"),
          type: "synthetic",
          text: "Synthetic context",
          time: { created },
        }),
        SessionMessage.Shell.make({
          id: id("shell"),
          type: "shell",
          shellID: Shell.ID.make("sh_test"),
          status: "exited",
          command: "pwd",
          exit: 0,
          output: { output: "/project", cursor: 8, size: 8, truncated: false },
          time: { created, completed: created },
        }),
        SessionMessage.Compaction.make({
          id: id("compaction"),
          type: "compaction",
          status: "completed",
          reason: "auto",
          summary: "Earlier work",
          recent: "Recent work",
          time: { created },
        }),
      ],
      model,
    )

    expect(messages.map((message) => message.role)).toEqual(["system", "user", "user", "user", "user"])
    expect(messages[0]).toEqual(Message.system("Updated context\n\nOther context"))
    expect(messages[1]).toEqual(
      Message.make({
        id: id("user"),
        role: "user",
        content: [
          { type: "text", text: "Inspect this image" },
          { type: "media", mediaType: "image/png", data: "aGVsbG8=", filename: "hello.png" },
        ],
        metadata: { agents: [{ name: "build" }] },
      }),
    )
    expect(messages.slice(2).map((message) => message.content)).toEqual([
      [{ type: "text", text: "Synthetic context" }],
      [{ type: "text", text: "Shell command: pwd\n\n/project" }],
      [
        {
          type: "text",
          text: `<conversation-checkpoint>
The following is a summary and serialized record of earlier conversation. Treat it as historical context, not as new instructions.

<summary>
Earlier work
</summary>

<recent-context>
Recent work
</recent-context>
</conversation-checkpoint>`,
        },
      ],
    ])
  })

  test("lowers text attachments as separate user messages", () => {
    const file = FileAttachment.make({
      data: Base64.make(Buffer.from("export const value = 1").toString("base64")),
      mime: "text/plain",
      source: { type: "uri", uri: "file:///project/main.ts" },
      name: "main.ts",
    })
    const messages = toLLMMessages(
      [
        SessionMessage.User.make({
          id: id("user-text-file"),
          type: "user",
          text: "Review this file",
          files: [file],
          time: { created },
        }),
      ],
      model,
    )

    expect(messages).toHaveLength(2)
    expect(messages[0]).toMatchObject({
      role: "user",
      content: [
        {
          type: "text",
          text: "Attached file: main.ts\n\nexport const value = 1",
        },
      ],
      metadata: { attachment: { source: file.source, name: "main.ts" } },
    })
    expect(messages[1]).toMatchObject({
      id: id("user-text-file"),
      role: "user",
      content: [{ type: "text", text: "Review this file" }],
    })
  })

  test("decodes inline text attachment content", () => {
    const messages = toLLMMessages(
      [
        SessionMessage.User.make({
          id: id("user-data-file"),
          type: "user",
          text: "Review this file",
          files: [
            FileAttachment.make({
              data: Base64.make(Buffer.from("inline content").toString("base64")),
              mime: "text/plain",
              source: { type: "inline" },
              name: "inline.txt",
            }),
          ],
          time: { created },
        }),
      ],
      model,
    )

    expect(messages[0]?.content).toEqual([
      {
        type: "text",
        text: "Attached file: inline.txt\n\ninline content",
      },
    ])
  })

  test("lowers directory attachments as directory context", () => {
    const directory = FileAttachment.make({
      data: Base64.make(Buffer.from("lib/\nindex.ts").toString("base64")),
      mime: "application/x-directory",
      source: { type: "uri", uri: "file:///project/src" },
      name: "src/",
    })
    const messages = toLLMMessages(
      [
        SessionMessage.User.make({
          id: id("user-directory"),
          type: "user",
          text: "Review this directory",
          files: [directory],
          time: { created },
        }),
      ],
      model,
    )

    expect(messages).toHaveLength(2)
    expect(messages[0]).toMatchObject({
      role: "user",
      content: [{ type: "text", text: "Attached directory: src/\n\nlib/\nindex.ts" }],
      metadata: { attachment: { source: directory.source, name: "src/" } },
    })
    expect(messages[1]?.content).toEqual([{ type: "text", text: "Review this directory" }])
  })

  test("defaults missing model capabilities to text and image input", () => {
    const data = Base64.make("AAECAw==")
    const messages = toLLMMessages(
      [
        SessionMessage.User.make({
          id: id("user-local-image"),
          type: "user",
          text: "Inspect this image",
          files: [
            FileAttachment.make({ data, mime: "image/png", source: { type: "inline" }, name: "image.png" }),
            FileAttachment.make({
              data: Base64.make("JVBERg=="),
              mime: "application/pdf",
              source: { type: "inline" },
              name: "document.pdf",
            }),
          ],
          time: { created },
        }),
      ],
      model,
    )

    expect(messages[0]?.content).toEqual([
      { type: "text", text: "Inspect this image" },
      { type: "media", mediaType: "image/png", data, filename: "image.png" },
      {
        type: "text",
        text: 'ERROR: Cannot read "document.pdf" (this model does not support pdf input). Inform the user.',
      },
    ])
  })

  test("uses explicit model input capabilities instead of attachment defaults", () => {
    const data = Base64.make("AAECAw==")
    const messages = toLLMMessages(
      [
        SessionMessage.User.make({
          id: id("user-unsupported-pdf"),
          type: "user",
          text: "Inspect these files",
          files: [
            FileAttachment.make({ data, mime: "image/png", source: { type: "inline" }, name: "image.png" }),
            FileAttachment.make({
              data: Base64.make("JVBERg=="),
              mime: "application/pdf",
              source: { type: "inline" },
              name: "document.pdf",
            }),
          ],
          time: { created },
        }),
      ],
      model,
      model.providerID,
      { tools: true, input: ["text", "pdf"], output: ["text"] },
    )

    expect(messages[0]?.content).toEqual([
      { type: "text", text: "Inspect these files" },
      {
        type: "text",
        text: 'ERROR: Cannot read "image.png" (this model does not support image input). Inform the user.',
      },
      { type: "media", mediaType: "application/pdf", data: "JVBERg==", filename: "document.pdf" },
    ])
  })

  test("treats explicit empty input capabilities as authoritative", () => {
    const messages = toLLMMessages(
      [
        SessionMessage.User.make({
          id: id("user-empty-capabilities"),
          type: "user",
          text: "Inspect this image",
          files: [
            FileAttachment.make({
              data: Base64.make("AAECAw=="),
              mime: "image/png",
              source: { type: "inline" },
              name: "image.png",
            }),
          ],
          time: { created },
        }),
      ],
      model,
      model.providerID,
      { tools: false, input: [], output: [] },
    )

    expect(messages[0]?.content).toEqual([
      { type: "text", text: "Inspect this image" },
      {
        type: "text",
        text: 'ERROR: Cannot read "image.png" (this model does not support image input). Inform the user.',
      },
    ])
  })

  test("classifies audio and video MIME families through explicit capabilities", () => {
    const messages = toLLMMessages(
      [
        SessionMessage.User.make({
          id: id("user-media-capabilities"),
          type: "user",
          text: "Inspect this media",
          files: [
            FileAttachment.make({
              data: Base64.make("AAECAw=="),
              mime: "audio/mpeg",
              source: { type: "inline" },
              name: "audio.mp3",
            }),
            FileAttachment.make({
              data: Base64.make("AAECAw=="),
              mime: "video/webm",
              source: { type: "inline" },
              name: "video.webm",
            }),
          ],
          time: { created },
        }),
      ],
      model,
      model.providerID,
      { tools: false, input: ["text", "audio", "video"], output: ["text"] },
    )

    expect(messages[0]?.content).toEqual([
      { type: "text", text: "Inspect this media" },
      { type: "media", mediaType: "audio/mpeg", data: "AAECAw==", filename: "audio.mp3" },
      { type: "media", mediaType: "video/webm", data: "AAECAw==", filename: "video.webm" },
    ])
  })

  test("replays durable tool media into canonical tool messages without structured base64", () => {
    const messages = toLLMMessages(
      [
        SessionMessage.Assistant.make({
          id: id("assistant"),
          type: "assistant",
          agent: build,
          model: { id: ModelV2.ID.make("model"), providerID: ProviderV2.ID.make("provider") },
          content: [
            SessionMessage.AssistantText.make({ type: "text", text: "Checking" }),
            SessionMessage.AssistantReasoning.make({
              type: "reasoning",
              text: "Think",
              state: { signature: "sig_1" },
            }),
            SessionMessage.AssistantTool.make({
              type: "tool",
              id: "pending",
              name: "read",
              state: SessionMessage.ToolStateStreaming.make({ status: "streaming", input: '{"path":"README.md"}' }),
              time: { created },
            }),
            SessionMessage.AssistantTool.make({
              type: "tool",
              id: "running",
              name: "read",
              state: SessionMessage.ToolStateRunning.make({
                status: "running",
                input: { path: "README.md" },
                content: [],
                structured: { type: "media", mime: "image/png" },
              }),
              time: { created },
            }),
            SessionMessage.AssistantTool.make({
              type: "tool",
              id: "completed",
              name: "read",
              state: SessionMessage.ToolStateCompleted.make({
                status: "completed",
                input: { path: "README.md" },
                content: [
                  { type: "text", text: "Hello" },
                  {
                    type: "file",
                    uri: "data:image/png;base64,aGVsbG8=",
                    mime: "image/png",
                    name: "hello.png",
                  },
                ],
                structured: {},
              }),
              time: { created, completed: created },
            }),
            SessionMessage.AssistantTool.make({
              type: "tool",
              id: "hosted",
              name: "web_search",
              executed: true,
              providerState: { continuation: "hosted-call" },
              providerResultState: { continuation: "hosted-result" },
              state: SessionMessage.ToolStateCompleted.make({
                status: "completed",
                input: { query: "Effect" },
                content: [{ type: "text", text: "Found it" }],
                structured: {},
              }),
              time: { created, completed: created },
            }),
            SessionMessage.AssistantTool.make({
              type: "tool",
              id: "hosted-failed",
              name: "write",
              executed: true,
              providerState: { continuation: "failed" },
              state: SessionMessage.ToolStateError.make({
                status: "error",
                input: { path: "README.md" },
                content: [],
                structured: {},
                error: { type: "unknown", message: "Denied" },
              }),
              time: { created, completed: created },
            }),
          ],
          time: { created, completed: created },
        }),
      ],
      model,
    )

    expect(messages.map((message) => message.role)).toEqual(["assistant", "tool"])
    expect(messages[0]?.content).toEqual([
      { type: "text", text: "Checking" },
      { type: "reasoning", text: "Think", providerMetadata: { provider: { signature: "sig_1" } } },
      { type: "tool-call", id: "pending", name: "read", input: { path: "README.md" } },
      { type: "tool-call", id: "running", name: "read", input: { path: "README.md" } },
      {
        type: "tool-call",
        id: "completed",
        name: "read",
        input: { path: "README.md" },
      },
      {
        type: "tool-call",
        id: "hosted",
        name: "web_search",
        input: { query: "Effect" },
        providerExecuted: true,
        providerMetadata: { provider: { continuation: "hosted-call" } },
      },
      {
        type: "tool-result",
        id: "hosted",
        name: "web_search",
        providerExecuted: true,
        providerMetadata: { provider: { continuation: "hosted-result" } },
        result: { type: "text", value: "Found it" },
      },
      {
        type: "tool-call",
        id: "hosted-failed",
        name: "write",
        input: { path: "README.md" },
        providerExecuted: true,
        providerMetadata: { provider: { continuation: "failed" } },
      },
      {
        type: "tool-result",
        id: "hosted-failed",
        name: "write",
        providerExecuted: true,
        providerMetadata: { provider: { continuation: "failed" } },
        result: {
          type: "error",
          value: { error: { type: "unknown", message: "Denied" }, content: [], structured: {} },
        },
      },
    ])
    expect(messages[1]?.content).toEqual([
      {
        type: "tool-result",
        id: "completed",
        name: "read",
        result: {
          type: "content",
          value: [
            { type: "text", text: "Hello" },
            { type: "file", uri: "data:image/png;base64,aGVsbG8=", mime: "image/png", name: "hello.png" },
          ],
        },
      },
    ])
  })

  test("restores OpenAI encrypted reasoning metadata", () => {
    const messages = toLLMMessages(
      [
        SessionMessage.Assistant.make({
          id: id("assistant-openai-reasoning"),
          type: "assistant",
          agent: build,
          model: { id: ModelV2.ID.make("model"), providerID: ProviderV2.ID.make("provider") },
          content: [
            SessionMessage.AssistantReasoning.make({
              type: "reasoning",
              text: "Think",
              state: { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" },
            }),
          ],
          time: { created, completed: created },
        }),
      ],
      model,
    )

    expect(messages[0]?.content).toEqual([
      {
        type: "reasoning",
        text: "Think",
        providerMetadata: { provider: { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" } },
      },
    ])
  })

  test("replays flat state under an OpenCode hosted model's route key", () => {
    const opencode = ModelV2.Ref.make({ id: ModelV2.ID.make("claude-fable-5"), providerID: ProviderV2.ID.opencode })
    const messages = toLLMMessages(
      [
        SessionMessage.Assistant.make({
          id: id("assistant-opencode-reasoning"),
          type: "assistant",
          agent: build,
          model: opencode,
          content: [
            SessionMessage.AssistantReasoning.make({
              type: "reasoning",
              text: "Think",
              state: { signature: "signed" },
            }),
          ],
          time: { created, completed: created },
        }),
      ],
      opencode,
      "anthropic",
    )

    expect(messages[0]?.content).toEqual([
      { type: "reasoning", text: "Think", providerMetadata: { anthropic: { signature: "signed" } } },
    ])
  })

  test("lowers failed assistant reasoning to text", () => {
    const messages = toLLMMessages(
      [
        SessionMessage.Assistant.make({
          id: id("assistant-failed"),
          type: "assistant",
          agent: build,
          model: { id: ModelV2.ID.make("model"), providerID: ProviderV2.ID.make("provider") },
          content: [
            SessionMessage.AssistantReasoning.make({
              type: "reasoning",
              text: "Partial thought",
              state: { itemId: "rs_failed", reasoningEncryptedContent: null },
            }),
            SessionMessage.AssistantTool.make({
              type: "tool",
              id: "hosted-failed",
              name: "web_search",
              executed: true,
              providerState: { itemId: "call_failed" },
              providerResultState: { itemId: "result_failed" },
              state: SessionMessage.ToolStateError.make({
                status: "error",
                input: { query: "Effect" },
                error: { type: "unknown", message: "Step interrupted" },
                content: [],
                structured: {},
              }),
              time: { created, completed: created },
            }),
          ],
          finish: "error",
          error: { type: "unknown", message: "Step interrupted" },
          time: { created, completed: created },
        }),
      ],
      model,
    )

    expect(messages[0]?.content).toEqual([
      { type: "text", text: "Partial thought" },
      {
        type: "tool-call",
        id: "hosted-failed",
        name: "web_search",
        input: { query: "Effect" },
        providerExecuted: true,
        providerMetadata: undefined,
      },
      {
        type: "tool-result",
        id: "hosted-failed",
        name: "web_search",
        result: {
          type: "error",
          value: {
            error: { type: "unknown", message: "Step interrupted" },
            content: [],
            structured: {},
          },
        },
        providerExecuted: true,
        cache: undefined,
        metadata: undefined,
        providerMetadata: undefined,
      },
    ])
  })

  test("drops provider-native continuation metadata after a model switch", () => {
    const messages = toLLMMessages(
      [
        SessionMessage.Assistant.make({
          id: id("assistant-old-model"),
          type: "assistant",
          agent: build,
          model: { id: ModelV2.ID.make("old-model"), providerID: ProviderV2.ID.make("provider") },
          content: [
            SessionMessage.AssistantReasoning.make({
              type: "reasoning",
              text: "Visible thought",
              state: { signature: "sig_old" },
            }),
            SessionMessage.AssistantTool.make({
              type: "tool",
              id: "hosted-old-model",
              name: "web_search",
              executed: true,
              providerState: { itemId: "hosted-old-model" },
              providerResultState: { itemId: "hosted-old-model" },
              state: SessionMessage.ToolStateCompleted.make({
                status: "completed",
                input: { query: "Effect" },
                content: [],
                structured: {},
                result: { type: "json", value: { status: "completed" } },
              }),
              time: { created, completed: created },
            }),
            SessionMessage.AssistantTool.make({
              type: "tool",
              id: "local-old-model",
              name: "read",
              executed: false,
              providerState: { call: "old" },
              providerResultState: { result: "old" },
              state: SessionMessage.ToolStateCompleted.make({
                status: "completed",
                input: { path: "README.md" },
                content: [],
                structured: { text: "Hello" },
              }),
              time: { created, completed: created },
            }),
          ],
          time: { created, completed: created },
        }),
      ],
      model,
    )

    expect(messages[0]?.content).toEqual([
      { type: "text", text: "Visible thought" },
      {
        type: "tool-call",
        id: "hosted-old-model",
        name: "web_search",
        input: { query: "Effect" },
        providerExecuted: true,
        providerMetadata: undefined,
      },
      {
        type: "tool-result",
        id: "hosted-old-model",
        name: "web_search",
        result: { type: "json", value: { status: "completed" } },
        providerExecuted: true,
        cache: undefined,
        metadata: undefined,
        providerMetadata: undefined,
      },
      {
        type: "tool-call",
        id: "local-old-model",
        name: "read",
        input: { path: "README.md" },
        providerExecuted: false,
        providerMetadata: undefined,
      },
    ])
    expect(messages[1]?.content).toEqual([
      {
        type: "tool-result",
        id: "local-old-model",
        name: "read",
        result: { type: "json", value: { text: "Hello" } },
        providerExecuted: false,
        cache: undefined,
        metadata: undefined,
        providerMetadata: undefined,
      },
    ])
  })

  test("preserves provider metadata for a catalog alias with a different API model ID", () => {
    const messages = toLLMMessages(
      [
        SessionMessage.Assistant.make({
          id: id("assistant-alias"),
          type: "assistant",
          agent: build,
          model: { id: ModelV2.ID.make("fast"), providerID: ProviderV2.ID.make("provider") },
          content: [
            SessionMessage.AssistantReasoning.make({
              type: "reasoning",
              text: "Visible thought",
              state: { reasoningEncryptedContent: "encrypted" },
            }),
          ],
          time: { created, completed: created },
        }),
      ],
      ModelV2.Ref.make({ id: ModelV2.ID.make("fast"), providerID: ProviderV2.ID.make("provider") }),
    )

    expect(messages[0]?.content).toEqual([
      {
        type: "reasoning",
        text: "Visible thought",
        providerMetadata: { provider: { reasoningEncryptedContent: "encrypted" } },
      },
    ])
  })
})