dsh-plugin-mobile-gateway 0.7.3 → 0.7.5

package/lib/dsh-host-adapter.mjs

@@ -13,88 +13,52 @@ function requireArray(value, endpoint) {
   return value
 }
 
-function chunkRowLength(event) {
-  if (event.type === 'chunkrow/tool-call-chunks') return requireArray(event.data?.args, event.type).length
-  return requireArray(event.data?.texts, event.type).length
+export const DSH_VERSION = '0.1.5-rc.2'
+export const SESSION_FORMAT_VERSION = 3
+
+export function readHistoryRecords(records) {
+  return requireArray(records, 'session history').map(record => {
+    const value = requireRecord(record, 'session history record')
+    if (value.type !== 'event') throw new Error('DSH 0.1.5-rc.2 history requires event records')
+    const event = requireRecord(value.event, 'session history event')
+    if (!Number.isSafeInteger(event.seq) || event.seq < 0) throw new Error('invalid history sequence')
+    return event
+  })
 }
 
-// DSH 0.1.2 compresses consecutive assistant deltas inside history pages.
-// dsh-mobile-v1 predates that storage shape, so restore the exact logical
-// SessionEvent sequence at this boundary instead of teaching every client a
-// Host-specific encoding detail.
-function expandChunkRow(event) {
-  const data = requireRecord(event.data, event.type)
-  const values = event.type === 'chunkrow/tool-call-chunks'
-    ? requireArray(data.args, event.type)
-    : requireArray(data.texts, event.type)
-  const gaps = requireArray(data.dt, event.type)
-  if (gaps.length !== Math.max(0, values.length - 1)) {
-    throw new Error(`${event.type} returned invalid timing data`)
-  }
-  const events = []
-  let time = event.time
-  for (let index = 0; index < values.length; index += 1) {
-    if (index > 0) time += gaps[index - 1]
-    let chunk
-    if (event.type === 'chunkrow/text-chunks') {
-      chunk = { type: 'text-delta', index: data.index, text: values[index] }
-    } else if (event.type === 'chunkrow/reasoning-chunks') {
-      chunk = { type: 'reasoning-delta', index: data.index, text: values[index] }
-    } else {
-      chunk = {
-        type: 'tool-call-delta',
-        index: data.index,
-        id: data.id,
-        ...(Object.hasOwn(data, 'name') ? { name: data.name } : {}),
-        argumentsDelta: values[index],
-      }
-    }
-    events.push({
-      type: 'assistant/chunk',
-      seq: event.seq + index,
-      time,
-      data: { turn: data.turn, step: data.step, chunk },
+export function readSessionSnapshot(frame, sessionId) {
+  requireRecord(frame, 'session/follow')
+  if (frame.type !== 'snapshot' || !Number.isSafeInteger(frame.cursor) || frame.cursor < -1
+    || frame.header?.id !== sessionId) throw new Error('session/follow returned an invalid snapshot')
+  if (frame.header.version !== SESSION_FORMAT_VERSION) {
+    throw Object.assign(new Error('mobile-gateway requires DSH 0.1.5-rc.2 Session format 3'), {
+      code: 'unsupported-session-format',
     })
   }
-  return events
-}
-
-export function expandHistoryRecords(records) {
-  const events = []
-  for (const record of requireArray(records, 'session history')) {
-    const value = requireRecord(record, 'session history record')
-    const event = requireRecord(value.event, 'session history event')
-    if (value.type === 'event') {
-      events.push(event)
-      continue
-    }
-    if (value.type !== 'chunks' || ![
-      'chunkrow/text-chunks',
-      'chunkrow/reasoning-chunks',
-      'chunkrow/tool-call-chunks',
-    ].includes(event.type)) {
-      throw new Error('session history returned an unsupported record')
-    }
-    if (chunkRowLength(event) === 0) throw new Error(`${event.type} returned an empty run`)
-    events.push(...expandChunkRow(event))
+  return {
+    events: readHistoryRecords(frame.records).map(event => ({ event })),
+    hasMore: frame.hasMore === true,
+    projections: requireRecord(frame.projections, 'session/follow projections'),
+    historyFormatVersion: frame.header.version,
+    cursor: frame.cursor,
   }
-  return events
 }
 
 async function firstStreamFrame(gateway, namespace, method, args, signal) {
-  const ownedAbort = signal === undefined ? new AbortController() : null
-  const streamSignal = signal ?? ownedAbort.signal
-  const iterable = await gateway.stream({ namespace, method, args, signal: streamSignal })
-  const iteratorFactory = iterable?.[Symbol.asyncIterator] ?? iterable?.[Symbol.iterator]
-  if (typeof iteratorFactory !== 'function') throw new Error(`${namespace}/${method} returned an invalid stream`)
-  const iterator = iteratorFactory.call(iterable)
+  const ownedAbort = new AbortController()
+  const streamSignal = signal ? AbortSignal.any([signal, ownedAbort.signal]) : ownedAbort.signal
+  let iterator
   try {
+    const iterable = await gateway.stream({ namespace, method, args, signal: streamSignal })
+    const iteratorFactory = iterable?.[Symbol.asyncIterator] ?? iterable?.[Symbol.iterator]
+    if (typeof iteratorFactory !== 'function') throw new Error(`${namespace}/${method} returned an invalid stream`)
+    iterator = iteratorFactory.call(iterable)
     const first = await iterator.next()
     if (first.done) throw new Error(`${namespace}/${method} ended before its opening frame`)
     return first.value
   } finally {
-    ownedAbort?.abort()
-    if (typeof iterator.return === 'function') await iterator.return()
+    ownedAbort.abort()
+    if (typeof iterator?.return === 'function') await iterator.return()
   }
 }
 
@@ -102,7 +66,7 @@ function requestArgs(request) {
   return { request }
 }
 
-// The RC.1 SessionController intentionally names its reserved list argument
+// The 0.1.5-rc.2 SessionController names its reserved list argument
 // `_request`. Typert descriptors preserve that source parameter name exactly,
 // so this endpoint cannot share the normal `{ request }` wrapper.
 function sessionListArgs(request) {
@@ -134,20 +98,19 @@ export function createDshHostAdapter(typertGateway) {
       requestArgs(request),
       signal,
     ), 'session/follow')
-    if (frame.type !== 'snapshot' || !Number.isSafeInteger(frame.cursor)) {
-      throw new Error('session/follow returned an invalid opening snapshot')
-    }
-    return frame
+    return readSessionSnapshot(frame, request.address.sessionId)
   }
 
   const history = async (payload, signal) => {
     const request = {
       address: { kind: 'session', sessionId: payload.sessionId },
-      ...(payload.maxMessages === undefined ? {} : { maxMessages: payload.maxMessages }),
+      // Older-page requests need only the opening cursor/projections, not another large latest page.
+      ...(payload.beforeSeq !== undefined ? { maxMessages: 1 }
+        : payload.maxMessages === undefined ? {} : { maxMessages: payload.maxMessages }),
     }
     const snapshot = await sessionSnapshot(request, signal)
-    let records = snapshot.records
-    let hasMore = snapshot.hasMore === true
+    let events = snapshot.events
+    let hasMore = snapshot.hasMore
     if (payload.beforeSeq !== undefined) {
       const page = requireRecord(await invoke('session', 'page', requestArgs({
         address: request.address,
@@ -155,13 +118,13 @@ export function createDshHostAdapter(typertGateway) {
         beforeSeq: payload.beforeSeq,
         ...(payload.maxMessages === undefined ? {} : { maxMessages: payload.maxMessages }),
       }), signal), 'session/page')
-      records = page.records
+      events = readHistoryRecords(page.records).map(event => ({ event }))
       hasMore = page.hasMore === true
     }
     return {
-      events: expandHistoryRecords(records).map(event => ({ event })),
+      ...snapshot,
+      events,
       hasMore,
-      projections: requireRecord(snapshot.projections, 'session/follow projections'),
     }
   }
 
@@ -172,10 +135,13 @@ export function createDshHostAdapter(typertGateway) {
 
   const commands = {
     list: (sessionId, signal) => invoke('commands', 'list', { agentId: sessionId }, signal),
-    execute: (sessionId, line, images, signal) => invoke(
+    // DSH 0.1.5-rc.2 accepts `submittedAttachments`. The parsed
+    // wire images already carry the { type: 'image', ... } shape it expects, so
+    // only the field name changes.
+    execute: (sessionId, line, attachments, signal) => invoke(
       'commands',
       'execute',
-      { agentId: sessionId, line, images },
+      { agentId: sessionId, line, submittedAttachments: attachments },
       signal,
     ),
   }
@@ -196,6 +162,8 @@ export function createDshHostAdapter(typertGateway) {
     ])
     return {
       version: 'remote-gateway',
+      dshVersion: DSH_VERSION,
+      historyFormatVersion: SESSION_FORMAT_VERSION,
       cwd: os.homedir(),
       attachedSessions: Array.isArray(sessions?.items) ? sessions.items.length : 0,
       canOpenPath: canOpenPath === true,
@@ -301,6 +269,14 @@ export function createDshHostAdapter(typertGateway) {
       describe: (_payload = {}, signal) => describeHost(signal),
     },
     describeHost,
+    openSessionStream(sessionId, signal) {
+      return typertGateway.stream({
+        namespace: 'session', method: 'follow',
+        // Bound the opening window at the Host; older records remain available via session.page.
+        args: requestArgs({ address: { kind: 'session', sessionId }, maxMessages: 12, assistantStream: true }),
+        signal,
+      })
+    },
     openControlStream(signal) {
       return typertGateway.stream({ namespace: 'session', method: 'control', args: {}, signal })
     },