ds-bot 0.1.4 → 0.1.5

package/src/host/tools.js

@@ -2,16 +2,18 @@
 // question card. Group rounds and reading chats are in groups.js.
 import { randomUUID } from 'node:crypto'
 import { defineTool } from '@deepseek-ai/dsh-tools'
-import { COLORS, EXTRA_COLORS, MAX_HOPS, ROOM_BOT_ROUNDS, ROOM_MODES } from './constants.js'
+import { COLORS, EXTRA_COLORS, MAX_HOPS, MAX_UNREAD_REQUESTS, ROOM_BOT_ROUNDS, ROOM_MODES, SOURCE_KIND } from './constants.js'
 import { unquote } from './text.js'
 
 export const output = { schema: { type: 'string' }, render: (_args, value) => [{ type: 'text', text: String(value) }] }
 export const GROUP_REF = { type: 'string', required: true, description: 'Exact group chat name from list_bots' }
+const BLOCKING_QUESTION_TOOL = 'ask_user_question'
 const MODE_PARAM = {
   type: 'string',
   enum: ROOM_MODES,
   description: '"everyone": every member answers a plain message in turn, admin first. "admin" (the default): a plain message goes to the admin, who calls others with @Name. @mentions always choose who answers.',
 }
+const WORK_DIR_PARAM = { type: 'string', description: 'Full path of the folder to work in, where commands and file tools start. Only when the user asks for it' }
 
 export function install(rt) {
   const { ctx, state } = rt
@@ -29,6 +31,7 @@ export function install(rt) {
       `members: ${members.join(', ')}`,
       room.mode === 'admin' && room.admin ? 'plain messages go to the admin first' : 'every member replies in turn',
       room.notice ? `notice: ${room.notice.split('\n')[0].slice(0, 100)}` : '',
+      room.workDir ? `members work in ${room.workDir} here` : '',
     ].filter(Boolean)
     return `- "${room.name}" — ${parts.join('; ')}`
   }
