@llblab/pi-kit 0.5.1 → 0.6.0

package/node_modules/@llblab/pi-telegram/lib/activity-verbosity.ts

@@ -4,7 +4,7 @@
  * Owns persistent bounded thinking and tool disclosures; excludes activity normalization, assistant answer rendering, and transport authority policy
  */
 
-import type { TelegramActivityEvent } from "./activity.ts";
+import type { TelegramActivityEvent, TelegramActivityPublicationRuntime } from "./activity.ts";
 import {
   escapeHtml,
   renderTelegramInlineMarkdownHtml,
@@ -321,6 +321,7 @@ export function createTelegramActivityVerbosityBinding(): TelegramActivityVerbos
 }
 
 export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
+  enqueue?: TelegramActivityPublicationRuntime["enqueue"];
   getActivityMode: () => "quiet" | "thinking" | "tools" | "verbose";
   refreshActivityMode?: () => Promise<void>;
   getNowMs?: () => number;
@@ -380,15 +381,20 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
   };
   const hasAuthority = (): boolean =>
     authority !== undefined && deps.isAuthorityActive(authority);
-  const ensureActivity = (event: TelegramActivityEvent): boolean => {
+  const isCurrent = (acceptedGeneration: number, admittedAuthority: TAuthority | undefined): boolean =>
+    active && generation === acceptedGeneration && admittedAuthority !== undefined && deps.isAuthorityActive(admittedAuthority);
+  const ensureActivity = (
+    event: TelegramActivityEvent,
+    admittedTarget: TelegramTarget | undefined,
+    admittedAuthority: TAuthority,
+  ): boolean => {
     if (deps.getActivityMode() === "quiet") return false;
     if (activityId === event.activityId) return hasAuthority();
     clearActivity();
-    const resolvedTarget = deps.resolveTarget(event);
-    if (!resolvedTarget) return false;
+    if (!admittedTarget) return false;
     activityId = event.activityId;
-    target = { ...resolvedTarget };
-    authority = deps.captureAuthority();
+    target = admittedTarget;
+    authority = admittedAuthority;
     return hasAuthority();
   };
   const closeToolBatch = () => {
@@ -398,10 +404,10 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
     event: TelegramActivityEvent,
     acceptedGeneration: number,
   ) => {
+    const admittedAuthority = authority;
     if (
-      generation !== acceptedGeneration ||
+      !isCurrent(acceptedGeneration, admittedAuthority) ||
       !target ||
-      !hasAuthority() ||
       reasoningBlocked
     ) {
       return;
@@ -440,22 +446,24 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
           parse_mode: "HTML",
           link_preview_options: { is_disabled: true },
         });
+        if (!isCurrent(acceptedGeneration, admittedAuthority)) return;
         reasoningMessage = {
           messageId: sent.message_id,
           target: { ...target },
         };
       }
-      if (generation !== acceptedGeneration) return;
+      if (!isCurrent(acceptedGeneration, admittedAuthority)) return;
       reasoningMessageFrames += 1;
       lastReasoningMessageChars = reasoningChars;
       lastReasoningPublishMs = getNowMs();
     } catch (error) {
+      if (!isCurrent(acceptedGeneration, admittedAuthority)) return;
+      reasoningBlocked = true;
       deps.recordFailure?.(
         canEdit ? "reasoning-edit" : "reasoning-send",
         event,
         error,
       );
-      reasoningBlocked = true;
     }
   };
   const publishTool = async (
@@ -463,11 +471,8 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
     tool: ToolActivity,
     acceptedGeneration: number,
   ) => {
-    if (
-      generation !== acceptedGeneration ||
-      !target ||
-      !hasAuthority()
-    ) {
+    const admittedAuthority = authority;
+    if (!isCurrent(acceptedGeneration, admittedAuthority) || !target) {
       return;
     }
     const canAppend =
@@ -495,6 +500,7 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
                 }),
           });
         } catch (error) {
+          if (!isCurrent(acceptedGeneration, admittedAuthority)) return;
           if (
             toolMessage.format !== "rich" ||
             !isKnownSafeRichActivityRejection(error)
@@ -508,9 +514,10 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
             parse_mode: "HTML",
             link_preview_options: { is_disabled: true },
           });
