kanna-code 0.16.0 → 0.18.0

package/src/server/uploads.test.ts

@@ -0,0 +1,282 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { mkdtemp, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { deleteProjectUpload, inferAttachmentContentType, persistProjectUpload } from "./uploads"
+import { getProjectUploadDir } from "./paths"
+import { persistUploadedFiles, startKannaServer } from "./server"
+
+const PNG_BASE64 =
+  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+yF9sAAAAASUVORK5CYII="
+
+const tempDirs: string[] = []
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })))
+})
+
+describe("uploads", () => {
+  test("stores uploads in .kanna/uploads and keeps duplicate filenames", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-upload-test-"))
+    tempDirs.push(projectDir)
+
+    const first = await persistProjectUpload({
+      projectId: "project-1",
+      localPath: projectDir,
+      fileName: "notes.txt",
+      bytes: new TextEncoder().encode("hello"),
+      fallbackMimeType: "text/plain",
+    })
+    const second = await persistProjectUpload({
+      projectId: "project-1",
+      localPath: projectDir,
+      fileName: "notes.txt",
+      bytes: new TextEncoder().encode("world"),
+      fallbackMimeType: "text/plain",
+    })
+
+    expect(first.absolutePath).toBe(path.join(projectDir, ".kanna/uploads/notes.txt"))
+    expect(first.relativePath).toBe("./.kanna/uploads/notes.txt")
+    expect(first.contentUrl).toBe("/api/projects/project-1/uploads/notes.txt/content")
+    expect(second.absolutePath).toBe(path.join(projectDir, ".kanna/uploads/notes-1.txt"))
+    expect(second.relativePath).toBe("./.kanna/uploads/notes-1.txt")
+    expect(second.contentUrl).toBe("/api/projects/project-1/uploads/notes-1.txt/content")
+    expect(await Bun.file(path.join(projectDir, ".kanna/uploads/notes.txt")).text()).toBe("hello")
+    expect(await Bun.file(path.join(projectDir, ".kanna/uploads/notes-1.txt")).text()).toBe("world")
+  })
+
+  test("stores concurrent same-name uploads without overwriting existing content", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-upload-concurrent-"))
+    tempDirs.push(projectDir)
+
+    const attachments = await Promise.all([
+      persistProjectUpload({
+        projectId: "project-1",
+        localPath: projectDir,
+        fileName: "notes.txt",
+        bytes: new TextEncoder().encode("first"),
+        fallbackMimeType: "text/plain",
+      }),
+      persistProjectUpload({
+        projectId: "project-1",
+        localPath: projectDir,
+        fileName: "notes.txt",
+        bytes: new TextEncoder().encode("second"),
+        fallbackMimeType: "text/plain",
+      }),
+      persistProjectUpload({
+        projectId: "project-1",
+        localPath: projectDir,
+        fileName: "notes.txt",
+        bytes: new TextEncoder().encode("third"),
+        fallbackMimeType: "text/plain",
+      }),
+    ])
+
+    const storedNames = attachments.map((attachment) => path.basename(attachment.absolutePath)).sort()
+    expect(storedNames).toEqual(["notes-1.txt", "notes-2.txt", "notes.txt"])
+
+    const contents = await Promise.all(attachments.map((attachment) => Bun.file(attachment.absolutePath).text()))
+    expect(new Set(contents)).toEqual(new Set(["first", "second", "third"]))
+  })
+
+  test("detects image uploads and returns absolute plus project-relative paths", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-upload-image-"))
+    tempDirs.push(projectDir)
+
+    const attachment = await persistProjectUpload({
+      projectId: "project-2",
+      localPath: projectDir,
+      fileName: "pixel.png",
+      bytes: Buffer.from(PNG_BASE64, "base64"),
+    })
+
+    expect(attachment.kind).toBe("image")
+    expect(attachment.mimeType).toBe("image/png")
+    expect(getProjectUploadDir(projectDir)).toBe(path.join(projectDir, ".kanna", "uploads"))
+    expect(attachment.absolutePath).toBe(path.join(projectDir, ".kanna/uploads/pixel.png"))
+    expect(attachment.relativePath).toBe("./.kanna/uploads/pixel.png")
+    expect(attachment.contentUrl).toBe("/api/projects/project-2/uploads/pixel.png/content")
+  })
+
+  test("serves uploaded attachment content through the project content URL", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-project-"))
+    tempDirs.push(projectDir)
+
+    const server = await startKannaServer({ port: 4310, strictPort: true })
+
+    try {
+      const project = await server.store.openProject(projectDir, "Project")
+      const attachment = await persistProjectUpload({
+        projectId: project.id,
+        localPath: projectDir,
+        fileName: "hello.txt",
+        bytes: new TextEncoder().encode("hello from upload"),
+        fallbackMimeType: "text/plain",
+      })
+
+      const response = await fetch(`http://localhost:${server.port}${attachment.contentUrl}`)
+      expect(response.status).toBe(200)
+      expect(response.headers.get("content-type")).toBe("text/plain; charset=utf-8")
+      expect(await response.text()).toBe("hello from upload")
+    } finally {
+      await server.stop()
+    }
+  })
+
+  test("serves TypeScript uploads as text content", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-project-typescript-"))
+    tempDirs.push(projectDir)
+
+    const server = await startKannaServer({ port: 4314, strictPort: true })
+
+    try {
+      const project = await server.store.openProject(projectDir, "Project")
+      const attachment = await persistProjectUpload({
+        projectId: project.id,
+        localPath: projectDir,
+        fileName: "main.ts",
+        bytes: new TextEncoder().encode("export const value = 1\n"),
+        fallbackMimeType: "video/mp2t",
+      })
+
+      const response = await fetch(`http://localhost:${server.port}${attachment.contentUrl}`)
+      expect(response.status).toBe(200)
+      expect(response.headers.get("content-type")).toBe("text/plain; charset=utf-8")
+      expect(await response.text()).toContain("export const value = 1")
+    } finally {
+      await server.stop()
+    }
+  })
+
+  test("rejects non-GET requests for attachment content", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-project-content-method-"))
+    tempDirs.push(projectDir)
+
+    const server = await startKannaServer({ port: 4312, strictPort: true })
+
+    try {
+      const project = await server.store.openProject(projectDir, "Project")
+      const attachment = await persistProjectUpload({
+        projectId: project.id,
+        localPath: projectDir,
+        fileName: "hello.txt",
+        bytes: new TextEncoder().encode("hello from upload"),
+        fallbackMimeType: "text/plain",
+      })
+
+      const response = await fetch(`http://localhost:${server.port}${attachment.contentUrl}`, { method: "POST" })
+      expect(response.status).toBe(405)
+      expect(response.headers.get("allow")).toBe("GET")
+    } finally {
+      await server.stop()
+    }
+  })
+
+  test("rejects oversized uploads before reading them into memory", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-project-oversize-"))
+    tempDirs.push(projectDir)
+
+    const server = await startKannaServer({ port: 4313, strictPort: true })
+
+    try {
+      const project = await server.store.openProject(projectDir, "Project")
+      const formData = new FormData()
+      formData.append("files", new File([new Uint8Array(25 * 1024 * 1024 + 1)], "big.bin", { type: "application/octet-stream" }))
+
+      const response = await fetch(`http://localhost:${server.port}/api/projects/${project.id}/uploads`, {
+        method: "POST",
+        body: formData,
+      })
+
+      expect(response.status).toBe(413)
+      expect(await response.json()).toEqual({
+        error: "File \"big.bin\" exceeds the 25 MB limit.",
+      })
+    } finally {
+      await server.stop()
+    }
+  })
+
+  test("cleans up already-persisted files when a later file in the batch fails", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-project-cleanup-"))
+    tempDirs.push(projectDir)
+
+    const files = [
+      new File(["first"], "first.txt", { type: "text/plain" }),
+      new File(["second"], "second.txt", { type: "text/plain" }),
+    ]
+
+    await expect(
+      persistUploadedFiles({
+        projectId: "project-4",
+        localPath: projectDir,
+        files,
+        persistUpload: async (args) => {
+          if (args.fileName === "second.txt") {
+            throw new Error("disk full")
+          }
+
+          return persistProjectUpload(args)
+        },
+      })
+    ).rejects.toThrow("disk full")
+
+    expect(await Bun.file(path.join(projectDir, ".kanna/uploads/first.txt")).exists()).toBe(false)
+    expect(await Bun.file(path.join(projectDir, ".kanna/uploads/second.txt")).exists()).toBe(false)
+  })
+
+  test("deletes uploaded attachments from the project uploads directory", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-upload-delete-"))
+    tempDirs.push(projectDir)
+
+    const attachment = await persistProjectUpload({
+      projectId: "project-3",
+      localPath: projectDir,
+      fileName: "delete-me.txt",
+      bytes: new TextEncoder().encode("bye"),
+      fallbackMimeType: "text/plain",
+    })
+
+    const deleted = await deleteProjectUpload({
+      localPath: projectDir,
+      storedName: "delete-me.txt",
+    })
+
+    expect(deleted).toBe(true)
+    expect(await Bun.file(attachment.absolutePath).exists()).toBe(false)
+  })
+
+  test("deletes uploaded attachment content through the project delete URL", async () => {
+    const projectDir = await mkdtemp(path.join(tmpdir(), "kanna-project-delete-"))
+    tempDirs.push(projectDir)
+
+    const server = await startKannaServer({ port: 4311, strictPort: true })
+
+    try {
+      const project = await server.store.openProject(projectDir, "Project")
+      const attachment = await persistProjectUpload({
+        projectId: project.id,
+        localPath: projectDir,
+        fileName: "bye.txt",
+        bytes: new TextEncoder().encode("delete over http"),
+        fallbackMimeType: "text/plain",
+      })
+
+      const deleteUrl = `http://localhost:${server.port}${attachment.contentUrl.replace(/\/content$/, "")}`
+      const response = await fetch(deleteUrl, { method: "DELETE" })
+      expect(response.status).toBe(200)
+      expect(await response.json()).toEqual({ ok: true })
+      expect(await Bun.file(attachment.absolutePath).exists()).toBe(false)
+    } finally {
+      await server.stop()
+    }
+  })
+
+  test("infers text-friendly content types for previewable source files", () => {
+    expect(inferAttachmentContentType("notes.txt")).toBe("text/plain; charset=utf-8")
+    expect(inferAttachmentContentType("README.md")).toBe("text/markdown; charset=utf-8")
+    expect(inferAttachmentContentType("main.ts", "video/mp2t")).toBe("text/plain; charset=utf-8")
+    expect(inferAttachmentContentType("archive.zip", "application/zip")).toBe("application/zip")
+  })
+})

