@pi-in-go/pigpen-acp 0.1.0

package/port/oracle/pi-acp/test/unit/new-session-runtime-startup-errors.test.ts

@@ -0,0 +1,148 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { PiAcpAgent } from '../../src/acp/agent.js'
+import { SessionStore } from '../../src/acp/session-store.js'
+import { FakeAgentSideConnection, asAgentConn } from '../helpers/fakes.js'
+
+class FakeSessions {
+  closeCalls: string[] = []
+
+  constructor(private readonly session: any) {}
+
+  async create() {
+    return this.session
+  }
+
+  close(sessionId: string) {
+    this.closeCalls.push(sessionId)
+  }
+}
+
+test('PiAcpAgent: newSession returns AUTH_REQUIRED when pi reports an auth error after spawn', async () => {
+  const conn = new FakeAgentSideConnection()
+  const root = mkdtempSync(join(tmpdir(), 'pi-acp-runtime-auth-'))
+  const sessionFile = join(root, 'sessions', 'failed.jsonl')
+  const sessionMapPath = join(root, 'session-map.json')
+
+  mkdirSync(join(root, 'sessions'), { recursive: true })
+  writeFileSync(
+    sessionFile,
+    JSON.stringify({
+      type: 'session',
+      version: 3,
+      id: 's-auth',
+      timestamp: '2026-05-07T00:00:00.000Z',
+      cwd: process.cwd()
+    }) + '\n',
+    'utf-8'
+  )
+
+  const session = {
+    sessionId: 's-auth',
+    cwd: process.cwd(),
+    proc: {
+      async getAvailableModels() {
+        throw new Error('Authentication required: missing key')
+      },
+      async getState() {
+        return { thinkingLevel: 'medium', model: null, sessionFile }
+      }
+    }
+  }
+
+  const sessions = new FakeSessions(session)
+  const store = new SessionStore(sessionMapPath)
+  store.upsert({ sessionId: 's-auth', cwd: process.cwd(), sessionFile })
+  const agent = new PiAcpAgent(asAgentConn(conn), {} as any)
+  ;(agent as any).sessions = sessions as any
+  ;(agent as any).store = store as any
+
+  await assert.rejects(
+    () => agent.newSession({ cwd: process.cwd(), mcpServers: [] } as any),
+    (e: any) => e?.code === -32000
+  )
+
+  assert.deepEqual(sessions.closeCalls, ['s-auth'])
+  assert.equal(existsSync(sessionFile), false)
+  assert.equal(store.get('s-auth'), null)
+})
+
+test('PiAcpAgent: newSession returns Internal error on non-auth model probe failures after spawn', async () => {
+  const conn = new FakeAgentSideConnection()
+
+  const session = {
+    sessionId: 's-internal',
+    cwd: process.cwd(),
+    proc: {
+      async getAvailableModels() {
+        throw new Error('socket hang up')
+      },
+      async getState() {
+        return { thinkingLevel: 'medium', model: null }
+      }
+    }
+  }
+
+  const sessions = new FakeSessions(session)
+  const agent = new PiAcpAgent(asAgentConn(conn), {} as any)
+  ;(agent as any).sessions = sessions as any
+
+  await assert.rejects(
+    () => agent.newSession({ cwd: process.cwd(), mcpServers: [] } as any),
+    (e: any) => e?.code === -32603 && String(e?.message ?? '').includes('socket hang up')
+  )
+
+  assert.deepEqual(sessions.closeCalls, ['s-internal'])
+})
+
+for (const failure of ['discovery', 'auth', 'invalid-current', 'inconsistent-current', 'state']) {
+  test(`PiAcpAgent: cleans up only the new session after ${failure} configuration failure`, async t => {
+    const root = mkdtempSync(join(tmpdir(), 'pi-acp-thinking-failure-'))
+    t.after(() => rmSync(root, { recursive: true, force: true }))
+    const sessionFile = join(root, 'failed.jsonl')
+    const existingFile = join(root, 'existing.jsonl')
+    writeFileSync(sessionFile, 'new session\n')
+    writeFileSync(existingFile, 'existing session\n')
+    const store = new SessionStore(join(root, 'map.json'))
+    store.upsert({ sessionId: 'failed', cwd: root, sessionFile })
+    store.upsert({ sessionId: 'existing', cwd: root, sessionFile: existingFile })
+    const session = {
+      sessionId: 'failed',
+      cwd: root,
+      proc: {
+        async getAvailableModels() {
+          return { models: [{ provider: 'test', id: 'model' }] }
+        },
+        async getState() {
+          if (failure === 'state') throw new Error('state read failed')
+          return {
+            sessionFile,
+            thinkingLevel: failure === 'invalid-current' ? '' : failure === 'inconsistent-current' ? 'medium' : 'max'
+          }
+        },
+        async getAvailableThinkingLevels() {
+          if (failure === 'discovery') throw new Error('discovery failed')
+          if (failure === 'auth') throw new Error('Authentication required: missing key')
+          return ['low', 'high', 'max']
+        }
+      }
+    }
+    const sessions = new FakeSessions(session)
+    const conn = new FakeAgentSideConnection()
+    const agent = new PiAcpAgent(asAgentConn(conn))
+    Reflect.set(agent, 'sessions', sessions)
+    Reflect.set(agent, 'store', store)
+    await assert.rejects(agent.newSession({ cwd: root, mcpServers: [] }), {
+      code: failure === 'auth' ? -32000 : -32603
+    })
+    assert.deepEqual(sessions.closeCalls, ['failed'])
+    assert.equal(existsSync(sessionFile), false)
+    assert.equal(store.get('failed'), null)
+    assert.equal(existsSync(existingFile), true)
+    assert.equal(store.get('existing')?.sessionFile, existingFile)
+    assert.deepEqual(conn.updates, [])
+  })
+}

