@vantran-se/openchamber-web 1.22.1 → 1.23.0

package/server/lib/session-goal/runtime.test.js

@@ -46,6 +46,78 @@ const startIdleTick = async (fetchImpl) => {
   return { runtime, getSmallModelService };
 };
 
+const assistantMessage = (id, infoOverrides = {}) => ({
+  info: {
+    id,
+    sessionID: SESSION_ID,
+    role: 'assistant',
+    providerID: 'provider',
+    modelID: 'model',
+    time: { created: 2, completed: 2 },
+    tokens: { input: 1, output: 1, cache: { read: 0 } },
+    ...infoOverrides,
+  },
+  parts: [{ type: 'text', text: 'The agent made progress.' }],
+});
+
+const createRuntimeHarness = ({ messages, messageFactory, goalOverrides = {}, maxAutoTurns = 20 }) => {
+  const requests = [];
+  let messageFetchCount = 0;
+  const activeSession = {
+    ...session,
+    metadata: { openchamber: { goal: { ...goal, ...goalOverrides } } },
+  };
+  const service = {
+    generateSmallModelText: vi.fn(async () => ({
+      text: '{"verdict":"continue","note":"More work remains"}',
+      providerID: 'provider',
+      modelID: 'model',
+    })),
+  };
+  const fetchImpl = vi.fn(async (input, init = {}) => {
+    const pathname = requestPath(input);
+    requests.push({ pathname, method: init.method ?? 'GET', body: init.body });
+    if (pathname === `/session/${SESSION_ID}` && init.method === 'PATCH') {
+      activeSession.metadata = JSON.parse(init.body).metadata;
+      return jsonResponse(activeSession);
+    }
+    if (pathname === `/session/${SESSION_ID}`) return jsonResponse(activeSession);
+    if (pathname === '/session/status') return jsonResponse({});
+    if (pathname === `/session/${SESSION_ID}/children`) return jsonResponse([]);
+    if (pathname === `/session/${SESSION_ID}/message`) {
+      const nextMessages = messageFactory ? messageFactory(messageFetchCount) : messages;
+      messageFetchCount += 1;
+      return jsonResponse(nextMessages);
+    }
+    if (pathname === `/session/${SESSION_ID}/prompt_async`) return jsonResponse({ ok: true });
+    throw new Error(`Unexpected request: ${pathname}`);
+  });
+  vi.stubGlobal('fetch', fetchImpl);
+  const runtime = createSessionGoalRuntime({
+    buildOpenCodeUrl: (pathname) => `http://opencode.test${pathname}`,
+    getOpenCodeAuthHeaders: () => ({}),
+    getSmallModelService: async () => service,
+    isEnabled: () => true,
+    idleQuietMs: 10,
+    maxAutoTurns,
+  });
+  return { runtime, requests, service, activeSession };
+};
+
+const runIdleTick = async (runtime) => {
+  runtime.processPayload({
+    type: 'session.status',
+    properties: { sessionID: SESSION_ID, status: { type: 'idle' }, directory: DIRECTORY },
+  });
+  await vi.runOnlyPendingTimersAsync();
+};
+
+const lastPatchedGoal = (requests) => {
+  const patches = requests.filter((request) => request.pathname === `/session/${SESSION_ID}` && request.method === 'PATCH');
+  expect(patches.length).toBeGreaterThan(0);
+  return JSON.parse(patches.at(-1).body).metadata.openchamber.goal;
+};
+
 describe('session goal live activity gate', () => {
   beforeEach(() => {
     vi.useFakeTimers();
@@ -178,4 +250,358 @@ describe('session goal live activity gate', () => {
     });
     runtime.stop();
   });
+
+  it('skips audit and sends continuation prompt when assistant message finishes with length stop', async () => {
+    const requests = [];
+    const fetchImpl = vi.fn(async (input, init = {}) => {
+      const pathname = requestPath(input);
+      requests.push({ pathname, method: init.method ?? 'GET', body: init.body });
+      if (pathname === `/session/${SESSION_ID}` && init.method === 'PATCH') return jsonResponse(session);
+      if (pathname === `/session/${SESSION_ID}`) return jsonResponse(session);
+      if (pathname === '/session/status') return jsonResponse({});
+      if (pathname === `/session/${SESSION_ID}/children`) return jsonResponse([]);
+      if (pathname === `/session/${SESSION_ID}/prompt_async`) return jsonResponse({ ok: true });
+      if (pathname === `/session/${SESSION_ID}/message`) {
+        return jsonResponse([{
+          info: {
+            id: 'msg_assistant_len',
+            sessionID: SESSION_ID,
+            role: 'assistant',
+            providerID: 'provider',
+            modelID: 'model',
+            finish: 'length',
+            time: { completed: 2 },
+            tokens: { input: 100, output: 4096, reasoning: 4096, cache: { read: 0 } },
+          },
+          parts: [{ type: 'reasoning', text: 'Drafting extensive implementation...' }],
+        }]);
+      }
+      throw new Error(`Unexpected request: ${pathname}`);
+    });
+    const service = {
+      generateSmallModelText: vi.fn(),
+    };
+    vi.stubGlobal('fetch', fetchImpl);
+    const runtime = createSessionGoalRuntime({
+      buildOpenCodeUrl: (pathname) => `http://opencode.test${pathname}`,
+      getOpenCodeAuthHeaders: () => ({}),
+      getSmallModelService: async () => service,
+      isEnabled: () => true,
+      idleQuietMs: 10,
+    });
+
+    runtime.processPayload({
+      type: 'session.status',
+      properties: { sessionID: SESSION_ID, status: { type: 'idle' }, directory: DIRECTORY },
+    });
+    await vi.runOnlyPendingTimersAsync();
+
+    // Audit must be skipped on length-truncated turn
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+
+    // Goal accounting is persisted and turnsUsed incremented
+    const patch = requests.find((request) => request.pathname === `/session/${SESSION_ID}` && request.method === 'PATCH');
+    expect(patch).toBeDefined();
+    const writtenGoal = JSON.parse(patch.body).metadata.openchamber.goal;
+    expect(writtenGoal).toMatchObject({
+      status: 'active',
+      turnsUsed: 2,
+    });
+
+    // Continuation prompt is dispatched
+    const promptAsync = requests.find((request) => request.pathname === `/session/${SESSION_ID}/prompt_async` && request.method === 'POST');
+    expect(promptAsync).toBeDefined();
+    const promptBody = JSON.parse(promptAsync.body);
+    expect(promptBody.parts[0].text).toContain('Continue working toward the active session goal.');
+    runtime.stop();
+  });
+
+  it('skips audit and sends continuation prompt when assistant message carries MessageOutputLengthError', async () => {
+    const requests = [];
+    const fetchImpl = vi.fn(async (input, init = {}) => {
+      const pathname = requestPath(input);
+      requests.push({ pathname, method: init.method ?? 'GET', body: init.body });
+      if (pathname === `/session/${SESSION_ID}` && init.method === 'PATCH') return jsonResponse(session);
+      if (pathname === `/session/${SESSION_ID}`) return jsonResponse(session);
+      if (pathname === '/session/status') return jsonResponse({});
+      if (pathname === `/session/${SESSION_ID}/children`) return jsonResponse([]);
+      if (pathname === `/session/${SESSION_ID}/prompt_async`) return jsonResponse({ ok: true });
+      if (pathname === `/session/${SESSION_ID}/message`) {
+        return jsonResponse([{
+          info: {
+            id: 'msg_assistant_len_err',
+            sessionID: SESSION_ID,
+            role: 'assistant',
+            providerID: 'provider',
+            modelID: 'model',
+            error: { name: 'MessageOutputLengthError', message: 'Maximum token limit reached' },
+            time: { completed: 2 },
+            tokens: { input: 100, output: 4096, reasoning: 4096, cache: { read: 0 } },
+          },
+          parts: [{ type: 'reasoning', text: 'Drafting extensive implementation...' }],
+        }]);
+      }
+      throw new Error(`Unexpected request: ${pathname}`);
+    });
+    const service = {
+      generateSmallModelText: vi.fn(),
+    };
+    vi.stubGlobal('fetch', fetchImpl);
+    const runtime = createSessionGoalRuntime({
+      buildOpenCodeUrl: (pathname) => `http://opencode.test${pathname}`,
+      getOpenCodeAuthHeaders: () => ({}),
+      getSmallModelService: async () => service,
+      isEnabled: () => true,
+      idleQuietMs: 10,
+    });
+
+    runtime.processPayload({
+      type: 'session.status',
+      properties: { sessionID: SESSION_ID, status: { type: 'idle' }, directory: DIRECTORY },
+    });
+    await vi.runOnlyPendingTimersAsync();
+
+    // Audit must be skipped on MessageOutputLengthError
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+
+    // Goal remains active and turnsUsed incremented
+    const patch = requests.find((request) => request.pathname === `/session/${SESSION_ID}` && request.method === 'PATCH');
+    expect(patch).toBeDefined();
+    const writtenGoal = JSON.parse(patch.body).metadata.openchamber.goal;
+    expect(writtenGoal).toMatchObject({
+      status: 'active',
+      turnsUsed: 2,
+    });
+
+    // Continuation prompt is dispatched
+    const promptAsync = requests.find((request) => request.pathname === `/session/${SESSION_ID}/prompt_async` && request.method === 'POST');
+    expect(promptAsync).toBeDefined();
+    runtime.stop();
+  });
+
+  it.each([
+    { name: 'APIError', error: { name: 'APIError', message: 'provider failed' } },
+    { name: 'StructuredOutputError', error: { name: 'StructuredOutputError', message: 'invalid output' } },
+    { name: 'unnamed errors', error: {} },
+  ])('blocks a length finish when the assistant also has a non-length $name', async ({ error }) => {
+    const { runtime, requests, service } = createRuntimeHarness({
+      messages: [assistantMessage('msg_assistant_error', { finish: 'length', error })],
+    });
+
+    await runIdleTick(runtime);
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.some((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toBe(false);
+    expect(lastPatchedGoal(requests)).toMatchObject({
+      status: 'blocked',
+      statusReason: error.name || 'assistant turn failed',
+    });
+    runtime.stop();
+  });
+
+  it('blocks after two consecutive length-truncated agent turns without persisting a counter, regardless of message IDs', async () => {
+    const firstLength = assistantMessage('z', { finish: 'length', time: { created: 10, completed: 11 } });
+    const summary = assistantMessage('summary', { summary: true, time: { created: 15, completed: 16 } });
+    const secondLength = assistantMessage('a', { finish: 'length', time: { created: 20, completed: 21 } });
+    const { runtime, requests, service } = createRuntimeHarness({
+      messageFactory: (fetchCount) => fetchCount < 2 ? [firstLength] : [firstLength, summary, secondLength],
+    });
+
+    await runIdleTick(runtime);
+    runtime.processPayload({
+      type: 'session.status',
+      properties: { sessionID: SESSION_ID, status: { type: 'idle' }, directory: DIRECTORY },
+    });
+    await vi.runOnlyPendingTimersAsync();
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.filter((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toHaveLength(1);
+    expect(lastPatchedGoal(requests)).toMatchObject({
+      status: 'blocked',
+      statusReason: 'repeated output truncation',
+    });
+    runtime.stop();
+  });
+
+  it('allows one explicit Resume after repeated truncation, then blocks another cutoff', async () => {
+    const first = assistantMessage('first', { finish: 'length', time: { created: 10, completed: 11 } });
+    const second = assistantMessage('second', { finish: 'length', time: { created: 20, completed: 21 } });
+    const messages = [first, second];
+    const { runtime, requests, activeSession } = createRuntimeHarness({ messages });
+    try {
+      await runIdleTick(runtime);
+      expect(lastPatchedGoal(requests).status).toBe('blocked');
+      expect(requests.filter((request) => request.pathname.endsWith('/prompt_async'))).toHaveLength(0);
+      Object.assign(activeSession.metadata.openchamber.goal, { status: 'active', statusReason: 'resumed', turnsUsed: 0 });
+      await runIdleTick(runtime);
+      expect(lastPatchedGoal(requests)).toMatchObject({ status: 'active', statusReason: '', turnsUsed: 1 });
+      expect(requests.filter((request) => request.pathname.endsWith('/prompt_async'))).toHaveLength(1);
+      messages.push(assistantMessage('third', { finish: 'length', time: { created: 30, completed: 31 } }));
+      await runIdleTick(runtime);
+      expect(lastPatchedGoal(requests)).toMatchObject({ status: 'blocked', statusReason: 'repeated output truncation' });
+      expect(requests.filter((request) => request.pathname.endsWith('/prompt_async'))).toHaveLength(1);
+    } finally {
+      runtime.stop();
+    }
+  });
+
+  it.each([
+    { tokenBudget: 1, error: undefined, expectedStatus: 'budgetLimited' },
+    { tokenBudget: null, error: { name: 'APIError' }, expectedStatus: 'blocked' },
+  ])('keeps $expectedStatus protection on explicit Resume', async ({ tokenBudget, error, expectedStatus }) => {
+    const { runtime, requests } = createRuntimeHarness({
+      goalOverrides: { statusReason: 'resumed', tokenBudget },
+      messages: [assistantMessage('resumed', { finish: 'length', error })],
+    });
+    try {
+      await runIdleTick(runtime);
+      expect(lastPatchedGoal(requests).status).toBe(expectedStatus);
+      expect(requests.filter((request) => request.pathname.endsWith('/prompt_async'))).toHaveLength(0);
+    } finally {
+      runtime.stop();
+    }
+  });
+
+  it('continues after a truncated agent turn followed by a length-finished summary', async () => {
+    const firstLength = assistantMessage('agent-length', { finish: 'length', time: { created: 10, completed: 11 } });
+    const summary = assistantMessage('summary', {
+      summary: true,
+      finish: 'length',
+      time: { created: 15, completed: 16 },
+    });
+    const { runtime, requests, service } = createRuntimeHarness({
+      messageFactory: (fetchCount) => fetchCount < 2 ? [firstLength] : [firstLength, summary],
+    });
+
+    await runIdleTick(runtime);
+    await runIdleTick(runtime);
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.filter((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toHaveLength(2);
+    expect(lastPatchedGoal(requests)).toMatchObject({ status: 'active' });
+    runtime.stop();
+  });
+
+  it('does not infer a repeated streak when a completed assistant timestamp is missing', async () => {
+    const firstLength = assistantMessage('z', { finish: 'length', time: { completed: 11 } });
+    const secondLength = assistantMessage('a', { finish: 'length', time: { created: 20, completed: 21 } });
+    const { runtime, requests, service } = createRuntimeHarness({
+      messageFactory: (fetchCount) => fetchCount < 2 ? [firstLength] : [firstLength, secondLength],
+    });
+
+    await runIdleTick(runtime);
+    await runIdleTick(runtime);
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.filter((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toHaveLength(2);
+    expect(lastPatchedGoal(requests)).toMatchObject({ status: 'active' });
+    runtime.stop();
+  });
+
+  it('ignores a missing timestamp on an older assistant when known post-goal turns establish a streak', async () => {
+    const olderLength = assistantMessage('legacy', { finish: 'length', time: { completed: 5 } });
+    const firstLength = assistantMessage('z', { finish: 'length', time: { created: 10, completed: 11 } });
+    const secondLength = assistantMessage('a', { finish: 'length', time: { created: 20, completed: 21 } });
+    const { runtime, requests, service } = createRuntimeHarness({
+      goalOverrides: { createdAt: 6 },
+      messageFactory: (fetchCount) => fetchCount < 2 ? [firstLength] : [olderLength, firstLength, secondLength],
+    });
+
+    await runIdleTick(runtime);
+    await runIdleTick(runtime);
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.filter((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toHaveLength(1);
+    expect(lastPatchedGoal(requests)).toMatchObject({
+      status: 'blocked',
+      statusReason: 'repeated output truncation',
+    });
+    runtime.stop();
+  });
+
+  it('does not count a previous truncated turn created at the goal boundary', async () => {
+    const firstLength = assistantMessage('before-boundary', { finish: 'length', time: { created: 10, completed: 11 } });
+    const secondLength = assistantMessage('after-boundary', { finish: 'length', time: { created: 20, completed: 21 } });
+    const { runtime, requests, service } = createRuntimeHarness({
+      goalOverrides: { createdAt: 10 },
+      messageFactory: (fetchCount) => fetchCount < 2 ? [firstLength] : [firstLength, secondLength],
+    });
+
+    await runIdleTick(runtime);
+    await runIdleTick(runtime);
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.filter((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toHaveLength(2);
+    expect(lastPatchedGoal(requests)).toMatchObject({ status: 'active' });
+    runtime.stop();
+  });
+
+  it('allows length recovery after an ordinary assistant turn breaks the streak', async () => {
+    const firstLength = assistantMessage('msg_length_before_normal', { finish: 'length' });
+    const normal = assistantMessage('msg_normal');
+    const secondLength = assistantMessage('msg_length_after_normal', { finish: 'length' });
+    const { runtime, requests, service } = createRuntimeHarness({
+      messageFactory: (fetchCount) => fetchCount < 2
+        ? [firstLength]
+        : [firstLength, normal, secondLength],
+    });
+
+    await runIdleTick(runtime);
+    await runIdleTick(runtime);
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.filter((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toHaveLength(2);
+    expect(lastPatchedGoal(requests)).toMatchObject({ status: 'active' });
+    runtime.stop();
+  });
+
+  it('keeps MessageAbortedError pause behavior instead of continuing', async () => {
+    const { runtime, requests, service } = createRuntimeHarness({
+      messages: [assistantMessage('msg_aborted', { error: { name: 'MessageAbortedError' } })],
+    });
+
+    await runIdleTick(runtime);
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.some((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toBe(false);
+    expect(lastPatchedGoal(requests)).toMatchObject({
+      status: 'paused',
+      statusReason: 'paused after abort',
+    });
+    runtime.stop();
+  });
+
+  it('checks the token budget before allowing length recovery', async () => {
+    const { runtime, requests, service } = createRuntimeHarness({
+      goalOverrides: { tokenBudget: 5 },
+      messages: [assistantMessage('msg_budget_length', {
+        finish: 'length',
+        tokens: { input: 3, output: 3, cache: { read: 0 } },
+      })],
+    });
+
+    await runIdleTick(runtime);
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.some((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toBe(false);
+    expect(lastPatchedGoal(requests)).toMatchObject({ status: 'budgetLimited' });
+    runtime.stop();
+  });
+
+  it('checks the auto-continuation cap before allowing length recovery', async () => {
+    const { runtime, requests, service } = createRuntimeHarness({
+      maxAutoTurns: 1,
+      messages: [assistantMessage('msg_cap_length', { finish: 'length' })],
+    });
+
+    await runIdleTick(runtime);
+
+    expect(service.generateSmallModelText).not.toHaveBeenCalled();
+    expect(requests.some((request) => request.pathname === `/session/${SESSION_ID}/prompt_async`)).toBe(false);
+    expect(lastPatchedGoal(requests)).toMatchObject({
+      status: 'blocked',
+      statusReason: 'auto-continuation limit reached',
+    });
+    runtime.stop();
+  });
 });

package/server/lib/skills-catalog/DOCUMENTATION.md

@@ -58,7 +58,7 @@ The following functions are internal helpers used by exported functions:
 - `safeRm(dir)`: Safely remove directory recursively (ignores errors).
 - `ensureDir(dirPath)`: Ensure directory exists with recursive creation.
 - `copyDirectoryNoSymlinks(srcDir, dstDir)`: Copy directory contents without symlinks, with path traversal protection.
-- `normalizeUserSkillDir(userSkillDir)`: Normalize user skill directory path (handles legacy `~/.config/opencode/skill` → `~/.config/opencode/skills` migration).
+- `normalizeUserSkillDir(userSkillDir)`: Normalize the user skill directory path (handles the legacy `skill` directory in the XDG config location, or `~/.config/opencode/skill` when XDG is unset, by selecting the plural `skills` directory when appropriate).
 
 ### Git Clone Helpers (`install.js`, `scan.js`)
 - `cloneRepo({ cloneUrl, identity, tempDir })`: Clone git repository with preferred partial clone (`--filter=blob:none`) and fallback. Uses non-interactive mode.

package/server/lib/skills-catalog/install.js

@@ -4,13 +4,14 @@ import path from 'path';
 
 import { assertGitAvailable, looksLikeAuthError, runGit } from './git.js';
 import { parseSkillRepoSource } from './source.js';
+import { OPENCODE_CONFIG_DIR } from '../opencode/shared.js';
 
 const SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/;
 
 function normalizeUserSkillDir(userSkillDir) {
   if (!userSkillDir) return null;
-  const legacySkillDir = path.join(os.homedir(), '.config', 'opencode', 'skill');
-  const pluralSkillDir = path.join(os.homedir(), '.config', 'opencode', 'skills');
+  const legacySkillDir = path.join(OPENCODE_CONFIG_DIR, 'skill');
+  const pluralSkillDir = path.join(OPENCODE_CONFIG_DIR, 'skills');
   if (userSkillDir === legacySkillDir) {
     if (fs.existsSync(legacySkillDir) && !fs.existsSync(pluralSkillDir)) return legacySkillDir;
     return pluralSkillDir;

package/server/lib/small-model/DOCUMENTATION.md

@@ -91,6 +91,10 @@ other runtime API.
   a blocker instead of a raw 500 message.
 - `call.js` — wire formats and per-provider auth, replicating OpenCode's
   plugin auth loaders:
+  - OpenCode-hosted providers receive `x-opencode-session`. Session-backed
+    features reuse the real OpenCode session id, walkthrough retries reuse the
+    walkthrough cache key, and standalone one-shot actions receive a fresh
+    opaque id for that generation.
   - **GitHub Copilot**: fetches the requested model's authenticated `/models`
     metadata from `https://api.githubcopilot.com` (or
     `copilot-api.<enterprise>`) and honors its advertised endpoint, preferring
@@ -113,8 +117,9 @@ other runtime API.
   - Everything else: OpenAI-compatible `/chat/completions` against the
     provider's base URL, resolved from (1) `provider.<id>.options.baseURL`
     in the OpenCode config, (2) the hardcoded `https://api.openai.com/v1`
-     endpoint, (3) the endpoint OpenCode resolved at runtime, or (4) the
-    provider's `api` field from the models.dev catalog. The credential follows
+     endpoint, (3) the selected model's endpoint OpenCode resolved at runtime,
+     (4) the provider-level runtime endpoint, or (5) the provider's `api` field
+     from the models.dev catalog. The credential follows
     the same shape: config `options.apiKey`, then the runtime credential, then
     the auth.json entry. `provider.<id>.options.headers` is sent with the
     request and overrides the bearer default, so gateways that authenticate on

package/server/lib/small-model/call.js

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
+import { randomUUID } from 'node:crypto';
 import { readAuthFile, writeAuthFile } from '../opencode/auth.js';
 import { readConfig, readConfigLayers, isPlainObject } from '../opencode/shared.js';
 import { getCatalogProvider } from './catalog.js';
@@ -605,6 +606,8 @@ const readProviderConfig = (workingDirectory, providerID) => {
   }
 }
 
+const getRuntimeModel = (runtimeProvider, modelID) => runtimeProvider?.models?.get(modelID) ?? null;
+
 // ---------------------------------------------------------------------------
 // Dispatch
 // ---------------------------------------------------------------------------
@@ -645,10 +648,11 @@ export async function resolveProviderLogin({ auth, workingDirectory, providerID
     || null;
 }
 
-export async function callSmallModel({ auth, catalog, workingDirectory, providerID, modelID, prompt, system, maxOutputTokens, responseSchema, timeoutMs, signal }) {
+export async function callSmallModel({ auth, catalog, workingDirectory, sessionID, providerID, modelID, prompt, system, maxOutputTokens, responseSchema, timeoutMs, signal }) {
   const tokens = Number(maxOutputTokens) > 0 ? Number(maxOutputTokens) : DEFAULT_MAX_OUTPUT_TOKENS;
   const providerConfig = readProviderConfig(workingDirectory, providerID);
   const runtimeProvider = await getRuntimeProvider(providerID);
+  const runtimeModel = getRuntimeModel(runtimeProvider, modelID);
   // Match OpenCode's resolveSDK precedence: config `provider.<id>.options`
   // wins, then what OpenCode itself resolved at runtime (the only place a
   // plugin's credential exists), and the auth.json entry last.
@@ -758,9 +762,10 @@ export async function callSmallModel({ auth, catalog, workingDirectory, provider
   // base URL for that provider (openai itself included). When a custom provider
   // is not in the catalog (e.g. a user-configured OpenAI-compatible proxy),
   // fall back to its baseURL from the OpenCode provider config, then to the
-  // endpoint OpenCode resolved at runtime — which for a plugin provider is the
-  // only place it exists, and for several of them is a local proxy the plugin
-  // itself runs. The openai provider also respects
+  // selected model's endpoint OpenCode resolved at runtime, then to the
+  // provider-level runtime endpoint. For a plugin provider, the runtime listing
+  // is the only place those endpoints exist, and several are local proxies the
+  // plugin itself runs. The openai provider also respects
   // provider.openai.options.baseURL — OpenCode itself uses the same config for
   // all providers including openai.
   const provider = getCatalogProvider(catalog, providerID);
@@ -770,7 +775,8 @@ export async function callSmallModel({ auth, catalog, workingDirectory, provider
     ? providerConfigUrl
     : providerID === 'openai'
       ? defaultOpenaiUrl
-      : runtimeProvider?.baseURL
+      : runtimeModel?.api?.url
+        ?? runtimeProvider?.baseURL
         ?? (typeof provider?.api === 'string' && provider.api
           ? provider.api
           : null);
@@ -795,7 +801,12 @@ export async function callSmallModel({ auth, catalog, workingDirectory, provider
     baseURL,
     // Configured headers last: a gateway that authenticates on its own header
     // must be able to override the bearer default rather than sit beside it.
-    headers: mergeHeadersCaseInsensitive({ Authorization: `Bearer ${apiKey}` }, providerConfig?.headers),
+    headers: mergeHeadersCaseInsensitive(
+      mergeHeadersCaseInsensitive({ Authorization: `Bearer ${apiKey}` }, providerConfig?.headers),
+      providerID.startsWith('opencode')
+        ? { 'x-opencode-session': typeof sessionID === 'string' && sessionID.trim() ? sessionID.trim() : randomUUID() }
+        : null,
+    ),
     modelID,
     prompt,
     system,

package/server/lib/small-model/call.test.js

@@ -483,6 +483,29 @@ describe('callSmallModel — custom provider config', () => {
   });
 
   describe('catalog-based base URL (no config override)', () => {
+    it('identifies OpenCode Go requests with the owning conversation', async () => {
+      readConfig.mockReturnValue({});
+      fetchMock.mockResolvedValue(ok('ok'));
+
+      await callSmallModel({
+        auth: { 'opencode-go': { type: 'api', key: 'go-key' } },
+        catalog: {
+          'opencode-go': {
+            id: 'opencode-go',
+            api: 'https://opencode.ai/zen/go/v1',
+            models: { utility: { id: 'utility' } },
+          },
+        },
+        workingDirectory: '/proj',
+        sessionID: 'ses_conversation',
+        providerID: 'opencode-go',
+        modelID: 'utility',
+        prompt: 'hi',
+      });
+
+      expect(lastCall(fetchMock).init.headers['x-opencode-session']).toBe('ses_conversation');
+    });
+
     it('uses the catalog api field when no config baseURL is set', async () => {
       readConfig.mockReturnValue({});
       fetchMock.mockResolvedValue(ok('ok'));
@@ -542,6 +565,35 @@ describe('callSmallModel — custom provider config', () => {
       expect(init.headers.Authorization).toBe('Bearer plugin-key');
     });
 
+    it('uses the selected runtime model endpoint', async () => {
+      readConfig.mockReturnValue({});
+      getRuntimeProvider.mockResolvedValue({
+        id: 'runtime-provider',
+        apiKey: 'plugin-key',
+        baseURL: 'https://runtime-provider/v1beta',
+        models: new Map([
+          ['first-model', { api: { url: 'https://runtime-provider/v1beta', npm: '@ai-sdk/google' } }],
+          ['selected-model', { api: { url: 'https://runtime-provider/v1', npm: '@ai-sdk/openai' } }],
+        ]),
+        anonymousZen: false,
+      });
+      fetchMock.mockResolvedValue(ok('done'));
+
+      await callSmallModel({
+        auth: {},
+        catalog: {},
+        workingDirectory: '/proj',
+        providerID: 'runtime-provider',
+        modelID: 'selected-model',
+        prompt: 'hi',
+      });
+
+      const { url, init } = lastCall(fetchMock);
+      expect(url).toBe('https://runtime-provider/v1/chat/completions');
+      expect(url).not.toContain('/v1beta');
+      expect(JSON.parse(init.body).model).toBe('selected-model');
+    });
+
     it('keeps the ChatGPT-plan login on its own transport instead of the runtime key', async () => {
       readConfig.mockReturnValue({});
       // OpenCode reports an OAuth access token as `options.apiKey` for openai;

package/server/lib/small-model/index.js

@@ -6,6 +6,7 @@ import { readConfigLayers } from '../opencode/shared.js';
 import { getModelCatalog } from './catalog.js';
 import { resolveSmallModel, parseModelRef, isUsableAuthEntry, getAuthEntryForProvider } from './resolve.js';
 import { DEDICATED_WIRE_FORMAT_PROVIDERS, callSmallModel, resolveProviderLogin } from './call.js';
+import { readMergedSettingsSync } from '../opencode/settings-files.js';
 import { getRuntimeProviderSnapshot } from './runtime-providers.js';
 
 // Never a small model, whatever the transport looks like. A plugin can publish
@@ -26,16 +27,10 @@ const OPENCHAMBER_SETTINGS_FILE = path.join(
 // OpenChamber's own settings: when the user unchecks "use default small model"
 // their explicit override outranks every other resolution step.
 const readSmallModelSettingsOverride = () => {
-  try {
-    const raw = fs.readFileSync(OPENCHAMBER_SETTINGS_FILE, 'utf8');
-    const settings = JSON.parse(raw);
-    if (!settings || typeof settings !== 'object') return null;
-    if (settings.smallModelUseDefault !== false) return null;
-    const override = typeof settings.smallModelOverride === 'string' ? settings.smallModelOverride.trim() : '';
-    return override || null;
-  } catch {
-    return null;
-  }
+  const settings = readMergedSettingsSync({ fs, path, settingsFilePath: OPENCHAMBER_SETTINGS_FILE });
+  if (settings.smallModelUseDefault !== false) return null;
+  const override = typeof settings.smallModelOverride === 'string' ? settings.smallModelOverride.trim() : '';
+  return override || null;
 };
 
 // Rough safety clamp so a huge input never blows the model's context window.
@@ -102,7 +97,7 @@ const readConfiguredSmallModel = (workingDirectory) => {
  * Generates text with the user's small model, resolved and authenticated
  * entirely server-side from the OpenCode config and auth store.
  */
-export async function generateSmallModelText({ prompt, system, maxOutputTokens, model, directory, preferredProviderID, preferredModelID, restrictToPreferredProvider = false, responseSchema, timeoutMs, signal, onOverflow = 'truncate' }) {
+export async function generateSmallModelText({ prompt, system, maxOutputTokens, model, directory, sessionID, preferredProviderID, preferredModelID, restrictToPreferredProvider = false, responseSchema, timeoutMs, signal, onOverflow = 'truncate' }) {
   if (typeof prompt !== 'string' || !prompt.trim()) {
     throw Object.assign(new Error('prompt is required'), { statusCode: 400 });
   }
@@ -169,6 +164,7 @@ export async function generateSmallModelText({ prompt, system, maxOutputTokens,
     auth,
     catalog,
     workingDirectory: directory,
+    sessionID,
     providerID: resolved.providerID,
     modelID: resolved.modelID,
     prompt: clamped.prompt,