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

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

@@ -18,6 +18,10 @@ import {
   projectSlimParts,
   SLIM_PARTS_PROJECTION,
 } from './service.js';
+import {
+  projectSessionMessage,
+  projectSessionMessageRecords as projectRecords,
+} from './session-message-projection.js';
 
 const TURNS_MIN = 1;
 const TURNS_MAX = 10;
@@ -210,103 +214,6 @@ const requestSignal = (req, res) => {
   return controller.signal;
 };
 
-/**
- * Native SessionMessageInfo carrier fields that become `parts`.
- * Must not remain on `info` after normalize — otherwise
- * includeReasoning=false can strip parts while leaking content/text.
- */
-const MESSAGE_PART_CARRIER_KEYS = new Set(['content', 'text', 'files', 'parts', 'agents', 'skills']);
-
-const stripMessagePartCarriers = (value) => {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return value;
-  let changed = false;
-  const next = {};
-  for (const [key, field] of Object.entries(value)) {
-    if (MESSAGE_PART_CARRIER_KEYS.has(key)) {
-      changed = true;
-      continue;
-    }
-    next[key] = field;
-  }
-  return changed ? next : value;
-};
-
-/**
- * Project SessionMessageInfo (or an already-projected {info, parts} row)
- * into the host HTTP DTO. External route contract stays {info, parts}.
- */
-const projectV2Parts = (entry) => {
-  if (Array.isArray(entry?.parts)) return entry.parts;
-  const messageID = typeof entry?.id === 'string' ? entry.id : '';
-  const sessionID = typeof entry?.sessionID === 'string' ? entry.sessionID : '';
-  const parts = [];
-  if (typeof entry?.text === 'string' && entry.text) {
-    parts.push({ id: `${messageID}:text`, sessionID, messageID, type: 'text', text: entry.text });
-  }
-  if (Array.isArray(entry?.files)) {
-    entry.files.forEach((file, index) => {
-      parts.push({
-        id: `${messageID}:file:${index}`,
-        sessionID,
-        messageID,
-        type: 'file',
-        mime: file?.mime || 'application/octet-stream',
-        url: file?.uri ?? file?.url,
-        ...(file?.name ? { filename: file.name } : {}),
-      });
-    });
-  }
-  if (Array.isArray(entry?.content)) {
-    entry.content.forEach((item, index) => {
-      const partID = item?.id || `${messageID}:content:${index}`;
-      if (item?.type === 'text') {
-        parts.push({ id: partID, sessionID, messageID, type: 'text', text: item.text ?? '' });
-      } else if (item?.type === 'reasoning') {
-        parts.push({ id: partID, sessionID, messageID, type: 'reasoning', text: item.text ?? '' });
-      } else if (item?.type === 'tool') {
-        parts.push({
-          id: partID,
-          sessionID,
-          messageID,
-          type: 'tool',
-          tool: item.name,
-          callID: item.id,
-          state: item.state ?? {},
-        });
-      }
-    });
-  }
-  return parts;
-};
-
-const projectSessionMessage = (entry) => {
-  if (entry && typeof entry === 'object' && entry.info && typeof entry.info === 'object') {
-    const info = stripMessagePartCarriers(entry.info);
-    return {
-      info: info === entry.info ? entry.info : info,
-      parts: Array.isArray(entry.parts) ? entry.parts : [],
-    };
-  }
-  if (!entry || typeof entry !== 'object' || typeof entry.id !== 'string' || entry.id.length === 0) {
-    return entry;
-  }
-  const role = entry.type === 'user' || entry.type === 'assistant' ? entry.type : (entry.role ?? entry.type);
-  const info = {
-    ...stripMessagePartCarriers(entry),
-    id: entry.id,
-    sessionID: entry.sessionID,
-    role,
-    time: entry.time ?? { created: 0 },
-  };
-  return {
-    info,
-    parts: projectV2Parts(entry),
-  };
-};
-
-const projectRecords = (records) =>
-  (Array.isArray(records) ? records : []).map(projectSessionMessage);
-
 /**
  * Host outbound order: normalize → slim/L1 bounds → reasoning strip.
  * Slim/reasoning must run on `{info, parts}` so native `content` cannot
@@ -327,11 +234,12 @@ const createV2FetchPage = ({ buildOpenCodeUrl, getOpenCodeAuthHeaders, logger })
     const headers = typeof getOpenCodeAuthHeaders === 'function' ? getOpenCodeAuthHeaders() : {};
     const client = makeOpenCodeV2Client({ baseUrl, authHeaders: headers });
 
+    // Upstream rejects `order` together with `cursor` (400); the cursor
+    // already encodes the desc direction of the first page.
     const result = await client.message.list({
       sessionID,
       ...(Number.isFinite(limit) ? { limit } : {}),
-      order: 'desc',
-      ...(typeof before === 'string' && before.length > 0 ? { cursor: before } : {}),
+      ...(typeof before === 'string' && before.length > 0 ? { cursor: before } : { order: 'desc' }),
     }, { signal });
 
     const items = Array.isArray(result?.data) ? result.data : null;
@@ -342,8 +250,8 @@ const createV2FetchPage = ({ buildOpenCodeUrl, getOpenCodeAuthHeaders, logger })
       throw error;
     }
 
-    const previous = result?.cursor?.previous;
-    const nextCursor = typeof previous === 'string' && previous.length > 0 ? previous : null;
+    const next = result?.cursor?.next;
+    const nextCursor = typeof next === 'string' && next.length > 0 ? next : null;
 
     return {
       records: items.slice().reverse(),
@@ -418,7 +326,14 @@ const createSdkFetchMessage = ({ buildOpenCodeUrl, getOpenCodeAuthHeaders, logge
     if (!data || typeof data !== 'object' || Array.isArray(data)) {
       throwUpstream(logger, '[session-turn-pages] session.message malformed payload');
     }
-    return projectSessionMessage(data);
+    const projected = projectSessionMessage(data);
+    // Control rows (idle / model-switched) are not chat messages.
+    if (!projected || !projected.info) {
+      const notFound = new Error('not_found');
+      notFound.code = 'not_found';
+      throw notFound;
+    }
+    return projected;
   };
 };
 

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

@@ -2,6 +2,10 @@ import { describe, expect, it, vi } from 'vitest';
 
 import { makeOpenCodeV2Client } from '../opencode/v2-client.js';
 import { registerSessionTurnPageRoutes } from './routes.js';
+import {
+  projectSessionMessage as projectSessionMessageRecord,
+  projectSessionMessageRecords,
+} from './session-message-projection.js';
 
 vi.mock('../opencode/v2-client.js', () => ({ makeOpenCodeV2Client: vi.fn() }));
 
@@ -33,6 +37,85 @@ const response = () => ({
 
 const ROUTE = '/api/openchamber/sessions/:sessionID/messages';
 
+describe('projectSessionMessageRecord (host SessionMessage → {info, parts})', () => {
+  it('drops idle control and projects two-turn wire without duplicate text', () => {
+    const records = projectSessionMessageRecords([
+      {
+        id: 'msg_u1',
+        type: 'user',
+        time: { created: 1 },
+        text: 'UI-E2E-FINAL-BUILD',
+        sessionID: 'ses_1',
+      },
+      {
+        id: 'msg_a1',
+        type: 'assistant',
+        time: { created: 2, completed: 3 },
+        sessionID: 'ses_1',
+        agent: 'build',
+        model: { id: 'glm-5.3-flash', providerID: 'zai-coding-plan', variant: 'default' },
+        content: [
+          { type: 'reasoning', text: 'think' },
+          { type: 'text', text: 'FINAL_BUILD_OK' },
+        ],
+        finish: 'stop',
+        rawFinish: 'stop',
+      },
+      {
+        id: 'msg_u2',
+        type: 'user',
+        time: { created: 4 },
+        text: 'UI-E2E-FINAL-FOLLOWUP',
+        sessionID: 'ses_1',
+      },
+      {
+        id: 'msg_a2',
+        type: 'assistant',
+        time: { created: 5, completed: 6 },
+        sessionID: 'ses_1',
+        agent: 'build',
+        model: { id: 'glm-5.3-flash', providerID: 'zai-coding-plan', variant: 'default' },
+        text: 'FINAL_FOLLOWUP_OK',
+        content: [
+          { type: 'reasoning', text: 'think2' },
+          { type: 'text', text: 'FINAL_FOLLOWUP_OK' },
+        ],
+        finish: 'stop',
+      },
+      {
+        id: 'msg_idle',
+        type: 'idle',
+        outcome: 'succeeded',
+        time: { created: 7 },
+      },
+    ]);
+
+    expect(records.map((row) => [row.info.role, row.info.id])).toEqual([
+      ['user', 'msg_u1'],
+      ['assistant', 'msg_a1'],
+      ['user', 'msg_u2'],
+      ['assistant', 'msg_a2'],
+    ]);
+    expect(projectSessionMessageRecord({
+      id: 'msg_idle2',
+      type: 'idle',
+      outcome: 'failed',
+      time: { created: 1 },
+    })).toBeNull();
+
+    const follow = records[3];
+    expect(follow.parts.filter((part) => part.type === 'text')).toHaveLength(1);
+    expect(follow.parts.find((part) => part.type === 'text').text).toBe('FINAL_FOLLOWUP_OK');
+    expect(follow.info.model).toEqual({
+      providerID: 'zai-coding-plan',
+      modelID: 'glm-5.3-flash',
+      variant: 'default',
+    });
+    expect(follow.info.type).toBeUndefined();
+    expect(follow.info.rawFinish).toBeUndefined();
+  });
+});
+
 describe('registerSessionTurnPageRoutes', () => {
   it('registers GET /api/openchamber/sessions/:sessionID/messages', () => {
     const { app, route } = registry();
@@ -737,6 +820,204 @@ describe('registerSessionTurnPageRoutes', () => {
     ]);
   });
 
+  it('default fetch continues desc pages with cursor.next only, never order + cursor', async () => {
+    const list = vi.fn()
+      .mockResolvedValueOnce({
+        data: [{ id: 'msg_a2', type: 'assistant', time: { created: 4, completed: 5 }, content: [{ type: 'text', text: 'later' }] }],
+        cursor: { previous: 'raw_prev', next: 'raw_next' },
+      })
+      .mockResolvedValueOnce({
+        data: [
+          { id: 'msg_a1', type: 'assistant', time: { created: 2, completed: 3 }, content: [{ type: 'text', text: 'ok' }] },
+          { id: 'msg_u1', type: 'user', time: { created: 1 }, text: 'hi' },
+        ],
+        cursor: { previous: 'raw_prev_2', next: null },
+      });
+    makeOpenCodeV2Client.mockReturnValue({
+      message: { list },
+      session: { messages: undefined, status: undefined, abort: undefined },
+    });
+    const { app, route } = registry();
+    registerSessionTurnPageRoutes(app, {
+      buildOpenCodeUrl: () => 'http://open.code/',
+      getOpenCodeAuthHeaders: () => ({}),
+    });
+    const res = response();
+    await route('GET', ROUTE)({
+      params: { sessionID: 'ses_1' },
+      query: { turns: '1' },
+      headers: {},
+    }, res);
+
+    expect(list).toHaveBeenCalledTimes(2);
+    expect(list.mock.calls[0][0]).toEqual({ sessionID: 'ses_1', limit: 100, order: 'desc' });
+    expect(list.mock.calls[1][0]).toEqual({ sessionID: 'ses_1', limit: 100, cursor: 'raw_next' });
+    expect(res.statusCode).toBe(200);
+    expect(res.body.complete).toBe(true);
+    expect(res.body.records.map((record) => record.info.id)).toEqual(['msg_u1', 'msg_a1', 'msg_a2']);
+  });
+
+  it('drops v2 idle/control rows and does not double-expand text+content (FINAL-GATE cold reload)', async () => {
+    // Real wire shape from isolated backend hard-reload sessions:
+    // user + assistant(content) + idle outcome=succeeded, and assistants that
+    // occasionally carry both top-level text and content[].text.
+    const list = vi.fn(async () => ({
+      data: [
+        {
+          id: 'msg_idle_ok',
+          time: { created: 4 },
+          type: 'idle',
+          outcome: 'succeeded',
+        },
+        {
+          id: 'msg_a_follow',
+          time: { created: 3, completed: 4 },
+          type: 'assistant',
+          agent: 'build',
+          model: { id: 'glm-5.3-flash', providerID: 'zai-coding-plan', variant: 'default' },
+          // Both carriers present — must project exactly one text part.
+          text: 'FINAL_FOLLOWUP_OK',
+          content: [
+            { type: 'reasoning', text: 'think' },
+            { type: 'text', text: 'FINAL_FOLLOWUP_OK' },
+          ],
+          finish: 'stop',
+          rawFinish: 'stop',
+          cost: 0,
+          tokens: { input: 1, output: 1, reasoning: 1, cache: { read: 0, write: 0 } },
+        },
+        {
+          id: 'msg_u_follow',
+          time: { created: 2 },
+          type: 'user',
+          text: 'UI-E2E-FINAL-FOLLOWUP',
+        },
+        {
+          id: 'msg_a1',
+          time: { created: 1, completed: 2 },
+          type: 'assistant',
+          agent: 'build',
+          model: { id: 'glm-5.3-flash', providerID: 'zai-coding-plan', variant: 'default' },
+          content: [
+            { type: 'reasoning', text: 'first think' },
+            { type: 'text', text: 'FINAL_BUILD_OK' },
+          ],
+          finish: 'stop',
+        },
+        {
+          id: 'msg_u1',
+          time: { created: 0 },
+          type: 'user',
+          text: 'UI-E2E-FINAL-BUILD',
+        },
+      ],
+      cursor: { previous: null, next: null },
+    }));
+    makeOpenCodeV2Client.mockReturnValue({
+      message: { list },
+      session: { messages: undefined, status: undefined, abort: undefined },
+    });
+    const { app, route } = registry();
+    registerSessionTurnPageRoutes(app, {
+      buildOpenCodeUrl: () => 'http://open.code/',
+      getOpenCodeAuthHeaders: () => ({}),
+    });
+    const res = response();
+    await route('GET', ROUTE)({
+      params: { sessionID: 'ses_final_build' },
+      query: { turns: '2' },
+      headers: {},
+    }, res);
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body.records.map((row) => row.info.role)).toEqual([
+      'user',
+      'assistant',
+      'user',
+      'assistant',
+    ]);
+    expect(res.body.records.map((row) => row.info.id)).toEqual([
+      'msg_u1',
+      'msg_a1',
+      'msg_u_follow',
+      'msg_a_follow',
+    ]);
+    // No idle / control leakage into ChatMessage props.
+    expect(res.body.records.some((row) => row.info.role === 'idle' || row.info.type === 'idle')).toBe(false);
+    expect(JSON.stringify(res.body)).not.toContain('"type":"idle"');
+
+    const firstAssistant = res.body.records[1];
+    expect(firstAssistant.info.agent).toBe('build');
+    expect(firstAssistant.info.modelID).toBe('glm-5.3-flash');
+    expect(firstAssistant.info.model).toEqual({
+      providerID: 'zai-coding-plan',
+      modelID: 'glm-5.3-flash',
+      variant: 'default',
+    });
+    expect(firstAssistant.info.type).toBeUndefined();
+    expect(firstAssistant.info.rawFinish).toBeUndefined();
+    const firstTexts = firstAssistant.parts.filter((part) => part.type === 'text');
+    expect(firstTexts).toHaveLength(1);
+    expect(firstTexts[0].text).toBe('FINAL_BUILD_OK');
+
+    const followAssistant = res.body.records[3];
+    const followTexts = followAssistant.parts.filter((part) => part.type === 'text');
+    expect(followTexts).toHaveLength(1);
+    expect(followTexts[0].text).toBe('FINAL_FOLLOWUP_OK');
+    expect(followAssistant.parts.filter((part) => part.type === 'reasoning')).toHaveLength(1);
+  });
+
+  it('keeps provider.auth 401 assistant error and drops idle failed control', async () => {
+    const list = vi.fn(async () => ({
+      data: [
+        { id: 'msg_idle_fail', time: { created: 3 }, type: 'idle', outcome: 'failed' },
+        {
+          id: 'msg_a_401',
+          time: { created: 2, completed: 3 },
+          type: 'assistant',
+          agent: 'build',
+          model: { id: 'deepseek-flash', providerID: 'deepseek', variant: 'default' },
+          content: null,
+          finish: 'error',
+          error: {
+            type: 'provider.auth',
+            message: 'Authentication Fails, Your api key: **** is invalid',
+            status: 401,
+          },
+        },
+        { id: 'msg_u_401', time: { created: 1 }, type: 'user', text: 'UI-E2E-FINAL-DS' },
+      ],
+      cursor: { previous: null, next: null },
+    }));
+    makeOpenCodeV2Client.mockReturnValue({
+      message: { list },
+      session: { messages: undefined, status: undefined, abort: undefined },
+    });
+    const { app, route } = registry();
+    registerSessionTurnPageRoutes(app, {
+      buildOpenCodeUrl: () => 'http://open.code/',
+      getOpenCodeAuthHeaders: () => ({}),
+    });
+    const res = response();
+    await route('GET', ROUTE)({
+      params: { sessionID: 'ses_ds' },
+      query: { turns: '1' },
+      headers: {},
+    }, res);
+
+    expect(res.statusCode).toBe(200);
+    expect(res.body.records).toHaveLength(2);
+    expect(res.body.records.map((row) => row.info.role)).toEqual(['user', 'assistant']);
+    const assistant = res.body.records[1];
+    expect(assistant.info.finish).toBe('error');
+    expect(assistant.info.error).toEqual({
+      type: 'provider.auth',
+      message: 'Authentication Fails, Your api key: **** is invalid',
+      status: 401,
+    });
+    expect(assistant.parts).toEqual([]);
+  });
+
   it('default fetch throws on message.list failure and maps to upstream', async () => {
     makeOpenCodeV2Client.mockReturnValue({
       message: { list: vi.fn(async () => { throw Object.assign(new Error('upstream'), { status: 500 }); }) },

package/server/lib/session-turn-pages/session-message-projection.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Type surface for session-message-projection.js (consumed by the VS Code
+ * turn-page bridge). Runtime implementation stays in the .js module.
+ */
+
+export type ProjectedSessionMessage = {
+  info: { id: string; role: string; [key: string]: unknown };
+  parts: unknown[];
+};
+
+export function projectSessionMessage(entry: unknown): ProjectedSessionMessage | null;
+
+export function projectSessionMessageRecords(records: unknown): ProjectedSessionMessage[];