@zooid/acp-client 0.7.4 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zooid/acp-client",
-  "version": "0.7.4",
+  "version": "0.9.0",
   "description": "Zooid's ACP client: spawn agent subprocesses, drive them via Agent Client Protocol, route events and permission requests through callbacks.",
   "type": "module",
   "license": "MIT",

package/src/command-discovery.integration.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from 'vitest'
+import { AcpClient } from './acp-client.js'
+import type { PresetName } from './index.js'
+import type { TapEvent } from './turn-tracker.js'
+
+const E2E = process.env.ZOOID_ACP_E2E === '1'
+const TURN_TIMEOUT_MS = 120_000
+
+interface Advert {
+  advertised: boolean
+  updateCount: number
+  totalCommands: number
+  sampleNames: string[]
+  firstSeenBeforeTurnEnd: boolean
+}
+
+async function probe(preset: PresetName): Promise<Advert> {
+  const taps: TapEvent[] = []
+  const client = new AcpClient({
+    agent: { id: `e2e-${preset}`, preset },
+    onEvent: () => {},
+    onApprovalRequest: async (req) => ({
+      decision: 'allow',
+      optionId: req.options[0]?.optionId ?? 'allow',
+    }),
+    onTap: (e) => taps.push(e),
+  })
+  await client.start()
+  try {
+    await client.prompt({ threadId: `e2e-cmd-${preset}`, content: [{ type: 'text', text: 'hi' }] })
+  } finally {
+    await client.stop()
+  }
+
+  const updates = taps.filter(
+    (t): t is Extract<TapEvent, { kind: 'session_update' }> =>
+      t.kind === 'session_update' && t.update.sessionUpdate === 'available_commands_update',
+  )
+  const names = new Set<string>()
+  for (const u of updates) {
+    for (const c of (u.update as { availableCommands?: Array<{ name?: string }> }).availableCommands ?? []) {
+      if (typeof c.name === 'string') names.add(c.name)
+    }
+  }
+  return {
+    advertised: updates.length > 0,
+    updateCount: updates.length,
+    totalCommands: names.size,
+    sampleNames: [...names].slice(0, 8),
+    firstSeenBeforeTurnEnd: updates.length > 0,
+  }
+}
+
+describe.skipIf(!E2E)('cross-shim command advertisement (opt-in: ZOOID_ACP_E2E=1)', () => {
+  for (const preset of ['claude', 'codex', 'opencode'] as const) {
+    it(
+      `${preset}: record whether commands are advertised over ACP`,
+      async () => {
+        const a = await probe(preset)
+        console.log(`[commands] ${preset}:`, JSON.stringify(a))
+        if (a.advertised) expect(a.sampleNames.every((n) => n.length > 0)).toBe(true)
+      },
+      TURN_TIMEOUT_MS,
+    )
+  }
+})

package/src/errors.ts

@@ -10,12 +10,13 @@ export type ErrorCode =
   | 'container_exit'
   | 'acp_protocol'
   | 'permission_denied'
+  | 'media_failed'
   | 'internal'
 
 export interface Classified {
   code: ErrorCode
   transient: boolean
-  /** Verbatim ACP RequestError triple — forwarded into eco.zoon.error.acp_error. */
+  /** Verbatim ACP RequestError triple — forwarded into dev.zooid.error.acp_error. */
   acp_error?: { code: number; message: string; data?: unknown }
 }
 

package/src/event-mapping.test.ts

@@ -97,6 +97,27 @@ describe('acpUpdateToAgentEvent', () => {
     }
   })
 
