@openchambery/web 1.19.21-beta.1 → 2.0.0-beta.1

package/server/lib/session-turn-pages/service.js

@@ -39,7 +39,7 @@ const hasPartType = (parts, type) =>
   Array.isArray(parts) && parts.some((part) => part && typeof part === 'object' && part.type === type);
 
 const isHostedSessionDivider = (record) => {
-  const id = record?.info?.id;
+  const id = record?.info?.id ?? record?.id;
   return typeof id === 'string' && id.startsWith(ASSISTANT_SESSION_DIVIDER_PREFIX);
 };
 
@@ -53,6 +53,10 @@ export const isUserAuthoredTurnBoundary = (record) => {
   if (!record || typeof record !== 'object') return false;
   if (isHostedSessionDivider(record)) return false;
 
+  if (typeof record.type === 'string' && record.info == null) {
+    return record.type === 'user';
+  }
+
   const info = record.info ?? {};
   const role = typeof info.clientRole === 'string' ? info.clientRole : info.role;
   if (role !== 'user') return false;
@@ -94,7 +98,7 @@ export const selectTurnRecords = (timeline, turnLimit) => {
 };
 
 const recordId = (record) => {
-  const id = record?.info?.id;
+  const id = record?.info?.id ?? record?.id;
   return typeof id === 'string' && id.length > 0 ? id : null;
 };
 

package/server/lib/session-turn-pages/service.test.js

@@ -1241,3 +1241,37 @@ describe('createSessionTurnPageService', () => {
     });
   });
 });
+
+describe('SessionMessageInfo turn pages', () => {
+  const v2User = (id, extra = {}) => ({ id, type: 'user', time: { created: 1 }, text: 'hi', ...extra });
+  const v2Assistant = (id, extra = {}) => ({
+    id,
+    type: 'assistant',
+    time: { created: 2, completed: 3 },
+    content: [{ type: 'text', text: 'ok' }],
+    ...extra,
+  });
+
+  it('counts SessionMessageInfo type=user as an authored boundary', () => {
+    expect(isUserAuthoredTurnBoundary(v2User('msg_u1'))).toBe(true);
+    expect(isUserAuthoredTurnBoundary(v2Assistant('msg_a1'))).toBe(false);
+    expect(isUserAuthoredTurnBoundary({ id: 'msg_syn', type: 'synthetic', time: { created: 1 }, text: 'loop' })).toBe(false);
+    expect(isUserAuthoredTurnBoundary({
+      id: `oc_asst_session_divider:ses_old`,
+      type: 'system',
+      time: { created: 0 },
+    })).toBe(false);
+  });
+
+  it('aggregates SessionMessageInfo pages by id and type', async () => {
+    const fetchPage = vi.fn(async () => ({
+      records: [v2User('msg_u1'), v2Assistant('msg_a1')],
+      nextCursor: null,
+      complete: true,
+    }));
+    const service = createSessionTurnPageService({ fetchPage });
+    const result = await service.loadPage({ sessionID: 'ses_1', turns: 1 });
+    expect(result).toMatchObject({ ok: true, turnCount: 1, complete: true });
+    expect(result.records.map((entry) => entry.id)).toEqual(['msg_u1', 'msg_a1']);
+  });
+});

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

@@ -24,10 +24,11 @@ every other runtime API.
   tasks. Tests may call the factory with a mock `getModelCatalog`. Returns
   `stop()` to remove the lazy temp directory used by the session path (wired
   from `server/index.js` `stop()`).
-- `opencode-session.js` — temporary OpenCode session path for non-dedicated
-  providers. Lazily creates `mkdtemp('openchamber-smallmodel-')` with a hidden
-  deny-all agent, then create → archive → `prompt_async` → poll idle → read
-  assistant text → best-effort `session.delete`.
+- `opencode-session.js` — fallback for non-dedicated providers. Lazily prepares
+  `mkdtemp('openchamber-smallmodel-')` with a hidden deny-all agent markdown
+  (isolation invariant), then calls official `@opencode/client`
+  `generate.text({ location?, prompt, model: { id, providerID } })`. No coding
+  session / `promptAsync` / `tool.ids` path. Empty text is never success.
 - `resolve.js` — model selection, mirroring OpenCode's `getSmallModel` chain:
   0. OpenChamber's own settings override (Settings → Sessions → Small Model):
      when `smallModelUseDefault` is `false`, `smallModelOverride`

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