package/src/server/uploads.ts

@@ -0,0 +1,127 @@
+import { randomUUID } from "node:crypto"
+import { mkdir, open, rm } from "node:fs/promises"
+import path from "node:path"
+import { fileTypeFromBuffer } from "file-type"
+import type { ChatAttachment } from "../shared/types"
+import { getProjectUploadDir } from "./paths"
+
+const DEFAULT_BINARY_MIME_TYPE = "application/octet-stream"
+const IMAGE_MIME_PREFIX = "image/"
+const TEXT_PLAIN_CONTENT_TYPE = "text/plain; charset=utf-8"
+
+const TEXT_CONTENT_TYPE_BY_EXTENSION = new Map<string, string>([
+  [".csv", "text/csv; charset=utf-8"],
+  [".json", "application/json; charset=utf-8"],
+  [".jsonc", TEXT_PLAIN_CONTENT_TYPE],
+  [".md", "text/markdown; charset=utf-8"],
+  [".tsv", "text/tab-separated-values; charset=utf-8"],
+])
+
+const TEXT_LIKE_EXTENSIONS = new Set([
+  ".c", ".cc", ".cfg", ".conf", ".cpp", ".cs", ".css", ".env", ".go", ".graphql", ".h", ".hpp", ".html",
+  ".ini", ".java", ".js", ".jsx", ".kt", ".lua", ".mjs", ".php", ".pl", ".properties", ".py", ".rb", ".rs",
+  ".scss", ".sh", ".sql", ".swift", ".toml", ".ts", ".tsx", ".txt", ".vue", ".xml", ".yaml", ".yml", ".zsh",
+])
+
+function sanitizeFileName(fileName: string) {
+  const baseName = path.basename(fileName).trim()
+  const cleaned = baseName.replace(/[^\w.-]+/g, "-").replace(/^-+|-+$/g, "")
+  return cleaned || "upload"
+}
+
+function getUploadCandidateNames(originalName: string) {
+  const sanitizedName = sanitizeFileName(originalName)
+  const parsed = path.parse(sanitizedName)
+  const extension = parsed.ext
+  const name = parsed.name || "upload"
+
+  return {
+    first: sanitizedName,
+    withCounter(counter: number) {
+      return `${name}-${counter}${extension}`
+    },
+  }
+}
+
+export async function persistProjectUpload(args: {
+  projectId: string
+  localPath: string
+  fileName: string
+  bytes: Uint8Array
+  fallbackMimeType?: string
+}): Promise<ChatAttachment> {
+  const uploadDir = getProjectUploadDir(args.localPath)
+  await mkdir(uploadDir, { recursive: true })
+
+  const detectedType = await fileTypeFromBuffer(args.bytes)
+  const mimeType = detectedType?.mime ?? args.fallbackMimeType ?? DEFAULT_BINARY_MIME_TYPE
+  const candidates = getUploadCandidateNames(args.fileName)
+
+  let storedName = candidates.first
+  let absolutePath = path.join(uploadDir, storedName)
+  let counter = 1
+
+  while (true) {
+    try {
+      const handle = await open(absolutePath, "wx")
+      try {
+        await handle.writeFile(args.bytes)
+      } finally {
+        await handle.close()
+      }
+      break
+    } catch (error) {
+      const code = error instanceof Error && "code" in error ? (error as NodeJS.ErrnoException).code : undefined
+      if (code !== "EEXIST") {
+        throw error
+      }
+
+      storedName = candidates.withCounter(counter)
+      absolutePath = path.join(uploadDir, storedName)
+      counter += 1
+    }
+  }
+
+  return {
+    id: randomUUID(),
+    kind: mimeType.startsWith(IMAGE_MIME_PREFIX) ? "image" : "file",
+    displayName: args.fileName,
+    absolutePath,
+    relativePath: `./.kanna/uploads/${storedName}`,
+    contentUrl: `/api/projects/${args.projectId}/uploads/${encodeURIComponent(storedName)}/content`,
+    mimeType,
+    size: args.bytes.byteLength,
+  }
+}
+
+export function inferAttachmentContentType(fileName: string, fallbackType?: string): string {
+  const extension = path.extname(fileName).toLowerCase()
+  const mappedType = TEXT_CONTENT_TYPE_BY_EXTENSION.get(extension)
+  if (mappedType) {
+    return mappedType
+  }
+
+  if (TEXT_LIKE_EXTENSIONS.has(extension)) {
+    return TEXT_PLAIN_CONTENT_TYPE
+  }
+
+  return fallbackType || DEFAULT_BINARY_MIME_TYPE
+}
+
+export async function deleteProjectUpload(args: {
+  localPath: string
+  storedName: string
+}): Promise<boolean> {
+  const storedName = args.storedName
+  if (!storedName || storedName.includes("/") || storedName.includes("\\") || storedName === "." || storedName === "..") {
+    return false
+  }
+
+  const absolutePath = path.join(getProjectUploadDir(args.localPath), storedName)
+  try {
+    await rm(absolutePath, { force: true })
+    return true
+  } catch {
+    return false
+  }
+}