package/port/oracle/pi-acp/test/unit/pi-command.test.ts

@@ -0,0 +1,44 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { defaultPiCommand, shouldUseShellForPiCommand } from '../../src/pi-rpc/command.js'
+
+test('defaultPiCommand: uses pi.cmd on Windows and pi elsewhere', () => {
+  const originalPlatform = process.platform
+
+  try {
+    Object.defineProperty(process, 'platform', { value: 'win32' })
+    assert.equal(defaultPiCommand(), 'pi.cmd')
+
+    Object.defineProperty(process, 'platform', { value: 'darwin' })
+    assert.equal(defaultPiCommand(), 'pi')
+  } finally {
+    Object.defineProperty(process, 'platform', { value: originalPlatform })
+  }
+})
+
+test('shouldUseShellForPiCommand: enables shell for Windows cmd launchers only', () => {
+  const originalPlatform = process.platform
+  Object.defineProperty(process, 'platform', { value: 'win32' })
+
+  try {
+    assert.equal(shouldUseShellForPiCommand('pi.cmd'), true)
+    assert.equal(shouldUseShellForPiCommand('C:\\Users\\me\\AppData\\Roaming\\npm\\pi.CMD'), true)
+    assert.equal(shouldUseShellForPiCommand('pi.bat'), true)
+    assert.equal(shouldUseShellForPiCommand('pi'), false)
+    assert.equal(shouldUseShellForPiCommand('C:\\tools\\pi.exe'), false)
+  } finally {
+    Object.defineProperty(process, 'platform', { value: originalPlatform })
+  }
+})
+
+test('shouldUseShellForPiCommand: keeps shell disabled on non-Windows', () => {
+  const originalPlatform = process.platform
+  Object.defineProperty(process, 'platform', { value: 'darwin' })
+
+  try {
+    assert.equal(shouldUseShellForPiCommand('pi.cmd'), false)
+    assert.equal(shouldUseShellForPiCommand('pi'), false)
+  } finally {
+    Object.defineProperty(process, 'platform', { value: originalPlatform })
+  }
+})

package/port/oracle/pi-acp/test/unit/pi-commands.test.ts

