@vantran-se/openchamber-web 1.24.4 → 2.0.2

package/server/lib/permission-auto-accept/runtime.js

@@ -90,10 +90,18 @@ export function createPermissionAutoAcceptRuntime({
 
   const rememberSession = (info, directoryHint) => {
     if (!info || typeof info.id !== 'string' || !info.id) return;
-    sessions.set(info.id, {
-      parentID: typeof info.parentID === 'string' && info.parentID ? info.parentID : null,
-      directory: typeof info.directory === 'string' && info.directory ? info.directory : directoryHint,
-    });
+    // v2 session updates are partial (a rename carries only the title), so a
+    // field the update does not name keeps what an earlier record said.
+    const previous = sessions.get(info.id);
+    const parentID = typeof info.parentID === 'string' && info.parentID ? info.parentID : previous?.parentID ?? null;
+    // v2 keeps the directory on `location`; translated events already flatten it.
+    const directory = typeof info.directory === 'string' && info.directory
+      ? info.directory
+      : (typeof info.location?.directory === 'string' && info.location.directory
+        ? info.location.directory
+        : previous?.directory ?? directoryHint);
+    if (previous) sessions.delete(info.id);
+    sessions.set(info.id, { parentID, directory });
     if (sessions.size > SESSION_CACHE_LIMIT) {
       sessions.delete(sessions.keys().next().value);
     }
@@ -101,12 +109,14 @@ export function createPermissionAutoAcceptRuntime({
 
   const request = async (path, { directory, method = 'GET', body } = {}) => {
     const url = new URL(buildOpenCodeUrl(path, ''));
-    if (directory) url.searchParams.set('directory', directory);
     const response = await fetchImpl(url, {
       method,
       headers: {
         Accept: 'application/json',
         ...(body ? { 'Content-Type': 'application/json' } : {}),
+        // OpenCode 2.x scopes a request to a directory through this header;
+        // the pending-permission list and services behind it are per location.
+        ...(directory ? { 'x-opencode-directory': encodeURIComponent(directory) } : {}),
         ...getOpenCodeAuthHeaders(),
       },
       ...(body ? { body: JSON.stringify(body) } : {}),
@@ -123,7 +133,7 @@ export function createPermissionAutoAcceptRuntime({
   const getSession = async (sessionId, directory) => {
     const cached = sessions.get(sessionId);
     if (cached) return cached;
-    const info = await request(`/session/${encodeURIComponent(sessionId)}`, { directory });
+    const info = await request(`/api/session/${encodeURIComponent(sessionId)}`, { directory });
     rememberSession(info?.data ?? info, directory);
     return sessions.get(sessionId) ?? null;
   };
@@ -156,10 +166,12 @@ export function createPermissionAutoAcceptRuntime({
       const verdict = await evaluatePermission(permission, directory);
       if (verdict?.action === 'hold') return true;
     }
-    await request(`/permission/${encodeURIComponent(permission.id)}/reply`, {
+    // v2 scopes a permission reply under its session.
+    await request(`/api/session/${encodeURIComponent(permission.sessionID)}/permission/${encodeURIComponent(permission.id)}/reply`, {
       directory,
       method: 'POST',
-      body: { reply: 'once' },
+      // OpenCode 2.0.8 renamed the reply body field `reply` to `decision`.
+      body: { decision: 'once' },
     });
     return true;
   };
@@ -198,7 +210,7 @@ export function createPermissionAutoAcceptRuntime({
       for (const directory of scopes) {
         let payload;
         try {
-          payload = await request('/permission', { directory });
+          payload = await request('/api/permission/request', { directory });
         } catch {
           continue;
         }
@@ -217,20 +229,24 @@ export function createPermissionAutoAcceptRuntime({
   }
 
   const processEvent = (event) => {
-    const raw = event?.payload;
-    const payload = raw?.payload && typeof raw.payload === 'object' ? raw.payload : raw;
     const directory = typeof event?.directory === 'string' && event.directory !== 'global' ? event.directory : undefined;
-    if (payload?.type === 'session.created' || payload?.type === 'session.updated') {
-      rememberSession(payload.properties?.info, directory);
-      return;
-    }
-    if (payload?.type === 'permission.asked') {
-      void processPermission(payload.properties, directory);
-      return;
-    }
-    if (payload?.type === 'permission.replied') {
-      const permissionId = payload.properties?.requestID;
-      if (typeof permissionId === 'string') onPermissionReplied?.(permissionId);
+    for (const payload of event?.translated?.() ?? []) {
+      if (payload.type === 'session.created' || payload.type === 'session.updated') {
+        rememberSession(payload.properties?.info, directory ?? payload.properties?.directory);
+        continue;
+      }
+      // A v2 permission request is `{ id, sessionID, action, resources, ... }`;
+      // only the id and session id are used to reply.
+      if (payload.type === 'permission.asked') {
+        void processPermission(payload.properties, directory ?? payload.properties?.directory);
+        continue;
+      }
+      // The routing safety net holds a request instead of replying; once the
+      // user answers it, stop tracking it.
+      if (payload.type === 'permission.replied') {
+        const permissionId = payload.properties?.requestID;
+        if (typeof permissionId === 'string' && permissionId) onPermissionReplied?.(permissionId);
+      }
     }
   };
 

package/server/lib/permission-auto-accept/runtime.test.js

@@ -23,11 +23,17 @@ const createRuntime = ({ stored, fetchImpl, retryDelaysMs = [0], evaluatePermiss
   return {
     runtime,
     getSettings: () => settings,
-    emit: (payload, directory = '/project') => eventHandler({ payload, directory }),
+    // The hub hands server-side subscribers already-translated events.
+    emit: (payload, directory = '/project') => eventHandler({ payload, directory, translated: () => [payload] }),
     connect: () => statusHandler({ type: 'connect' }),
   };
 };
 
+const directoryHeader = (init) => {
+  const value = init?.headers?.['x-opencode-directory'];
+  return typeof value === 'string' ? decodeURIComponent(value) : null;
+};
+
 const flush = async () => {
   for (let index = 0; index < 20; index += 1) await Promise.resolve();
 };
@@ -63,11 +69,24 @@ describe('permission auto-accept runtime', () => {
     await expect(runtime.isSessionAutoAccepting('grandchild', '/project')).resolves.toBe(true);
   });
 
+  it('keeps a subagent\'s lineage when a later partial update names only its title', async () => {
+    const fetchImpl = vi.fn(async () => Response.json({}));
+    const { runtime, emit } = createRuntime({ fetchImpl });
+    await runtime.setSessionPolicy('root', true);
+    emit({ type: 'session.created', properties: { info: { id: 'child', parentID: 'root', directory: '/project' } } });
+    // v2 renames arrive as partial session records without parentID.
+    emit({ type: 'session.updated', properties: { info: { id: 'child', title: 'Subagent' } } });
+    emit({ type: 'permission.asked', properties: { id: 'p1', sessionID: 'child', permission: 'bash', metadata: {} } });
+    await flush();
+    const replies = fetchImpl.mock.calls.map(([url]) => new URL(url).pathname).filter((path) => path.endsWith('/reply'));
+    expect(replies).toEqual(['/api/session/child/permission/p1/reply']);
+  });
+
   it('fetches missing subagent lineage before replying', async () => {
     const fetchImpl = vi.fn(async (url, init = {}) => {
       const path = new URL(url).pathname;
-      if (path === '/permission') return new Response('[]');
-      if (path === '/session/child') return Response.json({ id: 'child', parentID: 'root', directory: '/project' });
+      if (path === '/api/permission/request') return new Response('[]');
+      if (path === '/api/session/child') return Response.json({ id: 'child', parentID: 'root', directory: '/project' });
       if (init.method === 'POST') return Response.json({});
       return new Response('', { status: 404 });
     });
@@ -76,15 +95,16 @@ describe('permission auto-accept runtime', () => {
       fetchImpl,
     });
     await expect(runtime.processPermission({ id: 'perm', sessionID: 'child' }, '/project')).resolves.toBe(true);
-    expect(fetchImpl.mock.calls.some(([url, init]) => new URL(url).pathname === '/permission/perm/reply' && init.method === 'POST')).toBe(true);
+    // v2 scopes a permission reply under its session.
+    expect(fetchImpl.mock.calls.some(([url, init]) => new URL(url).pathname === '/api/session/child/permission/perm/reply' && init.method === 'POST')).toBe(true);
   });
 
   it('retries a transient reply failure and deduplicates concurrent events', async () => {
     let replyAttempts = 0;
     const fetchImpl = vi.fn(async (url, init = {}) => {
       const path = new URL(url).pathname;
-      if (path === '/permission') return new Response('[]');
-      if (path === '/permission/perm/reply' && init.method === 'POST') {
+      if (path === '/api/permission/request') return new Response('[]');
+      if (path === '/api/session/root/permission/perm/reply' && init.method === 'POST') {
         replyAttempts += 1;
         return replyAttempts === 1 ? new Response('', { status: 503 }) : Response.json({});
       }
@@ -105,8 +125,8 @@ describe('permission auto-accept runtime', () => {
   it('reconciles pending permissions after reconnect', async () => {
     const fetchImpl = vi.fn(async (url, init = {}) => {
       const path = new URL(url).pathname;
-      if (path === '/permission') return Response.json([{ id: 'pending', sessionID: 'root' }]);
-      if (path === '/permission/pending/reply' && init.method === 'POST') return Response.json({});
+      if (path === '/api/permission/request') return Response.json([{ id: 'pending', sessionID: 'root' }]);
+      if (path === '/api/session/root/permission/pending/reply' && init.method === 'POST') return Response.json({});
       return Response.json({ id: 'root' });
     });
     const { connect } = createRuntime({
@@ -115,23 +135,23 @@ describe('permission auto-accept runtime', () => {
     });
     connect();
     await flush();
-    expect(fetchImpl.mock.calls.some(([url]) => new URL(url).pathname === '/permission/pending/reply')).toBe(true);
+    expect(fetchImpl.mock.calls.some(([url]) => new URL(url).pathname === '/api/session/root/permission/pending/reply')).toBe(true);
   });
 
   it('accepts existing pending permissions when a session policy is enabled', async () => {
     const fetchImpl = vi.fn(async (url, init = {}) => {
       const parsed = new URL(url);
       const path = parsed.pathname;
-      if (path === '/permission') {
-        return parsed.searchParams.get('directory') === '/project'
+      if (path === '/api/permission/request') {
+        return directoryHeader(init) === '/project'
           ? Response.json([
             { id: 'root-pending', sessionID: 'root' },
             { id: 'other-pending', sessionID: 'other' },
           ])
           : Response.json([]);
       }
-      if (path === '/permission/root-pending/reply' && init.method === 'POST') return Response.json({});
-      if (path === '/session/other') return Response.json({ id: 'other' });
+      if (path === '/api/session/root/permission/root-pending/reply' && init.method === 'POST') return Response.json({});
+      if (path === '/api/session/other') return Response.json({ id: 'other' });
       return new Response('', { status: 404 });
     });
     const { runtime } = createRuntime({ fetchImpl });
@@ -141,8 +161,9 @@ describe('permission auto-accept runtime', () => {
     const replyPaths = fetchImpl.mock.calls
       .filter(([, init]) => init?.method === 'POST')
       .map(([url]) => new URL(url).pathname);
-    expect(replyPaths).toEqual(['/permission/root-pending/reply']);
-    expect(fetchImpl.mock.calls.some(([url]) => new URL(url).searchParams.get('directory') === '/project')).toBe(true);
+    expect(replyPaths).toEqual(['/api/session/root/permission/root-pending/reply']);
+    // OpenCode 2.x scopes the pending list by header, not by query.
+    expect(fetchImpl.mock.calls.some(([, init]) => directoryHeader(init) === '/project')).toBe(true);
     expect(await runtime.load()).toEqual({ sessions: { root: true }, revision: 1 });
   });
 
@@ -163,8 +184,9 @@ describe('permission auto-accept runtime', () => {
     emit({ type: 'permission.asked', properties: { id: 'safe', sessionID: 'root', permission: 'bash', metadata: {} } });
     await flush();
 
-    const replies = fetchImpl.mock.calls.map(([url]) => String(url)).filter((url) => url.includes('/reply'));
-    expect(replies).toEqual(['http://opencode.test/permission/safe/reply?directory=%2Fproject']);
+    const replies = fetchImpl.mock.calls.filter(([url]) => String(url).includes('/reply'));
+    expect(replies.map(([url]) => String(url))).toEqual(['http://opencode.test/api/session/root/permission/safe/reply']);
+    expect(directoryHeader(replies[0]?.[1])).toBe('/project');
     expect(evaluatePermission).toHaveBeenCalledTimes(2);
 
     emit({ type: 'permission.replied', properties: { sessionID: 'root', requestID: 'held', reply: 'once' } });

package/server/lib/quota/DOCUMENTATION.md

@@ -20,6 +20,10 @@ extension applies the same policy in its own process at activation.
 
 These provider IDs are currently dispatchable via `fetchQuotaForProvider(providerId)` in `packages/web/server/lib/quota/providers/index.js`.
 
+Where this table says "OpenCode `auth.json`", the credential is read through
+`../opencode/auth.js`, which answers from OpenCode 2.x's own credential
+database first and the legacy file second (see the opencode module docs).
+
 | Provider ID | Display name | Module | Auth aliases/keys |
 | --- | --- | --- | --- |
 | `claude` | Claude | `providers/claude/` | Claude Code Keychain entry, Claude Code credentials file, OpenCode `auth.json` (`anthropic`, `claude`), `CLAUDE_CODE_OAUTH_TOKEN` |

package/server/lib/quota/providers/xai.js

@@ -1,4 +1,4 @@
-import { readAuthFile, writeAuthFile } from '../../opencode/auth.js';
+import { readAuthFile } from '../../opencode/auth.js';
 import { buildResult, toUsageWindow } from '../utils/index.js';
 
 export const providerId = 'xai';
@@ -104,9 +104,9 @@ const refreshXaiOauth = async (entry) => {
         expires
       };
 
-      const auth = readAuthFile();
-      auth.xai = refreshed;
-      writeAuthFile(auth);
+      // The refreshed token is kept in memory for this process only: OpenCode
+      // 2.x owns `auth.json` (it imports it once and never reads it again), so
+      // writing it back would drift from the credential OpenCode actually uses.
       return refreshed;
     })().finally(() => {
       refreshPromise = null;

package/server/lib/relay/tunnel-host.js

@@ -34,7 +34,10 @@ const ALLOWED_WS_PATHS = new Set([
   '/api/dictation/ws',
   '/api/dev-tunnel',
 ]);
-export const isAllowedRelayWebSocketPath = (pathname) => ALLOWED_WS_PATHS.has(pathname);
+// Extension surfaces carry the extension id in the path, so they are matched
+// by shape rather than listed.
+const GUEST_SURFACE_WS_PATH = /^\/api\/guests\/[a-z][a-z0-9-]*\/surface\/ws$/;
+export const isAllowedRelayWebSocketPath = (pathname) => ALLOWED_WS_PATHS.has(pathname) || GUEST_SURFACE_WS_PATH.test(pathname);
 
 // Hop-by-hop headers stripped from tunneled requests; `host` is set by fetch
 // to the loopback origin. content-length is dropped too because the body is

package/server/lib/relay/tunnel-host.test.js

@@ -152,4 +152,11 @@ describe('relay host WebSocket allowlist', () => {
     expect(isAllowedRelayWebSocketPath('/api/dev-tunnel/')).toBe(false);
     expect(isAllowedRelayWebSocketPath('/api/database/ws')).toBe(false);
   });
+
+  test('allows an extension surface socket by path shape only', () => {
+    expect(isAllowedRelayWebSocketPath('/api/guests/server-chrome/surface/ws')).toBe(true);
+    expect(isAllowedRelayWebSocketPath('/api/guests/Server/surface/ws')).toBe(false);
+    expect(isAllowedRelayWebSocketPath('/api/guests/server-chrome/surface/ws/x')).toBe(false);
+    expect(isAllowedRelayWebSocketPath('/api/guests/server-chrome/service/request')).toBe(false);
+  });
 });

package/server/lib/routing/DOCUMENTATION.md

@@ -9,39 +9,53 @@ it with that category's model, thinking variant and agent. With the safety net
 on, the same call decides whether an auto-accepted permission should stay on
 screen for the user instead.
 
-Dark by default: `OPENCHAMBER_ROUTING_ENABLE` (`feature-flag.js`, read per call)
-gates the routes, the request rewrite, the settings page and the Auto row. VS
-Code has no OpenChamber server and never offers Auto.
+Routing needs the OpenChamber server, so it is present wherever that server is
+and absent everywhere else: VS Code talks to OpenCode directly and never offers
+Auto. There is no env gate — the feature shipped dark behind
+`OPENCHAMBER_ROUTING_ENABLE` until Jev stopped needing a key of the user's own
+(see "Where a Jev request goes"), which was the reason to hide it.
 
 ## Files
 
-- `feature-flag.js` — the env gate.
-- `defaults.js` — the Auto sentinel, Jev endpoint, built-in categories, the
-  question wording for routing and for the safety net, history excerpt limits.
+- `defaults.js` — the Auto sentinel, both Jev endpoints, built-in categories,
+  the question wording for routing and for the safety net, history excerpt
+  limits.
 - `store.js` — `routing.json` (only deviations from the built-ins) and
   `routing-auth.json` (the Jev key alone, mode 0600) in the OpenChamber data
   dir. `resolveEffectiveConfig` merges built-ins with stored overrides;
   `toStoredConfig` is its inverse. A missing file is the defaults, a malformed
   one throws.
-- `jev.js` — request builders, answer parsing, the HTTP call with a timeout.
+- `jev.js` — request builders, answer parsing, the HTTP call with a timeout,
+  and `jevEndpoint`, which picks where one request goes.
 - `history.js` — the last three settled turns through session assist's
   `loadAssistContext` (text parts only, attached quotes included, no files or
   tool payloads), each user message cut to its head and each answer to head
   plus tail. The new request is never cut.
-- `runtime.js` — `createRoutingRuntime`: `describe`, `resolvePromptBody`,
+- `runtime.js` — `createRoutingRuntime`: `describe`, `noteModelSelection`,
+  `isAutoSession`, `resolveAutoSelection`, `applySessionSelection`, `routeSend`,
   `evaluatePermission`, config and token writes, event broadcasts.
 - `routes.js` — `/api/routing` (GET, PUT), `/api/routing/token` (PUT, DELETE)
   and `registerRoutingPromptRewrite`.
 
 ## Invariants
 
-- The sentinel never reaches OpenCode. `resolvePromptBody` rewrites
-  `body.model` in place for `POST /api/session/:id/{prompt_async,prompt,command}`
-  ahead of the generic proxy (which replays a parsed body), inside the
-  message queue's `sendItem`, and in the OpenChamber session service's own
-  dispatch (`openchamber-sessions/routes.js`), which posts to OpenCode directly
-  and can pick Auto up from Session Defaults. Without a fallback model it
-  throws 400 rather than forwarding.
+- The sentinel never reaches OpenCode. OpenCode 2.x holds the model and agent
+  on the session and a prompt body carries only the user's text, so Auto is
+  per-session state: `POST /api/session` drops the sentinel from the create
+  body (the session starts on OpenCode's default; the first send switches it),
+  `POST /api/session/:id/model` with the sentinel is
+  swallowed and marks the session (`noteModelSelection`), and every
+  `POST /api/session/:id/{prompt,command}` in a marked session is routed
+  (`routeSend`) and switches the session onto the answer before the send is
+  forwarded. Both sit ahead of the generic proxy, which replays a parsed body.
+  The message queue calls `resolveAutoSelection` itself and applies the answer
+  with the model/agent switches it already makes. Without a fallback model the
+  runtime throws 400 rather than forwarding. The OpenChamber session service
+  (`openchamber-sessions/routes.js`) talks to OpenCode through the SDK and can
+  pick Auto up from Session Defaults, so it calls `resolveAutoSelection` itself
+  before switching the session.
+- The mark lives in process memory. A server restart between the model switch
+  and the next send drops it (see the TODO in `runtime.js`).
 - Every failure keeps the user's own behaviour. A Jev error, timeout, unknown
   category or low confidence routes to the fallback model; the decision carries
   the reason. A safety-net failure accepts the permission exactly as auto-accept
@@ -49,13 +63,29 @@ Code has no OpenChamber server and never offers Auto.
 - A category without a model uses the fallback model *and* variant; a variant
   only travels with the model it was chosen for. A category agent replaces the
   composer's agent; an empty one keeps it.
-- Auto is offered (`autoReady`) only with the flag, `enabled`, a saved key, a
-  fallback model and at least two enabled categories.
+- Auto is offered (`autoReady`) with `enabled`, a fallback model and at least
+  two enabled categories. A key is not among them: see the endpoint rule below.
 - Held permission decisions are cached for 15 minutes per request id so
   reconnect reconciliation in `permission-auto-accept` does not re-ask Jev;
   `permission.replied` forgets them.
-- The rewrite parses JSON only while the flag is set, so a build without it
-  leaves the proxy stream untouched.
+- The send rewrite reads a body only in a session already marked as routed,
+  which the URL alone answers; every other send, and anything that is not JSON,
+  reaches the proxy as the stream it arrived as.
+
+## Where a Jev request goes
+
+A saved TypeSafe key wins — the user pasted it and it carries their own quota —
+and the request goes to `api.typesafe.ai/v1/systemone` as `jev-latest`. Without
+a key the same body goes to `opencode.ai/zen/v1/systemone` as `jev-1.13-free`,
+which OpenCode Zen answers with no credential at all, tagged
+`x-opencode-client: openchamber`. Dax approved this use in Slack on 2026-09-22
+on terms the code and the copy keep together: zen can identify and throttle our
+calls through that header, and Settings → Routing tells the user in plain words
+that the free model is a limited-time OpenCode promotion that will later need a
+key. Zen rejects the `jev-latest` alias, so the versioned free id is sent.
+
+Never make the free tier the only path: the zen docs call it "available for a
+limited time", and the key field is what users fall back to when it ends.
 
 ## Events
 
@@ -79,5 +109,6 @@ debounced saves and manages the key.
 `store.test.js` (defaults, deviation round-trip, deleted built-ins, malformed
 file, token file mode), `runtime.test.js` (request text, excerpts, decisions,
 rewrite and fallback paths, safety net hold/skip/off), `routes.http.test.js`
-(rewrite ahead of a stand-in proxy, routes, flag off). The queue and
-auto-accept tests cover their hooks.
+(sentinel dropped from a create and swallowed on the model switch, routed send
+ahead of a stand-in proxy, the routes). The queue and auto-accept tests cover
+their hooks.

package/server/lib/routing/defaults.js

@@ -14,16 +14,33 @@ import { z } from 'zod';
 const AUTO_PROVIDER_ID = 'openchamber';
 const AUTO_MODEL_ID = 'auto';
 
-const autoModelSchema = z.object({ providerID: z.literal(AUTO_PROVIDER_ID), modelID: z.literal(AUTO_MODEL_ID) });
-const autoModelStringSchema = z.literal(`${AUTO_PROVIDER_ID}/${AUTO_MODEL_ID}`);
+// v2 names a model `{ providerID, id }` (`Model.Ref`); OpenChamber's own stored
+// config and the message queue's send config name it `{ providerID, modelID }`.
+const autoModelSchema = z.object({ providerID: z.literal(AUTO_PROVIDER_ID), id: z.literal(AUTO_MODEL_ID) });
+const autoStoredModelSchema = z.object({ providerID: z.literal(AUTO_PROVIDER_ID), modelID: z.literal(AUTO_MODEL_ID) });
 
-/** The command route carries the model as `provider/model`; the prompt routes as an object. */
-export const isAutoModel = (model) => autoModelSchema.safeParse(model).success || autoModelStringSchema.safeParse(model).success;
+export const isAutoModel = (model) => autoModelSchema.safeParse(model).success
+  || autoStoredModelSchema.safeParse(model).success;
 
-export const JEV_API_ORIGIN = 'https://api.typesafe.ai';
-export const JEV_API_PATH = '/v1/systemone';
+/** The sentinel itself, in the v2 `Model.Ref` shape. */
+export const AUTO_MODEL_REF = { providerID: AUTO_PROVIDER_ID, id: AUTO_MODEL_ID };
+
+/** The user's own TypeSafe key: their quota, their account, the `jev-latest` alias. */
+export const JEV_API_URL = 'https://api.typesafe.ai/v1/systemone';
 export const JEV_MODEL = 'jev-latest';
 
+/**
+ * OpenCode Zen serves the same System One endpoint and answers without any
+ * credential while `jev-1.13-free` is free. Dax approved OpenChamber using it
+ * (Slack, 2026-09-22) on terms this module keeps: the UI tells the user it is a
+ * limited-time free model that will later need a Zen key, and every call names
+ * OpenChamber so zen can see or throttle us. Zen rejects the `jev-latest`
+ * alias, so the versioned free id is sent instead.
+ */
+export const ZEN_JEV_API_URL = 'https://opencode.ai/zen/v1/systemone';
+export const ZEN_JEV_MODEL = 'jev-1.13-free';
+export const ZEN_CLIENT_ID = 'openchamber';
+
 /** Per-attempt timeout; the lab measured 250–700 ms warm, ~1 s on a cold TLS handshake. */
 export const JEV_TIMEOUT_MS = 4000;
 

package/server/lib/routing/jev.js

@@ -4,20 +4,30 @@
  */
 import { z } from 'zod';
 import {
-  JEV_API_ORIGIN,
-  JEV_API_PATH,
+  JEV_API_URL,
   JEV_MODEL,
   JEV_TIMEOUT_MS,
   ROUTING_INSTRUCTIONS,
   SAFETY_INSTRUCTIONS,
   SAFETY_KINDS,
+  ZEN_CLIENT_ID,
+  ZEN_JEV_API_URL,
+  ZEN_JEV_MODEL,
 } from './defaults.js';
 
+/**
+ * Where one request goes. A saved TypeSafe key wins: the user chose it and it
+ * carries their own quota. Without one, the same questions go to the free Jev
+ * model OpenCode Zen serves without a credential, identified as OpenChamber.
+ */
+export const jevEndpoint = (token) => (token
+  ? { url: JEV_API_URL, model: JEV_MODEL, headers: { authorization: `Bearer ${token}` }, source: 'typesafe' }
+  : { url: ZEN_JEV_API_URL, model: ZEN_JEV_MODEL, headers: { 'x-opencode-client': ZEN_CLIENT_ID }, source: 'zen-free' });
+
 export const buildRoutingRequest = ({ categories, history, request }) => {
   const criteria = {};
   for (const category of categories) criteria[category.id] = category.description;
   return {
-    model: JEV_MODEL,
     state: { history, request },
     questions: { category: { type: 'choice', instructions: ROUTING_INSTRUCTIONS, criteria } },
   };
@@ -25,7 +35,6 @@ export const buildRoutingRequest = ({ categories, history, request }) => {
 
 /** `permission` is what OpenCode reported: the tool kind, its patterns and its metadata. */
 export const buildPermissionRequest = (permission) => ({
-  model: JEV_MODEL,
   state: {
     permission: {
       type: permission.permission,
@@ -75,10 +84,11 @@ export const createJevClient = ({ fetchImpl = fetch, timeoutMs = JEV_TIMEOUT_MS
     const timer = setTimeout(() => abort.abort(), timeoutMs);
     const started = Date.now();
     try {
-      const response = await fetchImpl(JEV_API_ORIGIN + JEV_API_PATH, {
+      const endpoint = jevEndpoint(token);
+      const response = await fetchImpl(endpoint.url, {
         method: 'POST',
-        headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
-        body: JSON.stringify(request),
+        headers: { ...endpoint.headers, 'content-type': 'application/json' },
+        body: JSON.stringify({ ...request, model: endpoint.model }),
         signal: abort.signal,
       });
       const text = await response.text();