@j-o-r/hello-dave 0.0.3 → 0.0.4

package/scenarios.bak.1774780058/toolset.test.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+import { Test, assert, jsType } from '@j-o-r/sh';
+import ToolSet from '../lib/ToolSet.js';
+
+const t = new Test();
+
+// Constructor
+t.add('Constructor default auto', () => {
+  const ts = new ToolSet();
+  assert.strictEqual(ts.toolChoice, 'auto');
+  assert.strictEqual(ts.length, 0);
+  assert.strictEqual(jsType(ts), 'ToolSet');
+});
+
+t.add('Constructor valid choices', () => {
+  ['auto', 'none', 'required'].forEach(choice => {
+    const ts = new ToolSet(choice);
+    assert.strictEqual(ts.toolChoice, choice);
+  });
+});
+
+t.add('Constructor invalid choice throws', () => {
+  try {
+    new ToolSet('invalid');
+    assert.fail('Should throw on invalid choice');
+  } catch (e) {
+    assert.ok(e.message.includes('Tool choice not defined'));
+  }
+});
+
+// add method
+t.add('add invalid name throws', () => {
+  const ts = new ToolSet();
+  try {
+    ts.add('a', 'desc', { type: 'object' }, async () => {});
+    assert.fail('Should throw invalid name');
+  } catch (e) {
+    assert.ok(e.message.includes('Invalid name'));
+  }
+});
+
+t.add('add valid tool', () => {
+  const ts = new ToolSet();
+  const mockMethod = async (params) => ({ received: params });
+  ts.add('valid_tool', 'Valid tool description', {
+    type: 'object',
+    properties: { foo: { type: 'string' } },
+    required: ['foo']
+  }, mockMethod);
+  assert.strictEqual(ts.length, 1);
+  assert.strictEqual(ts.has('valid_tool'), true);
+});
+
+t.add('add duplicate no throw, overwrites', () => {
+  const ts = new ToolSet();
+  const method1 = async () => 'first';
+  const method2 = async () => 'second';
+  ts.add('dup', 'desc', { type: 'object' }, method1);
+  ts.add('dup', 'desc', { type: 'object' }, method2);
+  assert.strictEqual(ts.length, 1);
+  const tool = ts.get('dup');
+  assert.strictEqual(tool.description, 'desc'); // last one
+});
+
+t.add('get throws not found', () => {
+  const ts = new ToolSet();
+  try {
+    ts.get('missing');
+    assert.fail('Should throw');
+  } catch (e) {
+    assert.ok(e.message.includes('Function not found'));
+  }
+});
+
+t.add('get existing tool', () => {
+  const ts = new ToolSet();
+  ts.add('gettool', 'desc', { type: 'object' }, async () => {});
+  const tool = ts.get('gettool');
+  assert.strictEqual(jsType(tool), 'Object');
+  assert.strictEqual(tool.description, 'desc');
+  assert.strictEqual(jsType(tool.parameters), 'Object');
+  assert.strictEqual(jsType(tool.method), 'AsyncFunction');
+});
+
+// delete
+t.add('delete reduces length', () => {
+  const ts = new ToolSet();
+  ts.add('to_delete', 'desc', { type: 'object' }, async () => {});
+  assert.strictEqual(ts.length, 1);
+  ts.delete('to_delete');
+  assert.strictEqual(ts.length, 0);
+  assert.strictEqual(ts.has('to_delete'), false);
+});
+
+t.add('delete non-existing no error', () => {
+  const ts = new ToolSet();
+  ts.delete('nonexistent');
+  assert.strictEqual(ts.length, 0);
+});
+
+// list
+t.add('list empty', () => {
+  const ts = new ToolSet();
+  const list = ts.list();
+  assert.strictEqual(list.length, 0);
+  assert.strictEqual(jsType(list), 'Array');
+});
+
+t.add('list sorted by name', () => {
+  const ts = new ToolSet();
+  ts.add('b_tool', 'b desc', { type: 'object' }, async () => {});
+  ts.add('a_tool', 'a desc', { type: 'object' }, async () => {});
+  ts.add('c_tool', 'c desc', { type: 'object' }, async () => {});
+  const list = ts.list();
+  assert.strictEqual(list.length, 3);
+  assert.strictEqual(list[0].name, 'a_tool');
+  assert.strictEqual(list[1].name, 'b_tool');
+  assert.strictEqual(list[2].name, 'c_tool');
+});
+
+// call
+t.add('call success', async () => {
+  const ts = new ToolSet();
+  const expected = { result: 42 };
+  ts.add('calc', 'calc', { type: 'object' }, async () => expected);
+  const res = await ts.call('calc', {});
+  assert.deepStrictEqual(res, expected);
+});
+
+t.add('call not found throws', async () => {
+  const ts = new ToolSet();
+  try {
+    await ts.call('missing', {});
+    assert.fail('Should throw');
+  } catch (e) {
+    assert.ok(e.message.includes('Function not found'));
+  }
+});
+
+const report = await t.run();
+process.exit(report.errors > 0 ? 1 : 0);

