@llblab/pi-telegram 0.17.5 → 0.18.0

package/lib/outbound-voice.ts

@@ -8,11 +8,17 @@ import { unlink } from "node:fs/promises";
 import { basename, extname } from "node:path";
 
 import { assertTelegramInlineKeyboardCallbackData } from "./keyboard.ts";
+import { buildTelegramMultipartReplyParameters } from "./replies.ts";
+import {
+  getTelegramTargetThreadParams,
+  type TelegramTarget,
+} from "./target.ts";
 import { getTelegramVoiceSynthesisProviders } from "./voice.ts";
 
 export interface TelegramVoiceReplyTurnView {
   chatId: number;
   replyToMessageId: number;
+  target?: TelegramTarget;
 }
 
 export interface TelegramVoiceReplySenderDeps {
@@ -26,7 +32,12 @@ export interface TelegramVoiceReplySenderDeps {
       stdin?: string;
       retry?: number;
     },
-  ) => Promise<{ stdout: string; stderr: string; code: number; killed: boolean }>;
+  ) => Promise<{
+    stdout: string;
+    stderr: string;
+    code: number;
+    killed: boolean;
+  }>;
   sendMultipart: (
     method: string,
     fields: Record<string, string>,
@@ -68,15 +79,14 @@ export interface TelegramVoiceReplySenderPorts<THandler = unknown> {
 }
 
 function buildVoiceReplyParameters(
+  chatId: number,
   replyToPrompt: boolean | undefined,
   replyToMessageId: number | undefined,
+  target?: TelegramTarget,
 ): string | undefined {
   if (replyToPrompt === false || replyToMessageId === undefined)
     return undefined;
-  return JSON.stringify({
-    message_id: replyToMessageId,
-    allow_sending_without_reply: true,
-  });
+  return buildTelegramMultipartReplyParameters(chatId, replyToMessageId, target);
 }
 
 async function ensureTelegramVoiceFileFormat(
@@ -116,7 +126,7 @@ export function createTelegramVoiceReplySender<THandler = unknown>(
   deps: TelegramVoiceReplySenderDeps,
   ports: TelegramVoiceReplySenderPorts<THandler> = {},
 ) {
-  async function uploadVoiceFile(
+  const uploadVoiceFile = async (
     turn: TelegramVoiceReplyTurnView,
     filePath: string,
     options?: {
@@ -124,13 +134,15 @@ export function createTelegramVoiceReplySender<THandler = unknown>(
       replyMarkup?: unknown;
       transcriptText?: string;
     },
-  ): Promise<void> {
+  ): Promise<void> => {
     const voiceFilePath = await ensureTelegramVoiceFileFormat(filePath);
     assertTelegramInlineKeyboardCallbackData(options?.replyMarkup);
     await sendVoiceChatAction(deps, turn.chatId);
     const replyParameters = buildVoiceReplyParameters(
+      turn.chatId,
       options?.replyToPrompt,
       turn.replyToMessageId,
+      turn.target,
     );
     await deps.sendMultipart(
       "sendVoice",
@@ -138,6 +150,13 @@ export function createTelegramVoiceReplySender<THandler = unknown>(
         chat_id: String(turn.chatId),
         ...(options?.transcriptText ? { caption: options.transcriptText } : {}),
         ...(replyParameters ? { reply_parameters: replyParameters } : {}),
+        ...(turn.target
+          ? Object.fromEntries(
+              Object.entries(getTelegramTargetThreadParams(turn.target)).map(
+                ([key, value]) => [key, String(value)],
+              ),
+            )
+          : {}),
         ...(options?.replyMarkup !== undefined && options.replyMarkup !== null
           ? {
               reply_markup:
@@ -151,9 +170,9 @@ export function createTelegramVoiceReplySender<THandler = unknown>(
       voiceFilePath,
       basename(voiceFilePath),
     );
-  }
+  };
 
-  return async function sendVoiceReply(
+  return async (
     turn: TelegramVoiceReplyTurnView,
     text: string,
     options?: {
@@ -162,8 +181,9 @@ export function createTelegramVoiceReplySender<THandler = unknown>(
       replyToPrompt?: boolean;
       replyMarkup?: unknown;
     },
-  ): Promise<void> {
-    for (const handler of ports.findVoiceHandlers?.(deps.getHandlers?.()) ?? []) {
+  ): Promise<void> => {
+    for (const handler of ports.findVoiceHandlers?.(deps.getHandlers?.()) ??
+      []) {
       try {
         const filePath = await ports.generateVoiceFile?.(text, {
           lang: options?.lang,

package/lib/outbound.ts

@@ -19,6 +19,7 @@ import {
   type TelegramVoiceReplyItem,
 } from "./outbound-markup.ts";
 import { createTelegramVoiceReplySender as createTelegramVoiceReplySenderWithPorts } from "./outbound-voice.ts";
+import type { TelegramTarget } from "./target.ts";
 
 const OUTBOUND_HANDLER_REGISTRY_KEY = "__piTelegramOutboundHandlers__";
 const VOICE_EVENT_RECORDER_KEY = "__piTelegramVoiceEventRecorder__";
@@ -102,6 +103,7 @@ export interface TelegramVoiceExecResult {
 export interface TelegramVoiceReplyTurnView {
   chatId: number;
   replyToMessageId: number;
+  target?: TelegramTarget;
 }
 
 export interface TelegramVoiceReplySenderDeps {
@@ -207,13 +209,13 @@ export interface TelegramOutboundTextReplyRuntimeDeps<TReplyMarkup = unknown> {
     chatId: number,
     replyToMessageId: number | undefined,
     text: string,
-    options?: { parseMode?: "HTML" },
+    options?: { parseMode?: "HTML"; target?: TelegramTarget },
   ) => Promise<number | undefined>;
   sendMarkdownReply: (
     chatId: number,
     replyToMessageId: number | undefined,
     markdown: string,
-    options?: { replyMarkup?: TReplyMarkup },
+    options?: { replyMarkup?: TReplyMarkup; target?: TelegramTarget },
   ) => Promise<number | undefined>;
   cwd?: string;
   recordRuntimeEvent?: TelegramVoiceReplySenderDeps["recordRuntimeEvent"];
@@ -867,14 +869,14 @@ export function createTelegramOutboundReplyArtifactSender(
   deps: TelegramVoiceReplySenderDeps,
 ) {
   const sendVoiceReply = createTelegramVoiceReplySender(deps);
-  return async function sendOutboundReplyArtifacts(
+  return async (
     turn: TelegramVoiceReplyTurnView,
     plan: Pick<
       TelegramOutboundReplyPlan,
       "voiceText" | "voiceReplies" | "lang" | "rate" | "replyMarkup"
     >,
     options?: { replyToPrompt?: boolean },
-  ): Promise<void> {
+  ): Promise<void> => {
     // Normalize voice replies: either use explicit voiceReplies array or fall back to voiceText
     const voiceReplies = plan.voiceReplies?.length
       ? plan.voiceReplies

package/lib/ownership.ts

@@ -0,0 +1,119 @@
+/**
+ * Telegram message ownership helpers
+ * Zones: telegram routing, multi-instance bus, in-memory coordination
+ * Owns live message-id ownership lookup so callbacks/reactions can resolve a Telegram UI surface back to the instance/target that produced it
+ */
+
+import { getTelegramTargetKey, type TelegramTarget } from "./target.ts";
+
+export interface TelegramMessageOwnershipRecord {
+  chatId: number;
+  messageId: number;
+  target: TelegramTarget;
+  instanceId: string;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface TelegramMessageOwnershipStore {
+  record: (input: {
+    chatId: number;
+    messageId: number;
+    target?: TelegramTarget;
+    instanceId: string;
+    now?: number;
+  }) => TelegramMessageOwnershipRecord;
+  get: (
+    chatId: number,
+    messageId: number,
+  ) => TelegramMessageOwnershipRecord | undefined;
+  forget: (chatId: number, messageId: number) => boolean;
+  forgetTarget: (target: TelegramTarget) => number;
+  prune: (options: {
+    now: number;
+    maxAgeMs?: number;
+    maxRecords?: number;
+  }) => number;
+  entries: () => TelegramMessageOwnershipRecord[];
+  clear: () => void;
+}
+
+function getTelegramMessageOwnershipKey(
+  chatId: number,
+  messageId: number,
+): string {
+  return `${chatId}:${messageId}`;
+}
+
+function createTelegramMessageOwnershipRecord(input: {
+  chatId: number;
+  messageId: number;
+  target?: TelegramTarget;
+  instanceId: string;
+  now: number;
+  previous?: TelegramMessageOwnershipRecord;
+}): TelegramMessageOwnershipRecord {
+  return {
+    chatId: input.chatId,
+    messageId: input.messageId,
+    target: input.target ?? { chatId: input.chatId },
+    instanceId: input.instanceId,
+    createdAt: input.previous?.createdAt ?? input.now,
+    updatedAt: input.now,
+  };
+}
+
+export function createTelegramMessageOwnershipStore(): TelegramMessageOwnershipStore {
+  const records = new Map<string, TelegramMessageOwnershipRecord>();
+  return {
+    record: (input) => {
+      const key = getTelegramMessageOwnershipKey(input.chatId, input.messageId);
+      const now = input.now ?? Date.now();
+      const record = createTelegramMessageOwnershipRecord({
+        ...input,
+        now,
+        previous: records.get(key),
+      });
+      records.set(key, record);
+      return record;
+    },
+    get: (chatId, messageId) =>
+      records.get(getTelegramMessageOwnershipKey(chatId, messageId)),
+    forget: (chatId, messageId) =>
+      records.delete(getTelegramMessageOwnershipKey(chatId, messageId)),
+    forgetTarget: (target) => {
+      const targetKey = getTelegramTargetKey(target);
+      let removed = 0;
+      for (const [key, record] of records) {
+        if (getTelegramTargetKey(record.target) !== targetKey) continue;
+        records.delete(key);
+        removed += 1;
+      }
+      return removed;
+    },
+    prune: ({ now, maxAgeMs, maxRecords }) => {
+      let removed = 0;
+      if (maxAgeMs !== undefined) {
+        for (const [key, record] of records) {
+          if (now - record.updatedAt <= maxAgeMs) continue;
+          records.delete(key);
+          removed += 1;
+        }
+      }
+      if (maxRecords !== undefined && records.size > maxRecords) {
+        const oldest = [...records.entries()].sort(
+          (left, right) => left[1].updatedAt - right[1].updatedAt,
+        );
+        for (const [key] of oldest.slice(0, records.size - maxRecords)) {
+          records.delete(key);
+          removed += 1;
+        }
+      }
+      return removed;
+    },
+    entries: () => [...records.values()],
+    clear: () => {
+      records.clear();
+    },
+  };
+}

package/lib/pi.ts

@@ -33,6 +33,29 @@ export type {
   SlashCommandInfo,
 };
 
+export interface ToolExecutionStartEvent {
+  type: "tool_execution_start";
+  toolCallId: string;
+  toolName: string;
+  args: unknown;
+}
+
+export interface ToolExecutionUpdateEvent {
+  type: "tool_execution_update";
+  toolCallId: string;
+  toolName: string;
+  args: unknown;
+  partialResult: unknown;
+}
+
+export interface ToolExecutionEndEvent {
+  type: "tool_execution_end";
+  toolCallId: string;
+  toolName: string;
+  result: unknown;
+  isError: boolean;
+}
+
 export interface PiSettingsManager {
   reload: () => Promise<void>;
   flush: () => Promise<void>;
@@ -72,8 +95,8 @@ export function canStartPollingInExtensionContext(ctx: unknown): boolean {
 export function formatPollingStartBlockedByRunMode(ctx: unknown): string {
   const mode = getExtensionContextMode(ctx);
   return mode
-    ? `Telegram polling is unavailable in π ${mode} mode. Use /telegram-connect from a long-lived π session.`
-    : "Telegram polling is unavailable in this π run mode.";
+    ? `Telegram polling is unavailable in Pi ${mode} mode. Use /telegram-connect from a long-lived Pi session.`
+    : "Telegram polling is unavailable in this Pi run mode.";
 }
 
 export type PiSendUserMessageOptions = NonNullable<
@@ -118,7 +141,7 @@ export function createScopedModelPatternPersister(deps: {
   createSettingsManager: (cwd: string) => PiSettingsManager;
   clearCachedModelMenuInputs: () => void;
 }): (patterns: string[], ctx: ExtensionContext) => Promise<void> {
-  return async function persistScopedModelPatterns(patterns, ctx) {
+  return async (patterns, ctx) => {
     const settingsManager = deps.createSettingsManager(ctx.cwd);
     settingsManager.setEnabledModels(
       patterns.length > 0 ? patterns : undefined,