package/src/shared/dev-ports.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test"
 import {
   DEFAULT_DEV_CLIENT_PORT,
   getDefaultDevServerPort,
+  parseDevArgs,
   resolveDevPorts,
   stripPortArg,
 } from "./dev-ports"
@@ -50,3 +51,34 @@ describe("stripPortArg", () => {
     ])
   })
 })
+
+describe("parseDevArgs", () => {
+  test("derives dev share options from the client port", () => {
+    expect(parseDevArgs(["--share", "--port", "3333"], "dev-machine")).toEqual({
+      clientPort: 3333,
+      serverPort: 3334,
+      share: true,
+      backendTargetHost: "127.0.0.1",
+      allowedHosts: true,
+      serverArgs: [],
+    })
+  })
+
+  test("rejects combining --share with --host or --remote", () => {
+    expect(() => parseDevArgs(["--share", "--host", "dev-box"], "dev-machine")).toThrow("--share cannot be used with --host")
+    expect(() => parseDevArgs(["--host", "dev-box", "--share"], "dev-machine")).toThrow("--share cannot be used with --host")
+    expect(() => parseDevArgs(["--share", "--remote"], "dev-machine")).toThrow("--share cannot be used with --remote")
+    expect(() => parseDevArgs(["--remote", "--share"], "dev-machine")).toThrow("--share cannot be used with --remote")
+  })
+
+  test("preserves existing remote host behavior when share is off", () => {
+    expect(parseDevArgs(["--remote", "--port", "3333"], "dev-machine")).toEqual({
+      clientPort: 3333,
+      serverPort: 3334,
+      share: false,
+      backendTargetHost: "127.0.0.1",
+      allowedHosts: true,
+      serverArgs: ["--remote"],
+    })
+  })
+})

