ds-bot 0.1.4 → 0.1.5

package/index.js

@@ -1,7 +1,6 @@
 // DS Bot: a team of long-lived Bots on top of ordinary dsh root Sessions.
 // Every Bot is one root Session; the roster, rooms, and the bot-to-bot exchange log live
 // in one JSON file under DSH_HOME so they survive restarts without new Session event types.
-import { homedir } from 'node:os'
 import { join } from 'node:path'
 import * as diagnostics from './src/host/diagnostics.js'
 import * as store from './src/host/store.js'
@@ -10,6 +9,7 @@ import * as permissions from './src/host/permissions.js'
 import * as turns from './src/host/turns.js'
 import * as delivery from './src/host/delivery.js'
 import * as roster from './src/host/roster.js'
+import * as folders from './src/host/folders.js'
 import * as agents from './src/host/agents.js'
 import * as prompt from './src/host/prompt.js'
 import * as timeContext from './src/host/time-context.js'
@@ -40,17 +40,19 @@ export const inject = ['llm', 'tools', 'systemPrompt', 'sessionController', 'ses
 // the functions other modules call; they call them through `rt` at run time, never during
 // install. Listeners run and tools are listed in registration order, so this order holds:
 // usage meters model requests after every listener that rewrites them.
-const MODULES = [diagnostics, store, models, permissions, turns, delivery, roster, agents, prompt, timeContext, tools, chatIndex, groups, approvals, resume, memory, parts, images, secrets, connectors, capabilities, schedules, browser, usage, update, dshUpdate, channel]
+const MODULES = [diagnostics, store, models, permissions, turns, delivery, roster, folders, agents, prompt, timeContext, tools, chatIndex, groups, approvals, resume, memory, parts, images, secrets, connectors, capabilities, schedules, browser, usage, update, dshUpdate, channel]
 
 export function apply(ctx, config = {}) {
   createRuntime(ctx, config)
 }
 
 export function createRuntime(ctx, config = {}) {
-  const home = config.home ?? join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'bot')
+  const dshHome = folders.dshHomeOf(process.env.DSH_HOME)
+  const home = config.home ?? join(dshHome, 'bot')
   const rt = {
     ctx,
     config,
+    dshHome,
     home,
     statePath: join(home, 'state.json'),
     defaults: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ds-bot",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "DS Bot: a team of long-lived Bots for DeepSeek Harness, with Main Bots, Bot-to-Bot messages and group chats",
   "keywords": [
     "dsh-plugin",

package/src/host/channel.js

@@ -100,7 +100,7 @@ export function install(rt) {
     return rt.save()
   }
 
-  const handle = async (endpoint, payload) => {
+  const handle = async (endpoint, payload, signal) => {
     try {
       const body = payload ?? {}
       await rt.refresh()
@@ -141,7 +141,7 @@ export function install(rt) {
           return ok([...rt.roomProgress.entries()].filter(([, entry]) => entry.roomId === body.roomId).map(([callId, entry]) => ({ callId, replies: entry.replies, speaking: entry.speaking ?? null })))
         case 'create-bot': {
           await rt.bootstrap()
-          const bot = await rt.createBot({ name: body.name, role: body.role, color: body.color, instructions: body.instructions, brief: body.brief, avatar: body.avatar, model: body.model, effort: body.effort })
+          const bot = await rt.createBot({ name: body.name, role: body.role, color: body.color, instructions: body.instructions, brief: body.brief, avatar: body.avatar, model: body.model, effort: body.effort, workDir: body.workDir })
           return ok(bot)
         }
         case 'update-bot':
@@ -174,9 +174,15 @@ export function install(rt) {
             members: Array.isArray(body.members) ? body.members : undefined,
             add: Array.isArray(body.add) ? body.add : undefined,
             remove: Array.isArray(body.remove) ? body.remove : undefined,
+            workDir: body.workDir,
           })
           return ok({ room: view().rooms.find(entry => entry.id === room.id), changes })
         }
+        case 'folders':
+        case 'folder-pick':
+        case 'folder-list':
+          await rt.load()
+          return ok(await rt.folderEndpoint(endpoint, body, signal))
         case 'add-agent':
           await rt.load()
           return ok(await rt.addAgent())
@@ -332,7 +338,7 @@ export function install(rt) {
     fetch: async (request) => {
       let body
       try { body = await request.json() } catch { body = {} }
-      const result = await handle(String(body?.endpoint ?? ''), body?.payload)
+      const result = await handle(String(body?.endpoint ?? ''), body?.payload, request.signal)
       return new Response(JSON.stringify(result), { status: 200, headers: { 'content-type': 'application/json' } })
     },
   }), 'ds-bot: api route')

package/src/host/constants.js

@@ -21,6 +21,9 @@ export const OCR_CACHE_MAX = 500
 export const MAX_AVATAR_IMAGE = 160_000
 export const ROUTE = '/api/bot'
 export const MAX_HOPS = 6
+// Bot requests a Bot's own chat may hold unread; past this the Bot is most likely
+// stuck, and more messages only pile up behind it.
+export const MAX_UNREAD_REQUESTS = 10
 export const MAX_EXCHANGES = 600
 export const ROOM_REPLY_TIMEOUT_MS = 240_000
 export const SOURCE_KIND = 'bot'

package/src/host/delivery.js

@@ -9,6 +9,7 @@ export function install(rt) {
   const resolveAgent = async (sessionId) => {
     const resolved = await ctx.sessionController.resolveAgent(sessionId)
     if ('error' in resolved) throw new Error(resolved.error?.message ?? 'Session unavailable')
+    rt.hideBlockingQuestion(resolved.agent)
     return resolved.agent
   }
 

package/src/host/folders.js

@@ -0,0 +1,135 @@
+// Working folders: where a Bot's Sessions run. A group's folder holds for every member
+// there, else a Bot works in its own folder, else in the team workspace. A Session's
+// folder is fixed when it is made, so a change moves the conversation on to a fresh
+// part (parts.js).
+import { realpath, stat } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { basename, isAbsolute, join, resolve, sep } from 'node:path'
+import { unquote } from './text.js'
+
+const PICK_TIMEOUT_MS = 10 * 60_000
+
+export const within = (inner, outer) => inner === outer || inner.startsWith(outer.endsWith(sep) ? outer : outer + sep)
+
+const expandHome = text => (text === '~' ? homedir() : /^~[\\/]/.test(text) ? join(homedir(), text.slice(2)) : text)
+
+// Read as DSH reads it, so the team's data and the guarded folder are where DSH keeps
+// its own: a blank value counts as unset.
+export const dshHomeOf = value => resolve(expandHome(value?.trim() ? value : join(homedir(), '.dsh')))
+
+export function install(rt) {
+  const { ctx, state } = rt
+
+  const teamFolder = () => ctx.workspaceRegistry.get?.(state.workspaceId)?.path
+  const workDirOf = ({ botId, roomId } = {}) => rt.roomOf(roomId)?.workDir ?? rt.botOf(botId)?.workDir
+  const isFolder = path => stat(path).then(info => info.isDirectory(), () => false)
+  const real = path => realpath(path).catch(() => resolve(path))
+
+  // A Bot that could write where DSH or the team keeps its data could change its own
+  // permissions or the team, so neither those folders nor one that holds them is allowed.
+  async function guarded(path) {
+    const team = teamFolder()
+    for (const root of [rt.dshHome, rt.home]) {
+      const data = await real(root)
+      if (within(data, path)) return true
+      if (within(path, data) && !(team !== undefined && within(path, team))) return true
+    }
+    return false
+  }
+
+  // Saved as the real path, which is what a Session's cwd shows. Undefined means the
+  // team workspace.
+  async function cleanWorkDir(input) {
+    const text = unquote(input)
+    if (text === '') return undefined
+    const expanded = expandHome(text)
+    if (!isAbsolute(expanded)) throw new Error(`Give the full path of the folder, not ${text}`)
+    let path
+    try {
+      path = await realpath(expanded)
+    } catch {
+      throw new Error(`There is no folder at ${text}`)
+    }
+    if (!(await isFolder(path))) throw new Error(`${text} is a file, not a folder`)
+    if (await guarded(path)) throw new Error(`${path} holds DeepSeek Harness data, so Bots cannot work there`)
+    return path === teamFolder() ? undefined : path
+  }
+
+  // Every Session of a Bot: its own chat and its conversation in each of its groups.
+  const sessionsOfBot = botId => [rt.chatOf(botId), ...Object.values(state.rooms)
+    .filter(room => room.members.includes(botId)).map(room => room.sessions?.[botId])].filter(Boolean)
+
+  // A folder outside the team workspace widens where a Bot may write, so a Bot that
+  // sets one for Bots whose writes are bounded by their folder asks the user first.
+  // `sessions` are the Sessions that would work there; the default policy counts too,
+  // since the Sessions made there later start under it. Throws when it is not allowed.
+  async function approveFolder(exec, { path, sessions = [], who }) {
+    const team = teamFolder()
+    const policy = ctx.get?.('sandboxPolicy')
+    if (path === undefined || (team !== undefined && within(path, team)) || policy === undefined) return
+    const agents = await Promise.all(sessions.map(id => rt.resolveAgent(id)))
+    const modes = [policy.resolve(), ...agents.map(agent => policy.resolve({ session: agent.session }))].map(entry => entry.mode)
+    if (!modes.includes('workspace-write')) return
+    const approval = ctx.get?.('approval')
+    const agent = exec.agent
+    if (approval === undefined || agent?.session === undefined) throw new Error(`Working in ${path} needs the user's approval, and there is no way to ask for it here, so nothing changed. The user can make this change in the settings.`)
+    const outcome = await approval.request({
+      agent,
+      toolName: exec.name,
+      ...(exec.callId !== undefined ? { callId: exec.callId } : {}),
+      reason: `Let ${who.en} work in ${path}? Files there can then be changed.`,
+      displayReason: { en: `Let ${who.en} work in ${path}? Files there can then be changed.`, zh: `允许${who.zh}在 ${path} 中工作吗？之后可以修改这个文件夹里的文件。` },
+      ...(exec.signal ? { signal: exec.signal } : {}),
+    })
+    if (outcome === 'allowed-once') return
+    // An approval policy that never asks answers 'rejected' as well.
+    throw new Error(outcome === 'rejected' ? `Working in ${path} was not allowed, so nothing changed. The user can make this change in the settings.`
+      : outcome === 'cancelled' ? 'The approval was cancelled, so nothing changed.'
+        : `Working in ${path} needs the user's approval, and no one could answer, so nothing changed. The user can make this change in the settings.`)
+  }
+
+  const picker = () => {
+    try {
+      return ctx.get?.('directoryPicker')?.capability()
+    } catch {
+      return undefined
+    }
+  }
+
+  async function folderEndpoint(endpoint, body, signal) {
+    switch (endpoint) {
+      case 'folders': {
+        const team = teamFolder() ?? null
+        const known = new Map()
+        for (const workspace of ctx.workspaceRegistry.list?.() ?? []) {
+          if (workspace.path !== team) known.set(workspace.path, workspace.title)
+        }
+        for (const entry of [...Object.values(state.bots), ...Object.values(state.rooms)]) {
+          if (entry.workDir && !known.has(entry.workDir)) known.set(entry.workDir, basename(entry.workDir) || entry.workDir)
+        }
+        const present = await Promise.all([...known].map(async ([path, title]) => (await isFolder(path) ? { path, title } : undefined)))
+        const kind = picker()?.kind
+        return {
+          team,
+          picker: kind === 'native' || kind === 'browse' ? kind : null,
+          folders: present.filter(Boolean),
+        }
+      }
+      case 'folder-pick': {
+        const native = picker()
+        if (native?.kind !== 'native') throw new Error('This DeepSeek Harness has no folder chooser')
+        return await native.pick(AbortSignal.any([signal, AbortSignal.timeout(PICK_TIMEOUT_MS)].filter(Boolean)))
+      }
+      case 'folder-list': {
+        const browse = picker()
+        if (browse?.kind !== 'browse') throw new Error('This DeepSeek Harness cannot list folders')
+        const listing = await browse.list(typeof body.path === 'string' && body.path !== '' ? body.path : undefined, signal)
+        return { path: listing.path, home: listing.home, crumbs: listing.crumbs, entries: listing.entries, truncated: listing.truncated }
+      }
+      default:
+        throw new Error(`Unknown endpoint ${endpoint}`)
+    }
+  }
+
+  Object.assign(rt, { teamFolder, workDirOf, isFolder, cleanWorkDir, sessionsOfBot, approveFolder, folderEndpoint })
+}

package/src/host/groups.js

@@ -124,7 +124,7 @@ export function install(rt) {
       await rt.ensureCapabilities(known)
       return { id: known, brief: undefined }
     }
-    const id = await rt.createSession(`${member.name} · ${room.name}`)
+    const id = await rt.createSession(`${member.name} · ${room.name}`, { dir: rt.workDirOf({ botId: member.id, roomId: room.id }) })
     room.sessions[member.id] = id
     rt.groupOwners.set(id, { botId: member.id, roomId: room.id })
     delete room.seen[member.id]
@@ -651,9 +651,10 @@ export function install(rt) {
 
   // A group chat's own Session never consults the model: models drift from "only call
   // group_relay" (they message one member directly when the user names it), so the
-  // relay step is synthesized here. Auxiliary calls such as titles still reach the model.
+  // relay step is synthesized here. Auxiliary calls such as titles, and DS Bot's own
+  // calls for the room such as image readings, still reach the model.
   ctx.on('llm/stream', (options, next) => {
-    if (options.sessionId === undefined || options.purpose !== undefined) return next()
+    if (options.sessionId === undefined || options.purpose !== undefined || rt.ownRequest(options)) return next()
     return (async function* relayOrPass() {
       await rt.load()
       if (rt.roomOf(options.sessionId) === undefined) {

package/src/host/images.js

@@ -91,10 +91,10 @@ export function install(rt) {
     const route = await ocrRoute()
     if (route === undefined) throw new Error('no vision model is available')
     const assembler = new BlockAssembler()
-    // No sessionId: this call is not a Session request, so the hook below lets it through.
     for await (const chunk of ctx.llm.stream({
       provider: route.provider,
       model: route.model,
+      sessionId,
       messages: rt.tagUsage([{ role: 'user', content: [{ type: 'image', attachment }, { type: 'text', text: OCR_PROMPT }] }], { sessionId, kind: 'image' }),
       maxTokens: 8192,
       signal: AbortSignal.timeout(OCR_TIMEOUT_MS),
@@ -176,7 +176,7 @@ export function install(rt) {
   }
 
   ctx.on('llm/stream', (options, next) => {
-    if (options.sessionId === undefined || !(options.messages ?? []).some(liveImages)) return next()
+    if (options.sessionId === undefined || rt.ownRequest(options) || !(options.messages ?? []).some(liveImages)) return next()
     return (async function* imagesAsTextOrPass() {
       await rt.load()
       if (rt.roomOf(options.sessionId) !== undefined || await readsImages(options.provider, options.model)) {

package/src/host/memory.js

@@ -919,6 +919,7 @@ export function install(rt) {
       for await (const chunk of ctx.llm.stream({
         provider: route.provider,
         model: route.model,
+        ...(tag?.sessionId === undefined ? {} : { sessionId: tag.sessionId }),
         ...(effort === undefined ? {} : { reasoningEffort: effort }),
         system,
         messages,
@@ -936,6 +937,25 @@ export function install(rt) {
     throw new Error(`The model's reasoning used up the output budget (${SUMMARY_MAX_TOKENS} and ${SUMMARY_RETRY_MAX_TOKENS} tokens); no complete answer was written`)
   }
 
+  // A served model can still refuse the call (a key without access, say), and
+  // desiredModel only falls back for models that are not served; so a failed call
+  // is tried once more on the profile default.
+  async function botShot(bot, system, text, tag) {
+    const own = await modelFor(bot)
+    try {
+      return await oneShot(own, system, text, tag)
+    } catch (error) {
+      const fallback = splitRef(await rt.defaultModel())
+      if (fallback === undefined || (fallback.provider === own.provider && fallback.model === own.model)) throw error
+      try {
+        return await oneShot(fallback, system, text, tag)
+      } catch (again) {
+        const said = failure => failure?.message ?? String(failure)
+        throw new Error(`${own.provider}/${own.model}: ${said(error)}; ${fallback.provider}/${fallback.model}: ${said(again)}`)
+      }
+    }
+  }
+
   /** @type {Map<string, {hash:string, text:string, at:number}>} */
   const summaries = new Map()
   const summarizing = new Map()
@@ -955,21 +975,23 @@ export function install(rt) {
   const linesFor = files => allEntries(files).map(entry => `- ${entry.file.topic ? `[[${entry.file.topic}]] ` : ''}${entry.text}`)
 
   function startSummary(bot, own, team, language, hash) {
+    const model = bot.model
     const job = (async () => {
-      const text = await oneShot(await modelFor(bot), SUMMARY_SYSTEM, summaryRequest({ name: bot.name, own: linesFor(own), team: linesFor(team), language }), { sessionId: rt.chatOf(bot.id), kind: 'memory' })
+      const text = await botShot(bot, SUMMARY_SYSTEM, summaryRequest({ name: bot.name, own: linesFor(own), team: linesFor(team), language }), { sessionId: rt.chatOf(bot.id), kind: 'memory' })
       const value = { hash, text: text.slice(0, SUMMARY_TEXT_MAX), at: Date.now() }
       summaries.set(bot.id, value)
       summaryFailures.delete(bot.id)
       if (rt.readOnly() === undefined) await writeText(summaryPath(bot.id), JSON.stringify(value, null, 2))
     })().catch((error) => {
-      summaryFailures.set(bot.id, { hash, message: error?.message ?? String(error) })
+      summaryFailures.set(bot.id, { hash, model, message: error?.message ?? String(error) })
       rt.warn('ds-bot: memory summary for %s failed: %s', bot.name, error)
     }).finally(() => summarizing.delete(bot.id))
     summarizing.set(bot.id, job)
   }
 
   // The summary is written again when the entries or the interface language change;
-  // a failed one waits for `regenerate` instead of retrying on every poll.
+  // a failed one waits for `regenerate`, or a new model for the Bot, instead of
+  // retrying on every poll.
   function memoryView(body) {
     const bot = rt.botOf(String(body.botId ?? ''))
     if (bot === undefined) throw new Error('Unknown Bot')
@@ -979,8 +1001,9 @@ export function install(rt) {
     const language = languageNow()
     const hash = createHash('sha256').update(JSON.stringify([language, linesFor(own), linesFor(team)])).digest('hex')
     const saved = savedSummary(bot.id)
-    const failed = summaryFailures.get(bot.id)
-    const wanted = body.regenerate === true || (body.summarize === true && saved?.hash !== hash && failed?.hash !== hash)
+    const prior = summaryFailures.get(bot.id)
+    const failed = prior?.hash === hash && prior.model === bot.model ? prior : undefined
+    const wanted = body.regenerate === true || (body.summarize === true && saved?.hash !== hash && failed === undefined)
     if (wanted && entries.length > 0 && !summarizing.has(bot.id)) startSummary(bot, own, team, language, hash)
     return {
       botId: bot.id,
@@ -990,7 +1013,7 @@ export function install(rt) {
       summary: entries.length > 0 && saved !== undefined ? { text: saved.text, at: saved.at } : null,
       fresh: entries.length === 0 || saved?.hash === hash,
       summarizing: summarizing.has(bot.id),
-      error: failed?.hash === hash && !summarizing.has(bot.id) ? failed.message : null,
+      error: failed !== undefined && !summarizing.has(bot.id) ? failed.message : null,
     }
   }
 
@@ -1003,7 +1026,7 @@ export function install(rt) {
       ...allEntries(loadScope(ownScope(bot.id))).map(entry => ({ ...entry, scope: 'own' })),
       ...allEntries(loadScope(TEAM)).map(entry => ({ ...entry, scope: 'team' })),
     ]
-    const answer = parseAsk(await oneShot(await modelFor(bot), ASK_SYSTEM, askRequest({ name: bot.name, numbered, language: languageNow(), text }), { sessionId: rt.chatOf(bot.id), kind: 'memory' }))
+    const answer = parseAsk(await botShot(bot, ASK_SYSTEM, askRequest({ name: bot.name, numbered, language: languageNow(), text }), { sessionId: rt.chatOf(bot.id), kind: 'memory' }))
     const meta = { source: 'memory panel', by: 'user', added: today() }
     const changes = []
     for (const change of answer.changes.slice(0, ASK_CHANGES_MAX)) {
@@ -1236,7 +1259,7 @@ export function install(rt) {
       const sizes = { own: ownFiles[0].content.length, team: teamFiles[0].content.length }
       const earlier = batch.earlier.map(line => reviewLine(line.who, line.text, bot))
       const language = writtenIn(read.filter(line => line.who === 'user').map(line => line.text.replace(/^User: /, '')), languageNow())
-      const reply = await oneShot(await modelFor(bot), reviewSystem(writesTeam(bot.id)), reviewRequest({ bot, numbered, left, sizes, where: batch.where, earlier, fresh: fresh.texts, more, language }), { sessionId: rt.chatOf(bot.id), kind: 'memory' })
+      const reply = await botShot(bot, reviewSystem(writesTeam(bot.id)), reviewRequest({ bot, numbered, left, sizes, where: batch.where, earlier, fresh: fresh.texts, more, language }), { sessionId: rt.chatOf(bot.id), kind: 'memory' })
       const changes = parseReview(reply)
       if (changes === undefined) throw new Error(`the model's answer is not a list of changes: ${clip(reply.replace(/\s+/g, ' '), 120)}`)
       const unknown = changes.find(change => change.op !== 'add' && numbered[Number(change.entry) - 1] === undefined)