+          if (!isCurrent(acceptedGeneration, admittedAuthority)) return;
           toolMessage.format = "html";
         }
-        if (generation !== acceptedGeneration) return;
+        if (!isCurrent(acceptedGeneration, admittedAuthority)) return;
         toolMessage.tools = nextTools;
         return;
       }
@@ -528,6 +535,7 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
           rich_message: renderTelegramToolActivityRichMessage([tool]),
         });
       } catch (error) {
+        if (!isCurrent(acceptedGeneration, admittedAuthority)) return;
         if (!isKnownSafeRichActivityRejection(error)) throw error;
         sent = await deps.sendMessage({
           ...body,
@@ -537,7 +545,7 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
         });
         format = "html";
       }
-      if (generation !== acceptedGeneration) return;
+      if (!isCurrent(acceptedGeneration, admittedAuthority)) return;
       toolMessage = {
         messageId: sent.message_id,
         tools: [tool],
@@ -545,25 +553,30 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
         format,
       };
     } catch (error) {
-      deps.recordFailure?.(canAppend ? "tool-edit" : "tool-send", event, error);
+      if (!isCurrent(acceptedGeneration, admittedAuthority)) return;
       closeToolBatch();
+      deps.recordFailure?.(canAppend ? "tool-edit" : "tool-send", event, error);
     }
   };
   const process = async (
     event: TelegramActivityEvent,
     acceptedGeneration: number,
+    admittedTarget: TelegramTarget | undefined,
+    admittedAuthority: TAuthority,
   ) => {
     if (event.type === "agent-start" && deps.refreshActivityMode) {
       try {
         await deps.refreshActivityMode();
       } catch (error) {
-        deps.recordFailure?.("config-refresh", event, error);
+        if (!isCurrent(acceptedGeneration, admittedAuthority)) return;
         clearActivity();
         activityId = event.activityId;
+        deps.recordFailure?.("config-refresh", event, error);
         return;
       }
     }
-    if (!ensureActivity(event)) {
+    if (!isCurrent(acceptedGeneration, admittedAuthority)) return;
+    if (!ensureActivity(event, admittedTarget, admittedAuthority)) {
       if (
         activityId === event.activityId &&
         deps.getActivityMode() === "quiet"
@@ -614,6 +627,7 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
       ) {
         await publishReasoning(event, acceptedGeneration);
       }
+      if (!isCurrent(acceptedGeneration, admittedAuthority)) return;
       reasoningBuffer = "";
       reasoningChars = 0;
       reasoningMessageFrames = 0;
@@ -668,7 +682,7 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
         toolOrder.shift();
         tools.delete(next.id);
         await publishTool(event, next, acceptedGeneration);
-        if (generation !== acceptedGeneration) return;
+        if (!isCurrent(acceptedGeneration, admittedAuthority)) return;
       }
       return;
     }
@@ -680,6 +694,7 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
       ) {
         await publishReasoning(event, acceptedGeneration);
       }
+      if (!isCurrent(acceptedGeneration, admittedAuthority)) return;
       clearActivity();
     }
   };
