@soffits/dsh-telegram-bot 0.4.0 → 0.4.1

package/MAINTAINING.md

@@ -5,7 +5,7 @@ This repository is a maintained fork of [Boobaw/dsh-telegram-bot](https://github
 - `/new`: a fresh session in the same topic and workspace.
 - User-created topics: each new topic asks for its workspace and a new or existing session; `/workspace` switches; topic names are never changed after session titles.
 - Two-way sync: turns started in the Web UI, by scheduled tasks or by other plugins also appear in the bound topic (`mirrorTurns`).
-- Sending into topics by thread id: the `telegramTopics` Host service, the `telegram_send` tool and the `dsh-telegram-send` command, with the sender (job, session) recorded and remembered, so replies to those messages carry the full original.
+- Sending into topics by thread id: the `telegramTopics` Host service, the `telegram_send` tool and the `dsh-telegram-send` command, with the sender (job, session) recorded and remembered, so replies to those messages carry the full original. Every send, the bound session's own included, is recorded in the bound session as a `user/message` (`telegram-post:` request id, which the mirror skips) with its pictures, files and sticker image as attachments, because DSH has no non-model entry a plugin may append (new event types make a session unreadable) and a plain user message is what the Web UI draws with images. `recordMessage` appends it to an idle session and queues it otherwise.
 - Sessions the bot creates are never left blank (DSH's New conversation would reuse them): see `claimForTopic` in `src/app.js`.
 - Topic session titles are `<topic name> · <DSH title>`: DSH has no title hook, so `syncTopicTitle` re-appends each generated `session/title` with the prefix and the same source (automatic titling keeps running), and `startTopicTitle` calls `sessionTitle.refresh` at the first model request, because the bare-name placeholder is a user title that stops automatic titling. Topic renames record a `telegram-topic` notice as a `user/message` (`recordNote`): session search indexes only message, tool and todo events, not titles or queued inbox items.
 - Deleted topics are forgotten as soon as any Bot API call reports them gone (`forgetGoneTopic`).

package/README.md

@@ -142,7 +142,7 @@ Private-chat topics send with `message_thread_id`. If Telegram answers `message
 
 ## Send to a topic
 
-Scripts, scheduled jobs, other plugins and agents can post into a topic by its numeric thread id (`/id` in the topic shows it). The message (text and files) appears in the topic and is also recorded in the session bound to that topic, without starting a turn: it is queued as context for that session's next turn, labelled with who sent it. Thread ids belong to one chat, so the message goes to the chat the bot saw that thread in (its binding or known name), not the chat that last wrote to the bot. A thread id the bot does not know in any chat is an error; nothing is created. In the rare case two chats have a topic with the same thread id, the send fails until the caller names the chat (`chat`, `--chat`). Topic names are only labels, never addresses. A known topic with no session gets a new one first, made the way `/new` makes it (the configured working directory and preset, titled after the topic), so the message is recorded; only a topic whose user is still choosing its session just shows the message, and the result says so (`note`). If no session can take the record, the message is still sent and the result carries `recordError`.
+Scripts, scheduled jobs, other plugins and agents can post into a topic by its numeric thread id (`/id` in the topic shows it). The message (text, files, a sticker) appears in the topic and is also recorded in the session bound to that topic, without starting a turn, labelled with who sent it. This holds for the bound session's own sends too, so a Web UI reader of that session sees the same pictures, files and stickers: pictures and stickers (as their still image) are recorded as images, other files as file attachments. An idle session gets the record at once; a busy one gets it at its next step. Thread ids belong to one chat, so the message goes to the chat the bot saw that thread in (its binding or known name), not the chat that last wrote to the bot. A thread id the bot does not know in any chat is an error; nothing is created. In the rare case two chats have a topic with the same thread id, the send fails until the caller names the chat (`chat`, `--chat`). Topic names are only labels, never addresses. A known topic with no session gets a new one first, made the way `/new` makes it (the configured working directory and preset, titled after the topic), so the message is recorded; only a topic whose user is still choosing its session just shows the message, and the result says so (`note`). If no session can take the record, the message is still sent and the result carries `recordError`.
 
 The bot also remembers each such send (`$DSH_HOME/telegram/sent-messages.json`: the last 1,000 sends from the past 180 days, text up to 20,000 characters). When someone replies to or quotes one of those messages, the agent gets the whole original text, however many Telegram messages it was split into, with its send time, job name and sending session, and a hint to open that session for more context. This works after `/new` too, when the current session never saw the message.
 

package/client.js

@@ -1,5 +1,5 @@
 window.__ModuleLoader__.load({
-  id: 'dsh-telegram-bot',
+  id: '@soffits/dsh-telegram-bot',
   factory: (require) => {
     var module = { exports: {} }
     var exports = module.exports

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soffits/dsh-telegram-bot",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Telegram sessions, topics, model controls and approvals for DeepSeek Harness.",
   "type": "module",
   "main": "./index.js",

package/src/app.js

@@ -45,7 +45,7 @@ import { runProgram, spokenMediaOf, transcribe, transcriptNote } from './voice.j
 import { createStickerLibrary, describeSticker, STICKER_PREVIEW_DIR } from './stickers.js'
 import { composePrompt, DOWNLOAD_LIMIT_BYTES, downloadableFile, isForwarded, messageBody, repliedMessage, replyReference, senderLabel } from './message-context.js'
 import { createSentLog } from './sent-log.js'
-import { catalogKey, createModelCatalog, defaultModelOf, effortChoices, healGoneRoute, effortName, findModel, modelByKey, modelName, pageOf, pickedSelection, providerByKey, sameSelection, sessionModelOf } from './models.js'
+import { catalogKey, createModelCatalog, defaultModelOf, effortChoices, effortName, findModel, isGoneModel, modelByKey, modelName, pageOf, pickedSelection, providerByKey, sameSelection, sessionModelOf } from './models.js'
 import {
   allowedChatsOf,
   allowedUsersOf,
@@ -1060,6 +1060,7 @@ export function apply(ctx, config) {
     if (data.length >= 12 && data.toString('latin1', 0, 4) === 'RIFF' && data.toString('latin1', 8, 12) === 'WEBP') return { mediaType: 'image/webp', ext: '.webp' }
     if (data.length >= 3 && data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff) return { mediaType: 'image/jpeg', ext: '.jpg' }
     if (data.length >= 8 && data.toString('latin1', 1, 4) === 'PNG') return { mediaType: 'image/png', ext: '.png' }
+    if (data.length >= 6 && data.toString('latin1', 0, 4) === 'GIF8') return { mediaType: 'image/gif', ext: '.gif' }
     return undefined
   }
 
@@ -1966,18 +1967,43 @@ export function apply(ctx, config) {
    * @returns the live agent.
    */
   /**
-   * Move a bound session whose model route is gone from this host onto the
-   * default model (see `healGoneRoute`), so the topic keeps answering.
+   * Move a topic's session off a model the catalog no longer offers (a
+   * removed provider or a dropped model: every turn would fail before any
+   * request, so no fallback can help). The session goes to the current
+   * default through the Web picker's `selectModel`, a stale per-topic pick is
+   * dropped, and the topic gets one line about it. A model that is merely
+   * failing now, or no catalog, changes nothing.
+   * @param chat - chat bridge state.
    * @param agent - the session's live agent.
    */
-  async function healRoute(agent) {
+  async function healRoute(chat, agent) {
     try {
-      const moved = await healGoneRoute(ctx, agent)
-      if (moved !== undefined) {
-        warn(`${agent.session?.id ?? agent.id} was on ${moved.from.provider}/${moved.from.model}, which this host no longer has; it continues on the default ${moved.to.provider}/${moved.to.model}`)
+      const catalog = await modelCatalog.load()
+      const pickKey = `${chat.chatId}:${chat.threadId}`
+      if (isGoneModel(catalog, state.pickedModels?.[pickKey])) {
+        delete state.pickedModels[pickKey]
+        void persistState()
+      }
+      const current = agent.model?.current?.()
+      if (!isGoneModel(catalog, current)) return
+      const fallback = defaultModelOf(ctx)
+      if (fallback === undefined || isGoneModel(catalog, fallback)) return
+      const controller = ctx.get('sessionController')
+      if (typeof controller?.selectModel === 'function') {
+        await controller.selectModel({ sessionId: agent.session?.id ?? chat.sessionId, ...fallback })
+      } else {
+        agent.model.select(fallback)
       }
+      warn(`${agent.session?.id ?? agent.id} was on ${current.provider}/${current.model}, which is not offered any more; it continues on ${fallback.provider}/${fallback.model}`)
+      const name = (selection) => findModel(catalog, selection)?.model.name ?? `${selection.provider}/${selection.model}`
+      await send(
+        chat.chatId,
+        `🤖 ${tr(`${escapeHtml(`${current.provider}/${current.model}`)} is gone; this topic now uses ${escapeHtml(name(fallback))}.`, `${escapeHtml(`${current.provider}/${current.model}`)} больше недоступна; топик теперь использует ${escapeHtml(name(fallback))}.`)}`,
+        bridgeAbort.signal,
+        chat.threadId,
+      )
     } catch (error) {
-      warn(`could not check the model route of ${agent.session?.id ?? agent.id}: ${messageOf(error)}`)
+      warn(`could not check the model of ${agent.session?.id ?? agent.id}: ${messageOf(error)}`)
     }
   }
 
@@ -1996,7 +2022,7 @@ export function apply(ctx, config) {
         if (typeof live.session?.header?.cwd === 'string') chat.cwd = live.session.header.cwd
         attachAgent(live, chat)
         await syncPermission(chat, live)
-        await healRoute(live)
+        await healRoute(chat, live)
         return live
       }
       try {
@@ -2006,7 +2032,7 @@ export function apply(ctx, config) {
         if (typeof agent?.session?.header?.cwd === 'string') chat.cwd = agent.session.header.cwd
         attachAgent(agent, chat)
         await syncPermission(chat, agent)
-        await healRoute(agent)
+        await healRoute(chat, agent)
         info(`resumed Telegram session ${chat.sessionId}`)
         return agent
       } catch (error) {
@@ -3336,18 +3362,31 @@ export function apply(ctx, config) {
    * @param summary - one-line label the Web UI shows.
    */
   function recordNote(agent, text, summary) {
-    const message = {
+    recordMessage(agent, {
       id: randomUUID(),
       role: 'user',
       content: [{ type: 'text', text }],
       source: { kind: 'telegram-topic', form: 'notice', summary: summary.slice(0, 120) },
-    }
+    })
+  }
+
+  /**
+   * Put a message into a session without starting a turn: appended now to an
+   * idle session whose surface starts with its system prompt, otherwise queued
+   * for the next step (see recordNote for why). Either way the Web UI shows
+   * it, images included, and the model reads it at its next step.
+   * @param agent - the session's live agent.
+   * @param message - a user message (`{ id, role, content, source }`).
+   */
+  function recordMessage(agent, message) {
     if (agent.status === 'idle' && typeof agent.session?.append === 'function' && hasSystemHead(agent.session)) {
       agent.session.append('user/message', message, { surfaceOp: 'append' })
     } else if (typeof agent.inject === 'function') {
       agent.inject(message)
+    } else if (typeof agent.send === 'function') {
+      agent.send(message, 'next-step', false)
     } else {
-      throw new Error('The session cannot record notes.')
+      throw new Error('The session cannot record messages.')
     }
   }
 
@@ -3566,6 +3605,59 @@ export function apply(ctx, config) {
     return { path, name: basename(path), data }
   }
 
+  /**
+   * The content blocks that show sent files in a session: pictures as images
+   * (the Web UI draws them inline), everything else as file attachments. A
+   * picture DSH refuses as an image is kept as a file; a file that cannot be
+   * stored at all becomes a line naming it, so the rest is still recorded.
+   * @param files - `{ name, data }` as read for upload.
+   * @returns content blocks, in file order.
+   */
+  async function recordedFiles(files) {
+    const store = ctx.get('attachments')
+    const blocks = []
+    for (const file of files) {
+      const image = sniffImage(file.data)
+      try {
+        if (store === undefined) throw new Error('no attachment store')
+        if (image !== undefined) {
+          try {
+            blocks.push({ type: 'image', attachment: await store.saveImage({ data: file.data, mediaType: image.mediaType, name: file.name }) })
+            continue
+          } catch (error) {
+            warn(`${file.name} kept as a file, not an image: ${messageOf(error)}`)
+          }
+        }
+        blocks.push({ type: 'file', attachment: await store.saveFile({ data: file.data, name: file.name }) })
+      } catch (error) {
+        warn(`${file.name} not stored in the session: ${messageOf(error)}`)
+        blocks.push({ type: 'text', text: `[File ${file.name} was sent but could not be stored here: ${messageOf(error)}]` })
+      }
+    }
+    return blocks
+  }
+
+  /**
+   * The sticker's still picture as an image block, for the session record.
+   * @param sticker - sticker library entry.
+   * @param signal - request lifetime.
+   * @returns one image block, or none when the sticker has no still picture
+   *   or it cannot be stored (the text line still names the sticker).
+   */
+  async function recordedSticker(sticker, signal) {
+    const store = ctx.get('attachments')
+    if (store === undefined || typeof sticker?.id !== 'string') return []
+    try {
+      const preview = await stickerPreview(sticker, signal)
+      if (preview === undefined) return []
+      const attachment = await store.saveImage({ data: preview.data, mediaType: preview.mediaType, name: `sticker-${sticker.id}${extname(preview.path)}` })
+      return [{ type: 'image', attachment }]
+    } catch (error) {
+      warn(`sticker ${sticker.id} preview not stored in the session: ${messageOf(error)}`)
+      return []
+    }
+  }
+
   /**
    * Remember that a file went to a topic in one turn, so the same file is
    * not uploaded twice in that turn (present, telegram_send and reply images
@@ -3697,8 +3789,8 @@ export function apply(ctx, config) {
    *   thread id; the message goes to the chat the bot saw that thread in,
    *   or to `chat` when given (needed only when two chats share the id);
    *   `from` may hold `label` (who sent it), `job` (a job name)
-   *   and `sessionId` (the sender session; when it is the bound session
-   *   itself, no copy is recorded).
+   *   and `sessionId` (the sender session; the bound session sending into
+   *   its own topic gets its copy too, labelled "by this session").
    * @param signal - request lifetime.
    * @returns where it went and whether the session recorded it.
    */
@@ -3779,31 +3871,24 @@ export function apply(ctx, config) {
         }
       }
     }
-    if (typeof sessionId === 'string' && sessionId !== request?.from?.sessionId) {
+    // Every send is recorded in the bound session, the sender's own included:
+    // the Web UI shows that session, and a tool call alone shows neither the
+    // picture nor the sticker that went to Telegram.
+    if (typeof sessionId === 'string') {
       try {
         const chat = await chatFor(chatId, threadId)
         const agent = ctx.get('agents')?.get(sessionId) ?? await ensureAgent(chat)
-        const label = sender.length > 0 ? ` by ${sender}` : ''
+        const self = sessionId === request?.from?.sessionId
+        const label = self ? ' by this session' : sender.length > 0 ? ` by ${sender}` : ''
         const where = target.name === undefined ? `topic ${threadId}` : `topic "${target.name}"`
         const stickerLine = sticker === undefined ? '' : `\n[Sticker ${describeSticker(sticker)}]`
         const content = [{ type: 'text', text: `[Sent to the Telegram ${where}${label}]${text.trim().length > 0 ? `\n${text.trim()}` : ''}${stickerLine}` }]
-        const store = ctx.get('attachments')
-        for (const file of files) {
-          if (store === undefined) break
-          const mediaType = PHOTO_TYPES[extname(file.name).toLowerCase()]
-          const attachment = mediaType === undefined
-            ? await store.saveFile({ data: file.data, name: file.name })
-            : await store.saveImage({ data: file.data, mediaType, name: file.name })
-          content.push({ type: mediaType === undefined ? 'file' : 'image', attachment })
-        }
+        content.push(...await recordedFiles(files))
+        if (sticker !== undefined) content.push(...await recordedSticker(sticker, signal))
         const id = randomUUID()
-        // A next-step inbox item is durable and waits for whatever turn comes
-        // next; it does not wake the agent. The request id keeps the mirror from
-        // echoing it back into the topic.
-        const message = { id, role: 'user', content, source: { kind: 'user', rpcId: `telegram-post:${id}` } }
-        if (typeof agent?.inject === 'function') agent.inject(message)
-        else if (typeof agent?.send === 'function') agent.send(message, 'next-step', false)
-        else throw new Error('The bound session cannot record messages.')
+        // Recording never starts a turn. The request id keeps the mirror from
+        // echoing the copy back into the topic.
+        recordMessage(agent, { id, role: 'user', content, source: { kind: 'user', rpcId: `telegram-post:${id}` } })
         recorded = true
       } catch (error) {
         // The message is already in Telegram; report the missing record
@@ -3825,7 +3910,7 @@ export function apply(ctx, config) {
         job: typeof request?.from?.job === 'string' && request.from.job.trim().length > 0 ? request.from.job.trim() : null,
         label: typeof request?.from?.label === 'string' ? request.from.label : null,
         boundSession: typeof sessionId === 'string' ? sessionId : null,
-        recorded: recorded || (typeof sessionId === 'string' && sessionId === request?.from?.sessionId),
+        recorded,
       })
     } catch (error) {
       reportError('sent-log', error)
@@ -6095,7 +6180,7 @@ export function apply(ctx, config) {
   /** Model-facing tool for sending into a topic; see sendToTopic. */
   const sendTool = {
     name: 'telegram_send',
-    description: 'Send a message, and optionally files, into a Telegram topic of the DSH Telegram bot, addressed by its numeric thread id. The message appears in the topic and is recorded in the session bound to that topic, which sees it on its next turn; no turn is started. Use it to notify the user on Telegram. It goes to the chat that owns the thread; fails on a thread id the bot does not know.',
+    description: 'Send a message, and optionally files, into a Telegram topic of the DSH Telegram bot, addressed by its numeric thread id. The message appears in the topic and is recorded in the session bound to that topic, files and pictures included, so it also shows there in the Web UI; that session reads it at its next step, and no turn is started. Use it to notify the user on Telegram. It goes to the chat that owns the thread; fails on a thread id the bot does not know.',
     parameters: {
       type: 'object',
       properties: {
@@ -6128,7 +6213,7 @@ export function apply(ctx, config) {
   /** Model-facing tool for the sticker library; see stickers.js. */
   const stickerTool = {
     name: 'telegram_sticker',
-    description: 'Use the Telegram sticker library: stickers the user sent (added automatically) and whole sets you add. find: search by meaning words, emoji or set. view: see one sticker as an image. note: save what a sticker means and when to use it, so find can pick it later. add_set: load every sticker of a set by its name (the part after t.me/addstickers/). send: send a sticker into a topic by thread id; it is recorded in the bound session like telegram_send.',
+    description: 'Use the Telegram sticker library: stickers the user sent (added automatically) and whole sets you add. find: search by meaning words, emoji or set. view: see one sticker as an image. note: save what a sticker means and when to use it, so find can pick it later. add_set: load every sticker of a set by its name (the part after t.me/addstickers/). send: send a sticker into a topic by thread id; it is recorded in the bound session, with its picture, like telegram_send.',
     parameters: {
       type: 'object',
       properties: {

package/src/client.js

@@ -1,5 +1,5 @@
 window.__ModuleLoader__.load({
-  id: 'dsh-telegram-bot',
+  id: '@soffits/dsh-telegram-bot',
   factory: (require) => {
     var module = { exports: {} }
     var exports = module.exports

package/src/models.js

@@ -79,34 +79,19 @@ export function defaultModelOf(ctx) {
   return undefined
 }
 
-/** Failure codes that mean a route is gone from this host, not briefly down. */
-const GONE_ROUTE_CODES = new Set(['NO_ADAPTER', 'UNKNOWN_MODEL'])
-
 /**
- * Move a session off a model route this host no longer has (a provider that
- * was removed, a model dropped from its catalog) onto the default model, so
- * a topic left on that route answers again instead of failing every turn
- * with NO_ADAPTER. The switch is recorded on the session only, the way a job
- * picks its model; the saved default stays as it is. Routes that resolve, or
- * fail for any other reason, are left alone.
- * @param ctx - Host context (`llm`, `agentDefaultModel`).
- * @param agent - the session's live agent.
- * @returns the dead route and the default it moved to, or undefined.
+ * Whether the catalog no longer offers a selection's provider or model, for
+ * example after a provider was removed from the profile. A provider the
+ * catalog reports as failing is not counted: its models are unknown now, not
+ * gone. Without a catalog nothing is called gone.
+ * @param catalog - loaded catalog, or undefined.
+ * @param selection - provider and model, or undefined.
+ * @returns true when the selection names something the catalog dropped.
  */
-export async function healGoneRoute(ctx, agent) {
-  const current = agent?.model?.current?.()
-  const llm = ctx.get('llm')
-  if (current === undefined || typeof llm?.resolveCallConfig !== 'function') return undefined
-  try {
-    await llm.resolveCallConfig(toSelection(current))
-    return undefined
-  } catch (error) {
-    if (!GONE_ROUTE_CODES.has(error?.code)) return undefined
-  }
-  const fallback = defaultModelOf(ctx)
-  if (fallback === undefined || (fallback.provider === current.provider && fallback.model === current.model)) return undefined
-  agent.model.select(fallback)
-  return { from: toSelection(current), to: fallback }
+export function isGoneModel(catalog, selection) {
+  if (catalog === undefined || typeof selection?.provider !== 'string' || typeof selection?.model !== 'string') return false
+  if (catalog.failures.some((failure) => failure?.id === selection.provider)) return false
+  return findModel(catalog, selection) === undefined
 }
 
 /**