package/src/shared/dev-ports.ts

@@ -4,6 +4,15 @@ export function getDefaultDevServerPort(clientPort = DEFAULT_DEV_CLIENT_PORT) {
   return clientPort + 1
 }
 
+export interface DevArgResolution {
+  clientPort: number
+  serverPort: number
+  share: boolean
+  backendTargetHost: string
+  allowedHosts: true | string[]
+  serverArgs: string[]
+}
+
 export function resolveDevPorts(args: string[]) {
   let clientPort = DEFAULT_DEV_CLIENT_PORT
 
@@ -41,3 +50,49 @@ export function stripPortArg(args: string[]) {
 
   return stripped
 }
+
+export function parseDevArgs(args: string[], localHostname: string): DevArgResolution {
+  const { clientPort, serverPort } = resolveDevPorts(args)
+  const serverArgs = stripPortArg(args).filter((arg) => arg !== "--share")
+  let share = false
+  let sawHost = false
+  let sawRemote = false
+  let backendTargetHost = "127.0.0.1"
+  let allowAllHosts = false
+  const hosts = new Set<string>(["localhost", "127.0.0.1", "0.0.0.0", localHostname])
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index]
+    if (arg === "--share") {
+      if (sawHost) throw new Error("--share cannot be used with --host")
+      if (sawRemote) throw new Error("--share cannot be used with --remote")
+      share = true
+      continue
+    }
+    if (arg === "--remote") {
+      if (share) throw new Error("--share cannot be used with --remote")
+      sawRemote = true
+      backendTargetHost = "127.0.0.1"
+      allowAllHosts = true
+      continue
+    }
+    if (arg !== "--host") continue
+
+    const next = args[index + 1]
+    if (!next || next.startsWith("-")) continue
+    if (share) throw new Error("--share cannot be used with --host")
+    sawHost = true
+    hosts.add(next)
+    backendTargetHost = next === "0.0.0.0" ? "127.0.0.1" : next
+    index += 1
+  }
+
+  return {
+    clientPort,
+    serverPort,
+    share,
+    backendTargetHost,
+    allowedHosts: share || allowAllHosts ? true : [...hosts],
+    serverArgs,
+  }
+}