@@ -687,10 +702,13 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
     accept(event) {
       if (!active) return;
       const acceptedGeneration = generation;
-      tail = tail
-        .then(() => {
-          if (!active || generation !== acceptedGeneration) return;
-          return process(event, acceptedGeneration);
+      const resolvedTarget = deps.resolveTarget(event);
+      const admittedTarget = resolvedTarget ? { ...resolvedTarget } : undefined;
+      const admittedAuthority = deps.captureAuthority();
+      const enqueue = deps.enqueue ?? ((task: () => Promise<void>) => tail.then(task));
+      tail = enqueue(async () => {
+          if (!active || generation !== acceptedGeneration || !deps.isAuthorityActive(admittedAuthority)) return;
+          await process(event, acceptedGeneration, admittedTarget, admittedAuthority);
         })
         .catch((error) => {
           deps.recordFailure?.("tool-send", event, error);

package/node_modules/@llblab/pi-telegram/lib/activity.ts

@@ -32,6 +32,7 @@ export interface TelegramActivityEnvelope {
   sequence: number;
   source: TelegramActivitySource;
   target?: TelegramActivityTarget;
+  replyToMessageId?: number;
   timestamp: number;
 }
 
@@ -422,8 +423,8 @@ export function createTelegramActivityBridgeRuntime(deps: {
     recordInputSource(source) {
       getRuntime()?.recordInputSource(source);
     },
-    onAgentStart(target) {
-      getRuntime()?.onAgentStart(target);
+    onAgentStart(target, replyToMessageId) {
+      getRuntime()?.onAgentStart(target, replyToMessageId);
     },
     onAssistantEvent(event) {
       getRuntime()?.onAssistantEvent(event);
@@ -492,7 +493,7 @@ export type TelegramAssistantStreamEvent =
 export interface TelegramActivityRuntime {
   onSessionStart?: () => void;
   recordInputSource: (source: TelegramActivityInputSource) => void;
-  onAgentStart: (activeTelegramTarget?: TelegramActivityTarget) => void;
+  onAgentStart: (activeTelegramTarget?: TelegramActivityTarget, replyToMessageId?: number) => void;
   onAssistantEvent: (event: TelegramAssistantStreamEvent) => void;
   onAssistantMessageEnd: (stopReason?: string) => void;
   onToolStart: (event: {
@@ -549,6 +550,7 @@ export function createTelegramActivityRuntime(deps: {
   let activityId: string | undefined;
   let activitySource: TelegramActivitySource = "unknown";
   let activityTarget: TelegramActivityTarget | undefined;
+  let activityReplyToMessageId: number | undefined;
   let sequence = 0;
   let pendingInputSource: TelegramActivityInputSource = "unknown";
   let pendingAssistantSegment: PendingAssistantSegment | undefined;
@@ -584,6 +586,7 @@ export function createTelegramActivityRuntime(deps: {
       sequence,
       source: activitySource,
       ...(activityTarget ? { target: activityTarget } : {}),
+      ...(activityReplyToMessageId !== undefined ? { replyToMessageId: activityReplyToMessageId } : {}),
       timestamp: now(),
     } as TelegramActivityEvent;
     try {
@@ -610,6 +613,7 @@ export function createTelegramActivityRuntime(deps: {
     activityId = undefined;
     activitySource = "unknown";
     activityTarget = undefined;
+    activityReplyToMessageId = undefined;
     sequence = 0;
     pendingAssistantSegment = undefined;
     compactionInProgress = false;
@@ -627,9 +631,10 @@ export function createTelegramActivityRuntime(deps: {
     recordInputSource(source) {
       pendingInputSource = source;
     },
-    onAgentStart(activeTelegramTarget) {
+    onAgentStart(activeTelegramTarget, replyToMessageId) {
       abandonCompaction();
       ensureActivity(activeTelegramTarget);
+      activityReplyToMessageId = activitySource === "telegram" ? replyToMessageId : undefined;
       emit({ type: "agent-start" });
     },
     onAssistantEvent(event) {
@@ -738,6 +743,63 @@ export function createTelegramActivityRuntime(deps: {
   };
 }
 
+// --- Ordered Bridge-Owned Publication ---
+
+export interface TelegramActivityPublicationReservation {
+  publish: (task: () => Promise<void>) => Promise<void>;
+  cancel: () => void;
+}
+
+export interface TelegramActivityPublicationRuntime {
+  enqueue: (task: () => Promise<void>) => Promise<void>;
+  reserve: () => TelegramActivityPublicationReservation;
+  reset: () => void;
+}
+
+export function createTelegramActivityPublicationRuntime(): TelegramActivityPublicationRuntime {
+  let generation = 0;
+  let tail = Promise.resolve();
+  const pending = new Set<() => void>();
+  const reserve = (): TelegramActivityPublicationReservation => {
+    const admittedGeneration = generation;
+    let state: "pending" | "published" | "cancelled" = "pending";
+    let resolve!: (task: (() => Promise<void>) | undefined) => void;
+    const ready = new Promise<(() => Promise<void>) | undefined>((accept) => { resolve = accept; });
+    const cancel = () => {
+      if (state !== "pending") return;
+      state = "cancelled";
+      pending.delete(cancel);
+      resolve(undefined);
+    };
+    pending.add(cancel);
+    const result = tail.then(async () => {
+      const task = await ready;
+      if (admittedGeneration === generation && task) await task();
+    });
+    tail = result.catch(() => {});
+    return {
+      publish(task) {
+        if (state === "cancelled") return result;
+        if (state === "published") return Promise.reject(new Error("Publication reservation already published."));
+        state = "published";
+        pending.delete(cancel);
+        resolve(task);
+        return result;
+      },
+      cancel,
+    };
+  };
+  return {
+    reserve,
+    enqueue: (task) => reserve().publish(task),
+    reset() {
+      generation += 1;
+      for (const cancel of pending) cancel();
+      tail = Promise.resolve();
+    },
+  };
+}
+
 // --- Public Assistant Output Projection ---
 
 export interface TelegramAssistantOutputRuntime {
@@ -747,7 +809,14 @@ export interface TelegramAssistantOutputRuntime {
   stop: () => void;
 }
 
+export interface TelegramAssistantOutputPreparation {
+  wait: () => Promise<void>;
+  settle: () => void;
+}
+
 export function createTelegramAssistantOutputRuntime<TAuthority = undefined>(deps: {
+  prepareSend?: (event: TelegramAssistantSegmentEvent) => TelegramAssistantOutputPreparation | undefined;
+  enqueue?: TelegramActivityPublicationRuntime["enqueue"];
   captureAuthority?: () => TAuthority;
   isAuthorityActive?: (authority: TAuthority) => boolean;
   canDeliver: (event: TelegramAssistantSegmentEvent) => boolean;
@@ -785,7 +854,9 @@ export function createTelegramAssistantOutputRuntime<TAuthority = undefined>(dep
       admitted.add(key);
       const admittedGeneration = generation;
       const admittedAuthority = deps.captureAuthority?.();
-      tail = tail.then(async () => {
+      const preparation = deps.prepareSend?.(event);
+      const enqueue = deps.enqueue ?? ((task: () => Promise<void>) => tail.then(task));
+      tail = enqueue(async () => {
         const isAdmittedAuthorityActive = () =>
           running &&
           generation === admittedGeneration &&
@@ -794,6 +865,8 @@ export function createTelegramAssistantOutputRuntime<TAuthority = undefined>(dep
             deps.isAuthorityActive(admittedAuthority as TAuthority));
         if (!isAdmittedAuthorityActive() || !deps.canDeliver(event)) return;
         try {
+          if (preparation) await preparation.wait();
+          if (!isAdmittedAuthorityActive() || !deps.canDeliver(event)) return;
           await deps.send(
             event,
             admittedAuthority as TAuthority,
@@ -802,7 +875,7 @@ export function createTelegramAssistantOutputRuntime<TAuthority = undefined>(dep
         } catch (error) {
           deps.recordFailure?.(event, error);
         }
-      });
+      }).finally(() => preparation?.settle());
     },
     waitForIdle() {
       return tail;