@vantran-se/openchamber-web 1.23.0 → 1.24.3

package/server/lib/routing/DOCUMENTATION.md

@@ -0,0 +1,83 @@
+# Routing
+
+## Purpose
+
+Jev model routing and the permission safety net. With the `openchamber/auto`
+model selected, the server asks [Jev](https://docs.typesafe.ai) (TypeSafe's
+System One decision model) which task category a message belongs to and sends
+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.
+
+## 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.
+- `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.
+- `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`,
+  `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.
+- 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
+  would have and broadcasts `openchamber:routing.safety-skipped` with the error.
+- 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.
+- 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.
+
+## Events
+
+Broadcast on the OpenChamber control stream: `openchamber:routing.updated`
+(availability), `openchamber:routing.decision` (per send),
+`openchamber:routing.permission-held`, `openchamber:routing.safety-skipped`.
+
+## UI
+
+`packages/ui/src/stores/useRoutingStore.ts` projects `/api/routing` and these
+events; `hooks/useRoutingSync.ts` keeps it current and shows the skipped-check
+toast. `lib/routing/autoModel.ts` owns the sentinel; `useConfigStore` accepts it
+as a valid selection while `autoReady`. `ModelPickerList` renders it as the
+pinned `leadingEntry`; `ModelControls` hides the agent and thinking controls
+while Auto is selected. `PermissionCard` shows the hold reason. Settings →
+Routing (`components/sections/routing/RoutingPage.tsx`) edits the config with
+debounced saves and manages the key.
+
+## Tests
+
+`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.

package/server/lib/routing/defaults.js

@@ -0,0 +1,98 @@
+/**
+ * Built-in routing configuration. Everything here is the shipped default; the
+ * user's `routing.json` stores only deviations from it, so a later change to a
+ * built-in category reaches everyone who did not edit that category.
+ *
+ * Category descriptions are what Jev reads, verbatim, as the criteria of one
+ * choice question. Keep them about the reasoning a request demands, never about
+ * the length of the reply: that wording moved a long mechanical rename from
+ * "hard" to "trivial" in the lab runs.
+ */
+
+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}`);
+
+/** 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 JEV_API_ORIGIN = 'https://api.typesafe.ai';
+export const JEV_API_PATH = '/v1/systemone';
+export const JEV_MODEL = 'jev-latest';
+
+/** Per-attempt timeout; the lab measured 250–700 ms warm, ~1 s on a cold TLS handshake. */
+export const JEV_TIMEOUT_MS = 4000;
+
+/**
+ * The third line keeps a hard turn from dragging its follow-ups up. With a
+ * plain "classify request only" wording, "дякую, все працює" after a hard fix
+ * came back hard at ~40% and "запуш" trivial at ~50%, both under the threshold,
+ * so the fallback model took them. Saying that history only resolves what the
+ * request refers to, and that finished work carries no weight, put them at
+ * 97% and ~75% trivial while "ok, do it" after a plan stayed implement and a
+ * regression report stayed hard (jev-router lab, test/follow-up-instructions.js).
+ */
+export const ROUTING_INSTRUCTIONS = [
+  'Pick the task category that best describes this coding request, judging the reasoning it demands rather than the length of the reply it asks for.',
+  'A request that wants a one-line answer to a hard debugging or design question is still hard; a long but mechanical edit is still trivial.',
+  'The thing to classify is `request`, the latest user message. Read `history` (earlier conversation, oldest first) only to understand what `request` refers to, then judge the reasoning `request` itself demands. Do not let the difficulty of work already done in `history` raise or lower the category.',
+];
+
+/**
+ * Measured on 31 mixed bash/edit/mcp/webfetch permissions: this "should the agent
+ * ask" wording scored 28/31 at threshold 0.6 with every miss on the safe side,
+ * while "is it destructive" scored 23/31 and let through `brew install`, closing
+ * a PR, and edits to ~/.zshrc and ~/.ssh.
+ */
+export const SAFETY_INSTRUCTIONS = [
+  'An autonomous coding agent is about to perform this action inside a software project, and the user has allowed routine actions to proceed without asking.',
+  'Should the agent stop and ask the user first, instead of proceeding automatically?',
+  'Yes when the action is hard to undo, or reaches outside the project working tree (the system, the home directory, remote services, other people), or changes shared state others can see, or discards uncommitted work.',
+  "No for reading, searching, building, testing, installing project dependencies, ordinary commits, pushes and rebases of the agent's own branch, and file edits inside the project.",
+];
+
+/** Effect kinds reported alongside the hold decision; the UI shows the chosen one as the reason. */
+export const SAFETY_KINDS = {
+  read_only: 'Reads, lists, searches, builds, tests, or fetches public information; changes nothing.',
+  writes_project: 'Creates or edits files inside the project in a way version control can undo.',
+  git_history: 'Rewrites, deletes, or force-pushes git history or branches, or discards uncommitted work.',
+  deletes_data: 'Deletes files or data outside version control, drops databases, or wipes directories.',
+  system_change: 'Installs, removes, or reconfigures software, services, or system settings.',
+  external_side_effect: 'Changes state in an external system: posts, sends, deploys, pays, closes, or deletes something remotely.',
+  data_exfiltration: 'Sends local files, secrets, or private data to an external host, or fetches and executes remote code.',
+};
+
+/** History excerpts: a user message keeps its head, an answer keeps head and tail. */
+export const HISTORY_LIMITS = { turns: 3, user: 600, answerHead: 300, answerTail: 300 };
+
+export const THINKING_LEVELS = ['off', 'low', 'medium', 'high'];
+
+export const BUILTIN_CATEGORIES = [
+  {
+    id: 'trivial',
+    name: 'Trivial',
+    description: 'Trivial, mechanical, or purely factual work: rename a symbol, fix a typo, reformat, add a comment, answer a short factual question about a known file, run one obvious command and report the output. Not for anything requiring design judgement or multi-file reasoning.',
+  },
+  {
+    id: 'research',
+    name: 'Research',
+    description: 'Read and explain existing code or behaviour without changing it: explain how a module works, find where something is implemented, summarise what a change does. Not for requests that ask for edits or a plan.',
+  },
+  {
+    id: 'implement',
+    name: 'Implement',
+    description: 'Ordinary engineering with a clear, bounded shape: implement a well-specified function, endpoint, or component; write or fix tests for existing behaviour; a localised bug fix where the cause is already understood. Not for open-ended architecture, subtle concurrency, or unknown-cause debugging.',
+  },
+  {
+    id: 'hard',
+    name: 'Hard',
+    description: 'Hard reasoning, ambiguity, planning, or high blast radius: debug a failure whose cause is unknown, plan or design a change across several modules, security, auth, concurrency, data-migration, or money-handling logic. Not for work a competent mid-level engineer would finish without thinking hard.',
+  },
+];
+
+export const DEFAULT_MIN_CONFIDENCE = 0.6;
+export const DEFAULT_SAFETY_THRESHOLD = 0.6;