package/src/shared/protocol.ts

@@ -1,5 +1,6 @@
 import type {
   AgentProvider,
+  ChatAttachment,
   ChatSnapshot,
   KeybindingsSnapshot,
   LocalProjectsSnapshot,
@@ -67,6 +68,7 @@ export type ClientCommand =
       projectId?: string
       provider?: AgentProvider
       content: string
+      attachments?: ChatAttachment[]
       model?: string
       modelOptions?: ModelOptions
       effort?: string

package/src/shared/tools.test.ts

@@ -96,4 +96,69 @@ describe("hydrateToolResult", () => {
 
     expect(hydrateToolResult(tool, "line 1\nline 2")).toBe("line 1\nline 2")
   })
+
+  test("hydrates read image results with canonical image blocks intact", () => {
+    const tool = normalizeToolCall({
+      toolName: "Read",
+      toolId: "tool-image",
+      input: { file_path: "/tmp/example.png" },
+    })
+
+    expect(hydrateToolResult(tool, {
+      content: [
+        {
+          type: "text",
+          text: "Read image file [image/png]\n[Image: original 10x10, displayed at 10x10.]",
+        },
+        {
+          type: "image",
+          data: "ZmFrZS1pbWFnZS1kYXRh",
+          mimeType: "image/png",
+        },
+      ],
+    })).toEqual({
+      content: "Read image file [image/png]\n[Image: original 10x10, displayed at 10x10.]",
+      blocks: [
+        {
+          type: "text",
+          text: "Read image file [image/png]\n[Image: original 10x10, displayed at 10x10.]",
+        },
+        {
+          type: "image",
+          data: "ZmFrZS1pbWFnZS1kYXRh",
+          mimeType: "image/png",
+        },
+      ],
+    })
+  })
+
+  test("hydrates Claude read image results with source.base64 into canonical image blocks", () => {
+    const tool = normalizeToolCall({
+      toolName: "Read",
+      toolId: "tool-image-claude",
+      input: { file_path: "/tmp/example.png" },
+    })
+
+    expect(hydrateToolResult(tool, {
+      content: [
+        {
+          type: "image",
+          source: {
+            type: "base64",
+            data: "ZmFrZS1pbWFnZS1kYXRh",
+            media_type: "image/png",
+          },
+        },
+      ],
+    })).toEqual({
+      content: "",
+      blocks: [
+        {
+          type: "image",
+          data: "ZmFrZS1pbWFnZS1kYXRh",
+          mimeType: "image/png",
+        },
+      ],
+    })
+  })
 })

