ag-ai 0.1.0

package/runtime/tests/bridge.test.mjs

@@ -0,0 +1,554 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+/* eslint-disable import/extensions -- Native Node ESM requires file extensions. */
+
+import {
+  RunnerClient,
+  UncertainRequestError,
+  normalizeBaseUrl,
+  processJob,
+  readConfig,
+  validateJobEnvelope,
+} from '../bridge.mjs';
+import { createOpenCodeExecutor } from '../executor/opencode.mjs';
+
+const PNG_BASE64 = 'iVBORw0KGgo=';
+
+const readRequestBody = (request) =>
+  new Promise((resolve) => {
+    const chunks = [];
+    request.on('data', (chunk) => chunks.push(chunk));
+    request.on('end', () => resolve(Buffer.concat(chunks)));
+  });
+
+const listen = (server) =>
+  new Promise((resolve) => server.listen(0, '127.0.0.1', () => resolve(server.address().port)));
+
+const closeServer = (server) => new Promise((resolve) => server.close(() => resolve()));
+
+const waitFor = async (predicate, timeoutMs = 2000) => {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (predicate()) return;
+    // eslint-disable-next-line no-await-in-loop -- Polling the fake server keeps assertions deterministic.
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  throw new Error('condition was not met before the timeout');
+};
+
+const startFakeOpenCode = async ({ messageHandler } = {}) => {
+  const requests = [];
+  const server = createServer(async (request, response) => {
+    const url = new URL(request.url, 'http://localhost');
+    const raw = await readRequestBody(request);
+    let body;
+    try {
+      body = raw.length > 0 ? JSON.parse(raw.toString('utf8')) : undefined;
+    } catch {
+      body = undefined;
+    }
+    requests.push({
+      method: request.method,
+      pathname: url.pathname,
+      search: url.search,
+      headers: request.headers,
+      body,
+    });
+    const send = (status, value) => {
+      response.statusCode = status;
+      response.setHeader('content-type', 'application/json');
+      response.end(JSON.stringify(value));
+    };
+    if (request.method === 'GET' && url.pathname === '/global/health') {
+      send(200, { healthy: true, version: 'test' });
+      return;
+    }
+    if (request.method === 'GET' && url.pathname === '/config/providers') {
+      send(200, {
+        providers: [
+          {
+            id: 'openai',
+            models: {
+              'gpt-4': { id: 'gpt-4', capabilities: { input: { image: true } } },
+            },
+          },
+        ],
+        default: { openai: 'gpt-4' },
+      });
+      return;
+    }
+    if (request.method === 'POST' && url.pathname === '/session') {
+      send(200, { id: 'session-1' });
+      return;
+    }
+    if (request.method === 'POST' && url.pathname === '/session/session-1/message') {
+      if (messageHandler) {
+        await messageHandler(request, response, send);
+        return;
+      }
+      send(200, {
+        info: { modelID: 'gpt-4', time: { completed: 123 }, tokens: { input: 3, output: 4 } },
+        parts: [{ type: 'text', text: 'answer' }],
+      });
+      return;
+    }
+    if (request.method === 'POST' && url.pathname === '/session/session-1/abort') {
+      send(200, true);
+      return;
+    }
+    send(404, { error: 'not found' });
+  });
+  const port = await listen(server);
+  return { url: `http://127.0.0.1:${port}`, requests, close: () => closeServer(server) };
+};
+
+const createQueueFetch = (responses, requests) => async (url, init) => {
+  const parsed = new URL(url);
+  const key = `${init.method} ${parsed.pathname}`;
+  requests.push({
+    method: init.method,
+    pathname: parsed.pathname,
+    headers: init.headers,
+    body: init.body,
+  });
+  if (!(key in responses)) throw new Error(`unexpected queue request ${key}`);
+  return new Response(JSON.stringify(responses[key]), {
+    status: 200,
+    headers: { 'content-type': 'application/json' },
+  });
+};
+
+const textModel = {
+  id: 'openai/gpt-4',
+  inputModalities: ['text'],
+  outputModalities: ['text'],
+  supportedReasoningEfforts: ['medium'],
+  defaultReasoningEffort: 'medium',
+  prefer: ['quality'],
+  isDefault: true,
+};
+
+const textEnvelope = {
+  version: 1,
+  input: [{ role: 'user', content: [{ type: 'text', text: 'hi' }] }],
+  output: ['text'],
+  model: 'openai/gpt-4',
+  reasoningEffort: 'medium',
+};
+
+const imageModel = {
+  ...textModel,
+  outputModalities: ['text', 'image'],
+  imageGeneration: true,
+};
+
+const imageEnvelope = {
+  ...textEnvelope,
+  input: [{ role: 'user', content: [{ type: 'text', text: 'draw a tree' }] }],
+  output: ['text', 'image'],
+};
+
+test('executor creates a session and sends the prompt with model and json_schema', async () => {
+  const opencode = await startFakeOpenCode();
+  try {
+    const executor = await createOpenCodeExecutor({
+      baseUrl: opencode.url,
+      password: 'secret',
+    });
+    const result = await executor.execute({
+      instructions: 'be brief',
+      input: [{ role: 'user', content: [{ type: 'text', text: 'hi' }] }],
+      output: ['text'],
+      model: 'openai/gpt-4',
+      outputSchema: { name: 'answer', schema: { type: 'object' } },
+    });
+
+    const session = opencode.requests.find((request) => request.pathname === '/session');
+    assert.ok(session);
+    assert.equal(
+      session.headers.authorization,
+      `Basic ${Buffer.from('opencode:secret').toString('base64')}`,
+    );
+    const message = opencode.requests.find(
+      (request) => request.pathname === '/session/session-1/message',
+    );
+    assert.ok(message);
+    assert.deepEqual(message.body.model, { providerID: 'openai', modelID: 'gpt-4' });
+    assert.deepEqual(message.body.format, {
+      type: 'json_schema',
+      schema: { type: 'object' },
+      retryCount: 2,
+    });
+    assert.deepEqual(message.body.parts[0], { type: 'text', text: 'be brief' });
+    assert.deepEqual(message.body.parts[1], { type: 'text', text: 'hi' });
+
+    assert.deepEqual(result.output, [{ type: 'text', text: 'answer' }]);
+    assert.equal(result.model, 'openai/gpt-4');
+    assert.equal(result.generatedAt, 123);
+    assert.deepEqual(result.usage, { inputTokens: 3, outputTokens: 4, totalTokens: 7 });
+  } finally {
+    await opencode.close();
+  }
+});
+
+test('executor maps base64 media input to OpenCode file parts and lists provider models', async () => {
+  const opencode = await startFakeOpenCode();
+  try {
+    const executor = await createOpenCodeExecutor({ baseUrl: opencode.url, password: 'secret' });
+    await executor.execute({
+      input: [
+        {
+          role: 'user',
+          content: [
+            { type: 'text', text: 'describe' },
+            { type: 'image', mimeType: 'image/png', data: PNG_BASE64, name: 'ref.png' },
+          ],
+        },
+      ],
+      output: ['text'],
+      model: 'openai/gpt-4',
+    });
+    const message = opencode.requests.find(
+      (request) => request.pathname === '/session/session-1/message',
+    );
+    assert.deepEqual(message.body.parts[1], {
+      type: 'file',
+      mime: 'image/png',
+      filename: 'ref.png',
+      url: `data:image/png;base64,${PNG_BASE64}`,
+    });
+
+    const models = await executor.listModels();
+    assert.deepEqual(models, [
+      {
+        id: 'openai/gpt-4',
+        inputModalities: ['text', 'image'],
+        outputModalities: ['text'],
+        supportedReasoningEfforts: ['medium'],
+        defaultReasoningEffort: 'medium',
+        webSearch: false,
+        prefer: ['quality'],
+        isDefault: true,
+        imageGeneration: false,
+      },
+    ]);
+  } finally {
+    await opencode.close();
+  }
+});
+
+test('executor aborts the session when the turn is cancelled', async () => {
+  const opencode = await startFakeOpenCode({
+    messageHandler: async (request) => {
+      await new Promise((resolve) => request.on('close', resolve));
+    },
+  });
+  try {
+    const executor = await createOpenCodeExecutor({ baseUrl: opencode.url, password: 'secret' });
+    const controller = new AbortController();
+    const pending = executor.execute(
+      {
+        input: [{ role: 'user', content: [{ type: 'text', text: 'hi' }] }],
+        output: ['text'],
+        model: 'openai/gpt-4',
+      },
+      { signal: controller.signal },
+    );
+    await waitFor(() =>
+      opencode.requests.some((request) => request.pathname === '/session/session-1/message'),
+    );
+    controller.abort();
+    await assert.rejects(pending);
+    await waitFor(() =>
+      opencode.requests.some((request) => request.pathname === '/session/session-1/abort'),
+    );
+  } finally {
+    await opencode.close();
+  }
+});
+
+test('executor delegates image output to the image adapter', async () => {
+  const opencode = await startFakeOpenCode();
+  const generated = [];
+  const executor = await createOpenCodeExecutor({
+    baseUrl: opencode.url,
+    password: 'secret',
+    imageAdapter: {
+      name: 'fake',
+      generate: async (request) => {
+        generated.push(request);
+        return { type: 'image', mimeType: 'image/png', data: PNG_BASE64, name: 'image-0.png' };
+      },
+    },
+  });
+  try {
+    const result = await executor.execute({
+      input: [{ role: 'user', content: [{ type: 'text', text: 'draw a tree' }] }],
+      output: ['text', 'image'],
+      model: 'openai/gpt-4',
+    });
+    assert.deepEqual(result.output, [
+      { type: 'text', text: 'answer' },
+      { type: 'image', mimeType: 'image/png', data: PNG_BASE64, name: 'image-0.png' },
+    ]);
+    assert.equal(generated.length, 1);
+    assert.equal(generated[0].prompt, 'draw a tree');
+  } finally {
+    await opencode.close();
+  }
+});
+
+test('queue client reports job traffic and never reports polling or heartbeats', async () => {
+  const events = [];
+  const requests = [];
+  const responses = {
+    'POST /api/ai/runner/heartbeat': { ok: true },
+    'POST /api/ai/runner/claim': { job: null },
+    'POST /api/ai/runner/jobs/job-1/heartbeat': { cancelRequested: false, leaseExpiresAt: 2 },
+    'GET /api/ai/runner/jobs/job-1/input': {},
+    'POST /api/ai/runner/jobs/job-1/upload': { key: 'uploads/response.json' },
+    'POST /api/ai/runner/jobs/job-1/complete': { ok: true },
+    'POST /api/ai/runner/jobs/job-1/fail': { ok: true },
+  };
+  const client = new RunnerClient({
+    baseUrl: 'https://queue.example/api/ai/runner',
+    token: 'test-token',
+    runnerId: 'runner-1',
+    analytics: { emit: (...event) => events.push(event) },
+    fetchImpl: createQueueFetch(responses, requests),
+  });
+
+  await client.heartbeat(0, true, true);
+  await client.claim();
+  await client.leaseHeartbeat('job-1', 'lease-token');
+  await client.input('job-1', 'lease-token');
+
+  assert.deepEqual(events, [
+    ['runner-http', 'input', 'get', 'requested'],
+    ['runner-http', 'input', 'get', 'responded', 200],
+  ]);
+
+  events.length = 0;
+  await client.upload(
+    'job-1',
+    'lease-token',
+    Buffer.from('{}'),
+    'response.json',
+    'application/json',
+  );
+  await client.complete('job-1', 'lease-token', { responseKey: 'uploads/response.json' });
+  await client.fail('job-1', 'lease-token', 'boom', 'failed');
+  assert.deepEqual(
+    events.filter((event) => event[3] === 'requested').map((event) => event[1]),
+    ['upload', 'complete', 'fail'],
+  );
+
+  const leaseRequest = requests.find(
+    (request) => request.pathname === '/api/ai/runner/jobs/job-1/heartbeat',
+  );
+  assert.equal(leaseRequest.headers['x-ai-lease-token'], 'lease-token');
+  const uploadRequest = requests.find(
+    (request) => request.pathname === '/api/ai/runner/jobs/job-1/upload',
+  );
+  assert.equal(uploadRequest.headers['x-ai-result-name'], 'response.json');
+  assert.equal(uploadRequest.headers['x-ai-lease-token'], 'lease-token');
+  const failRequest = requests.find(
+    (request) => request.pathname === '/api/ai/runner/jobs/job-1/fail',
+  );
+  assert.deepEqual(JSON.parse(failRequest.body.toString('utf8')), {
+    error: 'boom',
+    outcome: 'failed',
+  });
+});
+
+test('processJob uploads the response and image artifacts then completes', async () => {
+  const workspace = await mkdtemp(path.join(tmpdir(), 'ag-ai-bridge-ws-'));
+  const mainWorkspace = await mkdtemp(path.join(tmpdir(), 'ag-ai-bridge-main-'));
+  try {
+    const uploads = [];
+    let completed;
+    const fails = [];
+    const runner = {
+      input: async () => imageEnvelope,
+      leaseHeartbeat: async () => ({ cancelRequested: false, leaseExpiresAt: Date.now() + 60_000 }),
+      upload: async (_id, _token, bytes, name) => {
+        uploads.push({ name, bytes });
+        return { key: `uploads/${name}` };
+      },
+      complete: async (_id, _token, payload) => {
+        completed = payload;
+      },
+      fail: async (_id, _token, message, outcome) => {
+        fails.push({ message, outcome });
+      },
+    };
+    const state = {
+      health: { models: [imageModel] },
+      executor: {
+        execute: async () => ({
+          output: [
+            { type: 'text', text: 'done' },
+            { type: 'image', mimeType: 'image/png', data: PNG_BASE64 },
+          ],
+          model: 'openai/gpt-4',
+          generatedAt: 7,
+        }),
+      },
+    };
+    const job = {
+      id: 'job-1',
+      runId: 'run-1',
+      leaseToken: 'lease',
+      leaseExpiresAt: Date.now() + 60_000,
+    };
+
+    await processJob(runner, job, { workspace, mainWorkspace }, state, 'cloud', {
+      emit: () => Promise.resolve(true),
+    });
+
+    assert.deepEqual(
+      uploads.map((upload) => upload.name),
+      ['response.json', 'image-0.png'],
+    );
+    const response = JSON.parse(uploads[0].bytes.toString('utf8'));
+    assert.deepEqual(response.output, [
+      { type: 'text', text: 'done' },
+      { type: 'image', mimeType: 'image/png', name: 'image-0.png' },
+    ]);
+    assert.equal(response.model, 'openai/gpt-4');
+    assert.equal(response.generatedAt, 7);
+    assert.deepEqual(completed, {
+      responseKey: 'uploads/response.json',
+      imageKeys: ['uploads/image-0.png'],
+    });
+    assert.equal(fails.length, 0);
+  } finally {
+    await rm(workspace, { recursive: true, force: true });
+    await rm(mainWorkspace, { recursive: true, force: true });
+  }
+});
+
+test('processJob reports an uncertain lost turn as unknown and never replays it', async () => {
+  const workspace = await mkdtemp(path.join(tmpdir(), 'ag-ai-bridge-ws-'));
+  const mainWorkspace = await mkdtemp(path.join(tmpdir(), 'ag-ai-bridge-main-'));
+  try {
+    let executeCalls = 0;
+    const uploads = [];
+    const fails = [];
+    const runner = {
+      input: async () => textEnvelope,
+      leaseHeartbeat: async () => ({ cancelRequested: false, leaseExpiresAt: Date.now() + 60_000 }),
+      upload: async (_id, _token, bytes, name) => {
+        uploads.push(name);
+        return { key: `uploads/${name}` };
+      },
+      complete: async () => undefined,
+      fail: async (_id, _token, message, outcome) => {
+        fails.push({ message, outcome });
+      },
+    };
+    const state = {
+      health: { models: [textModel] },
+      executor: {
+        execute: async () => {
+          executeCalls += 1;
+          throw new UncertainRequestError('model turn was lost');
+        },
+      },
+    };
+    const job = {
+      id: 'job-2',
+      runId: 'run-2',
+      leaseToken: 'lease',
+      leaseExpiresAt: Date.now() + 60_000,
+    };
+
+    await assert.rejects(
+      processJob(runner, job, { workspace, mainWorkspace }, state, 'cloud', {
+        emit: () => Promise.resolve(true),
+      }),
+      /model turn was lost/,
+    );
+
+    assert.equal(executeCalls, 1);
+    assert.equal(uploads.length, 0);
+    assert.equal(fails.length, 1);
+    assert.equal(fails[0].outcome, 'unknown');
+  } finally {
+    await rm(workspace, { recursive: true, force: true });
+    await rm(mainWorkspace, { recursive: true, force: true });
+  }
+});
+
+test('readConfig reads the AG_AI_* environment and validates the queue URL', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'ag-ai-bridge-config-'));
+  try {
+    const runnerToken = path.join(root, 'runner-token');
+    const analyticaToken = path.join(root, 'analytica-token');
+    await writeFile(runnerToken, 'runner-secret\n');
+    await writeFile(analyticaToken, 'analytica-secret\n');
+    const config = await readConfig({
+      AG_AI_RUNNER_TOKEN_FILE: runnerToken,
+      AG_AI_ANALYTICA_TOKEN_FILE: analyticaToken,
+      AG_AI_QUEUE_URL: 'https://queue.example/api/ai/runner',
+      AG_AI_OPENCODE_URL: 'http://127.0.0.1:5000',
+      AG_AI_OPENCODE_USERNAME: 'worker',
+      AG_AI_OPENCODE_PASSWORD_FILE: path.join(root, 'opencode-password'),
+      AG_AI_OPENCODE_PROVIDER: 'openai',
+      AG_AI_IMAGE_PROVIDER: 'openai',
+      AG_AI_RUNNER_ID: 'runner-42',
+      AG_AI_WORKSPACE: path.join(root, 'workspace'),
+      AG_AI_MAIN_WORKSPACE: path.join(root, 'main'),
+      AG_AI_GENERATION_STORE: path.join(root, 'store'),
+    });
+
+    assert.equal(config.token, 'runner-secret');
+    assert.equal(config.analyticaToken, 'analytica-secret');
+    assert.equal(config.runnerId, 'runner-42');
+    assert.equal(config.queueUrl, 'https://queue.example/api/ai/runner');
+    assert.equal(config.opencodeUrl, 'http://127.0.0.1:5000');
+    assert.equal(config.opencodeUsername, 'worker');
+    assert.equal(config.opencodeProvider, 'openai');
+    assert.equal(config.imageProvider, 'openai');
+    assert.equal(config.workspace, path.resolve(path.join(root, 'workspace')));
+    assert.equal(config.generationStore, path.resolve(path.join(root, 'store')));
+
+    assert.throws(() => normalizeBaseUrl('http://queue.example'), /https/);
+    assert.throws(() => normalizeBaseUrl('https://user:pass@queue.example'), /credentials/);
+    assert.equal(
+      normalizeBaseUrl('https://queue.example/anything/else').toString(),
+      'https://queue.example/anything/else',
+    );
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('validateJobEnvelope accepts a complete lease and rejects unsafe metadata', () => {
+  const envelope = validateJobEnvelope({
+    id: 'job-1',
+    runId: 'run-1',
+    leaseToken: 'lease',
+    leaseExpiresAt: 123,
+    model: 'openai/gpt-4',
+    reasoningEffort: 'medium',
+  });
+  assert.deepEqual(envelope, {
+    id: 'job-1',
+    runId: 'run-1',
+    leaseToken: 'lease',
+    leaseExpiresAt: 123,
+    model: 'openai/gpt-4',
+    reasoningEffort: 'medium',
+  });
+  assert.throws(() =>
+    validateJobEnvelope({ id: '../escape', runId: 'run-1', leaseToken: 'l', leaseExpiresAt: 1 }),
+  );
+  assert.throws(() =>
+    validateJobEnvelope({ id: 'job-1', runId: 'run-1', leaseToken: '', leaseExpiresAt: 1 }),
+  );
+});

package/runtime/tests/image-adapter.test.mjs

@@ -0,0 +1,148 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+/* eslint-disable import/extensions -- Native Node ESM requires file extensions. */
+
+import {
+  ImageAdapterError,
+  createImageAdapter,
+  createOpenAIImageAdapter,
+} from '../image/adapter.mjs';
+
+const PNG_BASE64 = 'iVBORw0KGgo=';
+
+const jsonResponse = (value, status = 200) =>
+  new Response(JSON.stringify(value), {
+    status,
+    headers: { 'content-type': 'application/json' },
+  });
+
+test('sends the configured model and prompt and returns a PNG image part', async () => {
+  const requests = [];
+  const adapter = createOpenAIImageAdapter({
+    apiKey: 'test-key',
+    fetch: async (url, init) => {
+      requests.push({
+        url: typeof url === 'string' ? url : url instanceof URL ? url.href : url.url,
+        init,
+      });
+      return jsonResponse({ data: [{ b64_json: PNG_BASE64 }] });
+    },
+  });
+
+  const part = await adapter.generate({ prompt: 'a lighthouse', name: 'hero.png' });
+
+  assert.equal(requests.length, 1);
+  assert.equal(requests[0].url, 'https://api.openai.com/v1/images/generations');
+  assert.equal(requests[0].init.method, 'POST');
+  assert.equal(requests[0].init.headers.authorization, 'Bearer test-key');
+  const body = JSON.parse(requests[0].init.body);
+  assert.equal(body.model, 'gpt-image-1');
+  assert.equal(body.prompt, 'a lighthouse');
+  assert.equal(body.n, 1);
+  assert.deepEqual(part, {
+    type: 'image',
+    mimeType: 'image/png',
+    data: PNG_BASE64,
+    name: 'hero.png',
+  });
+});
+
+test('honors a model override and request size and quality', async () => {
+  let captured;
+  const adapter = createOpenAIImageAdapter({
+    apiKey: 'test-key',
+    model: 'gpt-image-1-mini',
+    fetch: async (_url, init) => {
+      captured = JSON.parse(init.body);
+      return jsonResponse({ data: [{ b64_json: PNG_BASE64 }] });
+    },
+  });
+
+  await adapter.generate({ prompt: 'x', size: '1024x1024', quality: 'high' });
+  assert.equal(captured.model, 'gpt-image-1-mini');
+  assert.equal(captured.size, '1024x1024');
+  assert.equal(captured.quality, 'high');
+});
+
+test('rejects input reference images clearly instead of ignoring them', async () => {
+  let called = false;
+  const adapter = createOpenAIImageAdapter({
+    apiKey: 'test-key',
+    fetch: async () => {
+      called = true;
+      return jsonResponse({ data: [{ b64_json: PNG_BASE64 }] });
+    },
+  });
+
+  await assert.rejects(
+    adapter.generate({
+      prompt: 'edit this',
+      images: [{ mimeType: 'image/png', data: PNG_BASE64 }],
+    }),
+    /does not accept input reference images/,
+  );
+  assert.equal(called, false);
+});
+
+test('honors an abort signal', async () => {
+  const adapter = createOpenAIImageAdapter({
+    apiKey: 'test-key',
+    fetch: async (_url, init) =>
+      new Promise((_resolve, reject) => {
+        init.signal.addEventListener('abort', () =>
+          reject(Object.assign(new Error('aborted'), { name: 'AbortError' })),
+        );
+      }),
+  });
+
+  const controller = new AbortController();
+  const pending = adapter.generate({ prompt: 'x', signal: controller.signal });
+  controller.abort();
+  await assert.rejects(pending);
+});
+
+test('rejects an oversized provider response before parsing it', async () => {
+  const adapter = createOpenAIImageAdapter({
+    apiKey: 'test-key',
+    fetch: async () =>
+      new Response('{}', {
+        status: 200,
+        headers: { 'content-length': String(64 * 1024 * 1024 + 1) },
+      }),
+  });
+
+  await assert.rejects(adapter.generate({ prompt: 'x' }), /exceeds its size limit/);
+});
+
+test('rejects non-PNG and invalid provider content', async () => {
+  const notPng = createOpenAIImageAdapter({
+    apiKey: 'test-key',
+    fetch: async () => jsonResponse({ data: [{ b64_json: 'AAAA' }] }),
+  });
+  await assert.rejects(notPng.generate({ prompt: 'x' }), /not a PNG/);
+
+  const invalid = createOpenAIImageAdapter({
+    apiKey: 'test-key',
+    fetch: async () => jsonResponse({ data: [{ b64_json: 'not base64!!' }] }),
+  });
+  await assert.rejects(invalid.generate({ prompt: 'x' }), ImageAdapterError);
+});
+
+test('surfaces provider HTTP failures with their status', async () => {
+  const adapter = createOpenAIImageAdapter({
+    apiKey: 'test-key',
+    fetch: async () => jsonResponse({ error: 'nope' }, 401),
+  });
+
+  await assert.rejects(adapter.generate({ prompt: 'x' }), (error) => {
+    assert(error instanceof ImageAdapterError);
+    assert.equal(error.status, 401);
+    return true;
+  });
+});
+
+test('selects a provider by name and rejects unknown providers', () => {
+  const adapter = createImageAdapter({ provider: 'openai', apiKey: 'test-key' });
+  assert.equal(adapter.name, 'openai');
+  assert.throws(() => createImageAdapter({ provider: 'unknown', apiKey: 'k' }), ImageAdapterError);
+});