@openchambery/web 1.19.22-beta.1 → 2.0.0-beta.3

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

@@ -1,6 +1,13 @@
 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() }));
 
 const registry = () => {
   const routes = new Map();
@@ -30,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();
@@ -163,6 +249,59 @@ describe('registerSessionTurnPageRoutes', () => {
     expect(kept.body.records[0].parts.some((part) => part.type === 'reasoning')).toBe(true);
   });
 
+  it('normalizes native SessionMessage content before slim+reasoning so content cannot leak', async () => {
+    const loadPage = vi.fn(async () => ({
+      ok: true,
+      records: [{
+        id: 'msg_a1',
+        sessionID: 'ses_1',
+        type: 'assistant',
+        time: { created: 1, completed: 2 },
+        agent: 'build',
+        model: { providerID: 'p', id: 'm' },
+        tokens: { input: 1, output: 2, reasoning: 9 },
+        content: [
+          { type: 'reasoning', text: 'SECRET_REASONING_BODY' },
+          { type: 'text', text: 'visible-answer' },
+          {
+            type: 'tool',
+            name: 'bash',
+            id: 'call_1',
+            state: { status: 'completed', title: 'ran', output: 'HUGE_TOOL_OUTPUT' },
+          },
+        ],
+      }],
+      turnCount: 0,
+      cursor: null,
+      complete: true,
+    }));
+    const { app, route } = registry();
+    registerSessionTurnPageRoutes(app, { sessionTurnPageService: { loadPage } });
+
+    const stripped = response();
+    await route('GET', ROUTE)({
+      params: { sessionID: 'ses_1' },
+      query: { includeReasoning: 'false' },
+      headers: {},
+    }, stripped);
+
+    expect(stripped.statusCode).toBe(200);
+    const record = stripped.body.records[0];
+    expect(record.info.id).toBe('msg_a1');
+    expect(record.info.role).toBe('assistant');
+    expect(record.info.tokens.reasoning).toBe(9);
+    expect(record.info.content).toBeUndefined();
+    expect(record.parts.every((part) => part.type !== 'reasoning')).toBe(true);
+    expect(record.parts.some((part) => part.type === 'text' && part.text === 'visible-answer')).toBe(true);
+    const tool = record.parts.find((part) => part.type === 'tool');
+    expect(tool.slim).toBe(true);
+    expect(tool.state.output).toBeUndefined();
+    expect(stripped.body.partsProjection).toBe('slim-v1');
+    const serialized = JSON.stringify(stripped.body);
+    expect(serialized).not.toContain('SECRET_REASONING_BODY');
+    expect(serialized).not.toContain('HUGE_TOOL_OUTPUT');
+  });
+
   it('maps upstream service errors to an upstream HTTP status', async () => {
     const loadPage = vi.fn(async () => ({
       ok: false,
@@ -637,6 +776,285 @@ describe('registerSessionTurnPageRoutes', () => {
     resolveLoad?.();
     await pending;
   });
+
+  it('default fetch uses message.list SessionMessageInfo[] + cursor and projects {info, parts}', async () => {
+    const list = vi.fn(async () => ({
+      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: 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: () => ({ Authorization: 'secret' }),
+    });
+    const res = response();
+    await route('GET', ROUTE)({
+      params: { sessionID: 'ses_1' },
+      query: { turns: '1' },
+      headers: {},
+    }, res);
+
+    expect(list).toHaveBeenCalledWith({
+      sessionID: 'ses_1',
+      limit: 100,
+      order: 'desc',
+    }, expect.objectContaining({ signal: expect.any(Object) }));
+    expect(res.statusCode).toBe(200);
+    expect(res.body.complete).toBe(true);
+    expect(res.body.records).toEqual([
+      expect.objectContaining({
+        info: expect.objectContaining({ id: 'msg_u1', role: 'user' }),
+        parts: [expect.objectContaining({ type: 'text', text: 'hi' })],
+      }),
+      expect.objectContaining({
+        info: expect.objectContaining({ id: 'msg_a1', role: 'assistant' }),
+        parts: [expect.objectContaining({ type: 'text', text: 'ok' })],
+      }),
+    ]);
+  });
+
+  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 }); }) },
+    });
+    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(res.statusCode).toBeGreaterThanOrEqual(502);
+    expect(res.body).toMatchObject({ error: expect.stringMatching(/upstream/i) });
+  });
+
+  it('default fetch rejects HeyAPI data/error shapes without a SessionMessageInfo array', async () => {
+    makeOpenCodeV2Client.mockReturnValue({
+      message: { list: vi.fn(async () => ({ error: { status: 500 }, data: 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(res.statusCode).toBeGreaterThanOrEqual(502);
+    expect(res.body.records).toBeUndefined();
+  });
 });
 
 const EXACT_MESSAGE_ROUTE = '/api/session/:sessionID/message/:messageID';
@@ -752,6 +1170,154 @@ describe('registerSessionTurnPageRoutes — exact message GET', () => {
     expect(res.statusCode).toBe(404);
     expect(res.body.code).toBe('not_found');
   });
+
+  it('maps AbortError to 499 and does not fold it into upstream 502', async () => {
+    const fetchExactMessage = vi.fn(async () => {
+      const error = new Error('aborted');
+      error.name = 'AbortError';
+      throw error;
+    });
+    const { app, route } = registry();
+    registerSessionTurnPageRoutes(app, {
+      sessionTurnPageService: { loadPage: vi.fn() },
+      fetchExactMessage,
+    });
+    const res = response();
+    await route('GET', EXACT_MESSAGE_ROUTE)({
+      params: { sessionID: 'ses_1', messageID: 'msg_1' },
+      query: {},
+      headers: {},
+    }, res);
+    expect(res.statusCode).toBe(499);
+    expect(res.statusCode).not.toBe(502);
+  });
+});
+
+describe('registerSessionTurnPageRoutes — real OpenCode.make + fake HTTP', () => {
+  const jsonResponse = (status, body) => ({
+    ok: status >= 200 && status < 300,
+    status,
+    headers: {
+      get: (name) => (String(name).toLowerCase() === 'content-type' ? 'application/json' : null),
+    },
+    json: async () => body,
+    text: async () => JSON.stringify(body ?? null),
+    arrayBuffer: async () => new TextEncoder().encode(JSON.stringify(body ?? null)).buffer,
+  });
+
+  it('session.message MessageNotFoundError _tag maps to HTTP 404 via real client', async () => {
+    const fetchImpl = vi.fn(async (url) => {
+      const path = String(url);
+      if (path.includes('/message/msg_missing')) {
+        return jsonResponse(404, {
+          _tag: 'MessageNotFoundError',
+          sessionID: 'ses_1',
+          messageID: 'msg_missing',
+          message: 'Message not found',
+        });
+      }
+      return jsonResponse(500, { _tag: 'UnknownError', message: 'unexpected' });
+    });
+    const { makeOpenCodeV2Client: realMake } = await vi.importActual('../opencode/v2-client.js');
+    makeOpenCodeV2Client.mockImplementation(({ baseUrl, authHeaders }) =>
+      realMake({ baseUrl, authHeaders, fetchImpl }));
+
+    const { app, route } = registry();
+    registerSessionTurnPageRoutes(app, {
+      sessionTurnPageService: { loadPage: vi.fn() },
+      buildOpenCodeUrl: () => 'http://open.code/',
+      getOpenCodeAuthHeaders: () => ({ Authorization: 'Basic test' }),
+    });
+    const res = response();
+    await route('GET', EXACT_MESSAGE_ROUTE)({
+      params: { sessionID: 'ses_1', messageID: 'msg_missing' },
+      query: {},
+      headers: {},
+    }, res);
+
+    expect(res.statusCode).toBe(404);
+    expect(res.body.code).toBe('not_found');
+    expect(fetchImpl).toHaveBeenCalled();
+  });
+
+  it('exact message serializes native assistant with reasoning strip and L1 slim', async () => {
+    const nativeAssistant = {
+      id: 'msg_a1',
+      type: 'assistant',
+      time: { created: 10, completed: 20 },
+      agent: 'build',
+      model: { providerID: 'openai', id: 'gpt' },
+      tokens: { input: 3, output: 4, reasoning: 7 },
+      content: [
+        { type: 'reasoning', text: 'PRIVATE_CHAIN' },
+        { type: 'text', text: 'hello-world' },
+      ],
+      // Host may still see legacy summary on some mirrors; L1 must slim it.
+      summary: {
+        diffs: [{
+          file: 'a.ts',
+          status: 'modified',
+          additions: 1,
+          deletions: 0,
+          patch: 'PATCH_BODY_SHOULD_NOT_LEAVE',
+        }],
+      },
+    };
+    const fetchImpl = vi.fn(async () => jsonResponse(200, { data: nativeAssistant }));
+    const { makeOpenCodeV2Client: realMake } = await vi.importActual('../opencode/v2-client.js');
+    makeOpenCodeV2Client.mockImplementation(({ baseUrl, authHeaders }) =>
+      realMake({ baseUrl, authHeaders, fetchImpl }));
+
+    const { app, route } = registry();
+    registerSessionTurnPageRoutes(app, {
+      sessionTurnPageService: { loadPage: vi.fn() },
+      buildOpenCodeUrl: () => 'http://open.code/',
+      getOpenCodeAuthHeaders: () => ({}),
+    });
+
+    const stripped = response();
+    await route('GET', EXACT_MESSAGE_ROUTE)({
+      params: { sessionID: 'ses_1', messageID: 'msg_a1' },
+      query: { includeReasoning: 'false' },
+      headers: {},
+    }, stripped);
+
+    expect(stripped.statusCode).toBe(200);
+    expect(stripped.body.info.id).toBe('msg_a1');
+    expect(stripped.body.info.role).toBe('assistant');
+    expect(stripped.body.info.content).toBeUndefined();
+    expect(stripped.body.info.tokens.reasoning).toBe(7);
+    expect(stripped.body.parts.every((part) => part.type !== 'reasoning')).toBe(true);
+    expect(stripped.body.parts.some((part) => part.type === 'text' && part.text === 'hello-world')).toBe(true);
+    expect(stripped.body.info.summary?.diffs?.[0]?.patch).toBeUndefined();
+    expect(JSON.stringify(stripped.body)).not.toContain('PRIVATE_CHAIN');
+    expect(JSON.stringify(stripped.body)).not.toContain('PATCH_BODY_SHOULD_NOT_LEAVE');
+  });
+
+  it('preserves abort from real client transport instead of 502', async () => {
+    const fetchImpl = vi.fn(async () => {
+      const error = new Error('The operation was aborted');
+      error.name = 'AbortError';
+      throw error;
+    });
+    const { makeOpenCodeV2Client: realMake } = await vi.importActual('../opencode/v2-client.js');
+    makeOpenCodeV2Client.mockImplementation(({ baseUrl, authHeaders }) =>
+      realMake({ baseUrl, authHeaders, fetchImpl }));
+
+    const { app, route } = registry();
+    registerSessionTurnPageRoutes(app, {
+      sessionTurnPageService: { loadPage: vi.fn() },
+      buildOpenCodeUrl: () => 'http://open.code/',
+      getOpenCodeAuthHeaders: () => ({}),
+    });
+    const res = response();
+    await route('GET', EXACT_MESSAGE_ROUTE)({
+      params: { sessionID: 'ses_1', messageID: 'msg_1' },
+      query: {},
+      headers: {},
+    }, res);
+    expect(res.statusCode).toBe(499);
+  });
 });
 
 describe('registerSessionTurnPageRoutes — changes API', () => {

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/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[];