package/src/shared/tools.ts

@@ -203,6 +203,72 @@ function parseJsonValue(value: unknown): unknown {
   }
 }
 
+type ReadStructuredTextBlock = {
+  type: "text"
+  text: string
+}
+
+type ReadStructuredImageBlock = {
+  type: "image"
+  data: string
+  mimeType?: string
+}
+
+function normalizeReadBlocks(value: unknown): Array<ReadStructuredTextBlock | ReadStructuredImageBlock> {
+  const blocks = (
+    value
+    && typeof value === "object"
+    && "content" in value
+    && Array.isArray((value as { content?: unknown }).content)
+  )
+    ? (value as { content: unknown[] }).content
+    : Array.isArray(value)
+      ? value
+      : []
+
+  const normalized: Array<ReadStructuredTextBlock | ReadStructuredImageBlock> = []
+
+  for (const block of blocks) {
+    if (!block || typeof block !== "object" || !("type" in block)) {
+      continue
+    }
+
+    if (block.type === "text" && typeof block.text === "string") {
+      normalized.push({ type: "text", text: block.text })
+      continue
+    }
+
+    if (block.type === "image") {
+      if ("data" in block && typeof block.data === "string") {
+        normalized.push({
+          type: "image",
+          data: block.data,
+          mimeType: typeof block.mimeType === "string" ? block.mimeType : undefined,
+        })
+        continue
+      }
+
+      if (
+        "source" in block
+        && block.source
+        && typeof block.source === "object"
+        && "type" in block.source
+        && block.source.type === "base64"
+        && "data" in block.source
+        && typeof block.source.data === "string"
+      ) {
+        normalized.push({
+          type: "image",
+          data: block.source.data,
+          mimeType: typeof block.source.media_type === "string" ? block.source.media_type : undefined,
+        })
+      }
+    }
+  }
+
+  return normalized
+}
+
 export function hydrateToolResult(tool: NormalizedToolCall, raw: unknown): HydratedToolCall["result"] {
   const parsed = parseJsonValue(raw)
 
@@ -241,6 +307,16 @@ export function hydrateToolResult(tool: NormalizedToolCall, raw: unknown): Hydra
       if (typeof parsed === "string") {
         return parsed
       }
+      const blocks = normalizeReadBlocks(parsed)
+      if (blocks.length > 0) {
+        return {
+          content: blocks
+            .flatMap((block) => block.type === "text" ? [block.text] : [])
+            .join(""),
+          blocks,
+        } satisfies ReadFileToolResult
+      }
+
       const record = asRecord(parsed)
       return {
         content: typeof record?.content === "string" ? record.content : JSON.stringify(parsed, null, 2),