@@ -0,0 +1,32 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { toAvailableCommandsFromPiGetCommands } from '../../src/acp/pi-commands.js'
+
+test('toAvailableCommandsFromPiGetCommands: hides extension commands by default and filters skill commands', () => {
+  const data = {
+    commands: [
+      { name: 'x', description: 'X', source: 'extension' },
+      { name: 'skill:foo', description: 'Foo', source: 'skill', location: 'user' },
+      { name: 'y', source: 'prompt', location: 'project' }
+    ]
+  }
+
+  const all = toAvailableCommandsFromPiGetCommands(data, { enableSkillCommands: true }).commands
+  assert.deepEqual(all, [
+    { name: 'skill:foo', description: 'Foo' },
+    { name: 'y', description: '(prompt:project)' }
+  ])
+
+  const includeExt = toAvailableCommandsFromPiGetCommands(data, {
+    enableSkillCommands: true,
+    includeExtensionCommands: true
+  }).commands
+  assert.deepEqual(includeExt, [
+    { name: 'x', description: 'X' },
+    { name: 'skill:foo', description: 'Foo' },
+    { name: 'y', description: '(prompt:project)' }
+  ])
+
+  const noSkills = toAvailableCommandsFromPiGetCommands(data, { enableSkillCommands: false }).commands
+  assert.deepEqual(noSkills, [{ name: 'y', description: '(prompt:project)' }])
+})

package/port/oracle/pi-acp/test/unit/pi-enable-embed-context-flag.test.ts

