@openchambery/web 1.19.20 → 2.0.0-beta.1

package/server/lib/opencode/lifecycle.test.js

@@ -9,6 +9,7 @@ vi.mock('node:child_process', () => ({
 }));
 
 const { createOpenCodeLifecycleRuntime } = await import('./lifecycle.js');
+const { createOpenCodeNetworkRuntime } = await import('./network-runtime.js');
 
 const originalOpencodeBinary = process.env.OPENCODE_BINARY;
 const originalPath = process.env.PATH;
@@ -57,6 +58,7 @@ const createRuntime = (overrides = {}, stateRef = null) => {
     openCodeApiDetectionTimer: null,
     lastOpenCodeError: null,
     isOpenCodeReady: false,
+    v1Migration: null,
     openCodeNotReadySince: 0,
     isExternalOpenCode: false,
     isShuttingDown: false,
@@ -109,6 +111,53 @@ const createRuntime = (overrides = {}, stateRef = null) => {
   });
 };
 
+const jsonResponse = (body, status = 200) => new Response(JSON.stringify(body), {
+  status,
+  headers: { 'content-type': 'application/json' },
+});
+
+const DEFAULT_V2_HEALTH = { version: '2.0.12', pid: 1, urls: [], paths: { tmp: '/tmp' } };
+
+const stubOpenCodeFetch = (overrides = {}) => {
+  const fetchMock = vi.fn(async (url, init) => {
+    const href = String(url);
+    if (href.includes('/api/experimental/migration/v1')) {
+      const migration = overrides.migration;
+      if (typeof migration === 'function') {
+        return migration(url, init);
+      }
+      if (migration && typeof migration === 'object' && Number.isInteger(migration.httpStatus)) {
+        return jsonResponse(migration.body ?? {}, migration.httpStatus);
+      }
+      return jsonResponse(migration ?? { status: 'completed' });
+    }
+    if (href.includes('/api/info') || href.includes('/global/health')) {
+      if (overrides.reuseDefaultServe !== true && href.includes(':4096/')) {
+        return new Response('not found', { status: 404 });
+      }
+      const health = overrides.health;
+      if (typeof health === 'function') {
+        return health(url, init);
+      }
+      return jsonResponse(health ?? DEFAULT_V2_HEALTH);
+    }
+    return new Response('not found', { status: 404 });
+  });
+  vi.stubGlobal('fetch', fetchMock);
+  return fetchMock;
+};
+
+const startListeningChild = () => {
+  const child = createMockChild();
+  spawnMock.mockImplementationOnce(() => {
+    queueMicrotask(() => {
+      child.stdout.emit('data', 'server listening on http://127.0.0.1:45678\n');
+    });
+    return child;
+  });
+  return child;
+};
+
 describe('OpenCode lifecycle', () => {
   it('launches managed OpenCode with the managed PATH', async () => {
     delete process.env.OPENCODE_BINARY;
@@ -133,6 +182,76 @@ describe('OpenCode lifecycle', () => {
     await server.close();
   });
 
+  it('parses a v2 server listening line without the opencode prefix', async () => {
+    delete process.env.OPENCODE_BINARY;
+    const child = createMockChild();
+    spawnMock.mockImplementationOnce(() => {
+      queueMicrotask(() => {
+        child.stdout.emit('data', 'server listening on http://127.0.0.1:45678\n');
+      });
+      return child;
+    });
+
+    const runtime = createRuntime();
+    const server = await runtime.startOpenCode();
+
+    expect(server.url).toBe('http://127.0.0.1:45678');
+
+    await server.close();
+  });
+
+  it('probes /api/info with Basic auth after the managed server is listening', async () => {
+    delete process.env.OPENCODE_BINARY;
+    const child = createMockChild();
+    spawnMock.mockImplementationOnce(() => {
+      queueMicrotask(() => {
+        child.stdout.emit('data', 'server listening on http://127.0.0.1:45678\n');
+      });
+      return child;
+    });
+
+    const fetchMock = vi.fn(async (url) => {
+      if (String(url).includes('/api/info')) {
+        return new Response(JSON.stringify(DEFAULT_V2_HEALTH), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        });
+      }
+      if (String(url).includes('/api/experimental/migration/v1')) {
+        return new Response(JSON.stringify({ status: 'completed' }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        });
+      }
+      return new Response('not found', { status: 404 });
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const authHeaders = { Authorization: 'Basic Zml4dHVyZQ==' };
+    const network = createOpenCodeNetworkRuntime({
+      state: {
+        openCodePort: 45678,
+        openCodeBaseUrl: null,
+        openCodeApiPrefix: '',
+        openCodeApiPrefixDetected: false,
+        openCodeApiDetectionTimer: null,
+      },
+      getOpenCodeAuthHeaders: () => authHeaders,
+    });
+    const runtime = createRuntime({
+      getOpenCodeAuthHeaders: () => authHeaders,
+      waitForReady: network.waitForReady,
+    });
+    const server = await runtime.startOpenCode();
+    const healthCall = fetchMock.mock.calls.find((call) => String(call[0]).includes('/api/info'));
+
+    expect(healthCall).toBeDefined();
+    expect(String(healthCall[0])).toContain('/api/info');
+    expect(healthCall[1].headers.Authorization).toMatch(/^Basic /);
+
+    await server.close();
+  });
+
   it('prepares a fresh managed capability environment and records the spawned child pid', async () => {
     const child = createMockChild();
     spawnMock.mockImplementationOnce(() => {
@@ -298,7 +417,7 @@ describe('OpenCode lifecycle', () => {
     stateRef.current.openCodeProcess = managedChild;
     stateRef.current.openCodePort = 45678;
     stateRef.current.isExternalOpenCode = false;
-    vi.stubGlobal('fetch', vi.fn(async () => new Response(JSON.stringify({ healthy: true }), { status: 200 })));
+    stubOpenCodeFetch();
     await runtime.bootstrapOpenCodeAtStartup();
     expect(managedChild.close).toHaveBeenCalledTimes(1);
     expect(stateRef.current.openCodeProcess).toBeNull();
@@ -324,7 +443,7 @@ describe('OpenCode lifecycle', () => {
     }, stateRef);
     stateRef.current.isExternalOpenCode = true;
     stateRef.current.openCodeBaseUrl = 'http://127.0.0.1:3001';
-    vi.stubGlobal('fetch', vi.fn(async () => new Response(JSON.stringify({ healthy: true }), { status: 200 })));
+    stubOpenCodeFetch();
 
     await runtime.bootstrapOpenCodeAtStartup();
 
@@ -367,6 +486,7 @@ describe('OpenCode lifecycle', () => {
       clearResolvedOpenCodeBinary,
     }, stateRef);
     const errorLog = vi.spyOn(console, 'error').mockImplementation(() => {});
+    stubOpenCodeFetch();
 
     await runtime.bootstrapOpenCodeAtStartup();
     expect(spawnMock).not.toHaveBeenCalled();
@@ -378,10 +498,7 @@ describe('OpenCode lifecycle', () => {
       });
       return child;
     });
-    vi.stubGlobal('fetch', vi.fn(async () => new Response(JSON.stringify({ healthy: true }), {
-      status: 200,
-      headers: { 'content-type': 'application/json' },
-    })));
+    stubOpenCodeFetch();
 
     try {
       await runtime.retryOpenCodeStartup();
@@ -393,4 +510,257 @@ describe('OpenCode lifecycle', () => {
       await stateRef.current.openCodeProcess?.close();
     }
   });
+
+  it('does not mark OpenCode ready for messages while V1 migration is required', async () => {
+    delete process.env.OPENCODE_BINARY;
+    startListeningChild();
+    const stateRef = {};
+    stubOpenCodeFetch({ migration: { status: 'required' } });
+    const runtime = createRuntime({}, stateRef);
+
+    const server = await runtime.startOpenCode();
+
+    expect(stateRef.current.isOpenCodeReady).toBe(false);
+    expect(stateRef.current.v1Migration).toMatchObject({
+      admitTranscript: false,
+      phase: 'required',
+    });
+
+    await server.close();
+  });
+
+  it('keeps the ready gate closed while waitForOpenCodeReady sees required migration', async () => {
+    const stateRef = {};
+    const runtime = createRuntime({}, stateRef);
+    stateRef.current.openCodePort = 45678;
+    stubOpenCodeFetch({
+      migration: { status: 'required' },
+    });
+
+    await expect(runtime.waitForOpenCodeReady(250, 40)).rejects.toThrow(/V1 migration is required/);
+    expect(stateRef.current.isOpenCodeReady).toBe(false);
+    expect(stateRef.current.v1Migration).toMatchObject({
+      admitTranscript: false,
+      phase: 'required',
+    });
+  });
+
+  it('marks OpenCode ready for messages after V1 migration completed', async () => {
+    delete process.env.OPENCODE_BINARY;
+    startListeningChild();
+    const stateRef = {};
+    stubOpenCodeFetch({ migration: { status: 'completed' } });
+    const runtime = createRuntime({}, stateRef);
+
+    const server = await runtime.startOpenCode();
+
+    expect(stateRef.current.isOpenCodeReady).toBe(true);
+    expect(stateRef.current.v1Migration).toMatchObject({
+      admitTranscript: true,
+      phase: 'completed',
+    });
+
+    await server.close();
+  });
+
+  it('admits messages when V1 migration is absent', async () => {
+    const stateRef = {};
+    const runtime = createRuntime({}, stateRef);
+    stateRef.current.openCodePort = 45678;
+    stubOpenCodeFetch({
+      migration: { httpStatus: 404, body: {} },
+    });
+
+    await runtime.waitForOpenCodeReady(1000, 40);
+
+    expect(stateRef.current.isOpenCodeReady).toBe(true);
+    expect(stateRef.current.v1Migration).toMatchObject({
+      admitTranscript: true,
+      phase: 'absent',
+    });
+  });
+
+  it('retries V1 migration error and still blocks messages until completed', async () => {
+    const stateRef = {};
+    const runtime = createRuntime({}, stateRef);
+    stateRef.current.openCodePort = 45678;
+    let migrationCalls = 0;
+    const fetchMock = stubOpenCodeFetch({
+      migration: () => {
+        migrationCalls += 1;
+        if (migrationCalls === 1) {
+          return jsonResponse({ status: 'error', error: 'locked' });
+        }
+        return jsonResponse({ status: 'completed' });
+      },
+    });
+
+    await runtime.waitForOpenCodeReady(2000, 40);
+
+    expect(migrationCalls).toBeGreaterThan(1);
+    expect(fetchMock.mock.calls.some((call) => String(call[0]).includes('/api/experimental/migration/v1'))).toBe(true);
+    expect(fetchMock.mock.calls.every((call) => !call[1] || call[1].method !== 'POST')).toBe(true);
+    expect(stateRef.current.isOpenCodeReady).toBe(true);
+    expect(stateRef.current.v1Migration).toMatchObject({
+      admitTranscript: true,
+      phase: 'completed',
+    });
+  });
+
+  it('publishes v1Migration on lifecycle state for health snapshot', async () => {
+    const stateRef = {};
+    const runtime = createRuntime({}, stateRef);
+    stateRef.current.openCodePort = 45678;
+    stubOpenCodeFetch({
+      migration: {
+        status: 'running',
+        progress: { label: 'Sessions', numerator: 2, denominator: 8 },
+      },
+    });
+
+    await expect(runtime.waitForOpenCodeReady(200, 40)).rejects.toThrow(/V1 migration is running/);
+    expect(stateRef.current.isOpenCodeReady).toBe(false);
+    expect(stateRef.current.v1Migration).toMatchObject({
+      admitTranscript: false,
+      phase: 'running',
+      progress: { label: 'Sessions', numerator: 2, denominator: 8 },
+    });
+    expect(stateRef.current.v1Migration.userNotice).toContain('V1 subtasks do not appear in v2');
+  });
+
+  it('clears v1Migration when an external OpenCode restart probe fails', async () => {
+    const stateRef = {};
+    const runtime = createRuntime({
+      env: {
+        ENV_CONFIGURED_OPENCODE_PORT: null,
+        ENV_CONFIGURED_OPENCODE_HOST: null,
+        ENV_EFFECTIVE_PORT: 45678,
+        ENV_CONFIGURED_OPENCODE_HOSTNAME: '127.0.0.1',
+        ENV_SKIP_OPENCODE_START: false,
+      },
+    }, stateRef);
+    stateRef.current.isExternalOpenCode = true;
+    stateRef.current.openCodePort = 45678;
+    stateRef.current.openCodeBaseUrl = 'http://127.0.0.1:45678';
+    stateRef.current.v1Migration = { admitTranscript: true, phase: 'completed' };
+    vi.stubGlobal('fetch', vi.fn(async () => new Response(JSON.stringify({ healthy: false }), {
+      status: 200,
+      headers: { 'content-type': 'application/json' },
+    })));
+
+    await expect(runtime.restartOpenCode()).rejects.toThrow('External OpenCode server on port 45678 is not responding');
+    expect(stateRef.current.isOpenCodeReady).toBe(false);
+    expect(stateRef.current.v1Migration).toBeNull();
+    // Read-only external mount: failed re-probe keeps port + ownership; never spawn.
+    expect(stateRef.current.openCodePort).toBe(45678);
+    expect(stateRef.current.isExternalOpenCode).toBe(true);
+    expect(spawnMock).not.toHaveBeenCalled();
+  });
+
+  it('rejects healthy 1.x health bodies instead of admitting the process', async () => {
+    const stateRef = {};
+    const runtime = createRuntime({}, stateRef);
+    stateRef.current.openCodePort = 45678;
+    stubOpenCodeFetch({ health: { healthy: true, version: '1.15.0' } });
+
+    await expect(runtime.waitForOpenCodeReady(300, 40)).rejects.toThrow(/unhealthy|Timed out|1\.|version/i);
+    expect(stateRef.current.isOpenCodeReady).toBe(false);
+  });
+
+  it('rejects healthy responses with a missing version', async () => {
+    const stateRef = {};
+    const runtime = createRuntime({}, stateRef);
+    stateRef.current.openCodePort = 45678;
+    stubOpenCodeFetch({ health: { healthy: true } });
+
+    await expect(runtime.waitForOpenCodeReady(300, 40)).rejects.toThrow();
+    expect(stateRef.current.isOpenCodeReady).toBe(false);
+  });
+
+  it('health version + migration matrix: v2+completed admits, v2+running blocks, 1.x blocks', async () => {
+    const cases = [
+      { health: DEFAULT_V2_HEALTH, migration: { status: 'completed' }, admit: true },
+      { health: DEFAULT_V2_HEALTH, migration: { status: 'running' }, admit: false },
+      { health: DEFAULT_V2_HEALTH, migration: { status: 'required' }, admit: false },
+      { health: DEFAULT_V2_HEALTH, migration: { status: 'error', error: 'disk' }, admit: false },
+      { health: { healthy: true, version: '1.18.18' }, migration: { status: 'completed' }, admit: false },
+    ];
+
+    for (const entry of cases) {
+      const stateRef = {};
+      const runtime = createRuntime({}, stateRef);
+      stateRef.current.openCodePort = 45678;
+      stubOpenCodeFetch({ health: entry.health, migration: entry.migration });
+      if (entry.admit) {
+        await runtime.waitForOpenCodeReady(1000, 40);
+        expect(stateRef.current.isOpenCodeReady).toBe(true);
+      } else {
+        await expect(runtime.waitForOpenCodeReady(250, 40)).rejects.toThrow();
+        expect(stateRef.current.isOpenCodeReady).toBe(false);
+      }
+    }
+  });
+
+  it('aborts a hung migration probe with the same per-attempt signal after health', async () => {
+    const stateRef = {};
+    const runtime = createRuntime({}, stateRef);
+    stateRef.current.openCodePort = 45678;
+    let migrationStarted = 0;
+    let sawAbort = false;
+    stubOpenCodeFetch({
+      health: DEFAULT_V2_HEALTH,
+      migration: (_url, init) => {
+        migrationStarted += 1;
+        return new Promise((_resolve, reject) => {
+          const signal = init?.signal;
+          if (!signal) {
+            reject(new Error('migration probe missing abort signal'));
+            return;
+          }
+          if (signal.aborted) {
+            sawAbort = true;
+            reject(new DOMException('Aborted', 'AbortError'));
+            return;
+          }
+          signal.addEventListener('abort', () => {
+            sawAbort = true;
+            reject(new DOMException('Aborted', 'AbortError'));
+          }, { once: true });
+        });
+      },
+    });
+
+    // Default per-attempt health timeout is 5s; outer deadline must exceed it once
+    // so the hung migration is aborted by the attempt timer, not only the loop exit.
+    const started = Date.now();
+    await expect(runtime.waitForOpenCodeReady(6500, 50)).rejects.toThrow();
+    const elapsed = Date.now() - started;
+    expect(migrationStarted).toBeGreaterThan(0);
+    expect(sawAbort).toBe(true);
+    expect(elapsed).toBeLessThan(12_000);
+    expect(stateRef.current.isOpenCodeReady).toBe(false);
+  }, 15_000);
+
+  it('does not mark external skip-start ready before version and migration admit', async () => {
+    const stateRef = {};
+    const runtime = createRuntime({
+      env: {
+        ENV_CONFIGURED_OPENCODE_PORT: null,
+        ENV_CONFIGURED_OPENCODE_HOST: { origin: 'http://127.0.0.1:3001' },
+        ENV_EFFECTIVE_PORT: 3001,
+        ENV_CONFIGURED_OPENCODE_HOSTNAME: '127.0.0.1',
+        ENV_SKIP_OPENCODE_START: true,
+      },
+      syncFromHmrState: vi.fn(),
+    }, stateRef);
+    // Reject health so bootstrap's waitForOpenCodeReady fails quickly without a
+    // 20s migration spin, while still proving skip-start never pre-admits ready.
+    stubOpenCodeFetch({ health: { healthy: true, version: '1.15.0' } });
+
+    await runtime.bootstrapOpenCodeAtStartup();
+
+    expect(stateRef.current.isExternalOpenCode).toBe(true);
+    expect(stateRef.current.isOpenCodeReady).toBe(false);
+    expect(stateRef.current.openCodePort).toBe(3001);
+  }, 25_000);
 });

package/server/lib/opencode/network-runtime.js

@@ -1,3 +1,5 @@
+import { evaluateOpenCodeHealthBody } from './opencode2-pin.js';
+
 export const createOpenCodeNetworkRuntime = (deps) => {
   const {
     state,
@@ -41,26 +43,29 @@ export const createOpenCodeNetworkRuntime = (deps) => {
 
   const waitForReady = async (url, timeoutMs = 10000) => {
     const start = Date.now();
+    const baseUrl = url.replace(/\/+$/, '');
     while (Date.now() - start < timeoutMs) {
       let timeout = null;
       try {
         const controller = new AbortController();
         timeout = setTimeout(() => controller.abort(), 3000);
-        const response = await fetch(`${url.replace(/\/+$/, '')}/global/health`, {
-          method: 'GET',
-          headers: {
-            Accept: 'application/json',
-            ...getOpenCodeAuthHeaders(),
-          },
-          signal: controller.signal,
-        });
-        clearTimeout(timeout);
-        timeout = null;
-
-        if (response.ok) {
-          const body = await response.json().catch(() => null);
-          if (body?.healthy === true) {
-            return true;
+        const headers = {
+          Accept: 'application/json',
+          ...getOpenCodeAuthHeaders(),
+        };
+        for (const healthPath of ['/api/info', '/global/health']) {
+          const response = await fetch(`${baseUrl}${healthPath}`, {
+            method: 'GET',
+            headers,
+            signal: controller.signal,
+          });
+          if (response.ok) {
+            const body = await response.json().catch(() => null);
+            // Official 2.x /api/info is ServerInfo (version, no healthy);
+            // /global/health may still return { healthy, version }.
+            if (evaluateOpenCodeHealthBody(body).ok) {
+              return true;
+            }
           }
         }
       } catch {
@@ -88,8 +93,15 @@ export const createOpenCodeNetworkRuntime = (deps) => {
       throw new Error('OpenCode port is not available');
     }
     const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+    // v2 protocol mounts every route under `/api` (`@opencode-ai/protocol`).
+    // Callers pass unprefixed API paths (`/session`, `/event`, …); the bare
+    // upstream path falls through to the v2 Web UI HTML fallback. `/` stays the
+    // upstream origin for SDK base URLs, and already-prefixed paths are kept.
+    const apiPath = normalizedPath === '/' || normalizedPath.startsWith('/api')
+      ? normalizedPath
+      : `/api${normalizedPath}`;
     const prefix = normalizeApiPrefix(prefixOverride !== undefined ? prefixOverride : '');
-    const fullPath = `${prefix}${normalizedPath}`;
+    const fullPath = `${prefix}${apiPath}`;
     const base = state.openCodeBaseUrl ?? `http://${resolveConnectHostname()}:${state.openCodePort}`;
     return `${base}${fullPath}`;
   };

package/server/lib/opencode/network-runtime.test.js

@@ -23,6 +23,63 @@ describe('OpenCode network runtime', () => {
     globalThis.fetch = originalFetch;
   });
 
+  it('probes /api/info with Authorization and treats healthy true as ready', async () => {
+    const fetchMock = vi.fn(async (url, options) => {
+      expect(String(url)).toContain('/api/info');
+      expect(options.headers.Authorization).toMatch(/^Basic /);
+      return new Response(JSON.stringify({ version: '2.0.12', pid: 1, urls: [], paths: { tmp: '/tmp' } }), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+      });
+    });
+    globalThis.fetch = fetchMock;
+
+    const runtime = createOpenCodeNetworkRuntime({
+      state: {
+        openCodePort: 4096,
+        openCodeBaseUrl: null,
+        openCodeApiPrefix: '',
+        openCodeApiPrefixDetected: false,
+        openCodeApiDetectionTimer: null,
+      },
+      getOpenCodeAuthHeaders: () => ({ Authorization: 'Basic Zml4dHVyZQ==' }),
+    });
+
+    await expect(runtime.waitForReady('http://127.0.0.1:4096', 1000)).resolves.toBe(true);
+    expect(String(fetchMock.mock.calls[0][0])).toContain('/api/info');
+  });
+
+  it('falls back to /global/health when /api/info is not healthy', async () => {
+    const fetchMock = vi.fn(async (url) => {
+      if (String(url).includes('/api/info')) {
+        return new Response('not found', { status: 404 });
+      }
+      if (String(url).includes('/global/health')) {
+        return new Response(JSON.stringify({ healthy: true, version: '2.0.12' }), {
+          status: 200,
+          headers: { 'content-type': 'application/json' },
+        });
+      }
+      return new Response('no', { status: 500 });
+    });
+    globalThis.fetch = fetchMock;
+
+    const runtime = createOpenCodeNetworkRuntime({
+      state: {
+        openCodePort: 4096,
+        openCodeBaseUrl: null,
+        openCodeApiPrefix: '',
+        openCodeApiPrefixDetected: false,
+        openCodeApiDetectionTimer: null,
+      },
+      getOpenCodeAuthHeaders: () => ({ Authorization: 'Basic Zml4dHVyZQ==' }),
+    });
+
+    await expect(runtime.waitForReady('http://127.0.0.1:4096', 1000)).resolves.toBe(true);
+    expect(String(fetchMock.mock.calls[0][0])).toContain('/api/info');
+    expect(String(fetchMock.mock.calls[1][0])).toContain('/global/health');
+  });
+
   it('returns false when readiness fetch rejects', async () => {
     globalThis.fetch = vi.fn(async () => {
       throw new Error('offline');
@@ -37,7 +94,7 @@ describe('OpenCode network runtime', () => {
   it('builds managed OpenCode URLs against IPv4 loopback by default', () => {
     const runtime = createRuntime();
 
-    expect(runtime.buildOpenCodeUrl('/provider')).toBe('http://127.0.0.1:4096/provider');
+    expect(runtime.buildOpenCodeUrl('/provider')).toBe('http://127.0.0.1:4096/api/provider');
   });
 
   it('keeps external OpenCode base URLs authoritative', () => {
@@ -45,13 +102,20 @@ describe('OpenCode network runtime', () => {
       state: { openCodeBaseUrl: 'http://remote.example:4096' },
     });
 
-    expect(runtime.buildOpenCodeUrl('/provider')).toBe('http://remote.example:4096/provider');
+    expect(runtime.buildOpenCodeUrl('/provider')).toBe('http://remote.example:4096/api/provider');
+  });
+
+  it('keeps SDK base URLs (/) and already-prefixed paths untouched', () => {
+    const runtime = createRuntime();
+
+    expect(runtime.buildOpenCodeUrl('/')).toBe('http://127.0.0.1:4096/');
+    expect(runtime.buildOpenCodeUrl('/api/info')).toBe('http://127.0.0.1:4096/api/info');
   });
 
   it('normalizes wildcard and IPv6 OpenCode bind hosts for local connects', () => {
     expect(createRuntime({ configuredOpenCodeHostname: '0.0.0.0' }).buildOpenCodeUrl('/provider'))
-      .toBe('http://127.0.0.1:4096/provider');
+      .toBe('http://127.0.0.1:4096/api/provider');
     expect(createRuntime({ configuredOpenCodeHostname: '::1' }).buildOpenCodeUrl('/provider'))
-      .toBe('http://[::1]:4096/provider');
+      .toBe('http://[::1]:4096/api/provider');
   });
 });