package/scenarios.bak.1774780058/write_file_syntax.test.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+import { Test, assert, jsType } from '@j-o-r/sh';
+import { execSync } from 'child_process';
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from 'fs';
+import { tmpdir } from 'os';
+import { join, dirname } from 'path';
+
+const t = new Test();
+const TMP = mkdtempSync(join(tmpdir(), 'syntax_test_'));
+process.on('exit', () => rmSync(TMP, { recursive: true, force: true }));
+
+const checkSyntax = (file) => {
+  try {
+    execSync(`./utils/syntax_check.sh "${file}"`, { cwd: process.cwd(), stdio: 'pipe', timeout: 5000 });
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+const writeTemp = (relpath, content) => {
+  const file = join(TMP, relpath);
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, content);
+  return file;
+};
+
+t.add('checkSyntax returns boolean', () => {
+  const file = writeTemp('test.js', 'console.log("ok");');
+  assert.strictEqual(jsType(checkSyntax(file)), 'Boolean');
+});
+
+t.add('syntax_check: JS valid', () => {
+  const file = writeTemp('valid.js', '// Valid JS\nconsole.log("ok");');
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+t.add('syntax_check: JS invalid (unexpected token)', () => {
+  const file = writeTemp('invalid.js', 'const x = ; console.log(x);');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+t.add('syntax_check: JS invalid unterminated quote', () => {
+  const file = writeTemp('invalid-quote.js', 'console.log("hi );');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+t.add('syntax_check: JS invalid unbalanced paren', () => {
+  const file = writeTemp('invalid-paren.js', 'if (true {\n  console.log("ok");\n}');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+t.add('syntax_check: JS valid ESM import', () => {
+  const file = writeTemp('valid-esm.js', 'import { Test } from "@j-o-r/sh";\nconsole.log("ok");');
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+t.add('syntax_check: JS shebang valid', () => {
+  const file = writeTemp('valid-shebang.js', '#!/usr/bin/env node\nimport { Test } from "@j-o-r/sh";');
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+t.add('syntax_check: JS subdir valid', () => {
+  const file = writeTemp('subdir/valid.js', 'console.log("ok");');
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+// PY invalid: missing indent
+t.add('syntax_check: PY invalid (indent err)', () => {
+  const file = writeTemp('invalid.py', 'def f():\nprint("hi")');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+// PY valid
+t.add('syntax_check: PY valid', () => {
+  const file = writeTemp('valid.py', '#!/usr/bin/env python3\ndef f():\n    print("hi")\nf()');
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+// SH invalid: missing fi
+t.add('syntax_check: SH invalid (missing fi)', () => {
+  const file = writeTemp('invalid.sh', '#!/bin/bash\nif true; then\necho "hi"');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+// SH valid
+t.add('syntax_check: SH valid', () => {
+  const file = writeTemp('valid.sh', '#!/bin/bash\necho "ok"');
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+// SH shebang + if/fi
+t.add('syntax_check: SH valid (if/fi)', () => {
+  const file = writeTemp('valid-if.sh', '#!/usr/bin/env bash\nif true; then\n  echo "ok"\nfi');
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+// JSON invalid: trailing comma
+t.add('syntax_check: JSON invalid', () => {
+  const file = writeTemp('invalid.json', '{ "key": "value", }');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+// JSON valid
+t.add('syntax_check: JSON valid', () => {
+  const file = writeTemp('valid.json', '{ "key": "value" }');
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+// Unknown ext: non-fatal pass
+t.add('syntax_check: unknown ext (txt)', () => {
+  const file = writeTemp('test.txt', 'plain text');
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+// write_file sim: invalid → reject (PY/SH/JSON/JS)
+t.add('syntax_check: write_file sim JS reject', () => {
+  const file = writeTemp('sim_invalid.js', 'console.log("hi );');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+t.add('syntax_check: write_file sim PY reject', () => {
+  const file = writeTemp('sim_invalid.py', 'def f():\nprint("hi")');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+t.add('syntax_check: write_file sim SH reject', () => {
+  const file = writeTemp('sim_invalid.sh', '#!/bin/bash\nif true; then echo hi');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+t.add('syntax_check: write_file sim JSON reject', () => {
+  const file = writeTemp('sim_invalid.json', '{invalid}');
+  assert.strictEqual(checkSyntax(file), false);
+});
+
+t.add('syntax_check: async valid JS', async () => {
+  const file = writeTemp('async-valid.js', 'console.log("ok");');
+  await new Promise(r => setTimeout(r, 10));
+  assert.strictEqual(checkSyntax(file), true);
+});
+
+const report = await t.run();
+assert.strictEqual(jsType(report), 'Object');
+process.exit(report.errors > 0 ? 1 : 0);

package/scenarios.bak.1774780058/write_file_validation/README.md

@@ -0,0 +1,30 @@
+# write_file Auto-Validation Test Suite
+
+## Purpose
+Tests the enhanced \`write_file\` tool in \`lib/genericToolset.js\`:
+- **JS Syntax Check**: \`node --check\` on .js/shebang files → blocks invalid.
+- **Error Guidance**: Forces LLM retry with \\\` fix hints.
+- **chmod +x**: Auto for shebangs.
+- **Self-Healing**: LLM sees error → regenerates valid JS.
+
+## Files
+- \`bad.js\`: Intentional syntax error (unclosed template literal \`console.log(\`).
+- \`good.js\`: Fixed (properly escaped \`console.log(\\\\\\`hello\\\\\\\`); \`).
+- \`test.sh\`: Runs write_file simulation → expect error on bad → success on good.
+
+## Run
+```bash
+cd scenarios/write_file_validation
+chmod +x test.sh
+./test.sh
+```
+Expected:
+```
+❌ Write bad.js → SYNTAX ERROR (node --check fails)
+✅ Write good.js → ✓ JS syntax OK + chmod +x (if shebang)
+```
+
+## LLM Test (via CodeServer)
+Query: \"Use write_file to create bad.js with console.log(\`hi\`); then fix it.\" → Auto-triggers retry loop.
+
+Current date: March 27, 2026.

package/scenarios.bak.1774780058/write_file_validation/bad.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+console.log(`Unclosed backtick syntax error!
+import { foo } from 'bar';

package/scenarios.bak.1774780058/write_file_validation/good.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+console.log(`Hello, fixed template literal!`);
+console.log('Proper JS syntax.');
+import { parseArgs } from '@j-o-r/sh'; // ESM OK

package/scenarios.bak.1774780058/write_file_validation/test.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+set -e
+
+echo "=== write_file Auto-Validation Test ==="
+cd "$(dirname "$0")"
+
+# Simulate toolset write_file (manual for demo; real uses lib/genericToolset.js)
+echo "1. Write BAD JS (expect SYNTAX ERROR)..."
+cat > temp_bad.js << 'EOF'
+#!/usr/bin/env node
+console.log(`Unclosed backtick!  // ERROR: Missing closing \`
+EOF
+
+# Manual node --check (mimics tool)
+if node --check temp_bad.js 2>&1; then
+  echo "❌ FAIL: Bad JS passed check!"
+else
+  echo "✅ PASS: Bad JS correctly rejected ($(node --check temp_bad.js 2>&1 | head -1))"
+fi
+
+echo "2. Write GOOD JS (expect ✓ OK + chmod)..."
+cat > temp_good.js << 'EOF'
+#!/usr/bin/env node
+console.log(`Fixed template!`);
+console.log('All good.');
+EOF
+
+if node --check temp_good.js 2>&1; then
+  echo "✅ PASS: Good JS syntax OK"
+  chmod +x temp_good.js
+  echo "✅ PASS: chmod +x applied"
+  ./temp_good.js  # Runs!
+else
+  echo "❌ FAIL: Good JS failed check!"
+fi
+
+# Real toolset test (requires running agent)
+echo "3. REAL TOOL TEST (run via CodeServer):"
+echo "   echo 'write_file scenarios/write_file_validation/new.js: console.log(\`test\`);' | dave --connect ws://...:8081/ws"
+echo "   → If bad: Error → LLM fixes → ✓ OK"
+
+rm -f temp_*.js
+echo "=== ALL TESTS PASS ✅ ==="

package/scenarios.bak.1774780058/wsClient.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import cli from '@j-o-r/cli';
+import { WebSocketClient } from "@j-o-r/apiserver";
+const NAME = 'clarification';
+const wsUser = new WebSocketClient('ws://localhost:2000/ws?test=param');  // Match server port/path
+
+const queryMessages = new Map();
+
+/*
+HANDSHAKE:
+
+1: requests an introduction with 'introduce'
+2: get a response 'introduction'
+
+This must be DONE before anything else can take place
+
+*/
+
+cli.registerKeyMappings([
+    { name: 'd', ctrl: true, meta: false, shift: false, handler: async () => {
+    	process.exit(0);
+    }},
+    { name: 'r', ctrl: true, meta: false, shift: false, handler: async () => {
+    	cli.clear();
+    }}
+    
+]);
+// @ts-ignore
+cli.inputHandler = async (s, role) => {
+  const message = {
+  	action: 'query',
+  	content: s,
+  }
+  wsUser.send(JSON.stringify(message));
+  cli.startSpinner();
+}
+cli.focus('log');
+cli.write('CTRL - d exit');
+cli.write('CTRL - r clear screen / reset');
+// cli.focus('user', true);
+
+wsUser.onopen = () => {
+  cli.focus('log');
+	cli.write('Jorrit connected');
+	// Send my introduction to the server
+	wsUser.send(JSON.stringify({
+		action: 'introduction',
+		name: NAME,
+		content: 'I am a human named Jorrit. Query me for questions that needs clearfication',
+		id: new Date().getTime()
+	}));
+	cli.focus('user', true);
+
+};
+/**
+* @type {MessageEvent} event
+*/
+wsUser.onmessage = (event) => {
+	const data = JSON.parse(event.data);  // Forwarded HTTP request
+	console.log('Received request:', data);
+	cli.focus('user', true);
+};
+wsUser.onclose = () => {
+	console.log('WS closed');
+	process.exit();
+}
+wsUser.onerror = (err) => {
+	console.error('WS error:', err);
+}

package/scenarios.bak.1774780058/xai_responses.integration.test.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import { Test, assert } from '@j-o-r/sh';
+import { request } from '../lib/API/x.ai/responses.js';
+import Prompt from '../lib/Prompt.js';
+import tools from './testToolset.js';  // Reuse weather mock for recursion
+
+const t = new Test();
+
+// Real API: tools + recursion (default model)
+t.add('request: real with tools (recursion)', async () => {
+  const p = new Prompt();
+  p.add('system', 'You are helpful. Use tools for weather.', true);
+  p.add('user', 'Weather in Amsterdam?');
+  const msg = await request(p, tools);
+  assert.strictEqual(msg.role, 'assistant');
+  assert.ok(msg.content.some(c => c.type === 'text'), 'Final text response');
+  const toolMsg = p.messages.find(m => m.role === 'tool');
+  assert.ok(toolMsg, 'Tool executed');
+});
+
+// Real API: custom options (non-reasoning model)
+t.add('request: real options (model/temp/store)', async () => {
+  const p = new Prompt();
+  p.add('system', 'Answer in JSON.', true);
+  p.add('user', '2+2 as JSON.');
+  const msg = await request(p, null, {
+    model: 'grok-4-fast-non-reasoning',
+    temperature: 0.1,
+    store: true,
+    max_output_tokens: 100
+  });
+  assert.strictEqual(msg.role, 'assistant');
+  assert.ok(msg.content[0].text.includes('4'), 'JSON with 4');
+});
+
+// Real API: reasoning rejected (unsupported on default model)
+t.add('request: reasoning rejected on incompatible model', async () => {
+  const p = new Prompt();
+  p.add('user', 'Why is sky blue?');
+  await assert.rejects(
+    () => request(p, null, { reasoning: { effort: 'high', summary: 'concise' } }),
+    /invalid argument|reasoningEffort/
+  );
+});
+
+// Real API: invalid model rejects (4xx)
+t.add('request: invalid model rejects', async () => {
+  const p = new Prompt();
+  p.add('user', 'Hi');
+  await assert.rejects(
+    () => request(p, null, { model: 'invalid-xyz' }),
+    /Error.*4\\d{2}|Model not found|400/
+  );
+});
+
+const report = await t.run();
+process.exit(report.errors > 0 ? 1 : 0);

package/scenarios.bak.1774780058/xai_responses.test.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+import { Test, assert } from '@j-o-r/sh';
+import { generateRequest, parseResponse, request } from '../lib/API/x.ai/responses.js';
+import Prompt from '../lib/Prompt.js';
+import ToolSet from '../lib/ToolSet.js';
+import tools from './testToolset.js';
+
+const t = new Test();
+
+// Fake response helpers
+const fakeTextRes = () => ({
+  status: 200,
+  response: {
+    id: 'fake-text',
+    model: 'grok-beta',
+    created_at: Math.floor(Date.now() / 1000),
+    usage: { input_tokens: 10, output_tokens: 5 },
+    output: [{ type: 'message', content: [{ type: 'output_text', text: 'Hello!' }] }]
+  }
+});
+
+const fakeReasoningRes = () => ({
+  status: 200,
+  response: {
+    id: 'fake-reason',
+    model: 'grok-beta',
+    created_at: Math.floor(Date.now() / 1000),
+    usage: { input_tokens: 10, output_tokens: 5 },
+    output: [{ type: 'reasoning', summary: [{ type: 'summary_text', text: 'Thought.' }] }]
+  }
+});
+
+const fakeCitationRes = () => ({
+  status: 200,
+  response: {
+    id: 'fake-cit',
+    model: 'grok-beta',
+    created_at: Math.floor(Date.now() / 1000),
+    usage: { input_tokens: 10, output_tokens: 5 },
+    output: [{ type: 'message', content: [{ type: 'output_text', text: 'Text', annotations: [{ type: 'url_citation', url: 'https://ex.com' }] }] }]
+  }
+});
+
+const fakeToolRes = (name = 'get_current_weather', args = '{"location":"Amsterdam"}') => ({
+  status: 200,
+  response: {
+    id: 'fake-tool',
+    model: 'grok-beta',
+    created_at: Math.floor(Date.now() / 1000),
+    usage: { input_tokens: 20, output_tokens: 10 },
+    output: [{ type: 'function_call', name, id: 'fid', call_id: 'fcid', arguments: args, status: 'complete' }]
+  }
+});
+
+t.add('generateRequest: basic', () => {
+  const p = new Prompt();
+  p.add('system', 'Helpful', true);
+  p.add('user', 'Hi');
+  const { url, headers, body } = generateRequest(p);
+  assert.strictEqual(url, 'https://api.x.ai/v1/responses');
+  assert.strictEqual(headers['Content-Type'], 'application/json');
+  assert.ok(headers.Authorization.startsWith('Bearer'));
+  assert.strictEqual(body.model, 'grok-4-fast-reasoning');
+  assert.strictEqual(body.instructions, 'Helpful');
+  assert.strictEqual(body.input.length, 1);
+});
+
+t.add('generateRequest: tools', () => {
+  const p = new Prompt();
+  p.add('user', 'Weather');
+  const { body } = generateRequest(p, tools);
+  assert.ok(body.tools.some(tl => tl.name === 'get_current_weather'));
+  assert.strictEqual(body.parallel_tool_calls, true);
+});
+
+t.add('generateRequest: options', () => {
+  const p = new Prompt();
+  p.add('user', 'Hi');
+  const { body } = generateRequest(p, null, { model: 'grok-4-1-fast-reasoning' });
+  assert.strictEqual(body.model, 'grok-4-1-fast-reasoning');
+});
+
+t.add('generateRequest: throws bad last role', () => {
+  const p = new Prompt();
+  p.add('system', '', true);
+  p.add('assistant', 'bad');
+  assert.throws(() => generateRequest(p));
+});
+
+t.add('parseResponse: text', async () => {
+  const p = new Prompt();
+  p.add('user', 'Hi');
+  await parseResponse(100, p, fakeTextRes());
+  const msg = p.getLastMessage();
+  assert.strictEqual(msg.role, 'assistant');
+  assert.strictEqual(msg.content[0].text, 'Hello!');
+});
+
+t.add('parseResponse: reasoning', async () => {
+  const p = new Prompt();
+  await parseResponse(100, p, fakeReasoningRes());
+  const msg = p.getLastMessage();
+  assert.strictEqual(msg.role, 'reasoning');
+  assert.strictEqual(msg.content[0].text, 'Thought.');
+});
+
+t.add('parseResponse: citations', async () => {
+  const p = new Prompt();
+  await parseResponse(100, p, fakeCitationRes());
+  const log = p.messages.find(m => m.role === 'log');
+  assert.ok(log);
+  assert.ok(log.content[0].text.includes('https://ex.com'));
+});
+
+t.add('parseResponse: function_call', async () => {
+  const p = new Prompt();
+  p.add('user', 'Weather');
+  await parseResponse(100, p, fakeToolRes());
+  const msg = p.getLastMessage();
+  assert.strictEqual(msg.role, 'assistant');
+  assert.strictEqual(msg.content[0].type, 'function_request');
+  assert.strictEqual(msg.content[0].function_request.name, 'get_current_weather');
+  assert.strictEqual(msg.content[0].function_request.parameters, '{"location":"Amsterdam"}');
+  assert.strictEqual(msg.content[0].function_request.call_id, 'fcid');
+});
+
+t.add('parseResponse: toolset exec', async () => {
+  const p = new Prompt();
+  p.add('user', 'Weather Amsterdam');
+  await parseResponse(100, p, fakeToolRes('get_current_weather', '{"location":"Amsterdam"}'), tools);
+  const toolMsg = p.getLastMessage();
+  assert.strictEqual(toolMsg.role, 'tool');
+  assert.strictEqual(toolMsg.content[0].type, 'function_response');
+  assert.strictEqual(toolMsg.content[0].function_response.name, 'get_current_weather');
+  assert.ok(toolMsg.content[0].function_response.response.includes('24 C'));
+});
+
+t.add('parseResponse: non-200 rejects', async () => {
+  const p = new Prompt();
+  const bad = { status: 400, response: { error: 'bad' } };
+  await assert.rejects(async () => parseResponse(100, p, bad), /400: /);
+});
+
+t.add('request: real simple', async () => {
+  const p = new Prompt();
+  p.add('system', 'You are a helpful assistant. Answer briefly.', true);
+  p.add('user', 'What is 2+2?');
+  const msg = await request(p);
+  assert.strictEqual(msg.role, 'assistant');
+  assert.ok(msg.content.some(c => c.type === 'text' && c.text.includes('4')), 'Expected 4');
+});
+
+const report = await t.run();
+process.exit(report.errors > 0 ? 1 : 0);