@@ -1,4 +1,4 @@
-import { createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { OpenCode } from '@opencode/client';
 
 // Directory-scoped OpenCode provider catalog for small-model resolution.
 // Never contacts models.dev — source of truth is client.config.providers().
@@ -46,6 +46,51 @@ const normalizeDirectoryKey = (directory) => {
 
 const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
 
+// Compose official v2 provider.list + model.list into the SDK catalog shape
+// consumed by toSmallModelCatalog. Missing arrays are failure, not empty success.
+const composeV2ProviderCatalogSource = (providers, models) => {
+  if (!Array.isArray(providers) || !Array.isArray(models)) return null;
+
+  const modelsByProvider = new Map();
+  for (const model of models) {
+    if (!isRecord(model)) continue;
+    const providerID = typeof model.providerID === 'string' ? model.providerID : '';
+    const modelID = typeof model.modelID === 'string' && model.modelID
+      ? model.modelID
+      : (typeof model.id === 'string' ? model.id : '');
+    if (!providerID || !modelID) continue;
+    if (!modelsByProvider.has(providerID)) modelsByProvider.set(providerID, Object.create(null));
+    const entry = { id: modelID };
+    if (typeof model.family === 'string' && model.family) entry.family = model.family;
+    if (isRecord(model.limit)) {
+      const limit = Object.create(null);
+      if (Number.isFinite(model.limit.context)) limit.context = model.limit.context;
+      if (Number.isFinite(model.limit.output)) limit.output = model.limit.output;
+      if (Object.keys(limit).length > 0) entry.limit = limit;
+    }
+    if (isRecord(model.api) && typeof model.api.url === 'string' && model.api.url.trim()) {
+      entry.api = { url: model.api.url.trim() };
+    }
+    if (typeof model.time?.released === 'number' && Number.isFinite(model.time.released)) {
+      entry.release_date = new Date(model.time.released).toISOString().slice(0, 10);
+    } else if (typeof model.release_date === 'string' && model.release_date) {
+      entry.release_date = model.release_date;
+    }
+    modelsByProvider.get(providerID)[modelID] = entry;
+  }
+
+  const catalogProviders = [];
+  for (const provider of providers) {
+    if (!isRecord(provider) || typeof provider.id !== 'string' || !provider.id) continue;
+    catalogProviders.push({
+      id: provider.id,
+      name: typeof provider.name === 'string' && provider.name ? provider.name : provider.id,
+      models: modelsByProvider.get(provider.id) || Object.create(null),
+    });
+  }
+  return { providers: catalogProviders };
+};
+
 /**
  * Convert the official SDK provider list into the internal small-model catalog
  * shape. Keeps family / release_date / limit / cost.input|output /
@@ -126,17 +171,22 @@ export function createModelCatalogLoader({
 
   const fetchOpenCodeCatalog = async (directory) => {
     const baseUrl = buildOpenCodeUrl('/', '').replace(/\/$/, '');
-    const client = createOpencodeClient({
+    const client = OpenCode.make({
       baseUrl,
-      ...(directory ? { directory } : {}),
       headers: getOpenCodeAuthHeaders(),
       fetch: (request) => fetchImpl(request, { signal: AbortSignal.timeout(timeoutMs) }),
     });
-    const response = await client.config.providers(directory ? { directory } : {});
-    if (response?.error || response?.data === undefined) {
+    const location = directory ? { directory } : undefined;
+    const request = location ? { location } : undefined;
+    const [providersResult, modelsResult] = await Promise.all([
+      client.provider.list(request),
+      client.model.list(request),
+    ]);
+    const source = composeV2ProviderCatalogSource(providersResult?.data, modelsResult?.data);
+    if (!source) {
       throw new Error('OpenCode provider catalog is unavailable');
     }
-    const catalog = toSmallModelCatalog(response.data);
+    const catalog = toSmallModelCatalog(source);
     if (!catalog) {
       throw new Error('OpenCode provider catalog returned an unexpected payload');
     }

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

@@ -68,6 +68,53 @@ describe('createModelCatalogLoader', () => {
     expect(Object.keys(catalogA).length).toBeGreaterThan(0);
   });
 
+  it('composes official v2 provider.list + model.list into the small-model catalog', async () => {
+    const loader = createModelCatalogLoader({
+      buildOpenCodeUrl: () => 'http://127.0.0.1:4096/',
+      getOpenCodeAuthHeaders: () => ({ Authorization: 'Basic test' }),
+      fetchImpl: async (url) => {
+        const href = String(url);
+        const data = href.includes('/api/model')
+          ? [{
+              id: 'gemini-2.5-flash',
+              modelID: 'gemini-2.5-flash',
+              providerID: 'google',
+              family: 'gemini-flash',
+              name: 'Gemini 2.5 Flash',
+              capabilities: {},
+              variants: [],
+              time: { released: Date.parse('2025-06-01T00:00:00Z') },
+              cost: [],
+              status: 'active',
+              enabled: true,
+              limit: { context: 1_000_000, output: 8192 },
+              api: { url: 'https://generativelanguage.googleapis.com' },
+            }]
+          : [{ id: 'google', name: 'Google', package: '@ai-sdk/google' }];
+        return new Response(JSON.stringify({
+          location: { directory: '/proj', project: { id: 'p', directory: '/proj', canonical: '/proj' } },
+          data,
+        }), { status: 200, headers: { 'content-type': 'application/json' } });
+      },
+    });
+
+    const catalog = await loader.getModelCatalog('/proj');
+    expect(catalog).not.toBe(MINIMAL_FALLBACK_CATALOG);
+    expect(catalog.google).toEqual({
+      id: 'google',
+      name: 'Google',
+      models: {
+        'gemini-2.5-flash': {
+          id: 'gemini-2.5-flash',
+          family: 'gemini-flash',
+          release_date: '2025-06-01',
+          limit: { context: 1_000_000, output: 8192 },
+          api: { url: 'https://generativelanguage.googleapis.com' },
+        },
+      },
+    });
+  });
+
   it('normalizes directory keys so trailing slashes share a bucket', () => {
     const loader = createModelCatalogLoader({
       buildOpenCodeUrl: () => 'http://127.0.0.1:9/',

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

@@ -3,7 +3,7 @@ import os from 'os';
 import path from 'path';
 import { readAuthFile } from '../opencode/auth.js';
 import { readConfigLayers } from '../opencode/shared.js';
-import { createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { OpenCode } from '@opencode/client';
 import { loadConnectedCatalog } from '../llm/catalog.js';
 import { createModelCatalogLoader, getCatalogProvider } from './catalog.js';
 import { resolveSmallModel, parseModelRef, isUsableAuthEntry, getAuthEntryForProvider } from './resolve.js';
@@ -215,11 +215,11 @@ export function createSmallModelService(dependencies) {
       getOpenCodeAuthHeaders,
     }).getModelCatalog;
   const getConnectedCatalog = dependencies.getConnectedCatalog || (async (directory) => {
-    const client = createOpencodeClient({
+    const client = OpenCode.make({
       baseUrl: buildOpenCodeUrl('/', '').replace(/\/$/, ''),
-      ...(directory ? { directory } : {}),
       headers: getOpenCodeAuthHeaders(),
     });
+    void directory;
     return loadConnectedCatalog(client);
   });
 

package/server/lib/small-model/opencode-session.js

@@ -2,17 +2,18 @@ import fs from 'fs';
 import fsPromises from 'fs/promises';
 import os from 'os';
 import path from 'path';
-import { createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { OpenCode } from '@opencode/client';
 
-// Temporary OpenCode session path for providers that lack a dedicated
-// small-model adapter (plugin providers, region/credential-chain, …).
+// Temporary OpenCode path for providers that lack a dedicated small-model
+// adapter (plugin providers, region/credential-chain, …).
 // Auth, endpoint rewrite, and token refresh stay inside the OpenCode runtime.
+//
+// Prefer official `generate.text` (no session). The deny-all agent markdown in
+// the lazy temp directory remains available if a future caller needs a session
+// workspace, but pure-text small-model calls must not open coding sessions.
 
 export const SMALL_MODEL_AGENT_NAME = 'openchamber-smallmodel';
 export const SESSION_SETTLE_TIMEOUT_MS = 60_000;
-const SESSION_SETTLE_POLL_MS = 1_000;
-const ARCHIVE_RETRY_MS = 25;
-const INCOMPLETE_ASSISTANT_SETTLE_PROBES = 2;
 
 const AGENT_MARKDOWN = `---
 mode: primary
@@ -31,64 +32,9 @@ let tempDirectory = null;
 /** @type {Promise<string> | null} */
 let tempDirectoryInflight = null;
 
-const isMissing = (result) =>
-  result?.error?.status === 404
-  || result?.error?.statusCode === 404
-  || result?.error?.code === 'not_found'
-  || result?.status === 404;
-
-const promptAdmitted = (result) =>
-  !result?.error
-  && (result?.response?.status === 204
-    || result?.status === 204
-    || result?.data !== undefined
-    || result?.response?.ok === true);
-
-const sleep = (ms, signal) => new Promise((resolve, reject) => {
-  if (signal?.aborted) {
-    reject(signal.reason instanceof Error ? signal.reason : new Error('aborted'));
-    return;
-  }
-  const timer = setTimeout(resolve, ms);
-  const onAbort = () => {
-    clearTimeout(timer);
-    reject(signal.reason instanceof Error ? signal.reason : new Error('aborted'));
-  };
-  signal?.addEventListener?.('abort', onAbort, { once: true });
-});
-
-const sdkErrorMessage = (result, fallback) => {
-  const status = result?.error?.status ?? result?.error?.statusCode ?? result?.status;
-  const message = result?.error?.message || result?.error?.data?.message || fallback;
-  return status ? `${message} (${status})` : message;
-};
-
-const readMessageInfo = (message) => {
-  if (!message || typeof message !== 'object') return null;
-  if (message.info && typeof message.info === 'object') return message.info;
-  return message;
-};
-
-const assistantTextFromMessages = (messages) => {
-  if (!Array.isArray(messages) || messages.length === 0) return '';
-  for (let i = messages.length - 1; i >= 0; i -= 1) {
-    const message = messages[i];
-    const info = readMessageInfo(message);
-    if (info?.role !== 'assistant') continue;
-    if (info.error) {
-      const detail = typeof info.error === 'string'
-        ? info.error
-        : (info.error?.message || JSON.stringify(info.error));
-      throw new Error(`OpenCode small-model session assistant error: ${detail}`);
-    }
-    const parts = Array.isArray(message?.parts) ? message.parts : [];
-    const text = parts
-      .map((part) => (part?.type === 'text' && typeof part.text === 'string' ? part.text : ''))
-      .filter(Boolean)
-      .join('');
-    return text;
-  }
-  return '';
+const clientErrorMessage = (error, fallback) => {
+  if (typeof error?.message === 'string' && error.message.trim()) return error.message;
+  return fallback;
 };
 
 const ensureTempDirectory = async () => {
@@ -112,100 +58,16 @@ const ensureTempDirectory = async () => {
   return tempDirectoryInflight;
 };
 
-const createClient = ({ buildOpenCodeUrl, getOpenCodeAuthHeaders, directory }) => {
+const createClient = ({ buildOpenCodeUrl, getOpenCodeAuthHeaders }) => {
   const baseUrl = buildOpenCodeUrl('/', '').replace(/\/$/, '');
-  return createOpencodeClient({
+  return OpenCode.make({
     baseUrl,
-    directory,
     headers: getOpenCodeAuthHeaders(),
   });
 };
 
-const archiveCreatedSession = async (client, sessionID, directory) => {
-  const archiveAt = Date.now();
-  const update = () => client.session.update({
-    sessionID,
-    directory,
-    time: { archived: archiveAt },
-  });
-  let result = await update();
-  if (isMissing(result)) {
-    await sleep(ARCHIVE_RETRY_MS);
-    result = await update();
-  }
-  if (result?.error || isMissing(result)) {
-    throw new Error(`OpenCode small-model session archive failed: ${sdkErrorMessage(result, 'archive failed')}`);
-  }
-};
-
-const waitForIdleAssistant = async ({ client, sessionID, directory, signal }) => {
-  let incompleteAssistantProbes = 0;
-  let emptyIdleProbes = 0;
-
-  for (;;) {
-    signal?.throwIfAborted?.();
-
-    let sessionBusy = false;
-    try {
-      const statusResult = await client.session.status({ directory }, { signal });
-      if (!statusResult?.error && statusResult?.data && typeof statusResult.data === 'object') {
-        const statusValue = statusResult.data[sessionID];
-        const type = statusValue?.type ?? statusValue?.status;
-        sessionBusy = type === 'busy' || type === 'retry';
-      }
-    } catch (error) {
-      if (signal?.aborted) throw error;
-    }
-
-    if (sessionBusy) {
-      incompleteAssistantProbes = 0;
-      emptyIdleProbes = 0;
-      await sleep(SESSION_SETTLE_POLL_MS, signal);
-      continue;
-    }
-
-    try {
-      const messagesResult = await client.session.messages({
-        sessionID,
-        directory,
-        limit: 20,
-      }, { signal });
-      if (!messagesResult?.error && Array.isArray(messagesResult?.data)) {
-        const lastInfo = readMessageInfo(messagesResult.data.at(-1));
-        if (lastInfo?.role === 'assistant') {
-          emptyIdleProbes = 0;
-          if (lastInfo.error) {
-            const detail = typeof lastInfo.error === 'string'
-              ? lastInfo.error
-              : (lastInfo.error?.message || JSON.stringify(lastInfo.error));
-            throw new Error(`OpenCode small-model session assistant error: ${detail}`);
-          }
-          if (lastInfo.time?.completed) {
-            return messagesResult.data;
-          }
-          incompleteAssistantProbes += 1;
-          if (incompleteAssistantProbes >= INCOMPLETE_ASSISTANT_SETTLE_PROBES) {
-            return messagesResult.data;
-          }
-        } else {
-          incompleteAssistantProbes = 0;
-          emptyIdleProbes += 1;
-          if (emptyIdleProbes >= 5 && lastInfo?.role === 'user') {
-            throw new Error('OpenCode small-model session ended without assistant response');
-          }
-        }
-      }
-    } catch (error) {
-      if (signal?.aborted) throw error;
-      if (error instanceof Error && error.message.startsWith('OpenCode small-model')) throw error;
-    }
-
-    await sleep(SESSION_SETTLE_POLL_MS, signal);
-  }
-};
-
 /**
- * Generate text via a throwaway OpenCode session (deny-all hidden agent).
+ * Generate text via official OpenCode `generate.text`.
  * Errors are never masked as empty success.
  *
  * @param {{
@@ -217,6 +79,7 @@ const waitForIdleAssistant = async ({ client, sessionID, directory, signal }) =>
  *   system?: string,
  *   purpose?: string,
  *   directory?: string,
+ *   settleTimeoutMs?: number,
  * }} options
  */
 export async function generateViaOpenCodeSession({
@@ -226,7 +89,8 @@ export async function generateViaOpenCodeSession({
   modelID,
   prompt,
   system,
-  purpose,
+  purpose: _purpose,
+  directory,
   settleTimeoutMs = SESSION_SETTLE_TIMEOUT_MS,
 }) {
   if (typeof prompt !== 'string' || !prompt.trim()) {
@@ -236,79 +100,59 @@ export async function generateViaOpenCodeSession({
     throw new Error('OpenCode small-model session requires providerID and modelID');
   }
 
-  const purposeLabel = typeof purpose === 'string' && purpose.trim() ? purpose.trim() : 'utility';
   const budgetMs = Number(settleTimeoutMs) > 0 ? Number(settleTimeoutMs) : SESSION_SETTLE_TIMEOUT_MS;
-  const workingDirectory = await ensureTempDirectory();
+  // Keep the deny-all agent workspace warm for isolation invariants / future
+  // session needs, but pure text uses generate.text (no coding session).
+  await ensureTempDirectory();
+
   const client = createClient({
     buildOpenCodeUrl,
     getOpenCodeAuthHeaders,
-    directory: workingDirectory,
   });
 
-  let sessionID = null;
+  const locationDirectory = typeof directory === 'string' && directory.trim()
+    ? directory.trim()
+    : null;
+  const location = locationDirectory ? { directory: locationDirectory } : undefined;
+
+  const fullPrompt = [
+    typeof system === 'string' && system.trim() ? system.trim() : '',
+    prompt.trim(),
+  ].filter(Boolean).join('\n\n');
+
   const controller = new AbortController();
   const timeout = setTimeout(() => {
-    controller.abort(new Error(`OpenCode small-model session timed out after ${budgetMs}ms`));
+    controller.abort(new Error(`OpenCode small-model generate timed out after ${budgetMs}ms`));
   }, budgetMs);
 
   try {
-    const createResult = await client.session.create({
-      directory: workingDirectory,
-      title: `[small-model] ${purposeLabel}`,
-      agent: SMALL_MODEL_AGENT_NAME,
-      metadata: {
-        openchamber: {
-          smallModel: { purpose: purposeLabel },
-        },
-      },
-    }, { signal: controller.signal });
-
-    sessionID = createResult?.data?.id;
-    if (createResult?.error || !sessionID) {
-      throw new Error(`OpenCode small-model session create failed: ${sdkErrorMessage(createResult, 'create failed')}`);
-    }
-
-    // Archive before prompting so ordinary session lists never flash system sessions.
-    await archiveCreatedSession(client, sessionID, workingDirectory);
-
-    const promptResult = await client.session.promptAsync({
-      sessionID,
-      directory: workingDirectory,
-      agent: SMALL_MODEL_AGENT_NAME,
-      model: { providerID, modelID },
-      ...(typeof system === 'string' && system.trim() ? { system: system.trim() } : {}),
-      parts: [{ type: 'text', text: prompt, synthetic: false }],
-    }, { signal: controller.signal });
-
-    if (!promptAdmitted(promptResult)) {
-      throw new Error(`OpenCode small-model prompt_async failed: ${sdkErrorMessage(promptResult, 'prompt_async failed')}`);
+    let result;
+    try {
+      result = await client.generate.text({
+        ...(location ? { location } : {}),
+        prompt: fullPrompt,
+        model: { id: modelID, providerID },
+      }, { signal: controller.signal });
+    } catch (error) {
+      if (controller.signal.aborted) {
+        throw controller.signal.reason instanceof Error
+          ? controller.signal.reason
+          : new Error(`OpenCode small-model generate timed out after ${budgetMs}ms`);
+      }
+      throw new Error(
+        `OpenCode small-model generate.text failed: ${clientErrorMessage(error, 'generate.text failed')}`,
+      );
     }
 
-    const messages = await waitForIdleAssistant({
-      client,
-      sessionID,
-      directory: workingDirectory,
-      signal: controller.signal,
-    });
-    const text = assistantTextFromMessages(messages);
+    const text = typeof result?.text === 'string' ? result.text : '';
     if (!text.trim()) {
-      throw new Error('OpenCode small-model session returned no assistant text');
+      throw new Error('OpenCode small-model generate.text returned no assistant text');
     }
     return text;
   } finally {
     clearTimeout(timeout);
-    if (sessionID) {
-      try {
-        await client.session.delete({ sessionID, directory: workingDirectory });
-      } catch (error) {
-        console.warn(
-          '[small-model] failed to delete temporary OpenCode session:',
-          error?.message || error,
-        );
-      }
-    }
   }
-};
+}
 
 /** Best-effort cleanup of the lazy temp directory (agent markdown + empty root). */
 export async function stop() {