@@ -0,0 +1,35 @@
+import test, { afterEach, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+import { PiAcpAgent } from '../../src/acp/agent.js'
+import { FakeAgentSideConnection, asAgentConn } from '../helpers/fakes.js'
+
+beforeEach(() => {
+  delete process.env.PI_ACP_ENABLE_EMBEDDED_CONTEXT
+})
+
+afterEach(() => {
+  delete process.env.PI_ACP_ENABLE_EMBEDDED_CONTEXT
+})
+
+async function initializeWithEmbeddedContext(value?: string) {
+  if (value != null) process.env.PI_ACP_ENABLE_EMBEDDED_CONTEXT = value
+
+  const agent = new PiAcpAgent(asAgentConn(new FakeAgentSideConnection()))
+  const res = await agent.initialize({ protocolVersion: 1 } as any)
+
+  assert.ok(res.agentCapabilities)
+  assert.ok(res.agentCapabilities.promptCapabilities)
+  return res.agentCapabilities.promptCapabilities.embeddedContext
+}
+
+test('PI_ACP_ENABLE_EMBEDDED_CONTEXT: defaults embeddedContext to false when undefined', async () => {
+  assert.equal(await initializeWithEmbeddedContext(), false)
+})
+
+test("PI_ACP_ENABLE_EMBEDDED_CONTEXT: 'false' keeps embeddedContext disabled", async () => {
+  assert.equal(await initializeWithEmbeddedContext('false'), false)
+})
+
+test("PI_ACP_ENABLE_EMBEDDED_CONTEXT: 'true' enables embeddedContext", async () => {
+  assert.equal(await initializeWithEmbeddedContext('true'), true)
+})

package/port/oracle/pi-acp/test/unit/pi-messages.test.ts

@@ -0,0 +1,29 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { normalizePiAssistantText, normalizePiMessageText } from '../../src/acp/translate/pi-messages.js'
+
+test('normalizePiMessageText: supports string', () => {
+  assert.equal(normalizePiMessageText('hello'), 'hello')
+})
+
+test('normalizePiMessageText: joins text blocks', () => {
+  assert.equal(
+    normalizePiMessageText([
+      { type: 'text', text: 'a' },
+      { type: 'text', text: 'b' },
+      { type: 'not_text', x: 1 }
+    ]),
+    'ab'
+  )
+})
+
+test('normalizePiAssistantText: joins only text blocks', () => {
+  assert.equal(
+    normalizePiAssistantText([
+      { type: 'text', text: 'hi' },
+      { type: 'thinking', text: '...' },
+      { type: 'text', text: '!' }
+    ]),
+    'hi!'
+  )
+})

package/port/oracle/pi-acp/test/unit/pi-rpc-request-timeout.test.ts

@@ -0,0 +1,137 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { EventEmitter } from 'node:events'
+import { PassThrough } from 'node:stream'
+import { PiRpcProcess, SESSION_STATS_TIMEOUT_MS } from '../../src/pi-rpc/process.js'
+
+type FakeChild = {
+  child: any
+  stdout: PassThrough
+  written: string[]
+}
+
+function makeFakeChild(): FakeChild {
+  const stdout = new PassThrough()
+  const written: string[] = []
+  const child: any = new EventEmitter()
+  child.stdout = stdout
+  child.stderr = new PassThrough()
+  child.killed = false
+  child.kill = () => {}
+  child.stdin = {
+    write: (line: string, cb?: (error?: Error | null) => void) => {
+      written.push(String(line))
+      cb?.(null)
+      return true
+    }
+  }
+  return { child, stdout, written }
+}
+
+// The constructor is private in TS only; tests drive it directly to avoid spawning `pi`.
+function makeProcess(child: any): PiRpcProcess {
+  return new (PiRpcProcess as unknown as new (c: any) => PiRpcProcess)(child)
+}
+
+function pendingSize(proc: PiRpcProcess): number {
+  return (proc as unknown as { pending: Map<string, unknown> }).pending.size
+}
+
+function writeLine(stdout: PassThrough, msg: unknown): Promise<void> {
+  stdout.write(`${JSON.stringify(msg)}\n`)
+  return new Promise<void>(resolve => setImmediate(() => setImmediate(resolve)))
+}
+
+test('PiRpcProcess: auxiliary context usage has a one-second timeout', () => {
+  assert.equal(SESSION_STATS_TIMEOUT_MS, 1_000)
+})
+
+test('PiRpcProcess: getSessionStats without a timeout accepts a response after one second', async () => {
+  const { child, stdout, written } = makeFakeChild()
+  const proc = makeProcess(child)
+
+  const result = proc.getSessionStats()
+  const sent = JSON.parse(written[0]) as { id: string }
+
+  await new Promise(resolve => setTimeout(resolve, SESSION_STATS_TIMEOUT_MS + 50))
+  assert.equal(pendingSize(proc), 1)
+
+  await writeLine(stdout, {
+    type: 'response',
+    id: sent.id,
+    command: 'get_session_stats',
+    success: true,
+    data: { totalMessages: 42 }
+  })
+
+  assert.deepEqual(await result, { totalMessages: 42 })
+  assert.equal(pendingSize(proc), 0)
+})
+
+test('PiRpcProcess: request timeout rejects, clears pending, and swallows the late response', async () => {
+  const { child, stdout, written } = makeFakeChild()
+  const proc = makeProcess(child)
+
+  const events: unknown[] = []
+  proc.onEvent(ev => events.push(ev))
+
+  // The request timer is unref'd; keep the test process alive until it fires.
+  const keepAlive = setTimeout(() => {}, 50)
+  try {
+    await assert.rejects(proc.getSessionStats(5), /pi get_session_stats timed out after 5ms/)
+  } finally {
+    clearTimeout(keepAlive)
+  }
+  assert.equal(pendingSize(proc), 0)
+
+  const sent = JSON.parse(written[0]) as { id: string; type: string }
+  assert.equal(sent.type, 'get_session_stats')
+
+  await writeLine(stdout, {
+    type: 'response',
+    id: sent.id,
+    command: 'get_session_stats',
+    success: true,
+    data: { contextUsage: { tokens: 1, contextWindow: 2 } }
+  })
+
+  assert.deepEqual(events, [])
+  assert.equal(pendingSize(proc), 0)
+})
+
+test('PiRpcProcess: response before the timeout resolves and clears pending', async () => {
+  const { child, stdout, written } = makeFakeChild()
+  const proc = makeProcess(child)
+
+  const events: unknown[] = []
+  proc.onEvent(ev => events.push(ev))
+
+  const p = proc.getSessionStats(5_000)
+  const sent = JSON.parse(written[0]) as { id: string }
+
+  await writeLine(stdout, {
+    type: 'response',
+    id: sent.id,
+    command: 'get_session_stats',
+    success: true,
+    data: { contextUsage: { tokens: 10, contextWindow: 100 } }
+  })
+
+  assert.deepEqual(await p, { contextUsage: { tokens: 10, contextWindow: 100 } })
+  assert.equal(pendingSize(proc), 0)
+  assert.deepEqual(events, [])
+})
+
+test('PiRpcProcess: responses with unknown ids are dropped while real events are delivered', async () => {
+  const { child, stdout } = makeFakeChild()
+  const proc = makeProcess(child)
+
+  const events: unknown[] = []
+  proc.onEvent(ev => events.push(ev))
+
+  await writeLine(stdout, { type: 'response', id: 'nope', command: 'get_state', success: true, data: {} })
+  await writeLine(stdout, { type: 'response', command: 'get_state', success: true, data: {} })
+  await writeLine(stdout, { type: 'agent_start' })
+
+  assert.deepEqual(events, [{ type: 'agent_start' }])
+})

package/port/oracle/pi-acp/test/unit/pi-rpc-session-path.test.ts

@@ -0,0 +1,93 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { chmodSync, existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { PiRpcProcess } from '../../src/pi-rpc/process.js'
+
+function writeFakePi(root: string): string {
+  const fixture = join(root, 'fake-pi.cjs')
+  writeFileSync(
+    fixture,
+    [
+      "const { appendFileSync } = require('node:fs')",
+      "const readline = require('node:readline')",
+      "const sessionPath = process.argv[process.argv.indexOf('--session') + 1]",
+      "appendFileSync(sessionPath, 'started\\n')",
+      "readline.createInterface({ input: process.stdin }).on('line', line => {",
+      '  const command = JSON.parse(line)',
+      "  process.stdout.write(JSON.stringify({ type: 'response', id: command.id, command: command.type, success: true, data: { sessionFile: sessionPath } }) + '\\n')",
+      '  setTimeout(() => process.exit(0), 20)',
+      '})'
+    ].join('\n')
+  )
+  return fixture
+}
+
+test('PiRpcProcess passes distinct session paths intact to the pi launcher', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'pi-acp launcher '))
+  const fixture = writeFakePi(root)
+  const launchers = process.platform === 'win32' ? ['pi.cmd', 'pi.bat'] : ['pi']
+  const previousTestVar = process.env.PI_ACP_PATH_TEST
+
+  process.env.PI_ACP_PATH_TEST = 'expanded'
+
+  try {
+    const sessionDir = join(root, 'project & (a) ^ 100% !PI_ACP_PATH_TEST! %PI_ACP_PATH_TEST%')
+    mkdirSync(sessionDir)
+
+    for (const launcherName of launchers) {
+      const launcher = join(root, launcherName)
+      if (process.platform === 'win32') {
+        writeFileSync(launcher, `@echo off\r\n"${process.execPath}" "${fixture}" %*\r\n`)
+      } else {
+        writeFileSync(launcher, `#!/usr/bin/env node\nrequire('./fake-pi.cjs')\n`)
+        chmodSync(launcher, 0o755)
+      }
+
+      const first = join(sessionDir, `${launcherName}-first.jsonl`)
+      const second = join(sessionDir, `${launcherName}-second.jsonl`)
+
+      for (const sessionPath of [first, second]) {
+        const proc = await PiRpcProcess.spawn({ cwd: root, piCommand: launcher, sessionPath })
+        proc.dispose()
+      }
+
+      assert.equal(readFileSync(first, 'utf8'), 'started\n')
+      assert.equal(readFileSync(second, 'utf8'), 'started\n')
+      assert.equal(existsSync(join(root, 'project')), false)
+    }
+  } finally {
+    if (previousTestVar === undefined) delete process.env.PI_ACP_PATH_TEST
+    else process.env.PI_ACP_PATH_TEST = previousTestVar
+    await new Promise(resolve => setTimeout(resolve, 50))
+    rmSync(root, { recursive: true, force: true })
+  }
+})
+
+test(
+  'PiRpcProcess keeps a simulated Windows cmd session path intact',
+  { skip: process.platform === 'win32' },
+  async () => {
+    const root = mkdtempSync(join(tmpdir(), 'pi-acp-cmd-'))
+    writeFakePi(root)
+    const launcher = join(root, 'pi.cmd')
+    writeFileSync(launcher, "#!/usr/bin/env node\nrequire('./fake-pi.cjs')\n")
+    chmodSync(launcher, 0o755)
+    const sessionDir = join(root, 'my project')
+    mkdirSync(sessionDir)
+    const sessionPath = join(sessionDir, 'restored.jsonl')
+    const originalPlatform = process.platform
+
+    try {
+      Object.defineProperty(process, 'platform', { value: 'win32' })
+      const proc = await PiRpcProcess.spawn({ cwd: root, piCommand: launcher, sessionPath })
+      proc.dispose()
+      assert.equal(readFileSync(sessionPath, 'utf8'), 'started\n')
+    } finally {
+      Object.defineProperty(process, 'platform', { value: originalPlatform })
+      await new Promise(resolve => setTimeout(resolve, 50))
+      rmSync(root, { recursive: true, force: true })
+    }
+  }
+)

