dsh-monkeyai-sessions 0.1.1 → 0.1.3

package/README.md

@@ -39,7 +39,7 @@ All three request `device:connect`, `session:read`, and `session:control` throug
 
 ## Sessions
 
-Full conversation history is loaded over the runtime's HTTP read channel (`POST {http_base}/read/session` with `_monkeyai/session/messages`, paginated by cursor) instead of the bounded ACP `session/load` replay, so long sessions show every turn including the latest replies. While a turn is running the composer shows a stop button that sends `session/cancel`; the model switcher uses `_monkeyai/session/model/set` on the live session connection. Assistant messages render lightweight markdown (code blocks, inline code, bold, headings, lists).
+Full conversation history is loaded over the runtime's HTTP read channel (`POST {http_base}/read/session` with `_monkeyai/session/messages`, paginated by cursor) instead of the bounded ACP `session/load` replay, so long sessions show every turn including the latest replies. After mounting the session with the same `historyHTTP` capabilities as the MonkeyAI client, the panel subscribes to ACP live updates: messages and assistant chunks started in the MonkeyAI desktop client appear as they stream, without refreshing. For large replies persisted by the runtime, `history_changed` triggers a cursor-based HTTP delta refresh and replaces any partial snapshot. While a turn is running the composer shows a stop button that sends `session/cancel`; the model switcher uses `_monkeyai/session/model/set` on the live session connection. Assistant messages render lightweight markdown (code blocks, inline code, bold, headings, lists).
 
 ## Installation
 
@@ -61,7 +61,7 @@ From a checkout:
 npm install
 npm run build
 npm pack
-dsh plugin --profile web add ./dsh-monkeyai-sessions-0.1.1.tgz
+dsh plugin --profile web add ./dsh-monkeyai-sessions-0.1.3.tgz
 ```
 
 Verified against a real DSH `0.2.2-rc.1` web profile and a live MonkeyAI runtime: authorization, full history loading, prompt delivery, model switching, and turn cancellation all work end to end.

package/README.zh.md

@@ -28,7 +28,7 @@ https://artenx.github.io/dsh-monkeyai-sessions/index.json
 npm install
 npm run build
 npm pack
-dsh plugin --profile web add ./dsh-monkeyai-sessions-0.1.1.tgz
+dsh plugin --profile web add ./dsh-monkeyai-sessions-0.1.3.tgz
 ```
 
 已在真实的 DSH `0.2.2-rc.1` web profile 与在线 MonkeyAI runtime 上端到端验证：授权、完整历史加载、指令下发、模型切换、回合取消均正常工作。
@@ -45,7 +45,7 @@ dsh plugin --profile web add ./dsh-monkeyai-sessions-0.1.1.tgz
 
 ## 会话能力
 
-完整对话历史通过 runtime 的 HTTP 读取通道加载（`POST {http_base}/read/session`，方法 `_monkeyai/session/messages`，按游标翻页），而不是 ACP `session/load` 的有界回放，因此长会话能看到每一轮内容，包括最新回复。
+完整对话历史通过 runtime 的 HTTP 读取通道加载（`POST {http_base}/read/session`，方法 `_monkeyai/session/messages`，按游标翻页），而不是 ACP `session/load` 的有界回放，因此长会话能看到每一轮内容，包括最新回复。会话使用与 MonkeyAI 客户端相同的 `historyHTTP` 能力挂载后，面板会订阅 ACP 实时更新：在 MonkeyAI 桌面客户端发起的用户消息和助手回复都会边生成边显示，无需刷新。对于 runtime 先持久化再通知的超大回复，收到 `history_changed` 后会按游标增量读取，并用完整快照补齐部分内容。
 
 回合执行期间输入框旁会显示停止按钮，点击发送 `session/cancel`；模型切换在会话自己的连接上调用 `_monkeyai/session/model/set`。助手消息支持轻量 Markdown 渲染（代码块、行内代码、粗体、标题、列表）。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-monkeyai-sessions",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "在 DeepSeek Harness 中读取和继续 MonkeyAI 会话：查看完整对话历史、下发新指令，无缝接续之前在 MonkeyAI 客户端上的工作",
   "type": "module",
   "license": "MIT",

package/src/host/monkeyai-remote.js