package/server/lib/routing/feature-flag.js

@@ -0,0 +1,11 @@
+/**
+ * Whether Jev model routing exists at all in this build.
+ *
+ * The feature ships dark, the same way agent memory does: with the flag unset
+ * there is no Auto row in the model picker, no settings page, no routes and no
+ * request rewriting. Read per call so only the process environment decides.
+ */
+
+const TRUTHY = new Set(['1', 'true', 'yes', 'on']);
+
+export const isRoutingFeatureAvailable = () => TRUTHY.has((process.env.OPENCHAMBER_ROUTING_ENABLE ?? '').trim().toLowerCase());

package/server/lib/routing/history.js

@@ -0,0 +1,34 @@
+/**
+ * The conversation Jev sees next to the new request: the last settled turns,
+ * read the same way session assist reads them (text parts only, attached
+ * quotes included, tool payloads and files never), then cut down per message.
+ * A user message keeps its head, where the task usually sits; an answer keeps
+ * head and tail, where the finding and the outcome sit. The new request itself
+ * is never cut.
+ */
+import { loadAssistContext } from '../session-assist/context.js';
+import { HISTORY_LIMITS } from './defaults.js';
+
+export const excerptHead = (text, limit) => (text.length <= limit ? text : `${text.slice(0, limit).trimEnd()} […]`);
+
+export const excerptHeadTail = (text, head, tail) =>
+  (text.length <= head + tail ? text : `${text.slice(0, head).trimEnd()} […] ${text.slice(-tail).trimStart()}`);
+
+export const turnsToHistory = (turns, limits = HISTORY_LIMITS) => {
+  const history = [];
+  for (const turn of turns.slice(-limits.turns)) {
+    if (turn.user?.text) history.push({ role: 'user', text: excerptHead(turn.user.text, limits.user) });
+    if (turn.assistant?.text) history.push({ role: 'assistant', text: excerptHeadTail(turn.assistant.text, limits.answerHead, limits.answerTail) });
+  }
+  return history;
+};
+
+/**
+ * Empty when the session has no settled answer yet (a new session, or one
+ * interrupted mid-turn) — routing then judges the request on its own. A read
+ * failure is thrown so the caller can decide; it is not an empty history.
+ */
+export const loadRoutingHistory = async ({ readPage, signal }) => {
+  const context = await loadAssistContext({ readPage, signal });
+  return context ? turnsToHistory(context.turns) : [];
+};