package/port/oracle/pi-acp/test/unit/pi-tools.test.ts

@@ -0,0 +1,40 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { toolResultToText } from '../../src/acp/translate/pi-tools.js'
+
+test('toolResultToText: extracts text from content blocks', () => {
+  const text = toolResultToText({
+    content: [
+      { type: 'text', text: 'hello' },
+      { type: 'text', text: ' world' }
+    ]
+  })
+  assert.equal(text, 'hello world')
+})
+
+test('toolResultToText: prefers details.diff when present', () => {
+  const text = toolResultToText({
+    content: [{ type: 'text', text: 'Successfully replaced 2 block(s) in a.txt.' }],
+    details: { diff: '--- a\n+++ b\n' }
+  })
+  assert.equal(text, '--- a\n+++ b\n')
+})
+
+test('toolResultToText: falls back to JSON', () => {
+  const text = toolResultToText({ a: 1 })
+  assert.match(text, /"a": 1/)
+})
+
+test('toolResultToText: extracts bash stdout/stderr from details', () => {
+  const text = toolResultToText({
+    details: {
+      stdout: 'ok\n',
+      stderr: 'warn\n',
+      exitCode: 0
+    }
+  })
+  assert.match(text, /ok/)
+  assert.match(text, /stderr:/)
+  assert.match(text, /warn/)
+  assert.match(text, /exit code: 0/)
+})

