ds-bot 0.1.2 → 0.1.4

package/src/host/channel.js

@@ -40,7 +40,7 @@ export function install(rt) {
       ...bot, sessionId: rt.chatOf(bot.id), parts: (segments ?? []).map(segment => segment.sessionId), ...(kickoff ? { waiting: true } : {}),
     })),
     // `parts`: the members' hidden group Sessions and their earlier segments, for usage.
-    rooms: Object.values(state.rooms).map(({ log, seen, botRounds, sessions, segments, ...room }) => {
+    rooms: Object.values(state.rooms).map(({ log, seen, botRounds, lateRounds, sessions, segments, ...room }) => {
       const parts = [...Object.values(sessions ?? {}), ...Object.values(segments ?? {}).flat().map(segment => segment.sessionId)]
       const last = (log ?? []).filter(line => line.kind === undefined).at(-1)
       return { ...room, parts, ...(last ? { preview: last.who === 'User' ? last.text : `${last.who}：${last.text}` } : {}) }
@@ -51,6 +51,7 @@ export function install(rt) {
     agents: Object.values(state.agents),
     // Key names and who may use them; values never leave the host.
     secrets: rt.secretsView(),
+    capabilities: rt.capabilityLibraryView(),
     secretRequests: state.secretRequests ?? {},
     colors: [...COLORS, ...EXTRA_COLORS],
     models: rt.cachedCatalog(),
@@ -67,11 +68,19 @@ export function install(rt) {
   })
   // What changes without a new revision, sent with every state answer. `memoryNews`:
   // per Bot, its latest memory change; `memoryReviews`: memory reviews waiting or
-  // running.
-  const live = () => ({ activity: rt.activityView(), memoryNews: rt.memoryNews(), memoryReviews: rt.memoryReviews(), connectors: rt.connectorsView() })
+  // running; `work`: per Bot, the turn it runs and its tool; per group, the members whose
+  // turn there runs; and the approvals waiting.
+  const live = () => ({
+    activity: rt.activityView(),
+    work: { bots: rt.workView(), rooms: rt.roomWorkView(), approvals: rt.approvalsView() },
+    memoryNews: rt.memoryNews(),
+    memoryReviews: rt.memoryReviews(),
+    connectors: rt.connectorsView(),
+    capabilityStatuses: rt.capabilityStatusesView(),
+  })
   // What a host that only reads the team may still answer.
   // Updates change the dsh profile, not the team, so a reading host may run them too.
-  const READS = new Set(['state', 'models', 'efforts', 'earlier', 'room-progress', 'exchange', 'usage', 'schedules', 'memory-view', 'browser-wait', 'browser-result', 'diagnostics', 'diagnostics-log', 'diagnostics-clear', 'update-check', 'update-install', 'dsh-update-install', 'repo-stars'])
+  const READS = new Set(['state', 'models', 'efforts', 'earlier', 'room-progress', 'exchange', 'usage', 'schedules', 'memory-view', 'browser-wait', 'browser-result', 'diagnostics', 'diagnostics-log', 'diagnostics-clear', 'update-check', 'update-install', 'dsh-update-install', 'repo-stars', 'approval-answer'])
 
   function setPrefs(body) {
     if (body.theme !== undefined) {
@@ -196,6 +205,11 @@ export function install(rt) {
           await rt.load()
           await rt.deleteRoom(body.id)
           return ok(view())
+        case 'approval-answer':
+          rt.answerApproval(body.id, body.choice)
+          return ok(true)
+        case 'stop-member-work':
+          return ok(await rt.stopMemberWork(String(body.roomId ?? ''), String(body.botId ?? '')))
         case 'dismiss-question':
           await rt.load()
           if (state.questions[body.sessionId] !== undefined) {
@@ -215,6 +229,12 @@ export function install(rt) {
         case 'connector-retry':
           await rt.load()
           return ok(await rt.connectorEndpoint(endpoint, body))
+        case 'capability-save':
+        case 'capability-delete':
+        case 'capability-approve':
+        case 'bot-capability':
+          await rt.load()
+          return ok(await rt.capabilityEndpoint(endpoint, body))
         case 'schedules':
         case 'schedule-create':
         case 'schedule-delete':
@@ -237,6 +257,7 @@ export function install(rt) {
           // Claim the question before queueing so a second answer is refused.
           delete state.questions[sessionId]
           try {
+            await rt.ensureCapabilities(sessionId)
             const agent = await rt.resolveAgent(sessionId)
             agent.followup(createUserMessage({ content: [{ type: 'text', text: reply.text }], source: reply.source }))
             await ctx.sessions.flush(agent.session)
@@ -254,6 +275,7 @@ export function install(rt) {
           // A Bot id or an earlier part of its own chat means the current part.
           const past = rt.pastOwners.get(body.sessionId)
           const sessionId = rt.botOf(body.sessionId) ? rt.chatOf(body.sessionId) : past && past.roomId === undefined ? rt.chatOf(past.botId) : body.sessionId
+          await rt.ensureCapabilities(sessionId)
           await ctx.sessionController.prompt({
             requestId: randomUUID(),
             sessionId,

package/src/host/constants.js

@@ -26,6 +26,9 @@ export const ROOM_REPLY_TIMEOUT_MS = 240_000
 export const SOURCE_KIND = 'bot'
 // An answer from a question card, in the shape DSH's own late question replies use.
 export const REPLY_KIND = 'user-question-reply'
+// DSH's snapshot of a referenced conversation, logged right after the user's message
+// that cites it.
+export const REFERENCE_KIND = 'session-reference'
 // `everyone`: every member answers a plain message in turn, admin first. `admin`: a
 // plain message goes to the admin, who calls others with @mentions. New groups start
 // in `admin` mode, because every extra speaker re-reads its whole context; a group
@@ -42,13 +45,21 @@ export const AGENT_SESSION_TITLE_MAX = 80
 // Every tool this plugin registers for Bots. `read_browser` only exists in the
 // Desktop profile, so a restriction filters this list down to registered names.
 export const TEAM_TOOLS = [
-  'list_bots', 'message_bot', 'create_bot', 'update_bot', 'list_models',
+  'list_bots', 'message_bot', 'stop_bot', 'create_bot', 'update_bot', 'list_models',
   'create_group', 'update_group', 'delete_group', 'post_to_group', 'ask_user',
   'request_secret', 'list_secrets', 'group_relay', 'read_own_chat',
   'read_group_chat', 'remember', 'forget', 'recall', 'read_browser',
+  'list_capabilities', 'save_capability', 'delete_capability',
+  'attach_capability', 'detach_capability',
 ]
 // Rounds Bots may start in one group by posting, before the user speaks there again.
 export const ROOM_BOT_ROUNDS = 3
+// Answers a group gives to what members post after the round moved on (their finished
+// work, mostly), before the user speaks there again.
+export const ROOM_LATE_ROUNDS = 10
+// A member still at work this long after its first tool call lets the round go on; it
+// posts its reply when the work is done.
+export const ROOM_WORK_GRACE_MS = 15_000
 
 export const OWN_CHAT_LINE_MAX = 400
 // The message an anchor points at is shown whole (up to this), so a long draft takes

package/src/host/delivery.js

@@ -12,8 +12,13 @@ export function install(rt) {
     return resolved.agent
   }
 
-  const headerFor = (role, fromName, roomName, audience, note = 'new message') => {
+  const headerFor = (role, fromName, roomName, audience, note = 'new message', deferred = false, { resumed = false, retried = false } = {}) => {
+    if (deferred) return `[Message from ${fromName} · you read it during your last task; answer it now]`
+    if (retried && role !== 'room') return '[Your last reply wrote a tool call as text, so nothing ran]'
+    if (resumed && role === 'resume') return '[DeepSeek Harness restarted while you were working]'
+    if (resumed && role !== 'room') return `[Message from ${fromName} · DeepSeek Harness restarted while you were working on it]`
     if (role === 'reply') return `[Reply from ${fromName}]`
+    if (role === 'stopped') return `[Stopped by ${fromName}]`
     if (role === 'room') return `[Group chat "${roomName}" · ${note}]`
     if (role === 'report') return `[Group chat "${roomName}" · replies to your post]`
     if (role === 'kickoff') return '[Bot team setup]'
@@ -22,8 +27,18 @@ export function install(rt) {
     return `[Message from ${fromName}]`
   }
 
+  // Roles recorded as team exchanges.
+  const EXCHANGE_ROLES = new Set(['request', 'reply', 'stopped'])
+
   // `sessionId` defaults to the recipient's own chat; group turns name its group Session.
-  async function deliver({ fromId, toId, sessionId, text, role, hop = 0, replyTo, roomId, audience, note, exchangeId = randomUUID() }) {
+  // `deferred`: a request the Bot already read mid-turn, handed back to answer in a
+  // turn of its own; its exchange was recorded when it first arrived. `resumed` and
+  // `retried` carry on a turn that a restart cut off or that wrote its tool call as
+  // text (resume.js, turns.js), and `resent` is a message a shutdown cancelled; their
+  // exchange is recorded already too. `askedBy` is the member whose @mention called a
+  // group turn (groups.js). `fromRoomId`: the group whose Session the sender wrote
+  // from; the reply goes back to that Session (turns.js).
+  async function deliver({ fromId, toId, sessionId, text, role, hop = 0, replyTo, roomId, audience, note, exchangeId = randomUUID(), steer = false, deferred = false, resumed = false, retried = false, resent = false, askedBy, fromRoomId }) {
     const from = rt.botOf(fromId)
     const to = rt.botOf(toId)
     if (to === undefined) throw new Error(`Unknown Bot ${toId}`)
@@ -41,16 +56,27 @@ export function install(rt) {
       ...(replyTo ? { replyTo } : {}),
       ...(roomId ? { roomId } : {}),
       ...(audience === 'user' ? { audience } : {}),
+      ...(deferred ? { deferred: true } : {}),
+      ...(resumed ? { resumed: true } : {}),
+      ...(retried ? { retried: true } : {}),
+      ...(askedBy ? { askedBy } : {}),
+      ...(fromRoomId ? { senderRoomId: fromRoomId } : {}),
     }
-    if (role === 'request' || role === 'reply') {
+    if (EXCHANGE_ROLES.has(role) && !deferred && !resumed && !retried && !resent) {
       state.exchanges.push({ id: exchangeId, from: fromId, to: toId, text, role, time: Date.now(), ...(replyTo ? { replyTo } : {}), ...(audience === 'user' ? { audience } : {}) })
-      void rt.save()
+      void rt.save().catch(() => {})
     }
-    const agent = await resolveAgent(sessionId ?? rt.chatOf(toId))
-    agent.followup(createUserMessage({
-      content: [{ type: 'text', text: `${headerFor(role, fromName, room?.name, audience, note)}\n${text}` }],
+    const targetSessionId = sessionId ?? rt.chatOf(toId)
+    await rt.ensureCapabilities(targetSessionId)
+    const agent = await resolveAgent(targetSessionId)
+    // A steered message cuts into a running turn at its next step; a follow-up
+    // queues for the next turn (see turns.js for how each is routed).
+    const message = createUserMessage({
+      content: [{ type: 'text', text: `${headerFor(role, fromName, room?.name, audience, note, deferred, { resumed, retried })}\n${text}` }],
       source,
-    }))
+    })
+    if (steer) agent.steer(message)
+    else agent.followup(message)
     await ctx.sessions.flush(agent.session)
     return exchangeId
   }

package/src/host/diagnostics.js

@@ -16,7 +16,7 @@ const LOG_MAX_BYTES = 1 << 20
 const STACK_LINES = 8
 const TEXT_MAX = 2000
 export const REPORT_ENTRIES = 20
-export const ISSUES_URL = 'https://github.com/FeiZhuLulu/DeepSeek-Bot/issues/new'
+export const ISSUES_URL = 'https://github.com/Fei2411/DeepSeek-Bot/issues/new'
 
 const quote = value => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 
@@ -144,7 +144,7 @@ export function install(rt) {
     }).catch((error) => {
       if (fileFailed) return
       fileFailed = true
-      console.error('[ds-bot] diagnostics log not written:', error?.code ?? error?.message ?? error)
+      console.error('[ds-bot] diagnostics log not written:', error?.code ?? clean(error?.message ?? String(error)))
     })
   }
 
@@ -164,13 +164,15 @@ export function install(rt) {
   }
 
   const warn = (template, ...args) => {
-    ctx.logger.warn(template, ...args)
-    console.error(`[ds-bot] ${template}`, ...args.map(arg => arg?.stack ?? arg))
     const error = args.find(arg => arg instanceof Error)
+    const line = clean(format(template, ...args.map(arg => (arg instanceof Error ? errorText(arg) : arg))))
+    const frames = typeof error?.stack === 'string' ? error.stack.split('\n').filter(item => /^\s+at /.test(item)).slice(0, STACK_LINES).map(item => item.trim()) : []
+    ctx.logger.warn('%s', line)
+    console.error(`[ds-bot] ${line}${frames.length > 0 ? `\n${clean(frames.join('\n'))}` : ''}`)
     note({
       level: 'warn',
       source: 'host',
-      text: format(template, ...args.map(arg => (arg instanceof Error ? errorText(arg) : arg))).replace(/^ds-bot: /, ''),
+      text: line.replace(/^ds-bot: /, ''),
       code: typeof error?.code === 'string' ? error.code : undefined,
       stack: error?.stack,
     })