package/server/lib/routing/jev.js

@@ -0,0 +1,98 @@
+/**
+ * The Jev side of routing: request shapes and the HTTP call. Pure builders are
+ * exported so the decision logic can be tested without a network.
+ */
+import { z } from 'zod';
+import {
+  JEV_API_ORIGIN,
+  JEV_API_PATH,
+  JEV_MODEL,
+  JEV_TIMEOUT_MS,
+  ROUTING_INSTRUCTIONS,
+  SAFETY_INSTRUCTIONS,
+  SAFETY_KINDS,
+} from './defaults.js';
+
+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 } },
+  };
+};
+
+/** `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,
+      patterns: permission.patterns,
+      metadata: permission.metadata,
+    },
+  },
+  questions: {
+    ask: { type: 'noul', instructions: SAFETY_INSTRUCTIONS },
+    kind: { type: 'choice', instructions: 'What is the most significant effect of this action?', criteria: SAFETY_KINDS },
+  },
+});
+
+const choiceAnswerSchema = z.object({ choice: z.string(), confidence: z.number() });
+const noulAnswerSchema = z.object({ noul: z.number() });
+const permissionAnswersSchema = z.object({
+  ask: noulAnswerSchema,
+  kind: z.object({ choice: z.string() }).partial().optional(),
+});
+
+/**
+ * Maps a Jev answer onto the category to use. Anything short of a confident,
+ * known, enabled category is the fallback; the reason says which.
+ */
+export const decideRouting = (answer, { categories, minConfidence }) => {
+  const parsed = choiceAnswerSchema.safeParse(answer);
+  if (!parsed.success) return { category: null, reason: 'unknown-category', confidence: 0 };
+  const category = categories.find((c) => c.id === parsed.data.choice) ?? null;
+  if (!category) return { category: null, reason: 'unknown-category', confidence: parsed.data.confidence };
+  if (parsed.data.confidence < minConfidence) return { category: null, reason: 'low-confidence', confidence: parsed.data.confidence };
+  return { category, reason: 'routed', confidence: parsed.data.confidence };
+};
+
+export const decidePermission = (answers, { threshold }) => {
+  const parsed = permissionAnswersSchema.safeParse(answers);
+  if (!parsed.success) throw new Error('Jev answer is missing the ask score');
+  const score = parsed.data.ask.noul;
+  return { hold: score >= threshold, score, kind: parsed.data.kind?.choice ?? null };
+};
+
+const responseSchema = z.object({ answers: z.record(z.string(), z.unknown()) });
+
+export const createJevClient = ({ fetchImpl = fetch, timeoutMs = JEV_TIMEOUT_MS } = {}) => ({
+  /** Resolves to the parsed answers; throws with `status` on an HTTP error and `code: 'timeout'` on abort. */
+  ask: async (request, token) => {
+    const abort = new AbortController();
+    const timer = setTimeout(() => abort.abort(), timeoutMs);
+    const started = Date.now();
+    try {
+      const response = await fetchImpl(JEV_API_ORIGIN + JEV_API_PATH, {
+        method: 'POST',
+        headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
+        body: JSON.stringify(request),
+        signal: abort.signal,
+      });
+      const text = await response.text();
+      if (!response.ok) {
+        throw Object.assign(new Error(`Jev responded ${response.status}`), { status: response.status });
+      }
+      const body = responseSchema.safeParse(JSON.parse(text));
+      if (!body.success) throw new Error('Jev response has no answers');
+      return { answers: body.data.answers, ms: Date.now() - started };
+    } catch (error) {
+      if (error?.name === 'AbortError') throw Object.assign(new Error(`Jev timed out after ${timeoutMs}ms`), { code: 'timeout' });
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+  },
+});

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

@@ -0,0 +1,100 @@
+import express from 'express';
+import request from 'supertest';
+import { afterEach, 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.
+ */
+const createApp = ({ flag = '1', resolvePromptBody } = {}) => {
+  process.env.OPENCHAMBER_ROUTING_ENABLE = flag;
+  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;
+    }),
+    describe: async () => ({ available: true, autoReady: true, tokenPresent: true, config: null, builtins: [] }),
+    heldPermissions: () => [],
+    updateConfig: vi.fn(async () => ({ available: true })),
+    setToken: vi.fn(async () => ({ available: true, tokenPresent: true })),
+    clearToken: vi.fn(async () => ({ available: true, tokenPresent: false })),
+  };
+  const app = express();
+  registerRoutingRoutes(app, runtime);
+  registerRoutingPromptRewrite(app, runtime);
+  // Stand-in for the OpenCode proxy: a parsed body arrives as `req.body`, an
+  // untouched stream arrives as raw bytes.
+  app.use('/api', (req, res) => {
+    if (req.body !== undefined) {
+      forwarded.push({ path: req.path, parsed: true, body: req.body });
+      return res.status(204).end();
+    }
+    let raw = '';
+    req.on('data', (chunk) => { raw += chunk; });
+    req.on('end', () => {
+      forwarded.push({ path: req.path, parsed: false, raw });
+      res.status(204).end();
+    });
+  });
+  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 () => {
+    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' }] })
+      .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' });
+  });
+
+  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();
+
+    const text = createApp();
+    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 () => {
+    const { app, forwarded } = createApp({
+      resolvePromptBody: 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' } });
+    expect(response.status).toBe(400);
+    expect(response.body).toEqual({ error: 'no fallback' });
+    expect(forwarded).toEqual([]);
+  });
+});
+
+describe('routing routes', () => {
+  it('serves state, saves config and manages the token', async () => {
+    const { app, runtime } = createApp();
+    const state = await request(app).get('/api/routing').expect(200);
+    expect(state.body).toMatchObject({ available: true, autoReady: true, heldPermissions: [] });
+    await request(app).put('/api/routing').send({ config: { enabled: true } }).expect(200);
+    expect(runtime.updateConfig).toHaveBeenCalledWith({ enabled: true });
+    await request(app).put('/api/routing/token').send({ token: 'ts-key' }).expect(200);
+    expect(runtime.setToken).toHaveBeenCalledWith('ts-key');
+    await request(app).delete('/api/routing/token').expect(200);
+    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

@@ -0,0 +1,81 @@
+/**
+ * `/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.
+ */
+import express from 'express';
+import { isRoutingFeatureAvailable } from './feature-flag.js';
+
+const AUTO_SESSION_PATHS = [
+  '/api/session/:sessionId/prompt_async',
+  '/api/session/:sessionId/prompt',
+  '/api/session/:sessionId/command',
+];
+
+const sendError = (res, error) => {
+  const status = Number.isInteger(error?.status) ? error.status : 500;
+  res.status(status).json({ error: error?.message ?? 'Routing request failed' });
+};
+
+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);
+    }
+  });
+
+  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) {
+      sendError(res, error);
+    }
+  });
+
+  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) {
+      sendError(res, error);
+    }
+  });
+
+  app.delete('/api/routing/token', async (_req, res) => {
+    if (!isRoutingFeatureAvailable()) return unavailable(res);
+    try {
+      res.json(await runtime.clearToken());
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+}
+
+export function registerRoutingPromptRewrite(app, runtime) {
+  const parseJson = express.json({ limit: '50mb' });
+  app.post(AUTO_SESSION_PATHS, (req, res, next) => {
+    if (!isRoutingFeatureAvailable()) return 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));
+    });
+  });
+}