package/port/oracle/pi-acp/test/unit/prompt-to-pi-message.test.ts

@@ -0,0 +1,74 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { promptToPiMessage } from '../../src/acp/translate/prompt.js'
+
+test('promptToPiMessage: concatenates text and resource links', () => {
+  const { message, images } = promptToPiMessage([
+    { type: 'text', text: 'Hello' },
+    { type: 'resource_link', uri: 'file:///tmp/foo.txt', name: 'foo' },
+    { type: 'text', text: ' world' }
+  ])
+
+  assert.equal(message, 'Hello\n[Context] file:///tmp/foo.txt world')
+  assert.deepEqual(images, [])
+})
+
+test('promptToPiMessage: includes embedded resource text as marker', () => {
+  const { message, images } = promptToPiMessage([
+    {
+      type: 'resource',
+      resource: {
+        uri: 'file:///tmp/a.txt',
+        mimeType: 'text/plain',
+        text: 'hi'
+      }
+    }
+  ] as any)
+
+  assert.equal(message, '\n[Embedded Context] file:///tmp/a.txt (text/plain)\nhi')
+  assert.deepEqual(images, [])
+})
+
+test('promptToPiMessage: includes embedded resource blob as marker', () => {
+  const blob = Buffer.from('xyz', 'utf8').toString('base64')
+
+  const { message, images } = promptToPiMessage([
+    {
+      type: 'resource',
+      resource: {
+        uri: 'file:///tmp/a.bin',
+        mimeType: 'application/octet-stream',
+        blob
+      }
+    }
+  ] as any)
+
+  assert.equal(message, '\n[Embedded Context] file:///tmp/a.bin (application/octet-stream, 3 bytes)')
+  assert.deepEqual(images, [])
+})
+
+test('promptToPiMessage: includes audio as marker', () => {
+  const data = Buffer.from('abc', 'utf8').toString('base64')
+
+  const { message, images } = promptToPiMessage([{ type: 'audio', mimeType: 'audio/wav', data }] as any)
+
+  assert.equal(message, '\n[Audio] (audio/wav, 3 bytes) not supported by pi-acp')
+  assert.deepEqual(images, [])
+})
+
+test('promptToPiMessage: maps image to pi image content', () => {
+  const base64 = Buffer.from('abc', 'utf8').toString('base64')
+
+  const { message, images } = promptToPiMessage([
+    { type: 'text', text: 'see' },
+    { type: 'image', mimeType: 'image/png', data: base64, uri: 'img-1' }
+  ])
+
+  assert.equal(message, 'see')
+  assert.equal(images.length, 1)
+  assert.deepEqual(images[0], {
+    type: 'image',
+    mimeType: 'image/png',
+    data: base64
+  })
+})