@@ -390,6 +390,45 @@ export class MonkeyAIRemoteService extends TypertRemoteService {
     return this.exchangeAuthorization(auth, callbackUrl)
   }
 
+  // The runtime requires an expectedRevision on every configuration write and
+  // rejects a stale one with configuration_conflict. The MonkeyAI client (or
+  // another panel) can advance the revision at any time, so read the current
+  // value from the conflict payload — or from the HTTP session state when we
+  // have none — and retry instead of failing the switch.
+  async setSessionModel({ acp, sessionId, model, httpBase, ticket, revision, signal, onRevision }) {
+    let expected = revision
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      if (!Number.isSafeInteger(expected)) {
+        expected = await readSessionConfigurationRevision({ httpBase, ticket, sessionId, signal })
+      }
+      if (!Number.isSafeInteger(expected)) throw new Error('无法读取会话配置版本，暂时不能切换模型')
+      try {
+        const result = await acp.request('_monkeyai/session/model/set', {
+          sessionId,
+          model,
+          _meta: { expectedRevision: expected },
+        }, { signal, timeoutMs: 120_000 })
+        const next = result?._meta?.configurationRevision
+        if (Number.isSafeInteger(next)) onRevision(next)
+        return typeof result?.model === 'string' ? result.model : model
+      } catch (error) {
+        if (signal?.aborted) throw error
+        const current = error?.data?.configurationRevision
+        if (error?.data?.reason === 'configuration_conflict' && Number.isSafeInteger(current) && current !== expected) {
+          expected = current
+          onRevision(current)
+          continue
+        }
+        if (error?.data?.reason === 'configuration_version_required') {
+          expected = undefined
+          continue
+        }
+        throw error
+      }
+    }
+    throw new Error('会话配置持续被其他客户端修改，请重试切换模型')
+  }
+
   async exchangeAuthorization(auth, callbackUrl) {
     const callback = parseAuthorizationCallback(callbackUrl, auth)
     const tokens = await requestJson(auth.serverOrigin, '/oauth/token', {
@@ -650,6 +689,7 @@ export class MonkeyAIRemoteService extends TypertRemoteService {
     let reconnectsUsed = 0
     const MAX_REPLAY_RECONNECTS = 32
     let ticketValue
+    let ticketHttpBase
     let loadCompleted = false
     let currentLoadedModel = undefined
     const aborted = new Promise(resolve => {
@@ -687,10 +727,12 @@ export class MonkeyAIRemoteService extends TypertRemoteService {
     // for close detection but suppressed from the event stream to avoid
     // duplicating text the projection already folded in.
     const httpHistoryMessageIds = new Set()
-    // When the HTTP channel delivered the full history, the ACP replay adds
-    // nothing: skip session/load entirely and mount the session live.
+    // The full history was loaded over HTTP. Keep the message ids so ACP
+    // replay duplicates can be suppressed and history_changed notifications
+    // can fetch only newly persisted snapshots.
     let httpHistoryComplete = false
     let httpConfigurationRevision
+    let historyRefreshPromise = Promise.resolve()
     // history_loaded can be triggered by both the HTTP history channel and
     // the ACP load path; the stream must carry it exactly once.
     let historyLoadedEmitted = false
@@ -699,6 +741,26 @@ export class MonkeyAIRemoteService extends TypertRemoteService {
       historyLoadedEmitted = true
       emit({ type: 'history_loaded', sessionId: selectedSession, ...(model === undefined ? {} : { model }) })
     }
+    const refreshPersistedHistory = async changedMessageId => {
+      if (!ticketHttpBase || !ticketValue) return
+      const delta = await fetchSessionHistoryDelta({
+        httpBase: ticketHttpBase,
+        ticket: ticketValue,
+        sessionId: selectedSession,
+        signal,
+        knownMessageIds: httpHistoryMessageIds,
+        changedMessageId,
+      })
+      if (Number.isSafeInteger(delta.configurationRevision)) {
+        httpConfigurationRevision = delta.configurationRevision
+      }
+      for (const message of delta.messages) {
+        httpHistoryMessageIds.add(message.id)
+        for (const frame of historyMessageToFrames(selectedSession, message, delta.toolCalls, { snapshot: true })) {
+          await emit(frame)
+        }
+      }
+    }
 
     function replayKey(params) {
       const update = params?.update
@@ -745,6 +807,22 @@ export class MonkeyAIRemoteService extends TypertRemoteService {
             data: event.params,
           })
         } else {
+          if (event.method === '_monkeyai/session/history_changed' && httpHistoryComplete && ticketHttpBase) {
+            // Large live message bodies are persisted instead of streamed as
+            // chunks. Match the desktop client: refresh the newest HTTP pages
+            // and merge the resulting message snapshots into the projection.
+            historyRefreshPromise = historyRefreshPromise.then(() => refreshPersistedHistory(
+              typeof event.params?.messageId === 'string' ? event.params.messageId : undefined,
+            )).catch(error => {
+              if (!signal.aborted) emit({
+                type: 'error',
+                sessionId: selectedSession,
+                code: 'history_refresh_failed',
+                message: error instanceof Error ? error.message : '刷新实时会话内容失败',
+              })
+            })
+            return
+          }
         if (withLoad && !loadCompleted) {
           const key = replayKey(event.params)
             if (key !== null) {
@@ -756,7 +834,7 @@ export class MonkeyAIRemoteService extends TypertRemoteService {
           }
           // Suppress replayed messages already delivered over HTTP, on every
           // connection generation (re-mounts replay the same window again).
-          if (withLoad) {
+          if (withLoad && event.params?._meta?.replay === true) {
             const replayMessageId = (typeof event.params?._meta?.messageId === 'string' && event.params._meta.messageId !== '')
               ? event.params._meta.messageId
               : (typeof event.params?.update?.messageId === 'string' ? event.params.update.messageId : '')
@@ -848,7 +926,22 @@ export class MonkeyAIRemoteService extends TypertRemoteService {
       const initialized = await acp.request('initialize', {
         protocolVersion: 1,
         clientInfo: ACP_CLIENT_INFO,
-        clientCapabilities: {},
+        // Match the MonkeyAI desktop client. historyHTTP opts this connection
+        // into HTTP-backed snapshots and history_changed notifications;
+        // session/load then mounts the live subscription without replaying the
+        // oversized history over ACP.
+        clientCapabilities: {
+          _meta: {
+            messageSnapshots: true,
+            interactionReplies: true,
+            historyHTTP: true,
+            queueHTTP: true,
+            historyRefresh: true,
+            configHTTP: true,
+            stateHTTP: true,
+            interactionHTTP: true,
+          },
+        },
       }, { signal })
       if (initialized?.agentCapabilities?.loadSession !== true) {
         throw new Error('MonkeyAI runtime does not advertise ACP session history loading')
@@ -859,14 +952,11 @@ export class MonkeyAIRemoteService extends TypertRemoteService {
         return
       }
       emit({ type: 'ready', sessionId: selectedSession })
-      if (httpHistoryComplete) {
-        // History came over HTTP; prompts and model switches work on a plain
-        // initialized connection. Skip session/load: its bounded replay
-        // always dies mid-stream and would churn reconnects for nothing.
-        loadCompleted = true
-        return
-      }
       try {
+        // With historyHTTP advertised this mounts the session for live
+        // notifications while leaving persisted history reads to the HTTP
+        // cursor API above. Older runtimes may still replay a bounded window;
+        // the message-id filter suppresses those duplicate snapshots.
         const loadResult = await acp.request('session/load', {
           sessionId: selectedSession,
           cwd,
@@ -875,6 +965,13 @@ export class MonkeyAIRemoteService extends TypertRemoteService {
         loadCompleted = true
         currentLoadedModel = typeof loadResult?._meta?.model === 'string' ? loadResult._meta.model : currentLoadedModel
         emitHistoryLoaded(currentLoadedModel)
+        // Close the gap between the initial full-history read and mounting the
+        // live subscription. A turn can start during that interval; snapshots
+        // replace any partial chunks that arrived before session/load resolved.
+        if (httpHistoryComplete) {
+          historyRefreshPromise = historyRefreshPromise.then(() => refreshPersistedHistory())
+          await historyRefreshPromise
+        }
       } catch (error) {
         if (signal?.aborted) throw error
         const message = error instanceof Error ? error.message : String(error)
@@ -919,6 +1016,7 @@ export class MonkeyAIRemoteService extends TypertRemoteService {
       const token = await this.refreshAccessToken(accountId, signal)
       const ticket = await this.requestConnectionTicket(accountId, grantRef, token, target, { signal })
       ticketValue = ticket.ticket
+      ticketHttpBase = ticket.httpBase
       if (signal.aborted) throw signal.reason ?? new Error('远程会话已取消')
 
       // Load the full history over the runtime's HTTP read channel before the
@@ -977,14 +1075,16 @@ export class MonkeyAIRemoteService extends TypertRemoteService {
 
             if (command.type === 'switch_model') {
               try {
-                const result = await currentAcp.request('_monkeyai/session/model/set', {
+                const model = await this.setSessionModel({
+                  acp: currentAcp,
                   sessionId: selectedSession,
                   model: command.model,
-                  ...(httpConfigurationRevision === undefined ? {} : { _meta: { expectedRevision: httpConfigurationRevision } }),
-                }, { signal, timeoutMs: 120_000 })
-                const nextRevision = result?._meta?.configurationRevision
-                if (Number.isSafeInteger(nextRevision)) httpConfigurationRevision = nextRevision
-                const model = typeof result?.model === 'string' ? result.model : command.model
+                  httpBase: ticket.httpBase,
+                  ticket: ticketValue,
+                  revision: httpConfigurationRevision,
+                  signal,
+                  onRevision: value => { httpConfigurationRevision = value },
+                })
                 currentLoadedModel = model
                 emit({ type: 'model_switched', sessionId: selectedSession, data: { model } })
               } catch (switchError) {
@@ -1223,6 +1323,16 @@ async function readHistoryBodyText(response, maxBytes = HISTORY_PAGE_MAX_BYTES)
   return new TextDecoder().decode(joined)
 }
 
+// Reads the session's current configuration revision over the HTTP read
+// channel. Configuration writes must carry it, and the value changes whenever
+// any client edits the session.
+async function readSessionConfigurationRevision({ httpBase, ticket, sessionId, signal }) {
+  const timeout = AbortSignal.any([AbortSignal.timeout(20_000), ...(signal ? [signal] : [])])
+  const result = await readSessionHistoryPage({ httpBase, ticket, sessionId, limit: 1, signal: timeout })
+  const revision = result.session?.configurationRevision
+  return Number.isSafeInteger(revision) ? revision : undefined
+}
+
 async function readSessionHistoryPage({ httpBase, ticket, sessionId, cursor, direction, limit = 50, signal }) {
   const params = { sessionId, limit, ...(cursor ? { cursor, direction } : {}) }
   const response = await fetch(`${httpBase.endsWith('/') ? httpBase : `${httpBase}/`}read/session`, {
@@ -1261,7 +1371,7 @@ function historyMessageText(parts) {
 // Converts one history message snapshot into the same notification frame
 // shape the ACP replay produces, so the shared projection layer renders both
 // identically. Message ids match ACP replay messageIds (u-turn-N / a-turn-N).
-function historyMessageToFrames(sessionId, message, toolCallsById) {
+function historyMessageToFrames(sessionId, message, toolCallsById, { snapshot = false } = {}) {
   const frames = []
   const meta = { messageId: message.id, replay: true }
   const emitUpdate = update => {
@@ -1275,16 +1385,47 @@ function historyMessageToFrames(sessionId, message, toolCallsById) {
     const content = fileLinks.length > 0
       ? [...(text === '' ? [] : [{ type: 'text', text }]), ...fileLinks]
       : (text === '' ? undefined : { type: 'text', text })
-    if (content !== undefined) emitUpdate({ sessionUpdate: 'user_message_chunk', content })
+    if (content !== undefined) emitUpdate({ sessionUpdate: snapshot ? 'user_message' : 'user_message_chunk', content })
     return frames
   }
-  for (const part of Array.isArray(message.parts) ? message.parts : []) {
+  const parts = Array.isArray(message.parts) ? message.parts : []
+  const snapshotThought = snapshot
+    ? parts.filter(part => part?.type === 'thought' && typeof part.text === 'string').map(part => part.text).join('')
+    : ''
+  const snapshotText = snapshot
+    ? parts.filter(part => part?.type === 'text' && typeof part.text === 'string').map(part => part.text)
+      .concat(parts.filter(part => part?.type === 'error' && typeof part.reason === 'string').map(part => `[error] ${part.reason}`)).join('')
+    : ''
+  let snapshotThoughtEmitted = false
+  let snapshotTextEmitted = false
+  for (const part of parts) {
     if (part?.type === 'thought' && typeof part.text === 'string' && part.text !== '') {
-      emitUpdate({ sessionUpdate: 'agent_thought_chunk', content: { type: 'text', text: part.text } })
+      if (snapshot) {
+        if (!snapshotThoughtEmitted && snapshotThought !== '') {
+          emitUpdate({ sessionUpdate: 'agent_thought', content: { type: 'text', text: snapshotThought } })
+          snapshotThoughtEmitted = true
+        }
+      } else {
+        emitUpdate({ sessionUpdate: 'agent_thought_chunk', content: { type: 'text', text: part.text } })
+      }
     } else if (part?.type === 'text' && typeof part.text === 'string' && part.text !== '') {
-      emitUpdate({ sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: part.text } })
+      if (snapshot) {
+        if (!snapshotTextEmitted && snapshotText !== '') {
+          emitUpdate({ sessionUpdate: 'agent_message', content: { type: 'text', text: snapshotText } })
+          snapshotTextEmitted = true
+        }
+      } else {
+        emitUpdate({ sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: part.text } })
+      }
     } else if (part?.type === 'error' && typeof part.reason === 'string' && part.reason !== '') {
-      emitUpdate({ sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: `[error] ${part.reason}` } })
+      if (snapshot) {
+        if (!snapshotTextEmitted && snapshotText !== '') {
+          emitUpdate({ sessionUpdate: 'agent_message', content: { type: 'text', text: snapshotText } })
+          snapshotTextEmitted = true
+        }
+      } else {
+        emitUpdate({ sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: `[error] ${part.reason}` } })
+      }
     } else if (part?.type === 'file' && typeof part.uri === 'string') {
       emitUpdate({ sessionUpdate: 'agent_message_chunk', content: { type: 'resource_link', name: part.name, uri: part.uri } })
     } else if (part?.type === 'tool_call' && typeof part.toolCallId === 'string') {
@@ -1338,6 +1479,47 @@ async function fetchFullSessionHistory({ httpBase, ticket, sessionId, signal, on
   return { messageIds: [...seenIds], count: seenIds.size, configurationRevision }
 }
 
+// Refresh only the newest pages after a _monkeyai/session/history_changed
+// notification. Pages are oldest-to-newest internally and arrive newest-first;
+// stop once a known boundary is reached, retaining a changed message id even
+// when it was already present (the runtime may have replaced a partial body).
+async function fetchSessionHistoryDelta({ httpBase, ticket, sessionId, signal, knownMessageIds, changedMessageId, maxPages = 200 }) {
+  const pages = []
+  const seenIds = new Set()
+  const toolCalls = {}
+  let cursor
+  let configurationRevision
+  let foundBoundary = false
+  let foundChangedMessage = !changedMessageId
+  for (let page = 0; page < maxPages; page += 1) {
+    const timeout = AbortSignal.any([AbortSignal.timeout(30_000), ...(signal ? [signal] : [])])
+    const result = await readSessionHistoryPage({ httpBase, ticket, sessionId, cursor, direction: 'older', signal: timeout })
+    if (Number.isSafeInteger(result.session?.configurationRevision)) configurationRevision = result.session.configurationRevision
+    const pageMessages = []
+    for (const message of result.messages) {
+      if (typeof message?.id !== 'string' || message.id === '') continue
+      const known = knownMessageIds.has(message.id)
+      const changed = message.id === changedMessageId
+      if (changed) foundChangedMessage = true
+      if ((!known || changed) && !seenIds.has(message.id)) {
+        seenIds.add(message.id)
+        pageMessages.push(message)
+      }
+      if (known && !changed) foundBoundary = true
+    }
+    pages.push(pageMessages)
+    Object.assign(toolCalls, result.toolCalls ?? {})
+    if (foundBoundary && foundChangedMessage) break
+    cursor = typeof result.olderCursor === 'string' && result.olderCursor !== '' ? result.olderCursor : undefined
+    if (!cursor || result.messages.length === 0) break
+  }
+  return {
+    messages: pages.reverse().flat(),
+    toolCalls,
+    configurationRevision,
+  }
+}
+
 function validateResponse(method, params, result) {
   if (!isObject(result)) throw new TypeError('ACP response must be a JSON object')
   if (method === 'session/request_permission') {