subrouter-cli 0.0.0-stage → 0.1.0

package/test/effort.test.ts

@@ -0,0 +1,123 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { test } from 'node:test';
+import { EFFORT_LEVELS, parseEffort } from '../src/effort.ts';
+import { toWireBody } from '../src/adapters/openai.ts';
+import { toAnthropicBody, AnthropicStreamParser, parseAnthropicCompleteBody } from '../src/adapters/anthropic.ts';
+import { runAgentTurn } from '../src/loop.ts';
+import type { ChatRequest, ChatMessage, AnthropicThinkingBlock } from '../src/types.ts';
+
+const request: ChatRequest = { model: 'openai/test', dialect: 'openai', messages: [], system: '', stream: false, maxTokens: 8192 };
+
+test('effort levels validate input without guessing aliases or unsupported values', () => {
+  for (const effort of EFFORT_LEVELS) assert.equal(parseEffort(effort), effort);
+  assert.equal(parseEffort(' HIGH '), 'high');
+  for (const value of [undefined, null, 0, 'ultracode', 'off', 'unknown']) assert.equal(parseEffort(value), undefined);
+});
+
+test('Chat Completions sends selected reasoning effort and omits automatic defaults', () => {
+  for (const effort of EFFORT_LEVELS.filter((level) => level !== 'auto'))
+    assert.equal(toWireBody({ ...request, effort }).reasoning_effort, effort);
+  assert.ok(!('reasoning_effort' in toWireBody(request)));
+  assert.ok(!('reasoning_effort' in toWireBody({ ...request, effort: 'auto' })));
+});
+
+test('Messages translates effort into thinking budgets with output headroom', () => {
+  for (const [effort, budget] of Object.entries({ low: 2048, medium: 4096, high: 8192, xhigh: 16384, max: 32000 })) {
+    const body = toAnthropicBody({ ...request, dialect: 'anthropic', effort: parseEffort(effort) });
+    assert.deepEqual(body.thinking, { type: 'enabled', budget_tokens: budget });
+    assert.equal(body.max_tokens, Math.max(8192, budget + 4096));
+    assert.ok(!('reasoning_effort' in body));
+  }
+  assert.equal(toAnthropicBody({ ...request, effort: 'low', maxTokens: 40000 }).max_tokens, 40000);
+  for (const effort of [undefined, 'auto'] as const) assert.ok(!('thinking' in toAnthropicBody({ ...request, effort })));
+});
+
+test('signed and redacted thinking is retained for tool continuation, not emitted as answer text', () => {
+  const parser = new AnthropicStreamParser();
+  const push = (data: unknown) => parser.push(JSON.stringify(data));
+  assert.deepEqual(push({ type: 'content_block_start', index: 0, content_block: { type: 'thinking', thinking: '', signature: '' } }), []);
+  assert.deepEqual(push({ type: 'content_block_delta', index: 0, delta: { type: 'thinking_delta', thinking: 'private thought' } }), []);
+  assert.deepEqual(push({ type: 'content_block_delta', index: 0, delta: { type: 'signature_delta', signature: 'signed' } }), []);
+  push({ type: 'content_block_start', index: 1, content_block: { type: 'redacted_thinking', data: 'opaque' } });
+  push({ type: 'content_block_start', index: 2, content_block: { type: 'tool_use', id: 'call1', name: 'read_file', input: {} } });
+  push({ type: 'content_block_delta', index: 2, delta: { type: 'input_json_delta', partial_json: '{"path":"x"}' } });
+  const blocks: AnthropicThinkingBlock[] = [
+    { type: 'thinking', thinking: 'private thought', signature: 'signed' },
+    { type: 'redacted_thinking', data: 'opaque' },
+  ];
+  const message = parser.assistantMessage();
+  assert.equal(message.content, '');
+  assert.deepEqual(message.thinkingBlocks, blocks);
+  const body = toAnthropicBody({ ...request, messages: [message, { role: 'tool', toolCallId: 'call1', content: 'result' }] });
+  const messages = body.messages as { content: unknown[] }[];
+  assert.deepEqual(messages[0].content.slice(0, 2), blocks);
+  assert.equal((messages[0].content[2] as { type: string }).type, 'tool_use');
+  const complete = parseAnthropicCompleteBody({ content: [...blocks, { type: 'text', text: 'answer' }], stop_reason: 'end_turn' });
+  assert.deepEqual(complete.message.thinkingBlocks, blocks);
+  assert.equal(complete.message.content, 'answer');
+  assert.deepEqual((toWireBody({ ...request, messages: [complete.message] }).messages as unknown[]), [{ role: 'assistant', content: 'answer' }]);
+});
+
+test('effort stays selected across every tool round', async () => {
+  const requests: ChatRequest[] = [];
+  const history: ChatMessage[] = [{ role: 'user', content: 'do it' }];
+  await runAgentTurn({
+    model: 'openai/test', effort: 'high', history, system: '', tools: [], autoApprove: false,
+    maxRounds: 3, maxTokens: 8192, signal: new AbortController().signal, onEvent: () => {},
+    ask: async () => 'yes', execute: async (call) => ({ toolCallId: call.id, content: 'done' }),
+    client: { chat: async (req) => {
+      requests.push(req);
+      return requests.length === 1 ? {
+        message: { role: 'assistant', content: '', toolCalls: [{ id: 'call1', name: 'read_file', arguments: { path: 'x' }, argumentsJson: '{"path":"x"}' }] },
+        stopReason: 'tool_calls',
+      } : { message: { role: 'assistant', content: 'done' }, stopReason: 'stop' };
+    } },
+  });
+  assert.deepEqual(requests.map((req) => req.effort), ['high', 'high']);
+});
+
+test('saved effort is validated, defaults to auto, and never appears as a wire auto enum', (t) => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'sub-effort-config-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  const child = spawnSync(process.execPath, ['--input-type=module', '-e', String.raw`
+    import assert from 'node:assert/strict';
+    import fs from 'node:fs';
+    const { resolveConfig, saveConfigFile, configPath } = await import('./src/config.ts');
+    assert.equal(resolveConfig().config.reasoningEffort, 'auto');
+    saveConfigFile({ reasoning_effort: 'high' });
+    assert.equal(resolveConfig().config.reasoningEffort, 'high');
+    const json = JSON.parse(fs.readFileSync(configPath(), 'utf8'));
+    json.reasoning_effort = 'unknown';
+    fs.writeFileSync(configPath(), JSON.stringify(json));
+    assert.equal(resolveConfig().config.reasoningEffort, 'auto');
+    assert.ok(resolveConfig().warnings.some((warning) => warning.includes('reasoning_effort')));
+  `], { cwd: new URL('..', import.meta.url), encoding: 'utf8', env: { ...process.env, HOME: home } });
+  assert.equal(child.status, 0, child.stderr);
+});
+
+test('one-shot --effort overrides saved effort; invalid or missing levels exit before network', (t) => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'sub-effort-cli-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  const directory = path.join(home, '.config/subrouter-cli');
+  fs.mkdirSync(directory, { recursive: true });
+  fs.writeFileSync(path.join(directory, 'config.json'), JSON.stringify({ default_model: 'openai/test', reasoning_effort: 'low' }));
+  const preload = `import assert from 'node:assert/strict'; globalThis.fetch = async (_url, init) => {
+    const body = JSON.parse(init.body); assert.equal(body.reasoning_effort, 'high');
+    return new Response(JSON.stringify({ choices: [{ message: { role: 'assistant', content: 'ok' }, finish_reason: 'stop' }] }), { status: 200 });
+  };`;
+  const child = spawnSync(process.execPath, ['--import', 'data:text/javascript,' + encodeURIComponent(preload), 'src/index.ts', '--effort', 'high', '-p', 'test'], {
+    cwd: new URL('..', import.meta.url), encoding: 'utf8', timeout: 5000,
+    env: { ...process.env, HOME: home, SUBROUTER_API_KEY: 'test-placeholder', SUBROUTER_BASE_URL: 'https://example.invalid/v1' },
+  });
+  assert.equal(child.status, 0, child.stderr || String(child.error));
+  assert.match(child.stdout, /ok/);
+  for (const args of [['--effort'], ['--effort', 'invalid']]) {
+    const invalid = spawnSync(process.execPath, ['src/index.ts', ...args], { cwd: new URL('..', import.meta.url), encoding: 'utf8', env: { ...process.env, HOME: home } });
+    assert.equal(invalid.status, 2);
+    assert.match(invalid.stderr, /--effort requires/);
+  }
+});

package/test/fixtures/openai-tools.sse

@@ -0,0 +1,84 @@
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":"The"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" user"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" wants"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" me"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" to"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" call"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" the"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" echo"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" tool"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" with"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" any"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" JSON"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":","},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" then"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" summarize"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" what"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" I"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" did"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":"."},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" I"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" need"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" to"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" make"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" a"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" tool"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" call"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":"."},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" Let"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" me"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" call"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" echo"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" with"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" a"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" simple"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" JSON"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":" object"},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"reasoning_content":"."},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"id":"call_00_nhRG5dbexAZN8QG7Q2Ja3727","type":"function","function":{"name":"echo","arguments":""}}]},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"function":{"arguments":"{\"value\": {\"message\": \"Hello, world!\", \"number\": 42, \"valid\": true}}"}}]},"finish_reason":null}]}
+
+data: {"id":"chatcmpl-34339030298fa04a51c59cef","object":"chat.completion.chunk","created":1791649790,"model":"opencode/deepseek-v4-pro","choices":[{"index":0,"delta":{},"finish_reason":"tool_calls"}],"usage":{"prompt_tokens":377,"completion_tokens":97,"total_tokens":474,"prompt_tokens_details":{"cached_tokens":0}}}
+
+data: [DONE]
+

package/test/image-adapters.test.ts

@@ -0,0 +1,78 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { toWireBody } from '../src/adapters/openai.ts';
+import { toAnthropicBody } from '../src/adapters/anthropic.ts';
+import { runAgentTurn } from '../src/loop.ts';
+import type { ChatMessage, ChatRequest } from '../src/types.ts';
+import type { ImageAttachment } from '../src/images.ts';
+
+const image: ImageAttachment = { name: 'shot.png', mediaType: 'image/png', data: 'aW1hZ2U=' };
+const request = (messages: ChatMessage[]): ChatRequest => ({
+  model: 'openai/test', dialect: 'openai', system: '', messages, stream: true,
+});
+
+test('both wire formats support text plus multiple images and image-only turns', () => {
+  for (const text of ['Explain this screenshot', '']) {
+    const req = request([{ role: 'user', content: text, images: [image, image] }]);
+    const textBlocks = text ? [{ type: 'text', text }] : [];
+    assert.deepEqual(toWireBody(req).messages, [{ role: 'user', content: [
+      ...textBlocks,
+      ...[image, image].map((i) => ({ type: 'image_url', image_url: { url: `data:${i.mediaType};base64,${i.data}` } })),
+    ] }]);
+    assert.deepEqual(toAnthropicBody(req).messages, [{ role: 'user', content: [
+      ...textBlocks,
+      ...[image, image].map((i) => ({ type: 'image', source: { type: 'base64', media_type: i.mediaType, data: i.data } })),
+    ] }]);
+  }
+});
+
+test('text-only shapes and tool result ordering are unchanged by image support', () => {
+  const req = request([
+    { role: 'user', content: 'plain' },
+    { role: 'assistant', content: '', toolCalls: [{ id: 't', name: 'grep', arguments: {}, argumentsJson: '{}' }] },
+    { role: 'tool', toolCallId: 't', content: 'result' },
+    { role: 'user', content: '', images: [image] },
+  ]);
+  const openai = toWireBody(req).messages as { role: string; content: unknown }[];
+  const anthropic = toAnthropicBody(req).messages as { role: string; content: unknown }[];
+  assert.deepEqual(openai[0], { role: 'user', content: 'plain' });
+  assert.deepEqual(anthropic[0], { role: 'user', content: 'plain' });
+  assert.deepEqual(openai[2], { role: 'tool', tool_call_id: 't', content: 'result' });
+  assert.deepEqual(anthropic[2], { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't', content: 'result', is_error: false }] });
+  assert.ok(Array.isArray(anthropic[3].content));
+});
+
+test('images survive every tool round; rough budgets count images rather than base64 text', async () => {
+  const history: ChatMessage[] = [{ role: 'user', content: '', images: [image] }];
+  const warnings: number[] = [];
+  let rounds = 0;
+  await runAgentTurn({
+    client: { chat: async (req) => {
+      assert.deepEqual(req.messages[0].images, [image]);
+      if (++rounds === 1) return { message: { role: 'assistant', content: '', toolCalls: [
+        { id: 't', name: 'grep', arguments: {}, argumentsJson: '{}' },
+      ] }, stopReason: 'tool_calls' };
+      return { message: { role: 'assistant', content: 'done' }, stopReason: 'stop' };
+    } },
+    model: 'openai/test', history, system: '', tools: [],
+    execute: async (call) => ({ toolCallId: call.id, content: 'found' }),
+    ask: async () => 'yes', autoApprove: true, maxRounds: 3, maxTokens: 200,
+    contextTokens: 2500, onBudget: (percent) => warnings.push(percent),
+    signal: new AbortController().signal, onEvent: () => {},
+  });
+  assert.equal(rounds, 2);
+  assert.deepEqual(warnings, [80]);
+});
+
+test('exact image-aware token counting takes precedence over the rough allowance', async () => {
+  const warnings: number[] = [];
+  await runAgentTurn({
+    client: { chat: async () => ({ message: { role: 'assistant', content: 'done' }, stopReason: 'stop' }) },
+    model: 'anthropic/claude-test', history: [{ role: 'user', content: '', images: [image] }],
+    system: '', tools: [], execute: async () => { throw new Error('no tools'); }, ask: async () => 'yes',
+    autoApprove: true, maxRounds: 1, maxTokens: 200, contextTokens: 1000,
+    countTokens: async (_m, _s, messages) => { assert.deepEqual(messages[0].images, [image]); return 100; },
+    onBudget: (percent) => warnings.push(percent), signal: new AbortController().signal, onEvent: () => {},
+  });
+  assert.deepEqual(warnings, []);
+});

package/test/image-ui.test.ts

@@ -0,0 +1,151 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { test } from 'node:test';
+
+const cwd = new URL('..', import.meta.url);
+const png = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aWVAAAAAASUVORK5CYII=', 'base64');
+
+test('clipboard shortcuts queue images, preserve drafts, retry failures and clear explicitly without image commands', (t) => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'sub-image-ui-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  fs.writeFileSync(path.join(home, 'shot  two.png'), png);
+  const child = spawnSync(process.execPath, ['--input-type=module', '-e', String.raw`
+    import assert from 'node:assert/strict';
+    import fs from 'node:fs';
+    import path from 'node:path';
+    Object.defineProperty(process.stdin, 'isTTY', { value: true });
+    Object.defineProperty(process.stdout, 'isTTY', { value: true });
+    Object.defineProperty(process.stdout, 'rows', { value: 24 });
+    Object.defineProperty(process.stdout, 'columns', { value: 100 });
+    process.stdin.setRawMode = () => {};
+    const { default: childProcess } = await import('node:child_process');
+    const { syncBuiltinESMExports } = await import('node:module');
+    Object.defineProperty(process, 'platform', { value: 'darwin' });
+    const png = fs.readFileSync(path.join(process.env.HOME, 'shot  two.png')).toString('base64');
+    let clipboard = { data: png }, delayClipboard = false, clipboardFailure = false, clipboardReads = 0;
+    childProcess.execFile = (file, args, options, callback) => {
+      assert.equal(file, '/usr/bin/osascript');
+      assert.deepEqual(args.slice(0, 3), ['-l', 'JavaScript', '-e']);
+      assert.equal(options.shell, false);
+      assert.equal(options.timeout, 10000);
+      clipboardReads++;
+      const finish = () => callback(options.signal.aborted ? options.signal.reason : clipboardFailure ? new Error(png) : null, JSON.stringify(clipboard), '');
+      if (delayClipboard) setTimeout(finish, 50);
+      else setImmediate(finish);
+      return {};
+    };
+    syncBuiltinESMExports();
+    const { ui } = await import('./src/ui.ts');
+    const { startRepl } = await import('./src/repl.ts');
+    process.chdir(process.env.HOME);
+    let status = 'ready';
+    let attached = [];
+    const setStatus = ui.setStatus.bind(ui), setAttachments = ui.setAttachments.bind(ui);
+    ui.setStatus = (value) => { status = value; setStatus(value); };
+    ui.setAttachments = (names) => { attached = names; setAttachments(names); };
+    const requests = [];
+    const client = {
+      listModels: async () => [{ id: 'openai/vision' }], usage: async () => ({}),
+      chat: async (req, emit) => {
+        requests.push(structuredClone(req));
+        if (requests.length === 1) throw new Error('temporary vision failure');
+        emit({ kind: 'text', text: '\n\nImage received.\n\n\n' });
+        return { message: { role: 'assistant', content: '\n\nImage received.\n\n\n' }, stopReason: 'stop' };
+      },
+    };
+    startRepl({ client, model: 'openai/vision', config: { maxToolRounds: 25, maxOutputTokens: 8192, autoApprove: false } });
+    const key = (text) => process.stdin.emit('data', Buffer.from(text));
+    const send = async (text) => {
+      key(text);
+      const deadline = Date.now() + 4000;
+      while (status !== 'ready' && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, 10));
+      assert.equal(status, 'ready');
+      await new Promise(setImmediate);
+    };
+    await new Promise(setImmediate);
+    for (const removed of ['/attach', '/detach', '/paste', '/help']) await send(removed + '\r');
+    assert.equal(clipboardReads, 0);
+    await send('\x16');
+    assert.deepEqual(attached, ['clipboard.png']);
+    assert.equal(requests.length, 0); // reading the clipboard never sends it
+    clipboard = { error: 'empty' };
+    await send('\x16');
+    assert.deepEqual(attached, ['clipboard.png']);
+    clipboard = { data: png };
+    clipboardFailure = true;
+    await send('\x16');
+    assert.deepEqual(attached, ['clipboard.png']);
+    clipboardFailure = false;
+    delayClipboard = true;
+    key('\x16\x16\x03');
+    await send(''); // cancellation must not add an image or start a second read
+    assert.equal(clipboardReads, 4);
+    assert.deepEqual(attached, ['clipboard.png']);
+    delayClipboard = false;
+    key('explain it');
+    await send('\x18');
+    assert.deepEqual(attached, []);
+    await send('\x16'); // keep the draft while awaiting clipboard data
+    assert.equal(requests.length, 0);
+    await send('\r');
+    assert.equal(requests[0].messages[0].content, 'explain it');
+    assert.deepEqual(attached, ['clipboard.png']); // failed request restores the queue
+    await send('\r');
+    assert.equal(requests[1].messages[0].content, '');
+    assert.equal(requests[1].messages[0].images[0].name, 'clipboard.png');
+    assert.deepEqual(attached, []);
+    await send('follow up\r');
+    const users = requests[2].messages.filter((message) => message.role === 'user');
+    assert.equal(users[0].images.length, 1); // sent images remain in history
+    assert.equal(users.at(-1).images, undefined); // queue is consumed exactly once
+    for (let i = 0; i < 5; i++) await send('\x16');
+    assert.equal(attached.length, 4); // rejected fifth paste leaves the queue intact
+    await send('\x18');
+    assert.deepEqual(attached, []);
+    await send('\x16');
+    await send('/clear\r');
+    assert.deepEqual(attached, []);
+    await send('fresh text\r');
+    assert.ok(requests.at(-1).messages.every((message) => !message.images));
+    const sessions = path.join(process.env.HOME, '.config/subrouter-cli/sessions');
+    const files = fs.readdirSync(sessions);
+    const markdown = files.filter((file) => file.endsWith('.md')).map((file) => fs.readFileSync(path.join(sessions, file), 'utf8')).join('\n');
+    const records = files.filter((file) => file.endsWith('.jsonl')).flatMap((file) => fs.readFileSync(path.join(sessions, file), 'utf8').trim().split('\n').filter(Boolean).map((line) => JSON.parse(line)));
+    assert.match(markdown, /image: clipboard.png · image\/png/);
+    assert.ok(!markdown.includes(requests[1].messages[0].images[0].data));
+    assert.ok(records.some((record) => record.messages.some((message) => message.images?.length)));
+    key('/exit\r');
+  `], { cwd, encoding: 'utf8', timeout: 15000, env: { ...process.env, HOME: home, NO_COLOR: '' } });
+  assert.equal(child.status, 0, child.stderr || String(child.error));
+  assert.ok(!child.stdout.includes(png.toString('base64')), 'image bytes must never be rendered');
+});
+
+test('repeated --image flags reach one-shot wire requests; invalid paths fail before networking', (t) => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'sub-image-cli-'));
+  t.after(() => fs.rmSync(home, { recursive: true, force: true }));
+  const file = path.join(home, 'shot.png');
+  fs.writeFileSync(file, png);
+  const preload = 'data:text/javascript,' + encodeURIComponent(`
+    import assert from 'node:assert/strict';
+    globalThis.fetch = async (_url, init) => {
+      const body = JSON.parse(init.body);
+      assert.equal(body.messages[1].content[0].text, 'explain');
+      assert.equal(body.messages[1].content.length, 3);
+      assert.equal(body.messages[1].content[1].image_url.url, ${JSON.stringify('data:image/png;base64,' + png.toString('base64'))});
+      return new Response(JSON.stringify({ choices: [{ message: { role: 'assistant', content: 'Image received.' }, finish_reason: 'stop' }] }));
+    };
+  `);
+  const env = { ...process.env, HOME: home, SUBROUTER_API_KEY: 'test-only-key' };
+  const child = spawnSync(process.execPath, ['--import', preload, 'src/index.ts', '--model', 'openai/vision', '--image', file, '--image', file, '-p', 'explain'], { cwd, encoding: 'utf8', timeout: 15000, env });
+  assert.equal(child.status, 0, child.stderr || String(child.error));
+  assert.match(child.stdout, /Image received/);
+  assert.ok(!child.stdout.includes(png.toString('base64')));
+  for (const args of [['--image'], ['--image', 'missing.png', '-p', 'explain'], ['--check', '--image', file]]) {
+    const invalid = spawnSync(process.execPath, ['--import', 'data:text/javascript,globalThis.fetch=()=>{throw new Error("unexpected network")}', 'src/index.ts', ...args], { cwd, encoding: 'utf8', timeout: 15000, env });
+    assert.equal(invalid.status, 2, invalid.stderr || String(invalid.error));
+    assert.ok(!invalid.stderr.includes('unexpected network'));
+  }
+});

package/test/images.test.ts

@@ -0,0 +1,60 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { test } from 'node:test';
+import { attachmentPath, loadImage, imageBytes, addImages, MAX_IMAGE_BYTES } from '../src/images.ts';
+
+// Minimal signatures test format detection; the router/model validates actual image decoding.
+const signatures = [
+  ['png', Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])],
+  ['jpeg', Buffer.from([255, 216, 255, 224])],
+  ['gif', Buffer.from('GIF89a')],
+  ['webp', Buffer.from('RIFF0000WEBP')],
+] as const;
+
+test('explicit attachments resolve quoted, dragged, relative, absolute, and home paths', () => {
+  assert.equal(attachmentPath('"shots/my image.png"', '/tmp/project'), '/tmp/project/shots/my image.png');
+  assert.equal(attachmentPath("'shots/my image.png'", '/tmp/project'), '/tmp/project/shots/my image.png');
+  assert.equal(attachmentPath('/tmp/my\\ image.png', '/tmp/project'), '/tmp/my image.png');
+  assert.equal(attachmentPath('~/image.png', '/tmp/project'), path.join(os.homedir(), 'image.png'));
+  assert.throws(() => attachmentPath('', '/tmp/project'), /provide a local image path/);
+  assert.throws(() => attachmentPath('bad\0path', '/tmp/project'), /provide a local image path/);
+});
+
+test('loads supported local images using signatures rather than extensions', async (t) => {
+  const cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'sub-images-'));
+  t.after(() => fs.rm(cwd, { recursive: true, force: true }));
+  for (const [type, bytes] of signatures) {
+    const file = `sample.${type === 'png' ? 'txt' : type}`;
+    await fs.writeFile(path.join(cwd, file), bytes);
+    const image = await loadImage(file, cwd);
+    assert.equal(image.mediaType, `image/${type}`);
+    assert.equal(image.name, file);
+    assert.equal(image.data, bytes.toString('base64'));
+    assert.equal(imageBytes(image), bytes.length);
+  }
+});
+
+test('attachment queue enforces count and aggregate byte limits without mutating current images', () => {
+  const image = { name: 'a.png', mediaType: 'image/png' as const, data: 'aW1hZ2U=' };
+  const current = [image];
+  assert.equal(addImages(current, [image]).length, 2);
+  assert.equal(current.length, 1);
+  assert.throws(() => addImages(current, [image, image, image, image]), /at most 4/);
+  const large = { ...image, data: Buffer.alloc(MAX_IMAGE_BYTES).toString('base64') };
+  assert.throws(() => addImages([large, large], [image]), /20 MiB/);
+});
+
+test('rejects missing, non-image, directory, and oversized attachments', async (t) => {
+  const cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'sub-bad-images-'));
+  t.after(() => fs.rm(cwd, { recursive: true, force: true }));
+  await assert.rejects(loadImage('missing.png', cwd), /could not open/);
+  await assert.rejects(loadImage('.', cwd), /regular image files/);
+  await fs.writeFile(path.join(cwd, 'not-image.png'), 'not image bytes');
+  await assert.rejects(loadImage('not-image.png', cwd), /unsupported image/);
+  const handle = await fs.open(path.join(cwd, 'huge.png'), 'w');
+  await handle.truncate(MAX_IMAGE_BYTES + 1);
+  await handle.close();
+  await assert.rejects(loadImage('huge.png', cwd), /10 MiB/);
+});