@@ -45,7 +48,7 @@ export function install(rt) {
       const self = rt.selfOf(exec.agent?.id)
       const lines = Object.values(state.bots).map(bot => {
         const model = bot.appliedModel ?? bot.model
-        const tags = [bot.role, model ? `model ${model}` : '', rt.isMain(bot.id) ? 'Main Bot' : '', bot.id === self ? 'you' : ''].filter(Boolean).join(', ')
+        const tags = [bot.role, model ? `model ${model}` : '', bot.workDir ? `works in ${bot.workDir}` : '', rt.isMain(bot.id) ? 'Main Bot' : '', bot.id === self ? 'you' : ''].filter(Boolean).join(', ')
         const job = bot.instructions ? ` — ${bot.instructions.split('\n')[0].slice(0, 120)}` : ''
         return `- ${bot.name}${tags ? ` (${tags})` : ''}${job}`
       })
@@ -72,6 +75,12 @@ export function install(rt) {
     const room = rt.roomOf(rt.groupOwners.get(sessionId)?.roomId)
     return room ? `group "${room.name}"` : 'its own chat'
   }
+  // Delivered but not read yet: no step or turn has taken them out of the inbox.
+  const unreadRequests = agent => [...(agent.inbox?.nextStep ?? []), ...(agent.inbox?.nextTurn ?? [])]
+    .filter(message => message.source?.kind === SOURCE_KIND && message.source.role === 'request').length
+
+  // A tool that throws shows as failed in the chat, instead of as sent or stopped.
+  const refuse = (message) => { throw new Error(message) }
 
   ctx.tools.register(defineTool({
     name: 'message_bot',
@@ -101,8 +110,13 @@ export function install(rt) {
       const turn = rt.live.get(exec.agent?.id)
       const hop = Math.max(turn?.info?.hop ?? 0, ...(turn?.joined ?? []).map(joined => joined.info?.hop ?? 0))
       if (hop >= MAX_HOPS) return 'This chain of Bot messages is already long. Stop here and report to the user instead.'
+      const chat = rt.chatOf(target.id)
+      const unread = unreadRequests(await rt.resolveAgent(chat))
+      if (unread >= MAX_UNREAD_REQUESTS) {
+        refuse(`Not sent: ${target.name} has not read the last ${unread} messages from Bots yet, so it is most likely stuck, for example waiting for the user. Do not send it more; tell the user that ${target.name} is not responding.`)
+      }
       const toUser = args.reply_to === 'user'
-      const working = rt.live.get(rt.chatOf(target.id))?.turn !== undefined
+      const working = rt.live.get(chat)?.turn !== undefined
       const steer = args.when !== 'queue' && !toUser
       await rt.deliver({ fromId: sender.id, toId: target.id, text: args.message, role: 'request', hop, steer, ...(toUser ? { audience: 'user' } : callerRoom(exec)) })
       const sent = toUser
@@ -112,18 +126,20 @@ export function install(rt) {
           : working
             ? `Queued for ${target.name}: it reads your message after its current work. Its reply will arrive later as a new message; do not wait for it.`
             : `Delivered to ${target.name}. Its reply will arrive later as a new message; do not wait for it.`
+      // "Delivered" only means it is in the inbox; say so when it may sit there a while.
+      const notes = [
+        rt.waitsForApproval?.(chat) ? `${target.name} is waiting for the user's approval, so it reads your message only after the user answers.` : '',
+        unread > 0 ? `${target.name} has not read ${unread === 1 ? 'an earlier message' : `${unread} earlier messages`} from Bots yet.` : '',
+      ].filter(Boolean)
+      const status = notes.length === 0 ? sent : `${sent} ${notes.join(' ')}`
       // Messages reach a Bot's own chat only; work in a group goes on without them.
-      const groups = activeSessions(target.id).running.filter(sessionId => sessionId !== rt.chatOf(target.id))
-      if (groups.length === 0) return sent
+      const groups = activeSessions(target.id).running.filter(sessionId => sessionId !== chat)
+      if (groups.length === 0) return status
       const stop = rt.isMain(sender.id) ? ' If it must not go on there, use stop_bot.' : ''
-      return `${sent} ${target.name} is also working in ${groups.map(whereOf).join(' and ')}; your message does not reach that work.${stop}`
+      return `${status} ${target.name} is also working in ${groups.map(whereOf).join(' and ')}; your message does not reach that work.${stop}`
     },
   }))
 
-  // stop_bot throws when it does nothing, so the chat shows the call as failed
-  // instead of "Stopped".
-  const refuse = (message) => { throw new Error(message) }
-
   ctx.tools.register(defineTool({
     name: 'stop_bot',
     description: 'Main Bot only. Stop another Bot\'s running turn immediately — when it must not finish a dangerous action and a message_bot warning is not enough. Its queued messages are dropped with the turn. It is then told why in a new turn, whose reply comes back to you.',
@@ -160,14 +176,18 @@ export function install(rt) {
       instructions: { type: 'string', required: true, description: 'What this Bot is responsible for and how it should work' },
       brief: { type: 'string', description: 'Why the user wants it, passed to the new Bot as its first context' },
       model: { type: 'string', description: 'Model the Bot runs on, as provider/model or a model id. Only when the user names one; otherwise the DSH default model.' },
+      work_dir: WORK_DIR_PARAM,
     },
     output,
     async execute(args, exec) {
       await rt.load()
       if (!rt.isMain(rt.selfOf(exec.agent?.id))) return 'Only the Main Bot can create Bots. Ask the Main Bot instead.'
       try {
-        const bot = await rt.createBot({ ...args, createdBy: rt.selfOf(exec.agent.id) })
-        return `Created ${bot.name}. It is greeting the user now.`
+        const workDir = args.work_dir ? await rt.cleanWorkDir(args.work_dir) : undefined
+        const name = String(args.name ?? '').trim()
+        await rt.approveFolder(exec, { path: workDir, who: { en: `the new Bot ${name}`, zh: `新 Bot ${name} ` } })
+        const bot = await rt.createBot({ ...args, workDir, createdBy: rt.selfOf(exec.agent.id) })
+        return `Created ${bot.name}${workDir ? `, working in ${workDir}` : ''}. It is greeting the user now.`
       } catch (error) {
         return `Could not create the Bot: ${error.message}`
       }
@@ -176,7 +196,7 @@ export function install(rt) {
 
   ctx.tools.register(defineTool({
     name: 'update_bot',
-    description: 'Change a Bot\'s name, role, color, model, or instructions. Every Bot may change itself; only a Main Bot may change another Bot.',
+    description: 'Change a Bot\'s name, role, color, model, working folder, or instructions. Every Bot may change itself; only a Main Bot may change another Bot.',
     parameters: {
       bot: { type: 'string', description: 'Current name of the Bot to change; leave out to change yourself' },
       name: { type: 'string', description: 'New name' },
@@ -184,6 +204,7 @@ export function install(rt) {
       instructions: { type: 'string', description: 'Replacement instructions' },
       color: { type: 'string', description: `One of ${[...COLORS, ...EXTRA_COLORS].join(', ')}` },
       model: { type: 'string', description: 'Move the Bot to another model, as provider/model or a model id' },
+      work_dir: { ...WORK_DIR_PARAM, description: `${WORK_DIR_PARAM.description}; an empty string returns it to the team workspace` },
     },
     output,
     async execute(args, exec) {
@@ -196,8 +217,13 @@ export function install(rt) {
       if (bot.id !== caller.id && !rt.isMain(self)) return 'Only a Main Bot can change another Bot. Leave out bot to change yourself, or ask a Main Bot with message_bot.'
       try {
         const { name: newName, role, instructions, color, model } = args
-        const next = await rt.updateBot(bot.id, { name: newName, role, instructions, color, ...(model ? { model } : {}) })
-        return `Updated ${next.name}.`
+        const moving = typeof args.work_dir === 'string'
+        const workDir = moving ? await rt.cleanWorkDir(args.work_dir) : undefined
+        if (moving && workDir !== bot.workDir) await rt.approveFolder(exec, { path: workDir, sessions: rt.sessionsOfBot(bot.id), who: { en: bot.name, zh: ` ${bot.name} ` } })
+        const next = await rt.updateBot(bot.id, { name: newName, role, instructions, color, ...(model ? { model } : {}), ...(moving ? { workDir: workDir ?? '' } : {}) })
+        if (!moving) return `Updated ${next.name}.`
+        const folder = workDir ?? 'the team workspace'
+        return bot.id === caller.id ? `Updated ${next.name}. From your next step on, you work in ${folder}.` : `Updated ${next.name}. It now works in ${folder}.`
       } catch (error) {
         return `Could not update the Bot: ${error.message}`
       }
@@ -280,6 +306,7 @@ export function install(rt) {
       remove_members: { type: 'array', items: { type: 'string' }, description: 'Exact names of Bots to remove' },
       admin: { type: 'string', description: 'Member to make the admin; "none" leaves the group without one (Main Bots only)' },
       mode: MODE_PARAM,
+      work_dir: { ...WORK_DIR_PARAM, description: `${WORK_DIR_PARAM.description}. Every member works there in this group; an empty string lets each member work in its own folder again (Main Bots only)` },
     },
     output,
     async execute(args, exec) {
@@ -288,6 +315,8 @@ export function install(rt) {
       if (rt.botOf(self) === undefined) return 'Only Bots on the team can use update_group.'
       const { room, error } = pickRoom(args.group, self)
       if (error) return error
+      const moving = typeof args.work_dir === 'string'
+      if (moving && !rt.isMain(self)) return `Only a Main Bot can set the folder of "${room.name}".`
       const add = resolveBots(args.add_members)
       const remove = resolveBots(args.remove_members)
       const unknown = [...add.unknown, ...remove.unknown]
@@ -301,6 +330,16 @@ export function install(rt) {
         }
       }
       try {
+        const workDir = moving ? await rt.cleanWorkDir(args.work_dir) : undefined
+        // A Bot that joins a group with a folder works there from its first turn.
+        const joining = add.bots.filter(bot => !room.members.includes(bot.id))
+        if (moving && workDir !== room.workDir) {
+          const members = [...room.members, ...joining.map(bot => bot.id)]
+          await rt.approveFolder(exec, { path: workDir, sessions: members.map(id => room.sessions?.[id]).filter(Boolean), who: { en: `every member of "${room.name}"`, zh: `群聊「${room.name}」的成员` } })
+        } else if (joining.length > 0) {
+          const names = joining.map(bot => bot.name)
+          await rt.approveFolder(exec, { path: room.workDir, sessions: joining.map(bot => room.sessions?.[bot.id]).filter(Boolean), who: { en: names.join(', '), zh: ` ${names.join('、')} ` } })
+        }
         const { room: next, changes } = await rt.updateRoom(room.id, {
           name: args.name,
           notice: args.notice,
@@ -308,6 +347,7 @@ export function install(rt) {
           admin,
           add: add.bots.map(bot => bot.id),
           remove: remove.bots.map(bot => bot.id),
+          ...(moving ? { workDir: workDir ?? '' } : {}),
         }, self)
         return changes.length === 0 ? `Nothing changed in "${next.name}".` : `Updated "${next.name}": ${changes.join('; ')}.`
       } catch (failure) {
@@ -425,6 +465,38 @@ export function install(rt) {
     },
   }))
 
+  // dsh's own question tool holds the turn open until the user answers, and every
+  // message from another Bot or a group round queues behind it. Bot Sessions ask
+  // through ask_user instead, so the tool is taken out of their tool list.
+  const hiddenQuestion = new WeakSet()
+  const hideBlockingQuestion = (agent) => {
+    if (agent === undefined || hiddenQuestion.has(agent) || !rt.isBotSession(agent.session?.id)) return
+    if (typeof agent.ctx?.tools?.restrict !== 'function') return
+    try {
+      // restrict() throws on a name this profile does not serve.
+      if (!ctx.tools.schemas(agent).some(schema => schema.name === BLOCKING_QUESTION_TOOL)) return
+      agent.ctx.tools.restrict({ deny: [BLOCKING_QUESTION_TOOL] })
+      hiddenQuestion.add(agent)
+    } catch (error) {
+      rt.warn('ds-bot: %s stays in the tool list of %s: %s', BLOCKING_QUESTION_TOOL, agent.session?.id, error)
+    }
+  }
+  // A new Bot, part, or group Session gets its Agent before ds-bot records it, so the
+  // list is only trimmed once ds-bot resolves that Agent again; the guard refuses
+  // the tool in any Bot Session meanwhile.
+  ctx.tools.guard(exec => (exec.name === BLOCKING_QUESTION_TOOL && rt.isBotSession(exec.agent?.id)
+    ? `Bots cannot use ${BLOCKING_QUESTION_TOOL}. Ask with ask_user in your own chat, or ask in your reply.`
+    : undefined))
+  // Creation waits for this listener, so the Agent's first step already lacks the tool.
+  ctx.on('agent/created', async ({ agent }) => {
+    try {
+      await rt.load()
+      hideBlockingQuestion(agent)
+    } catch (error) {
+      rt.warn('ds-bot: hiding %s on agent/created failed: %s', BLOCKING_QUESTION_TOOL, error)
+    }
+  })
+
   ctx.tools.register(defineTool({
     name: 'list_capabilities',
     description: 'List shared MCP servers, skills, and packs, plus the capabilities attached to you.',
@@ -523,5 +595,5 @@ export function install(rt) {
     }))
   }
 
-  Object.assign(rt, { pickRoom })
+  Object.assign(rt, { pickRoom, hideBlockingQuestion })
 }

package/src/host/turns.js

@@ -40,6 +40,10 @@ export const stripWrittenCalls = text => text
   .replace(/<function=[\w.-]+>[\s\S]*?(?:<\/function>|$)/g, '')
   .trim()
 
+// Under DSH's PTC presentation the model calls only this tool; the program's sub-calls
+// are the tools it really runs.
+const PROGRAM_TOOL = 'run_code'
+
 const RETRY_TEXT = 'Your last reply wrote a tool call as plain text (<tool_call>…), so it did not run and nothing happened. Call the tool through the tool interface now, then reply as you meant to.'
 
 export function install(rt) {
@@ -120,6 +124,22 @@ export function install(rt) {
     else next[id] = value
     activity = next
   }
+  // The newest call still running, a program's sub-calls included, is what the Session
+  // is doing.
+  const showCall = (id, entry) => {
+    const name = [...(entry.calls?.values() ?? [])].at(-1)?.name
+    entry.tool = name
+    if (name !== undefined) setActivity(id, name === 'ask_user' ? undefined : activityOf(name))
+    else if (entry.turn !== undefined) setActivity(id, 'thinking')
+  }
+  const startCall = (id, entry, callId, name, args) => {
+    if (typeof callId === 'string') (entry.calls ??= new Map()).set(callId, { name, args })
+    showCall(id, entry)
+  }
+  const endCall = (id, entry, callId) => {
+    entry.calls?.delete(callId)
+    showCall(id, entry)
+  }
 
   const markExchangeTurn = (sessionId, turn) => {
     const turns = state.exchangeTurns[sessionId] ??= []
@@ -211,7 +231,7 @@ export function install(rt) {
   // the command, path or address it acts on.
   const callDetail = (sessionId, callId) => {
     let args
-    try { args = JSON.parse(live.get(sessionId)?.calls?.get(callId) ?? '{}') } catch { args = {} }
+    try { args = JSON.parse(live.get(sessionId)?.calls?.get(callId)?.args ?? '{}') } catch { args = {} }
     const first = keys => keys.map(key => args?.[key]).find(value => typeof value === 'string' && value.trim() !== '')
     const text = first(['description', 'justification'])
     const code = first(['command', 'cmd', 'file_path', 'path', 'url', 'query'])
@@ -245,16 +265,22 @@ export function install(rt) {
     switch (event.type) {
       case 'tool/call': {
         const name = String(event.data?.name ?? '')
-        setActivity(id, name === 'ask_user' ? undefined : activityOf(name))
-        entry.tool = name
+        startCall(id, entry, event.data?.callId, name, String(event.data?.arguments ?? ''))
+        // A program is as quick as the tools it runs, so its sub-calls decide.
+        if (rt.groupOwners.has(id) && name !== PROGRAM_TOOL) rt.workRoomTurn?.(id, name)
+        break
+      }
+      case 'tool/ptc-dispatch-start': {
+        const name = String(event.data?.name ?? '')
+        startCall(id, entry, event.data?.subCallId, name, JSON.stringify(event.data?.arguments ?? {}))
         if (rt.groupOwners.has(id)) rt.workRoomTurn?.(id, name)
-        if (typeof event.data?.callId === 'string') (entry.calls ??= new Map()).set(event.data.callId, String(event.data.arguments ?? ''))
         break
       }
+      case 'tool/ptc-dispatch':
+        endCall(id, entry, event.data?.subCallId)
+        break
       case 'tool/result':
-        if (entry.turn !== undefined) setActivity(id, 'thinking')
-        entry.tool = undefined
-        entry.calls?.delete(event.data?.callId)
+        endCall(id, entry, event.data?.callId)
         break
       case 'turn/start':
         setActivity(id, 'thinking')

package/src/host/usage.js

@@ -523,6 +523,9 @@ export function install(rt) {
     const tag = from !== null && typeof from === 'object' ? tags.get(from) : undefined
     if (tag !== undefined) tagUsage(to, tag)
   }
+  // DS Bot's own requests name the Session they serve, as some routes require, so
+  // `sessionId` alone does not make a request that Session's own round; the tag does.
+  const ownRequest = options => tags.has(options?.messages)
   // Owner and group use are journaled with the call itself: a Bot or room that
   // is deleted before the first scan still leaves its calls under its own name.
   const journaled = new Map()
@@ -590,5 +593,5 @@ export function install(rt) {
     })()
   })
 
-  Object.assign(rt, { usageView, tagUsage, carryUsageTag })
+  Object.assign(rt, { usageView, tagUsage, carryUsageTag, ownRequest })
 }