@vantran-se/openchamber-web 1.24.4 → 2.0.2

package/server/lib/routing/routes.http.test.js

@@ -1,23 +1,29 @@
 import express from 'express';
 import request from 'supertest';
-import { afterEach, describe, expect, it, vi } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 
 import { registerRoutingPromptRewrite, registerRoutingRoutes } from './routes.js';
 
 /**
- * The prompt rewrite sits in front of the generic OpenCode proxy, which
- * replays `req.body` when a middleware parsed it. These tests mount the
- * rewrite ahead of a stand-in proxy that records what it would forward.
+ * The send rewrite sits in front of the generic OpenCode proxy, which replays
+ * `req.body` when a middleware parsed it. These tests mount the rewrite ahead
+ * of a stand-in proxy that records what it would forward.
  */
-const createApp = ({ flag = '1', resolvePromptBody } = {}) => {
-  process.env.OPENCHAMBER_ROUTING_ENABLE = flag;
+const createApp = ({ routeSend, autoSessions = new Set() } = {}) => {
   const forwarded = [];
   const runtime = {
-    resolvePromptBody: resolvePromptBody ?? vi.fn(async (body) => {
-      if (body.model?.modelID === 'auto') body.model = { providerID: 'openai', modelID: 'gpt-6-astra' };
-      return null;
+    noteModelSelection: vi.fn((sessionId, model) => {
+      const auto = model?.providerID === 'openchamber' && model?.id === 'auto';
+      if (auto) autoSessions.add(sessionId);
+      else autoSessions.delete(sessionId);
+      return auto;
     }),
-    describe: async () => ({ available: true, autoReady: true, tokenPresent: true, config: null, builtins: [] }),
+    isAutoSession: (sessionId) => autoSessions.has(sessionId),
+    routeSend: routeSend ?? vi.fn(async ({ body }) => {
+      if (typeof body?.command === 'string') body.model = { providerID: 'openai', id: 'gpt-6-astra' };
+      return {};
+    }),
+    describe: async () => ({ available: true, autoReady: true, tokenPresent: true, jevSource: 'typesafe', config: null, builtins: [] }),
     heldPermissions: () => [],
     updateConfig: vi.fn(async () => ({ available: true })),
     setToken: vi.fn(async () => ({ available: true, tokenPresent: true })),
@@ -43,37 +49,70 @@ const createApp = ({ flag = '1', resolvePromptBody } = {}) => {
   return { app, runtime, forwarded };
 };
 
-afterEach(() => {
-  delete process.env.OPENCHAMBER_ROUTING_ENABLE;
-});
-
-describe('routing prompt rewrite', () => {
-  it('rewrites the Auto sentinel on prompt_async and passes the directory along', async () => {
+describe('routing send rewrite', () => {
+  it('swallows the Auto sentinel on a model switch instead of forwarding it', async () => {
     const { app, runtime, forwarded } = createApp();
     await request(app)
-      .post('/api/session/s1/prompt_async?directory=%2Frepo')
-      .send({ model: { providerID: 'openchamber', modelID: 'auto' }, parts: [{ type: 'text', text: 'hi' }] })
+      .post('/api/session/s1/model?directory=%2Frepo')
+      .send({ model: { providerID: 'openchamber', id: 'auto' } })
+      .expect(204);
+    expect(forwarded).toEqual([]);
+    expect(runtime.noteModelSelection).toHaveBeenCalledWith('s1', { providerID: 'openchamber', id: 'auto' }, '/repo');
+    expect(runtime.isAutoSession('s1')).toBe(true);
+  });
+
+  it('drops the Auto sentinel from a session create so OpenCode never stores it', async () => {
+    const { app, forwarded, runtime } = createApp();
+    await request(app)
+      .post('/api/session?directory=%2Frepo')
+      .send({ title: 'btw', model: { providerID: 'openchamber', id: 'auto' }, agent: 'build' })
       .expect(204);
-    expect(forwarded).toEqual([{ path: '/session/s1/prompt_async', parsed: true, body: { model: { providerID: 'openai', modelID: 'gpt-6-astra' }, parts: [{ type: 'text', text: 'hi' }] } }]);
-    expect(runtime.resolvePromptBody).toHaveBeenCalledWith(expect.anything(), { sessionId: 's1', directory: '/repo' });
+    expect(forwarded).toEqual([{ path: '/session', parsed: true, body: { title: 'btw', agent: 'build' } }]);
+    expect(runtime.noteModelSelection).not.toHaveBeenCalled();
+
+    await request(app).post('/api/session').send({ model: { providerID: 'anthropic', id: 'claude-opus-5' } }).expect(204);
+    expect(forwarded[1]).toEqual({ path: '/session', parsed: true, body: { model: { providerID: 'anthropic', id: 'claude-opus-5' } } });
   });
 
-  it('leaves the stream untouched when the flag is off or the body is not JSON', async () => {
-    const off = createApp({ flag: '' });
-    await request(off.app).post('/api/session/s1/prompt').send({ model: { providerID: 'openchamber', modelID: 'auto' } }).expect(204);
-    expect(off.forwarded[0].parsed).toBe(false);
-    expect(off.runtime.resolvePromptBody).not.toHaveBeenCalled();
+  it('forwards a real model switch untouched and takes the session off Auto', async () => {
+    const { app, forwarded, runtime } = createApp();
+    await request(app).post('/api/session/s1/model').send({ model: { providerID: 'openchamber', id: 'auto' } }).expect(204);
+    await request(app).post('/api/session/s1/model').send({ model: { providerID: 'anthropic', id: 'claude-opus-5' } }).expect(204);
+    expect(forwarded).toEqual([{ path: '/session/s1/model', parsed: true, body: { model: { providerID: 'anthropic', id: 'claude-opus-5' } } }]);
+    expect(runtime.isAutoSession('s1')).toBe(false);
+  });
 
-    const text = createApp();
+  it('routes a prompt in an Auto session and passes the directory along', async () => {
+    const autoSessions = new Set(['s1']);
+    const { app, runtime, forwarded } = createApp({ autoSessions });
+    await request(app)
+      .post('/api/session/s1/prompt?directory=%2Frepo')
+      .send({ text: 'hi' })
+      .expect(204);
+    expect(forwarded).toEqual([{ path: '/session/s1/prompt', parsed: true, body: { text: 'hi' } }]);
+    expect(runtime.routeSend).toHaveBeenCalledWith({ sessionId: 's1', directory: '/repo', body: { text: 'hi' } });
+  });
+
+  it('leaves a send in a session that is not on Auto unread', async () => {
+    const { app, runtime, forwarded } = createApp();
+    await request(app).post('/api/session/s1/prompt').send({ text: 'hi' }).expect(204);
+    expect(runtime.routeSend).not.toHaveBeenCalled();
+    expect(forwarded[0].parsed).toBe(false);
+  });
+
+  it('leaves the stream untouched when the body is not JSON', async () => {
+    const text = createApp({ autoSessions: new Set(['s1']) });
     await request(text.app).post('/api/session/s1/command').set('content-type', 'text/plain').send('raw').expect(204);
     expect(text.forwarded[0]).toEqual({ path: '/session/s1/command', parsed: false, raw: 'raw' });
   });
 
-  it('answers with the runtime error instead of forwarding an unresolved sentinel', async () => {
+
+  it('answers with the runtime error instead of forwarding an unroutable send', async () => {
     const { app, forwarded } = createApp({
-      resolvePromptBody: vi.fn(async () => { throw Object.assign(new Error('no fallback'), { status: 400 }); }),
+      autoSessions: new Set(['s1']),
+      routeSend: vi.fn(async () => { throw Object.assign(new Error('no fallback'), { status: 400 }); }),
     });
-    const response = await request(app).post('/api/session/s1/prompt_async').send({ model: { providerID: 'openchamber', modelID: 'auto' } });
+    const response = await request(app).post('/api/session/s1/prompt').send({ text: 'hi' });
     expect(response.status).toBe(400);
     expect(response.body).toEqual({ error: 'no fallback' });
     expect(forwarded).toEqual([]);
@@ -93,8 +132,4 @@ describe('routing routes', () => {
     expect(runtime.clearToken).toHaveBeenCalled();
   });
 
-  it('is absent without the feature flag', async () => {
-    const { app } = createApp({ flag: '' });
-    await request(app).put('/api/routing/token').send({ token: 'x' }).expect(404);
-  });
 });

package/server/lib/routing/routes.js

@@ -2,17 +2,27 @@
  * `/api/routing` — configuration and the Jev key. Normal authenticated
  * OpenChamber routes: do not add them to browser URL-token allowlists.
  *
- * `/api/session/:id/{prompt_async,prompt,command}` — the rewrite that turns
- * `openchamber/auto` into a real model before the generic OpenCode proxy
- * forwards the request. Registered ahead of the proxy; it parses the JSON body
- * only while Auto can actually be selected, so a build without the flag pays
- * nothing on the send path.
+ * The send-path rewrite, registered ahead of the generic OpenCode proxy. In
+ * OpenCode 2.x a prompt body carries no model: the client switches the session
+ * first (`POST /session/:id/model`) and sends afterwards. So the rewrite is in
+ * two halves:
+ *
+ * - `POST /session/:id/model` with `openchamber/auto` never reaches OpenCode,
+ *   which has no such provider. It marks the session as routed and answers as
+ *   a switch would.
+ * - `POST /session/:id/{prompt,command}` in a routed session asks Jev on the
+ *   request text and switches the session onto the chosen model and agent
+ *   before the prompt is forwarded.
+ *
+ * Both parse the JSON body only for JSON requests, so a streamed or non-JSON
+ * upload reaches the proxy untouched.
  */
 import express from 'express';
-import { isRoutingFeatureAvailable } from './feature-flag.js';
+import { isAutoModel } from './defaults.js';
 
-const AUTO_SESSION_PATHS = [
-  '/api/session/:sessionId/prompt_async',
+const CREATE_PATH = '/api/session';
+const MODEL_PATH = '/api/session/:sessionId/model';
+const SEND_PATHS = [
   '/api/session/:sessionId/prompt',
   '/api/session/:sessionId/command',
 ];
@@ -23,12 +33,9 @@ const sendError = (res, error) => {
 };
 
 export function registerRoutingRoutes(app, runtime) {
-  const unavailable = (res) => res.status(404).json({ error: 'Routing is not available in this build' });
-
   app.get('/api/routing', async (_req, res) => {
     try {
       const state = await runtime.describe();
-      if (!state.available) return unavailable(res);
       res.json({ ...state, heldPermissions: runtime.heldPermissions() });
     } catch (error) {
       sendError(res, error);
@@ -36,7 +43,6 @@ export function registerRoutingRoutes(app, runtime) {
   });
 
   app.put('/api/routing', express.json({ limit: '256kb' }), async (req, res) => {
-    if (!isRoutingFeatureAvailable()) return unavailable(res);
     try {
       res.json(await runtime.updateConfig(req.body?.config));
     } catch (error) {
@@ -45,7 +51,6 @@ export function registerRoutingRoutes(app, runtime) {
   });
 
   app.put('/api/routing/token', express.json({ limit: '16kb' }), async (req, res) => {
-    if (!isRoutingFeatureAvailable()) return unavailable(res);
     try {
       res.json(await runtime.setToken(req.body?.token));
     } catch (error) {
@@ -54,7 +59,6 @@ export function registerRoutingRoutes(app, runtime) {
   });
 
   app.delete('/api/routing/token', async (_req, res) => {
-    if (!isRoutingFeatureAvailable()) return unavailable(res);
     try {
       res.json(await runtime.clearToken());
     } catch (error) {
@@ -65,17 +69,56 @@ export function registerRoutingRoutes(app, runtime) {
 
 export function registerRoutingPromptRewrite(app, runtime) {
   const parseJson = express.json({ limit: '50mb' });
-  app.post(AUTO_SESSION_PATHS, (req, res, next) => {
-    if (!isRoutingFeatureAvailable()) return next();
+
+  /** Parses the body only for JSON requests; anything else stays a stream. */
+  const withParsedBody = (handler) => (req, res, next) => {
     const contentType = String(req.headers['content-type'] ?? '').toLowerCase();
     if (!contentType.includes('application/json')) return next();
     parseJson(req, res, (parseError) => {
       if (parseError) return next(parseError);
-      const url = new URL(req.url, 'http://localhost');
-      const directory = url.searchParams.get('directory') || req.get('x-opencode-directory') || undefined;
-      runtime.resolvePromptBody(req.body, { sessionId: req.params.sessionId, directory })
-        .then(() => next())
-        .catch((error) => sendError(res, error));
+      handler(req, res, next);
     });
-  });
+  };
+
+  const directoryOf = (req) => {
+    const url = new URL(req.url, 'http://localhost');
+    return url.searchParams.get('directory') || req.get('x-opencode-directory') || undefined;
+  };
+
+  // Session creation is the other v2 request that carries a model: flows that
+  // know their first turn's selection create the session on it (btw forks,
+  // auto review, fusion, extension starts). OpenCode accepts the sentinel at
+  // creation and only fails the first prompt with "provider.no-route", so the
+  // model is dropped here and the session starts on OpenCode's default. No
+  // session id exists yet to mark; the first send resends the sentinel through
+  // the model switch below because the session's record never matches Auto.
+  app.post(CREATE_PATH, withParsedBody((req, _res, next) => {
+    if (!isAutoModel(req.body?.model)) return next();
+    delete req.body.model;
+    next();
+  }));
+
+  app.post(MODEL_PATH, withParsedBody((req, res, next) => {
+    const directory = directoryOf(req);
+    // Swallowed, not forwarded: OpenCode has no `openchamber` provider, and the
+    // real model is only known once the request text arrives.
+    if (runtime.noteModelSelection(req.params.sessionId, req.body?.model, directory)) return res.status(204).end();
+    next();
+  }));
+
+  // Whether the session is routed is known from the URL alone, so an ordinary
+  // send is never read: it reaches the proxy as the stream it arrived as, the
+  // way it did before routing existed.
+  const routedSendsOnly = (handler) => {
+    const parsed = withParsedBody(handler);
+    return (req, res, next) => (runtime.isAutoSession(req.params.sessionId) ? parsed(req, res, next) : next());
+  };
+
+  app.post(SEND_PATHS, routedSendsOnly((req, res, next) => {
+    const sessionId = req.params.sessionId;
+    const directory = directoryOf(req);
+    runtime.routeSend({ sessionId, directory, body: req.body })
+      .then(() => next())
+      .catch((error) => sendError(res, error));
+  }));
 }

package/server/lib/routing/runtime.js

@@ -1,16 +1,21 @@
 /**
- * Owns Jev routing at runtime: whether Auto is ready, rewriting a prompt body
- * that names the `openchamber/auto` model, and the safety net consulted before
- * a permission is auto-accepted. Every failure path keeps the user's own
+ * Owns Jev routing at runtime: whether Auto is ready, which model and agent a
+ * send that selected `openchamber/auto` runs on, and the safety net consulted
+ * before a permission is auto-accepted. Every failure path keeps the user's own
  * behaviour: a prompt goes to the fallback model, a permission is accepted as
  * auto-accept would have, and the UI is told why.
+ *
+ * OpenCode 2.x holds the model and the agent on the session, switched by their
+ * own calls, and a prompt body carries only the user's text. So Auto is a
+ * per-session state here: the sentinel arrives on `POST /session/:id/model`
+ * and is swallowed, and every prompt in that session is routed until a real
+ * model is selected.
  */
-import { createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { OpenCode } from '@opencode/client';
 import { z } from 'zod';
-import { isRoutingFeatureAvailable } from './feature-flag.js';
-import { BUILTIN_CATEGORIES, isAutoModel } from './defaults.js';
+import { AUTO_MODEL_REF, BUILTIN_CATEGORIES, isAutoModel } from './defaults.js';
 import { createRoutingStore, parseEffectiveConfig } from './store.js';
-import { buildPermissionRequest, buildRoutingRequest, createJevClient, decidePermission, decideRouting } from './jev.js';
+import { buildPermissionRequest, buildRoutingRequest, createJevClient, decidePermission, decideRouting, jevEndpoint } from './jev.js';
 import { loadRoutingHistory } from './history.js';
 
 const HISTORY_TIMEOUT_MS = 2500;
@@ -19,25 +24,31 @@ const PERMISSION_DECISION_TTL_MS = 15 * 60 * 1000;
 
 const errorMessage = (error) => (error instanceof Error ? error.message : String(error));
 
-const textPartSchema = z.object({ type: z.literal('text'), text: z.string(), synthetic: z.boolean().optional() });
-const commandBodySchema = z.object({ command: z.string(), arguments: z.string().optional() });
-const promptBodySchema = z.object({ parts: z.array(z.unknown()).optional() });
+// v2's command body (`session.command` in the protocol) names the command in
+// `name` and carries its arguments in `text`; a prompt body has no `name`.
+const commandBodySchema = z.object({ name: z.string().trim().min(1), text: z.string().nullish() });
+// v2 sends one user turn as flat text; the context the composer attached went
+// ahead of it as synthetic messages, which are never the request being routed.
+const promptBodySchema = z.object({ text: z.string().nullish() });
 
-/** The user's words for this send: text parts the composer authored, or the slash command. */
+/** The user's words for this send: the prompt text, or the slash command. */
 export const requestTextOf = (body) => {
   const command = commandBodySchema.safeParse(body);
   if (command.success) {
-    const args = command.data.arguments?.trim();
-    return `/${command.data.command}${args ? ` ${args}` : ''}`;
+    const args = command.data.text?.trim();
+    return `/${command.data.name}${args ? ` ${args}` : ''}`;
   }
   const prompt = promptBodySchema.safeParse(body);
-  const parts = prompt.success ? prompt.data.parts ?? [] : [];
-  return parts
-    .map((part) => textPartSchema.safeParse(part))
-    .filter((part) => part.success && !part.data.synthetic)
-    .map((part) => part.data.text)
-    .join('\n\n')
-    .trim();
+  return (prompt.success ? prompt.data.text ?? '' : '').trim();
+};
+
+const agentBodySchema = z.object({ agent: z.string().trim().min(1) });
+
+/** OpenChamber stores a model as `{ providerID, modelID }`; v2 wants a `Model.Ref`. */
+const toModelRef = (model, variant) => {
+  const ref = { providerID: model.providerID, id: model.modelID };
+  if (variant) ref.variant = variant;
+  return ref;
 };
 
 export function createRoutingRuntime({
@@ -51,6 +62,14 @@ export function createRoutingRuntime({
   now = Date.now,
 }) {
   const permissionDecisions = new Map();
+  // Sessions the user put on Auto. The sentinel never reaches OpenCode, so
+  // nothing upstream remembers the choice for us.
+  // TODO(v2): this is process memory. A server restart drops the mark and the
+  // session silently runs on whatever model it was last switched to while the
+  // composer still shows Auto. Either persist it next to `routing.json` or have
+  // the client resend the sentinel with every send.
+  const autoSessions = new Map();
+  const AUTO_SESSION_LIMIT = 1000;
 
   const broadcast = (type, properties) => {
     try {
@@ -64,63 +83,82 @@ export function createRoutingRuntime({
 
   /** What the client needs to decide whether to offer Auto and what the settings page shows. */
   const describe = async () => {
-    const available = isRoutingFeatureAvailable();
-    if (!available) return { available: false, autoReady: false, tokenPresent: false, config: null, builtins: [] };
     const [config, token] = await Promise.all([store.readConfig(), store.readToken()]);
     const tokenPresent = Boolean(token);
-    const autoReady = config.enabled && tokenPresent && Boolean(config.fallback) && enabledCategories(config).length >= 2;
+    // A key is not a precondition: without one Jev answers through the free
+    // model zen serves, so Auto only needs a fallback and two categories.
+    const autoReady = config.enabled && Boolean(config.fallback) && enabledCategories(config).length >= 2;
     // Built-in text travels with the config so "Reset" in Settings restores the shipped wording.
-    return { available, autoReady, tokenPresent, config, builtins: BUILTIN_CATEGORIES };
+    // `available` stays in the payload for the client: a runtime without an
+    // OpenChamber server (VS Code) answers 404 and reads it as false.
+    return { available: true, autoReady, tokenPresent, jevSource: jevEndpoint(token).source, config, builtins: BUILTIN_CATEGORIES };
   };
 
   const publishUpdated = async () => {
     const state = await describe();
-    broadcast('openchamber:routing.updated', { available: state.available, autoReady: state.autoReady, tokenPresent: state.tokenPresent });
+    broadcast('openchamber:routing.updated', {
+      available: state.available, autoReady: state.autoReady, tokenPresent: state.tokenPresent, jevSource: state.jevSource,
+    });
     return state;
   };
 
+  const openCodeClient = (directory) => {
+    const headers = { ...getOpenCodeAuthHeaders() };
+    // v2 scopes by header and rejects non-ASCII header values.
+    const scope = z.string().trim().min(1).safeParse(directory);
+    if (scope.success) headers['x-opencode-directory'] = encodeURIComponent(scope.data);
+    return OpenCode.make({ baseUrl: buildOpenCodeUrl('/', '').replace(/\/$/, ''), headers });
+  };
+
   const readHistory = async ({ sessionId, directory }) => {
-    const baseUrl = buildOpenCodeUrl('/', '').replace(/\/$/, '');
-    const client = createOpencodeClient({ baseUrl, headers: getOpenCodeAuthHeaders(), throwOnError: true });
+    const client = openCodeClient(directory);
     const signal = AbortSignal.timeout(HISTORY_TIMEOUT_MS);
     return loadRoutingHistory({
       signal,
-      readPage: (page) => client.session.messages({ sessionID: sessionId, directory, ...page }, { signal }),
+      // v2 pages a session's messages newest first and returns `{ data, cursor }`.
+      readPage: ({ limit, cursor }) => client.message.list(
+        { sessionID: sessionId, limit, ...(cursor ? { cursor } : { order: 'desc' }) },
+        { signal },
+      ),
     });
   };
 
   // A category without a model of its own means "the fallback pair"; a variant
   // only travels with the model it was chosen for.
-  const applyChoice = (body, config, choice) => {
+  const chooseSelection = (config, choice, composerAgent) => {
     const own = Boolean(choice?.model);
     const model = own ? choice.model : config.fallback.model;
     const variant = own ? choice.variant : config.fallback.variant;
-    // Keep the wire shape the route uses: a string on /command, an object on the prompt routes.
-    body.model = z.string().safeParse(body.model).success
-      ? `${model.providerID}/${model.modelID}`
-      : { providerID: model.providerID, modelID: model.modelID };
-    if (variant) body.variant = variant;
-    else delete body.variant;
-    if (choice?.agent) body.agent = choice.agent;
-    return { providerID: model.providerID, modelID: model.modelID, variant: variant ?? null, agent: choice?.agent ?? null };
+    return {
+      model: toModelRef(model, variant),
+      // A category agent replaces the composer's; an empty one keeps it.
+      agent: choice?.agent || composerAgent || null,
+      decision: { providerID: model.providerID, modelID: model.modelID, variant: variant ?? null, agent: choice?.agent ?? null },
+    };
   };
 
   /**
-   * Rewrites `body.model` in place when it is the Auto sentinel. Returns the
-   * decision that was applied, or null when the body named a real model.
+   * Resolves one send that named the Auto sentinel. Returns the model and
+   * agent the send must use, or null when a real model was selected.
+   *
+   * v2 carries neither model nor agent in a prompt body — they are session
+   * state, switched by their own calls — so the caller applies the selection
+   * (`applySessionSelection`, or its own switch calls) instead of the runtime
+   * rewriting a body in place the way v1 allowed.
+   *
    * Throws only when Auto cannot be honoured at all (no fallback configured):
    * the sentinel must never reach OpenCode.
    */
-  const resolvePromptBody = async (body, { sessionId, directory }) => {
-    if (!isAutoModel(body?.model)) return null;
+  const resolveAutoSelection = async ({ sessionId, directory, model, agent, requestText }) => {
+    if (!isAutoModel(model)) return null;
     const state = await describe();
     const config = state.config;
     if (!config?.fallback) {
       throw Object.assign(new Error('Auto routing is selected but no fallback model is configured'), { status: 400 });
     }
     const decision = { sessionId, at: now(), category: null, confidence: 0, reason: 'not-ready', ms: 0 };
+    let selection;
     if (state.autoReady) {
-      const request = requestTextOf(body);
       let history = [];
       try {
         history = await readHistory({ sessionId, directory });
@@ -129,23 +167,69 @@ export function createRoutingRuntime({
       }
       try {
         const token = await store.readToken();
+        const request = (requestText ?? '').trim();
         const { answers, ms } = await jev.ask(buildRoutingRequest({ categories: enabledCategories(config), history, request }), token);
         const result = decideRouting(answers.category, { categories: enabledCategories(config), minConfidence: config.minConfidence });
         decision.category = result.category?.id ?? null;
         decision.confidence = result.confidence;
         decision.reason = result.reason;
         decision.ms = ms;
-        Object.assign(decision, applyChoice(body, config, result.category));
+        selection = chooseSelection(config, result.category, agent);
       } catch (error) {
         decision.reason = 'error';
         decision.error = errorMessage(error);
-        Object.assign(decision, applyChoice(body, config, null));
+        selection = chooseSelection(config, null, agent);
       }
     } else {
-      Object.assign(decision, applyChoice(body, config, null));
+      selection = chooseSelection(config, null, agent);
     }
+    Object.assign(decision, selection.decision);
     broadcast('openchamber:routing.decision', decision);
-    return decision;
+    return { model: selection.model, agent: selection.agent, decision };
+  };
+
+  /**
+   * `POST /session/:id/model` with the sentinel puts the session on Auto;
+   * with any real model it takes it off again.
+   */
+  const noteModelSelection = (sessionId, model, directory) => {
+    if (!sessionId) return false;
+    if (!isAutoModel(model)) {
+      autoSessions.delete(sessionId);
+      return false;
+    }
+    autoSessions.delete(sessionId);
+    autoSessions.set(sessionId, { directory: directory ?? null, at: now() });
+    while (autoSessions.size > AUTO_SESSION_LIMIT) autoSessions.delete(autoSessions.keys().next().value);
+    return true;
+  };
+
+  const isAutoSession = (sessionId) => Boolean(sessionId) && autoSessions.has(sessionId);
+
+  /** Switches the session onto a resolved selection, the way a v2 send does. */
+  const applySessionSelection = async (sessionId, directory, selection) => {
+    const client = openCodeClient(directory);
+    await client.session.switchModel({ sessionID: sessionId, model: selection.model });
+    if (selection.agent) await client.session.switchAgent({ sessionID: sessionId, agent: selection.agent });
+  };
+
+  /**
+   * One send in a routed session: asks Jev on the request text, switches the
+   * session onto the answer, and keeps the body in step with it.
+   */
+  const routeSend = async ({ sessionId, directory, body }) => {
+    const resolved = await resolveAutoSelection({
+      sessionId,
+      directory,
+      model: AUTO_MODEL_REF,
+      agent: agentBodySchema.safeParse(body).data?.agent ?? null,
+      requestText: requestTextOf(body),
+    });
+    if (!resolved) return null;
+    // v2 prompt and command bodies carry neither model nor agent: switching
+    // the session is the whole application of the decision.
+    await applySessionSelection(sessionId, directory, resolved);
+    return resolved.decision;
   };
 
   /**
@@ -158,7 +242,7 @@ export function createRoutingRuntime({
     const cached = permissionDecisions.get(permission.id);
     if (cached && now() - cached.at < PERMISSION_DECISION_TTL_MS) return cached.result;
     const state = await describe();
-    if (!state.available || !state.config?.enabled || !state.config.safetyNet.enabled || !state.tokenPresent) return { action: 'accept' };
+    if (!state.config?.enabled || !state.config.safetyNet.enabled) return { action: 'accept' };
     let result;
     try {
       const token = await store.readToken();
@@ -213,5 +297,18 @@ export function createRoutingRuntime({
     return held;
   };
 
-  return { describe, resolvePromptBody, evaluatePermission, forgetPermission, heldPermissions, updateConfig, setToken, clearToken };
+  return {
+    describe,
+    noteModelSelection,
+    isAutoSession,
+    resolveAutoSelection,
+    applySessionSelection,
+    routeSend,
+    evaluatePermission,
+    forgetPermission,
+    heldPermissions,
+    updateConfig,
+    setToken,
+    clearToken,
+  };
 }