@1agh/maude 0.45.1 → 0.46.0

package/apps/studio/test/element-structural-edit.test.ts

@@ -12,9 +12,13 @@ import {
   applyInsertElement,
   applyInsertElementIntoArtboard,
   applyResizeArtboard,
+  applySetArtboardGuides,
   applySetArtboardHug,
+  applySetArtboardKind,
+  applySetArtboardPrint,
   applySetArtboardStyle,
   CanvasEditError,
+  readArtboardPrintProp,
 } from '../canvas-edit.ts';
 import { transpileCanvasSource } from '../canvas-pipeline.ts';
 
@@ -337,6 +341,252 @@ describe('canvas-edit / applySetArtboardStyle (background/padding/layout/gap)',
       CanvasEditError
     );
   });
+
+  // Dogfood (artboard panel ↔ shared inspector controls) — padding/gap accept
+  // a var(--token) STRING binding alongside raw px numbers.
+  test('padding/gap accept a var(--token) string (space-token binding)', () => {
+    const out = applySetArtboardStyle(CANVAS, canvas, 'home', {
+      padding: 'var(--space-4)',
+      gap: 'var(--space-2)',
+    });
+    expect(out.source).toContain('padding="var(--space-4)"');
+    expect(out.source).toContain('gap="var(--space-2)"');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('a token binding round-trips back to a raw number (detach) and vice versa', () => {
+    const bound = applySetArtboardStyle(CANVAS, canvas, 'home', { padding: 'var(--space-4)' });
+    const detached = applySetArtboardStyle(CANVAS, bound.source, 'home', { padding: 24 });
+    expect(detached.source).toContain('padding={24}');
+    expect(detached.source).not.toContain('var(--space-4)');
+    const rebound = applySetArtboardStyle(CANVAS, detached.source, 'home', {
+      padding: 'var(--space-6)',
+    });
+    expect(rebound.source).toContain('padding="var(--space-6)"');
+    expect(rebound.source).not.toContain('padding={24}');
+    expect(parses(rebound.source)).toBe(true);
+  });
+});
+
+// feature-1-artboard-kinds-foundation, T5/T8 — kind-switch write lane.
+describe('canvas-edit / applySetArtboardKind', () => {
+  const canvas = [
+    'export default function Demo() {',
+    '  return (',
+    '    <DesignCanvas>',
+    '      <DCArtboard id="home" label="Home" width={1440} height={1024}>',
+    '        <div>content</div>',
+    '      </DCArtboard>',
+    '    </DesignCanvas>',
+    '  );',
+    '}',
+  ].join('\n');
+
+  test('writes kind as a plain string-literal prop', () => {
+    const out = applySetArtboardKind(CANVAS, canvas, 'home', 'print');
+    expect(out.source).toContain('kind="print"');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('switching kind replaces the previous value, no duplicate attr', () => {
+    const printed = applySetArtboardKind(CANVAS, canvas, 'home', 'print');
+    const out = applySetArtboardKind(CANVAS, printed.source, 'home', 'web');
+    expect(out.source).toContain('kind="web"');
+    expect(out.source).not.toContain('kind="print"');
+    expect(out.source.match(/\bkind=/g)?.length).toBe(1);
+  });
+
+  test('kind=null clears back to the implicit default', () => {
+    const printed = applySetArtboardKind(CANVAS, canvas, 'home', 'print');
+    const out = applySetArtboardKind(CANVAS, printed.source, 'home', null);
+    expect(out.source).not.toContain('kind=');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('an invalid kind value throws rather than writing garbage', () => {
+    expect(() => applySetArtboardKind(CANVAS, canvas, 'home', 'poster')).toThrow(CanvasEditError);
+  });
+
+  test('unknown artboard id throws', () => {
+    expect(() => applySetArtboardKind(CANVAS, canvas, 'nope', 'print')).toThrow(CanvasEditError);
+  });
+});
+
+// feature-1-artboard-kinds-foundation, T5 — generic layout guides write lane.
+describe('canvas-edit / applySetArtboardGuides (replace-whole-prop)', () => {
+  const canvas = [
+    'export default function Demo() {',
+    '  return (',
+    '    <DesignCanvas>',
+    '      <DCArtboard id="home" label="Home" width={1440} height={1024}>',
+    '        <div>content</div>',
+    '      </DCArtboard>',
+    '    </DesignCanvas>',
+    '  );',
+    '}',
+  ].join('\n');
+
+  test('inserts guides as a {{...}} object-expression prop', () => {
+    const out = applySetArtboardGuides(CANVAS, canvas, 'home', {
+      columns: { count: 12, gutter: 24, margin: 80 },
+    });
+    expect(out.source).toContain('guides={{"columns":{"count":12,"gutter":24,"margin":80}}}');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('a second write REPLACES the whole prop rather than merging', () => {
+    const first = applySetArtboardGuides(CANVAS, canvas, 'home', {
+      columns: { count: 12, gutter: 24, margin: 80 },
+    });
+    const out = applySetArtboardGuides(CANVAS, first.source, 'home', { grid: { size: 8 } });
+    expect(out.source).toContain('guides={{"grid":{"size":8}}}');
+    expect(out.source).not.toContain('columns');
+    expect(out.source.match(/\bguides=/g)?.length).toBe(1);
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('guides=null removes the prop', () => {
+    const written = applySetArtboardGuides(CANVAS, canvas, 'home', { grid: { size: 8 } });
+    const out = applySetArtboardGuides(CANVAS, written.source, 'home', null);
+    expect(out.source).not.toContain('guides=');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('unknown artboard id throws', () => {
+    expect(() => applySetArtboardGuides(CANVAS, canvas, 'nope', { grid: { size: 8 } })).toThrow(
+      CanvasEditError
+    );
+  });
+});
+
+// feature-2-print-artboards T2 — print prop write lane (same replace-whole-
+// prop shape as applySetArtboardGuides).
+describe('canvas-edit / applySetArtboardPrint (replace-whole-prop)', () => {
+  const canvas = [
+    'export default function Demo() {',
+    '  return (',
+    '    <DesignCanvas>',
+    '      <DCArtboard id="home" label="Home" width={1440} height={1024}>',
+    '        <div>content</div>',
+    '      </DCArtboard>',
+    '    </DesignCanvas>',
+    '  );',
+    '}',
+  ].join('\n');
+
+  test('inserts print as a {{...}} object-expression prop', () => {
+    const out = applySetArtboardPrint(CANVAS, canvas, 'home', { paper: 'a4', bleedMm: 3 });
+    expect(out.source).toContain('print={{"paper":"a4","bleedMm":3}}');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('a second write REPLACES the whole prop rather than merging', () => {
+    const first = applySetArtboardPrint(CANVAS, canvas, 'home', { paper: 'a4', bleedMm: 3 });
+    const out = applySetArtboardPrint(CANVAS, first.source, 'home', {
+      paper: 'letter',
+      orientation: 'landscape',
+    });
+    expect(out.source).toContain('print={{"paper":"letter","orientation":"landscape"}}');
+    expect(out.source).not.toContain('a4');
+    expect(out.source.match(/\bprint=/g)?.length).toBe(1);
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('print=null removes the prop', () => {
+    const written = applySetArtboardPrint(CANVAS, canvas, 'home', { paper: 'a4' });
+    const out = applySetArtboardPrint(CANVAS, written.source, 'home', null);
+    expect(out.source).not.toContain('print=');
+    expect(parses(out.source)).toBe(true);
+  });
+
+  test('unknown artboard id throws', () => {
+    expect(() => applySetArtboardPrint(CANVAS, canvas, 'nope', { paper: 'a4' })).toThrow(
+      CanvasEditError
+    );
+  });
+});
+
+// feature-2-print-artboards T5 — the AST-only (no-eval) reader the PDF
+// exporter uses to resolve an artboard's print geometry.
+describe('canvas-edit / readArtboardPrintProp (no-eval AST read)', () => {
+  test('reads a JSON-shaped print prop on a kind="print" artboard (the picker\'s own write shape)', () => {
+    const canvas = [
+      'export default function Demo() {',
+      '  return (',
+      '    <DesignCanvas>',
+      '      <DCArtboard id="home" label="Home" kind="print" width={816} height={1146} print={{"paper":"a4","bleedMm":3}}>',
+      '        <div>content</div>',
+      '      </DCArtboard>',
+      '    </DesignCanvas>',
+      '  );',
+      '}',
+    ].join('\n');
+    expect(readArtboardPrintProp(CANVAS, canvas, 'home')).toEqual({ paper: 'a4', bleedMm: 3 });
+  });
+
+  test('reads a hand-authored JS-literal print prop (unquoted keys, nested object)', () => {
+    const canvas = [
+      'export default function Demo() {',
+      '  return (',
+      '    <DesignCanvas>',
+      '      <DCArtboard id="home" label="Home" kind="print" width={816} height={1146} print={{ paper: \'a4\', orientation: \'landscape\', marginsMm: { top: 10, left: 5 } }}>',
+      '        <div>content</div>',
+      '      </DCArtboard>',
+      '    </DesignCanvas>',
+      '  );',
+      '}',
+    ].join('\n');
+    expect(readArtboardPrintProp(CANVAS, canvas, 'home')).toEqual({
+      paper: 'a4',
+      orientation: 'landscape',
+      marginsMm: { top: 10, left: 5 },
+    });
+  });
+
+  test('no print prop → null', () => {
+    const canvas = [
+      'export default function Demo() {',
+      '  return (',
+      '    <DesignCanvas>',
+      '      <DCArtboard id="home" label="Home" kind="print" width={1440} height={1024}>',
+      '        <div>content</div>',
+      '      </DCArtboard>',
+      '    </DesignCanvas>',
+      '  );',
+      '}',
+    ].join('\n');
+    expect(readArtboardPrintProp(CANVAS, canvas, 'home')).toBeNull();
+  });
+
+  test('unknown artboard id → null (not a throw — read-only, best-effort)', () => {
+    const canvas = [
+      'export default function Demo() {',
+      '  return (',
+      '    <DesignCanvas>',
+      '      <DCArtboard id="home" label="Home" kind="print" width={1440} height={1024}>',
+      '        <div>content</div>',
+      '      </DCArtboard>',
+      '    </DesignCanvas>',
+      '  );',
+      '}',
+    ].join('\n');
+    expect(readArtboardPrintProp(CANVAS, canvas, 'nope')).toBeNull();
+  });
+
+  test('dogfood regression — a print prop present but kind NOT "print" → null (a stale prop from a prior kind switch must never leak into export)', () => {
+    const canvas = [
+      'export default function Demo() {',
+      '  return (',
+      '    <DesignCanvas>',
+      '      <DCArtboard id="home" label="Home" width={1440} height={1024} print={{"paper":"a4","bleedMm":3}}>',
+      '        <div>content</div>',
+      '      </DCArtboard>',
+      '    </DesignCanvas>',
+      '  );',
+      '}',
+    ].join('\n');
+    expect(readArtboardPrintProp(CANVAS, canvas, 'home')).toBeNull();
+  });
 });
 
 describe('canvas-edit / applyInsertArtboard (I4)', () => {

package/apps/studio/test/exporters/png.test.ts

@@ -8,7 +8,7 @@
 
 import { describe, expect, test } from 'bun:test';
 
-import { clampScale, run } from '../../exporters/png.ts';
+import { clampDpi, clampScale, resolveDeviceScale, run } from '../../exporters/png.ts';
 
 const CTX = {
   designRoot: '/tmp/.design',
@@ -53,3 +53,51 @@ describe('png clampScale — size presets (item 1)', () => {
     expect(clampScale(1.2)).toBe(1);
   });
 });
+
+describe('png clampDpi — feature-2-print-artboards T4', () => {
+  test('undefined/null → undefined (falls back to scale)', () => {
+    expect(clampDpi(undefined)).toBeUndefined();
+    expect(clampDpi(null)).toBeUndefined();
+  });
+
+  test('non-numeric → undefined', () => {
+    expect(clampDpi('nonsense')).toBeUndefined();
+  });
+
+  test('exact presets pass through', () => {
+    expect(clampDpi(96)).toBe(96);
+    expect(clampDpi(150)).toBe(150);
+    expect(clampDpi(300)).toBe(300);
+    expect(clampDpi(600)).toBe(600);
+  });
+
+  test('snaps to the nearest preset', () => {
+    expect(clampDpi(200)).toBe(150);
+    expect(clampDpi(250)).toBe(300);
+    expect(clampDpi(1000)).toBe(600);
+    expect(clampDpi(0)).toBe(96);
+  });
+});
+
+describe('png resolveDeviceScale — dpi wins over scale', () => {
+  test('dpi=300 → 3.125× (300/96)', () => {
+    expect(resolveDeviceScale({ dpi: 300 })).toBeCloseTo(300 / 96, 10);
+  });
+
+  test('dpi=600 → 6.25× (300dpi ceiling raise, item T4)', () => {
+    expect(resolveDeviceScale({ dpi: 600 })).toBeCloseTo(600 / 96, 10);
+  });
+
+  test('dpi=96 → 1× (no-op)', () => {
+    expect(resolveDeviceScale({ dpi: 96 })).toBeCloseTo(1, 10);
+  });
+
+  test('no dpi → falls back to the legacy scale preset', () => {
+    expect(resolveDeviceScale({ scale: 3 })).toBe(3);
+    expect(resolveDeviceScale({})).toBe(2); // clampScale default
+  });
+
+  test('dpi present but not a number → falls back to scale', () => {
+    expect(resolveDeviceScale({ dpi: 'nope', scale: 1 })).toBe(1);
+  });
+});

package/apps/studio/test/fixtures/mock-acp-agent-caps.mjs

@@ -0,0 +1,158 @@
+#!/usr/bin/env bun
+// Mock ACP agent exercising the session-capabilities channel (feature-acp-
+// panel-dynamic-claude-code-capabilities) — modes + configOptions returned
+// from session/new, live session/set_mode + session/set_config_option, and
+// the config_option_update / session_info_update notifications a real
+// claude-agent-acp session emits. No real `claude` needed.
+//
+// Mirrors the REAL adapter's observed behavior (read from the installed
+// @agentclientprotocol/claude-agent-acp source, not guessed):
+//   - session/set_mode updates the mode AND mirrors it into configOptions'
+//     "mode" entry, emitting ONLY a config_option_update notification (no
+//     current_mode_update) — bridge.ts cross-derives lastModes from that.
+//   - session/set_config_option('model', …) can change which OTHER options
+//     are offered (here: picking "opus" adds a "fast" option) and returns
+//     the FULL refreshed configOptions in its RPC response (no notification).
+
+import { Readable, Writable } from 'node:stream';
+
+import * as acp from '@agentclientprotocol/sdk';
+
+const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
+
+const MODEL_OPTIONS = [
+  { value: 'sonnet', name: 'Sonnet' },
+  { value: 'opus', name: 'Opus' },
+];
+const EFFORT_OPTIONS = [
+  { value: 'default', name: 'Default' },
+  { value: 'high', name: 'High' },
+];
+const MODE_OPTIONS = [
+  { value: 'default', name: 'Manual' },
+  { value: 'plan', name: 'Plan Mode' },
+];
+const AVAILABLE_MODES = [
+  {
+    id: 'default',
+    name: 'Manual',
+    description: 'Standard behavior, prompts for dangerous operations',
+  },
+  { id: 'plan', name: 'Plan Mode', description: 'Planning mode, no actual tool execution' },
+];
+
+// `session` carries every tracked field (model/effort/mode/fast) so a call
+// that rebuilds the FULL option set (e.g. session/set_mode, which is scoped
+// to just the mode) never regresses a field a PRIOR call already changed —
+// mirrors the real adapter's `session.configOptions` being one persistent
+// object, not independently recomputed per field.
+function baseConfigOptions(session) {
+  const opts = [
+    {
+      id: 'model',
+      name: 'Model',
+      category: 'model',
+      type: 'select',
+      currentValue: session.model,
+      options: MODEL_OPTIONS,
+    },
+    {
+      id: 'effort',
+      name: 'Effort',
+      category: 'thought_level',
+      type: 'select',
+      currentValue: session.effort,
+      options: EFFORT_OPTIONS,
+    },
+    {
+      id: 'mode',
+      name: 'Mode',
+      category: 'mode',
+      type: 'select',
+      currentValue: session.mode,
+      options: MODE_OPTIONS,
+    },
+  ];
+  if (session.model === 'opus') {
+    opts.push({
+      id: 'fast',
+      name: 'Fast mode',
+      category: 'model_config',
+      type: 'select',
+      currentValue: session.fast,
+      options: [
+        { value: 'on', name: 'On' },
+        { value: 'off', name: 'Off' },
+      ],
+    });
+  }
+  return opts;
+}
+
+let n = 0;
+const sessions = new Map(); // sessionId -> { model, effort, mode, fast }
+
+acp
+  .agent({ name: 'mock-acp-agent-caps' })
+  .onRequest('initialize', () => ({
+    protocolVersion: acp.PROTOCOL_VERSION,
+    agentCapabilities: { loadSession: false },
+  }))
+  .onRequest('session/new', async (ctx) => {
+    const sessionId = `mock-caps-session-${++n}`;
+    const session = { model: 'sonnet', effort: 'default', mode: 'default', fast: 'off' };
+    sessions.set(sessionId, session);
+    await ctx.client.notify('session/update', {
+      sessionId,
+      update: { sessionUpdate: 'session_info_update', title: 'New chat' },
+    });
+    return {
+      sessionId,
+      modes: { currentModeId: 'default', availableModes: AVAILABLE_MODES },
+      configOptions: baseConfigOptions(session),
+    };
+  })
+  .onRequest('session/prompt', async (ctx) => {
+    await ctx.client.notify('session/update', {
+      sessionId: ctx.params.sessionId,
+      update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'ok' } },
+    });
+    return { stopReason: 'end_turn' };
+  })
+  .onRequest('session/set_mode', async (ctx) => {
+    const session = sessions.get(ctx.params.sessionId);
+    if (!session) throw new Error('session not found');
+    if (!AVAILABLE_MODES.some((m) => m.id === ctx.params.modeId)) {
+      throw new Error(`unknown mode: ${ctx.params.modeId}`);
+    }
+    session.mode = ctx.params.modeId;
+    // Real adapter: setSessionMode emits ONLY config_option_update, never
+    // current_mode_update — bridge.ts must cross-derive lastModes from it.
+    await ctx.client.notify('session/update', {
+      sessionId: ctx.params.sessionId,
+      update: { sessionUpdate: 'config_option_update', configOptions: baseConfigOptions(session) },
+    });
+    return {};
+  })
+  .onRequest('session/set_config_option', async (ctx) => {
+    const session = sessions.get(ctx.params.sessionId);
+    if (!session) throw new Error('session not found');
+    const { configId, value } = ctx.params;
+    if (configId === 'model') {
+      if (!MODEL_OPTIONS.some((o) => o.value === value)) throw new Error(`unknown model: ${value}`);
+      session.model = value;
+    } else if (configId === 'effort') {
+      if (!EFFORT_OPTIONS.some((o) => o.value === value))
+        throw new Error(`unknown effort: ${value}`);
+      session.effort = value;
+    } else if (configId === 'mode') {
+      if (!AVAILABLE_MODES.some((m) => m.id === value)) throw new Error(`unknown mode: ${value}`);
+      session.mode = value;
+    } else if (configId === 'fast') {
+      session.fast = value;
+    } else {
+      throw new Error(`unknown config option: ${configId}`);
+    }
+    return { configOptions: baseConfigOptions(session) };
+  })
+  .connect(stream);

package/apps/studio/test/fixtures/mock-acp-agent-elicit-flood.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env bun
+// Mock ACP agent proving the MAX_PENDING_ELICITATIONS cap (feature-acp-ask-
+// user-question, SECURITY / ethical-hacker finding — an unbounded queue lets
+// any connected MCP server flood the client with elicitation requests). Fires
+// MORE than the cap concurrently, without waiting for each one — mirroring a
+// hostile/compromised MCP server that never waits for an answer before
+// issuing the next request — and reports which ones actually round-tripped to
+// the client vs. were declined immediately by the bridge's own cap.
+
+import { Readable, Writable } from 'node:stream';
+
+import * as acp from '@agentclientprotocol/sdk';
+
+const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
+
+const FLOOD_COUNT = 8; // > MAX_PENDING_ELICITATIONS (5) in acp/bridge.ts
+
+let n = 0;
+
+acp
+  .agent({ name: 'mock-acp-agent-elicit-flood' })
+  .onRequest('initialize', () => ({
+    protocolVersion: acp.PROTOCOL_VERSION,
+    agentCapabilities: { loadSession: false },
+  }))
+  .onRequest('session/new', () => ({ sessionId: `mock-elicit-flood-session-${++n}` }))
+  .onRequest('session/prompt', async (ctx) => {
+    const requests = Array.from({ length: FLOOD_COUNT }, (_, i) =>
+      ctx.client.request(acp.methods.client.elicitation.create, {
+        mode: 'form',
+        sessionId: ctx.params.sessionId,
+        message: `Flood question ${i}`,
+        requestedSchema: { type: 'object', properties: { [`q${i}`]: { type: 'string' } } },
+      })
+    );
+    const responses = await Promise.all(requests);
+    await ctx.client.notify('session/update', {
+      sessionId: ctx.params.sessionId,
+      update: {
+        sessionUpdate: 'agent_message_chunk',
+        content: { type: 'text', text: `responses=${JSON.stringify(responses)}` },
+      },
+    });
+    return { stopReason: 'end_turn' };
+  })
+  .connect(stream);

package/apps/studio/test/fixtures/mock-acp-agent-elicit-url.mjs

@@ -0,0 +1,42 @@
+#!/usr/bin/env bun
+// Mock ACP agent that sends a `mode:'url'` elicitation request — proves
+// AcpBridge.unstable_createElicitation rejects it structurally (declines
+// without ever calling onElicitationRequest) even though the adapter/agent
+// side ignored the client's declared `elicitation:{form:{}}`-only capability
+// (ethical-hacker finding — capability negotiation is advisory, not
+// enforced; the client must reject what it never advertised, not just hope
+// the other side honors it).
+
+import { Readable, Writable } from 'node:stream';
+
+import * as acp from '@agentclientprotocol/sdk';
+
+const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
+
+let n = 0;
+
+acp
+  .agent({ name: 'mock-acp-agent-elicit-url' })
+  .onRequest('initialize', () => ({
+    protocolVersion: acp.PROTOCOL_VERSION,
+    agentCapabilities: { loadSession: false },
+  }))
+  .onRequest('session/new', () => ({ sessionId: `mock-elicit-url-session-${++n}` }))
+  .onRequest('session/prompt', async (ctx) => {
+    const response = await ctx.client.request(acp.methods.client.elicitation.create, {
+      mode: 'url',
+      sessionId: ctx.params.sessionId,
+      message: 'Confirm you have completed verification',
+      url: 'https://example.com/verify',
+      elicitationId: 'elicit-url-1',
+    });
+    await ctx.client.notify('session/update', {
+      sessionId: ctx.params.sessionId,
+      update: {
+        sessionUpdate: 'agent_message_chunk',
+        content: { type: 'text', text: `response=${JSON.stringify(response)}` },
+      },
+    });
+    return { stopReason: 'end_turn' };
+  })
+  .connect(stream);

package/apps/studio/test/fixtures/mock-acp-agent-elicit.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env bun
+// Mock ACP agent exercising the elicitation-form gate (feature-acp-ask-user-
+// question) — session/prompt calls back INTO the client via a REAL
+// `elicitation/create` request, shaped exactly like
+// `askUserQuestionsToCreateRequest`'s single-question output (confirmed on
+// disk against the installed `@agentclientprotocol/claude-agent-acp` — a
+// titled `oneOf` enum plus its sibling `_custom` free-text field), before
+// streaming its final reply. Mirrors mock-acp-agent-permission.mjs's shape.
+// No real `claude` needed.
+
+import { Readable, Writable } from 'node:stream';
+
+import * as acp from '@agentclientprotocol/sdk';
+
+const stream = acp.ndJsonStream(Writable.toWeb(process.stdout), Readable.toWeb(process.stdin));
+
+let n = 0;
+
+acp
+  .agent({ name: 'mock-acp-agent-elicit' })
+  .onRequest('initialize', () => ({
+    protocolVersion: acp.PROTOCOL_VERSION,
+    agentCapabilities: { loadSession: false },
+  }))
+  .onRequest('session/new', () => ({ sessionId: `mock-elicit-session-${++n}` }))
+  .onRequest('session/prompt', async (ctx) => {
+    // `ctx.client` (AgentContext) only exposes the generic request()/notify() —
+    // no typed convenience method — so call the raw ACP method via
+    // `acp.methods.client.elicitation.create` (confirmed on disk: acp.js's
+    // `methods.client.elicitation.create === schema.CLIENT_METHODS.elicitation_create`).
+    const response = await ctx.client.request(acp.methods.client.elicitation.create, {
+      mode: 'form',
+      sessionId: ctx.params.sessionId,
+      toolCallId: 'tc-elicit-1',
+      message: 'Which color do you like?',
+      requestedSchema: {
+        type: 'object',
+        properties: {
+          question_0: {
+            type: 'string',
+            oneOf: [
+              { const: 'Red', title: 'Red' },
+              { const: 'Blue', title: 'Blue' },
+            ],
+          },
+          question_0_custom: {
+            type: 'string',
+            title: 'Other',
+            description: 'Type your own answer instead of choosing an option above (optional).',
+          },
+        },
+      },
+    });
+    await ctx.client.notify('session/update', {
+      sessionId: ctx.params.sessionId,
+      update: {
+        sessionUpdate: 'agent_message_chunk',
+        content: { type: 'text', text: `response=${JSON.stringify(response)}` },
+      },
+    });
+    return { stopReason: 'end_turn' };
+  })
+  .connect(stream);