+  it('maps available_commands_update to an available_commands event', () => {
+    const event = acpUpdateToAgentEvent({
+      sessionId: 's-1',
+      update: {
+        sessionUpdate: 'available_commands_update',
+        availableCommands: [
+          { name: 'plan', description: 'Switch to plan mode' },
+          { name: 'compact', description: 'Compact the context', input: null },
+        ],
+      } as never,
+    })
+    expect(event).toEqual<AgentEvent>({
+      type: 'available_commands',
+      sessionId: 's-1',
+      commands: [
+        { name: 'plan', description: 'Switch to plan mode' },
+        { name: 'compact', description: 'Compact the context' },
+      ],
+    })
+  })
+
   it('returns null for unknown update variants (forward-compat)', () => {
     const event = acpUpdateToAgentEvent({
       sessionId: 's-1',

package/src/event-mapping.ts

@@ -47,6 +47,17 @@ export function acpUpdateToAgentEvent(
       }
     case 'plan':
       return { type: 'plan', sessionId, entries: update.entries }
+    case 'available_commands_update': {
+      const u = update as { availableCommands?: Array<{ name: string; description: string }> }
+      return {
+        type: 'available_commands',
+        sessionId,
+        commands: (u.availableCommands ?? []).map((c) => ({
+          name: c.name,
+          description: c.description,
+        })),
+      }
+    }
     default:
       return null
   }

package/src/index.ts

@@ -18,6 +18,8 @@ export type {
   ApprovalDecision,
   ApprovalRequest,
   AgentMessageChunkEvent,
+  AvailableCommandsEvent,
+  ContentBlock,
   PlanEvent,
   PromptInput,
   PromptResult,

package/src/planning-tools.integration.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it } from 'vitest'
+import { AcpClient } from './acp-client.js'
+import type { AgentEvent, PresetName } from './index.js'
+
+const E2E = process.env.ZOOID_ACP_E2E === '1'
+const PROMPT =
+  "let's test your planning tools. Using your tasks/planning tools, make a grocery " +
+  'list with bananas, bread, and milk, and then complete it.'
+
+// Per-shim turn budget — real model calls are slow.
+const TURN_TIMEOUT_MS = 180_000
+
+interface PlanLike {
+  content: string
+  status: string
+}
+
+// Recognize a planning tool call by its rawInput shape (tool *kind* is an opaque
+// ACP enum like "other"/"think", so we key on the payload, not the name).
+function planFromToolInput(rawInput: unknown): PlanLike[] | null {
+  if (!rawInput || typeof rawInput !== 'object') return null
+  const r = rawInput as Record<string, unknown>
+  if (Array.isArray(r.todos)) {
+    return r.todos
+      .map((t) => t as Record<string, unknown>)
+      .filter((t) => typeof t.content === 'string' && typeof t.status === 'string')
+      .map((t) => ({ content: t.content as string, status: t.status as string }))
+  }
+  if (Array.isArray(r.plan)) {
+    return r.plan
+      .map((p) => p as Record<string, unknown>)
+      .filter((p) => typeof p.step === 'string' && typeof p.status === 'string')
+      .map((p) => ({ content: p.step as string, status: p.status as string }))
+  }
+  return null
+}
+
+interface Classification {
+  viaPlanEvent: boolean
+  viaToolCall: boolean
+  sawInProgressOrCompleted: boolean
+  snapshots: number
+}
+
+function classify(events: AgentEvent[]): Classification {
+  let viaPlanEvent = false
+  let viaToolCall = false
+  let sawProgress = false
+  let snapshots = 0
+  for (const ev of events) {
+    let entries: PlanLike[] | null = null
+    if (ev.type === 'plan') {
+      viaPlanEvent = true
+      entries = ev.entries.map((e) => ({ content: e.content, status: e.status }))
+    } else if (ev.type === 'tool_call' || ev.type === 'tool_call_update') {
+      entries = planFromToolInput(ev.rawInput)
+      if (entries) viaToolCall = true
+    }
+    if (entries) {
+      snapshots++
+      if (entries.some((e) => e.status === 'in_progress' || e.status === 'completed')) {
+        sawProgress = true
+      }
+    }
+  }
+  return { viaPlanEvent, viaToolCall, sawInProgressOrCompleted: sawProgress, snapshots }
+}
+
+async function runShim(preset: PresetName): Promise<Classification> {
+  const events: AgentEvent[] = []
+  const client = new AcpClient({
+    agent: { id: `e2e-${preset}`, preset },
+    onEvent: (e) => events.push(e),
+    // Auto-approve everything so file/exec tools don't block the turn.
+    onApprovalRequest: async (req) => ({
+      decision: 'allow',
+      optionId: req.options[0]?.optionId ?? 'allow',
+    }),
+  })
+  await client.start()
+  try {
+    await client.prompt({
+      threadId: `e2e-thread-${preset}`,
+      content: [{ type: 'text', text: PROMPT }],
+    })
+  } finally {
+    await client.stop()
+  }
+  return classify(events)
+}
+
+describe.skipIf(!E2E)('cross-shim planning tools (opt-in: ZOOID_ACP_E2E=1)', () => {
+  for (const preset of ['claude', 'codex', 'opencode'] as const) {
+    it(
+      `${preset} surfaces a plan in some form, with a status transition`,
+      async () => {
+        const c = await runShim(preset)
+        // Record the finding (visible in test output) — this is the deliverable.
+        console.log(`[planning] ${preset}:`, JSON.stringify(c))
+        expect(c.viaPlanEvent || c.viaToolCall).toBe(true)
+        expect(c.snapshots).toBeGreaterThan(0)
+        expect(c.sawInProgressOrCompleted).toBe(true)
+      },
+      TURN_TIMEOUT_MS,
+    )
+  }
+})

package/src/types.ts

@@ -6,6 +6,8 @@ import type {
   ToolCallStatus,
   ToolKind,
 } from '@agentclientprotocol/sdk'
+
+export type { ContentBlock }
 import type { PresetName } from './presets.js'
 
 /**
@@ -58,6 +60,13 @@ export type AgentEvent =
   | ToolCallEvent
   | ToolCallUpdateEvent
   | PlanEvent
+  | AvailableCommandsEvent
+
+export interface AvailableCommandsEvent {
+  type: 'available_commands'
+  sessionId: string
+  commands: Array<{ name: string; description: string }>
+}
 
 export interface AgentMessageChunkEvent {
   type: 'agent_message_chunk'