@vantran-se/openchamber-web 1.24.3 → 2.0.1

package/server/lib/session-assist/context.test.js

@@ -1,40 +1,57 @@
 import { describe, expect, it } from 'vitest';
-import { excerpt, loadAssistContext } from './context.js';
+import { excerpt, loadAssistContext, newestContentId } from './context.js';
 import { buildAssistPrompt } from './prompt.js';
 
-const record = (id, role, text, extra = {}, parts = []) => ({
-  info: { id, role, parentID: 'user', finish: 'stop', time: { completed: 1 }, providerID: 'provider', modelID: 'model', ...extra },
-  parts: [...(text ? [{ type: 'text', text }] : []), ...parts],
+// v2 message records are flat and a page lists them newest first.
+const user = (id, text, extra = {}) => ({ id, type: 'user', text, ...extra });
+const assistant = (id, text, extra = {}) => ({
+  id,
+  type: 'assistant',
+  content: text ? [{ type: 'text', text }] : [],
+  finish: 'stop',
+  time: { completed: 1 },
+  model: { providerID: 'provider', id: 'model' },
+  ...extra,
 });
-const pair = (id) => [record(`u${id}`, 'user', `request ${id}`), record(`a${id}`, 'assistant', `answer ${id}`, { parentID: `u${id}` })];
-const page = (data, cursor = '') => ({ data, response: { headers: new Headers({ 'x-next-cursor': cursor }) } });
+const synthetic = (id, text, extra = {}) => ({ id, type: 'synthetic', text, ...extra });
+// OpenCode closes every turn with an idle marker; a switch is appended when
+// the user changes model or agent between turns.
+const idle = (id, outcome = 'succeeded') => ({ id, type: 'idle', outcome, time: { created: 2 } });
+const modelSwitch = (id) => ({ id, type: 'model-switched', model: { providerID: 'p', id: 'm' } });
+
+const pair = (id) => [user(`u${id}`, `request ${id}`), assistant(`a${id}`, `answer ${id}`)];
+
+/** `data` is given oldest-first here and reversed, the way OpenCode serves it. */
+const page = (data, next = null) => ({ data: [...data].reverse(), cursor: next ? { next } : {} });
 const load = (readPage) => loadAssistContext({ readPage, signal: new AbortController().signal });
 
 describe('session assist context', () => {
   it('stops paging at three human turns and excludes tools and injected instructions', async () => {
     let calls = 0;
     const records = [...pair(1), ...pair(2), ...pair(3), ...pair(4)];
-    records.at(-1).parts.push({ type: 'tool', state: { output: 'TOOL_PAYLOAD' } }, { type: 'text', synthetic: true, text: 'INJECTED_PROMPT' });
-    const context = await load(async ({ limit, before }) => {
+    records.at(-1).content.push(
+      { type: 'tool', tool: 'bash', state: { output: 'TOOL_PAYLOAD' } },
+    );
+    const context = await load(async ({ limit, cursor }) => {
       calls++;
       expect(limit).toBe(50);
-      expect(before).toBeUndefined();
+      expect(cursor).toBeUndefined();
       return page(records, 'more');
     });
     expect(calls).toBe(1);
     expect(context.turns.map((t) => t.user.id)).toEqual(['u2', 'u3', 'u4']);
     expect(context.last.text).toBe('answer 4');
     expect(JSON.stringify(context)).not.toContain('TOOL_PAYLOAD');
-    expect(JSON.stringify(context)).not.toContain('INJECTED_PROMPT');
   });
 
-  it('finds the real user across a page boundary and compaction continuations', async () => {
-    const summary = record('summary', 'assistant', 'INTERNAL SUMMARY', { summary: true });
-    const continuation = record('continuation', 'user', '', {}, [{ type: 'text', synthetic: true, text: 'Continue' }]);
-    const final = record('final', 'assistant', 'All requested work done', { parentID: 'continuation' });
-    const context = await load(async ({ before }) => before
-      ? page([...pair(1), ...pair(2), record('human', 'user', 'Finish the requested work')])
-      : page([summary, continuation, final], 'older'));
+  it('finds the real user across a page boundary and past a compaction', async () => {
+    // v2 gives compaction its own message role instead of an assistant message
+    // flagged `summary`.
+    const compaction = { id: 'summary', type: 'compaction', status: 'completed', summary: 'INTERNAL SUMMARY' };
+    const final = assistant('final', 'All requested work done');
+    const context = await load(async ({ cursor }) => (cursor
+      ? page([...pair(1), ...pair(2), user('human', 'Finish the requested work')])
+      : page([compaction, final], 'older')));
     expect(context.last.id).toBe('final');
     expect(context.turns.at(-1).user.id).toBe('human');
     expect(context.turns.at(-1).assistant.id).toBe('final');
@@ -43,8 +60,8 @@ describe('session assist context', () => {
 
   it('retains interrupted requests as progress, not as completed turns', async () => {
     const context = await load(async () => page([
-      record('u1', 'user', 'Implement both fixes'),
-      record('a1', 'assistant', 'First fix done', { finish: 'tool-calls', parentID: 'u1' }),
+      user('u1', 'Implement both fixes'),
+      assistant('a1', 'First fix done', { finish: 'tool-calls' }),
       ...pair(2),
     ]));
     expect(context.turns[0].complete).toBe(false);
@@ -52,22 +69,31 @@ describe('session assist context', () => {
     expect(context.turns[1].complete).toBe(true);
   });
 
-  it('keeps synthetic annotations and separates author language from quoted material', async () => {
-    const user = record('u', 'user', '', {}, [{
-      type: 'text', synthetic: true, text: 'Serialized attachment',
+  it('folds an attached synthetic into the user message it belongs to', async () => {
+    // v1 carried an attachment as a synthetic part of the user message; v2
+    // sends it as its own turn just before the prompt.
+    const attachment = synthetic('s', 'Serialized attachment', {
       metadata: { openchamberContext: { kind: 'chat-quote', quote: 'English quoted source', text: 'Виправ саме це' } },
-    }]);
-    const context = await load(async () => page([user, record('a', 'assistant', 'Done', { parentID: 'u' })]));
+    });
+    const context = await load(async () => page([attachment, user('u', 'Fix it'), assistant('a', 'Done')]));
+    expect(context.turns).toHaveLength(1);
     expect(context.turns[0].user.text).toContain('> English quoted source');
     expect(context.turns[0].user.text).toContain('User comment:\nВиправ саме це');
-    expect(context.turns[0].user.authored).toBe('Виправ саме це');
+    expect(context.turns[0].user.text).toContain('Fix it');
+    expect(context.turns[0].user.authored).toContain('Виправ саме це');
   });
 
   it('retains the comment after a large quote and the conclusion after a long answer', async () => {
-    const user = record('u', 'user', '', {}, [{ type: 'text', synthetic: true, text: 'attachment', metadata: {
-      openchamberContext: { kind: 'browser-annotation', prompt: 'x'.repeat(30_000), text: 'USER_REQUEST_END' },
-    } }]);
-    const context = await load(async () => page([user, record('a', 'assistant', `START${'x'.repeat(30_000)}CONCLUSION`, { parentID: 'u' })]));
+    const attachment = synthetic('s', 'attachment', {
+      metadata: {
+        openchamberContext: { kind: 'browser-annotation', prompt: 'x'.repeat(30_000), text: 'USER_REQUEST_END' },
+      },
+    });
+    const context = await load(async () => page([
+      attachment,
+      user('u', 'Look at this'),
+      assistant('a', `START${'x'.repeat(30_000)}CONCLUSION`),
+    ]));
     expect(context.turns[0].user.text).toContain('USER_REQUEST_END');
     expect(context.last.text).toMatch(/^START/);
     expect(context.last.text).toMatch(/CONCLUSION$/);
@@ -75,10 +101,10 @@ describe('session assist context', () => {
   });
 
   it('fails explicitly on malformed annotation text instead of losing the comment', async () => {
-    const user = record('u', 'user', '', {}, [{ type: 'text', synthetic: true, text: 'attachment', metadata: {
-      openchamberContext: { kind: 'chat-quote', quote: 'source', text: 42 },
-    } }]);
-    await expect(load(async () => page([user, record('a', 'assistant', 'done')]))).rejects.toThrow();
+    const attachment = synthetic('s', 'attachment', {
+      metadata: { openchamberContext: { kind: 'chat-quote', quote: 'source', text: 42 } },
+    });
+    await expect(load(async () => page([attachment, user('u', 'Fix'), assistant('a', 'done')]))).rejects.toThrow();
   });
 
   it('does not treat a failed or repeated page as complete history', async () => {
@@ -93,24 +119,68 @@ describe('session assist context', () => {
 
   it('bounds retrieval and refuses to invent a user for an orphaned answer', async () => {
     let calls = 0;
-    const context = await load(async () => page([record(`a${++calls}`, 'assistant', 'answer')], `cursor${calls}`));
+    const context = await load(async () => page([assistant(`a${++calls}`, 'answer')], `cursor${calls}`));
     expect(calls).toBe(8);
     expect(context).toBeNull();
   });
 
-  it('skips unfinished, failed, summary, and user tails', async () => {
+  it('looks past the idle marker that closes a finished turn', async () => {
+    // The ordinary v2 transcript: answer, then `idle`, possibly followed by a
+    // switch the user made afterwards. The answer is still the last message.
+    for (const tail of [[idle('i')], [idle('i'), modelSwitch('m')], [modelSwitch('m'), idle('i')]]) {
+      const context = await load(async () => page([...pair(1), ...tail]));
+      expect(context?.last.id).toBe('a1');
+      expect(context.turns).toHaveLength(1);
+      expect(context.turns[0].assistant.id).toBe('a1');
+    }
+  });
+
+  it('keeps an attachment glued to its prompt across a switch, and a turn across an idle', async () => {
+    const attachment = synthetic('s', 'Attached note');
+    const context = await load(async () => page([
+      ...pair(1), idle('i1'),
+      attachment, modelSwitch('m'), user('u2', 'Use the note'), assistant('a2', 'Used'), idle('i2'),
+    ]));
+    expect(context.turns.map((turn) => turn.user.id)).toEqual(['u1', 'u2']);
+    expect(context.turns[1].user.text).toBe('Attached note\n\nUse the note');
+    expect(context.turns[0].complete).toBe(true);
+  });
+
+  it('treats a failed or interrupted idle as evidence the turn did not finish', async () => {
+    for (const outcome of ['failed', 'interrupted']) {
+      expect(await load(async () => page([...pair(1), idle('i', outcome)]))).toBeNull();
+    }
+  });
+
+  it('keeps paging when a page holds only service records', async () => {
+    const context = await load(async ({ cursor }) => (cursor
+      ? page([...pair(1)])
+      : page([idle('i1'), modelSwitch('m'), idle('i2')], 'older')));
+    expect(context?.last.id).toBe('a1');
+  });
+
+  it('names the newest content record of a newest-first page', () => {
+    expect(newestContentId([idle('i'), modelSwitch('m'), assistant('a', 'x'), user('u', 'y')])).toBe('a');
+    expect(newestContentId([idle('i', 'failed'), assistant('a', 'x')])).toBe('i');
+    expect(newestContentId([idle('i')])).toBeNull();
+    expect(newestContentId(undefined)).toBeNull();
+  });
+
+  it('skips unfinished, failed, compaction, and user tails', async () => {
     for (const tail of [
-      record('tail', 'user', 'New request'),
-      record('tail', 'assistant', 'Working', { finish: 'tool-calls' }),
-      record('tail', 'assistant', 'Failed', { error: { name: 'error' } }),
-      record('tail', 'assistant', 'Summary', { summary: true }),
+      user('tail', 'New request'),
+      assistant('tail', 'Working', { finish: 'tool-calls' }),
+      assistant('tail', 'Failed', { error: { type: 'APIError', message: 'boom' } }),
+      { id: 'tail', type: 'compaction', status: 'completed', summary: 'Summary' },
     ]) expect(await load(async () => page([...pair(1), tail]))).toBeNull();
   });
 
   it('keeps both sides of the newest exchange within a small model budget', async () => {
     const context = await load(async () => page([
-      ...pair(1), ...pair(2), record('latest', 'user', `REQUEST_START${'u'.repeat(8000)}REQUEST_END`),
-      record('answer', 'assistant', `ANSWER_START${'a'.repeat(16000)}ANSWER_END`, { parentID: 'latest' }),
+      ...pair(1),
+      ...pair(2),
+      user('latest', `REQUEST_START${'u'.repeat(8000)}REQUEST_END`),
+      assistant('answer', `ANSWER_START${'a'.repeat(16000)}ANSWER_END`),
     ]));
     for (const budget of [1_000, 4_000, 14_000, 32_000, 1_000_000]) {
       const prompt = buildAssistPrompt(context.turns, { recap: true, suggestion: true }, budget);
@@ -118,15 +188,13 @@ describe('session assist context', () => {
       for (const marker of ['REQUEST_START', 'REQUEST_END', 'ANSWER_START', 'ANSWER_END']) expect(prompt.text).toContain(marker);
     }
     expect(buildAssistPrompt(context.turns, { recap: true }, 500)).toBeNull();
-    expect(excerpt('long text', 0)).toBe('');
-    expect(excerpt('long text', 2)).toBe('lo');
-    for (let limit = 0; limit < 60; limit++) expect(excerpt('x'.repeat(100), limit).length).toBeLessThanOrEqual(limit);
   });
 
-  it('does not assign an older parent\'s late answer to a newer user request', async () => {
-    expect(await load(async () => page([
-      ...pair(1), record('new-user', 'user', 'A different request'),
-      record('late-answer', 'assistant', 'Old work done', { parentID: 'u1' }),
-    ]))).toBeNull();
+  it('excerpts from both ends so the start and the end both survive', () => {
+    expect(excerpt('abcdef', 10)).toBe('abcdef');
+    const trimmed = excerpt(`START${'x'.repeat(500)}END`, 100);
+    expect(trimmed.length).toBeLessThanOrEqual(100);
+    expect(trimmed).toMatch(/^START/);
+    expect(trimmed).toMatch(/END$/);
   });
 });

package/server/lib/session-assist/runtime.js

@@ -3,9 +3,9 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
-import { createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { OpenCode } from '@opencode/client';
 import { readMergedSettingsSync } from '../opencode/settings-files.js';
-import { loadAssistContext } from './context.js';
+import { loadAssistContext, newestContentId } from './context.js';
 import { buildAssistPrompt, buildAssistSystemPrompt } from './prompt.js';
 
 const OPENCHAMBER_SETTINGS_FILE = path.join(
@@ -28,6 +28,8 @@ const RECAP_CHAR_LIMIT = 320;
 const SUGGESTION_CHAR_LIMIT = 500;
 const FETCH_TIMEOUT_MS = 5_000;
 const GENERATION_TIMEOUT_MS = 120_000;
+// Enough records to look past the idle marker and a couple of switches.
+const TAIL_RECHECK_LIMIT = 8;
 const QUIET_FAILURE_CODES = new Set(['context-too-small', 'output-exhausted']);
 
 const extractJsonObject = (value) => {
@@ -77,12 +79,22 @@ const extractUserMessage = (payload) => {
   };
 };
 
+/**
+ * The recap and the suggestion live in OpenChamber's own session metadata
+ * store: OpenCode 2.x accepts session metadata only when a session is created.
+ * `persistSessionAssist(sessionID, directory, assist)` writes it; without that
+ * seam the runtime stays inert rather than generating text it cannot save.
+ */
 export const createSessionAssistRuntime = ({
   buildOpenCodeUrl,
   getOpenCodeAuthHeaders,
   getSmallModelService,
   getTargets = getSessionAssistTargets,
   quietMs = IDLE_QUIET_MS,
+  persistSessionAssist = null,
+  // Archive state is OpenChamber's own in v2 (no OpenCode route sets it), so
+  // the runtime asks rather than reading `time.archived` off the record.
+  isSessionArchived = async () => false,
 }) => {
   const timers = new Map();
   const inflight = new Map();
@@ -107,20 +119,32 @@ export const createSessionAssistRuntime = ({
     const targets = getTargets();
     if (!targets.recap && !targets.suggestion) return;
     const baseUrl = buildOpenCodeUrl('/', '').replace(/\/$/, '');
-    const client = createOpencodeClient({ baseUrl, headers: getOpenCodeAuthHeaders(), throwOnError: true });
+    const client = OpenCode.make({
+      baseUrl,
+      headers: {
+        ...getOpenCodeAuthHeaders(),
+        // v2 scopes by header and rejects non-ASCII header values.
+        ...(directory ? { 'x-opencode-directory': encodeURIComponent(directory) } : {}),
+      },
+    });
     const requestOptions = () => ({ signal: AbortSignal.any([signal, AbortSignal.timeout(FETCH_TIMEOUT_MS)]) });
     const checkCurrent = () => {
       signal.throwIfAborted();
       if (buildOpenCodeUrl('/', '').replace(/\/$/, '') !== baseUrl) throw new Error('Session assist runtime changed');
     };
-    const { data: session } = await client.session.get({ sessionID: sessionId, directory }, requestOptions());
+    const session = await client.session.get({ sessionID: sessionId }, requestOptions());
     checkCurrent();
     // Reverted history is not the active conversation. A new prompt clears
     // the revert boundary before its next idle event.
-    if (session?.id !== sessionId || session.parentID || session.revert?.messageID || session.time?.archived) return;
+    if (session?.id !== sessionId || session.parentID || session.revert?.messageID) return;
+    // An archived session is put away: no recap or suggestion is generated for it.
+    if (await isSessionArchived(sessionId)) return;
     const context = await loadAssistContext({
       signal,
-      readPage: (page) => client.session.messages({ sessionID: sessionId, directory, ...page }, requestOptions()),
+      readPage: ({ limit, cursor }) => client.message.list(
+        { sessionID: sessionId, limit, ...(cursor ? { cursor } : { order: 'desc' }) },
+        requestOptions(),
+      ),
     });
     checkCurrent();
     if (!context) return;
@@ -160,30 +184,28 @@ export const createSessionAssistRuntime = ({
     if (recap && scriptMismatch(recap)) recap = '';
     if (suggestion && scriptMismatch(suggestion)) suggestion = '';
     if (!recap && !suggestion) return;
-    const { data: latest } = await client.session.messages({ sessionID: sessionId, directory, limit: 1 }, requestOptions());
+    // v2 lists newest first. The answer is followed by its `idle` marker and
+    // possibly a model or agent switch, so read a short tail and compare the
+    // newest content record rather than the newest record.
+    const latestPage = await client.message.list({ sessionID: sessionId, limit: TAIL_RECHECK_LIMIT, order: 'desc' }, requestOptions());
     checkCurrent();
-    if (latest?.at(-1)?.info.id !== last.id) return;
+    if (newestContentId(latestPage?.data) !== last.id) return;
     // Never fall back to the pre-generation metadata snapshot after a failed
     // fresh read: doing so overwrites dismissals and unrelated metadata.
-    const { data: freshSession } = await client.session.get({ sessionID: sessionId, directory }, requestOptions());
+    const freshSession = await client.session.get({ sessionID: sessionId }, requestOptions());
     checkCurrent();
-    if (freshSession?.id !== sessionId || freshSession.revert?.messageID || freshSession.time?.archived || freshSession.directory !== session.directory) return;
+    if (freshSession?.id !== sessionId || freshSession.revert?.messageID || freshSession.location?.directory !== session.location?.directory) return;
+    if (await isSessionArchived(sessionId)) return;
     const enabled = getTargets();
     if (!enabled.recap) recap = '';
     if (!enabled.suggestion) suggestion = '';
     if (!recap && !suggestion) return;
-    const currentMetadata = freshSession.metadata ?? {};
-    const currentNamespace = currentMetadata.openchamber ?? {};
-    await client.session.update({
-      sessionID: sessionId, directory,
-      metadata: {
-        ...currentMetadata,
-        openchamber: {
-          ...currentNamespace,
-          assist: { recap, suggestion, forMessageID: last.id, generatedAt: Date.now() },
-        },
-      },
-    }, requestOptions());
+    await persistSessionAssist(sessionId, directory, {
+      recap,
+      suggestion,
+      forMessageID: last.id,
+      generatedAt: Date.now(),
+    });
   };
 
   const startGeneration = (sessionId, directory, armedAt) => {
@@ -219,8 +241,16 @@ export const createSessionAssistRuntime = ({
     timers.set(sessionId, { timer, armedAt });
   };
 
+  let parkedNoticeLogged = false;
   const processPayload = (payload, directoryHint = '') => {
     if (stopped) return;
+    if (typeof persistSessionAssist !== 'function') {
+      if (!parkedNoticeLogged) {
+        parkedNoticeLogged = true;
+        console.log('[session-assist] parked: no session metadata store is wired, so a recap could not be saved');
+      }
+      return;
+    }
     const status = extractSessionStatus(payload);
     if (status) {
       if (status.type === 'idle') armTimer(status.sessionId, status.directory || directoryHint);