@llblab/pi-telegram 0.20.6 → 0.21.1

package/lib/bindings.ts

@@ -4,6 +4,7 @@
  * Owns pi-facing tool, command, and lifecycle hook registration for the entrypoint
  */
 
+import * as Activity from "./activity.ts";
 import * as CommandTemplates from "./command-templates.ts";
 import * as Commands from "./commands.ts";
 import * as Config from "./config.ts";
@@ -200,6 +201,7 @@ export function registerTelegramCommandsAndTools({
 
 interface TelegramLifecycleBindingDeps {
   pi: Pi.ExtensionAPI;
+  activityRuntime: Activity.TelegramActivityRuntime;
   sessionLifecycleRuntime: Pick<
     Lifecycle.TelegramLifecycleRegistrationDeps,
     "onSessionStart" | "onSessionShutdown" | "onModelSelect"
@@ -276,6 +278,7 @@ interface TelegramLifecycleBindingDeps {
 
 export function registerTelegramLifecycleRuntimeHooks({
   pi,
+  activityRuntime,
   sessionLifecycleRuntime,
   configStore,
   abort,
@@ -517,6 +520,7 @@ export function registerTelegramLifecycleRuntimeHooks({
       deferredQueueDispatchRuntime.request,
     dispatchNextQueuedTelegramTurn,
     recordRuntimeEvent,
+    onCompactionAbandoned: activityRuntime.onCompactionAbandoned,
   });
   const messageActivityTypingHooks =
     Lifecycle.createTelegramMessageActivityTypingHooks({
@@ -530,29 +534,77 @@ export function registerTelegramLifecycleRuntimeHooks({
   Lifecycle.registerTelegramLifecycleHooks(pi, {
     ...sessionLifecycleRuntime,
     ...agentLifecycleHooks,
+    onInput(event) {
+      activityRuntime.recordInputSource(event.source ?? "unknown");
+    },
+    async onSessionStart(event, ctx) {
+      activityRuntime.onSessionStart?.();
+      await sessionLifecycleRuntime.onSessionStart(event, ctx);
+    },
     async onSessionShutdown(event, ctx) {
+      activityRuntime.onSessionShutdown();
       compactionObserver.onSessionShutdown();
       await sessionLifecycleRuntime.onSessionShutdown(event, ctx);
     },
-    onSessionBeforeCompact: compactionObserver.onSessionBeforeCompact,
-    onSessionCompact: compactionObserver.onSessionCompact,
+    onSessionBeforeCompact(event, ctx) {
+      activityRuntime.onCompactionStart(Pi.getSessionCompactionReason(event));
+      compactionObserver.onSessionBeforeCompact(event, ctx);
+    },
+    onSessionCompact(event, ctx) {
+      activityRuntime.onCompactionEnd(Pi.getSessionCompactionReason(event));
+      compactionObserver.onSessionCompact(event, ctx);
+    },
     async onAgentStart(event, ctx) {
       await agentStartWithDedupReset(event, ctx);
+      activityRuntime.onAgentStart(activeTurnRuntime.get()?.target);
       startAgentActivityTypingLoop(ctx);
     },
-    async onToolExecutionStart(_event, _ctx) {
+    async onToolExecutionStart(event, _ctx) {
       agentLifecycleHooks.onToolExecutionStart();
+      activityRuntime.onToolStart({
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+        args: event.args,
+      });
+    },
+    onToolExecutionUpdate(event) {
+      activityRuntime.onToolUpdate({
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+        update: event.partialResult,
+      });
+    },
+    async onToolExecutionEnd(event, ctx) {
+      activityRuntime.onToolEnd({
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+        result: event.result,
+        isError: event.isError,
+      });
+      agentLifecycleHooks.onToolExecutionEnd(event, ctx);
+    },
+    async onMessageStart(event, ctx) {
+      await messageActivityHooks.onMessageStart(event, ctx);
+    },
+    async onMessageUpdate(event, ctx) {
+      if (event.assistantMessageEvent) {
+        activityRuntime.onAssistantEvent(
+          event.assistantMessageEvent as Activity.TelegramAssistantStreamEvent,
+        );
+      }
+      await messageActivityHooks.onMessageUpdate(event, ctx);
+    },
+    async onAgentEnd(event, ctx) {
+      activityRuntime.onAgentEnd();
+      await agentLifecycleHooks.onAgentEnd(event, ctx);
     },
-    onToolExecutionUpdate() {},
-    async onToolExecutionEnd(_event, ctx) {
-      agentLifecycleHooks.onToolExecutionEnd(_event, ctx);
+    onAgentSettled() {
+      activityRuntime.onAgentSettled();
     },
-    onAgentEnd: agentLifecycleHooks.onAgentEnd,
     onBeforeAgentStart: Prompts.createTelegramProactiveBeforeAgentStartHook({
       isConfigured: configStore.hasBotToken,
       isProactivePushEnabled,
       isCurrentOwner: lockOwnershipGuard.ownsContext,
     }),
-    ...messageActivityHooks,
   });
 }

package/lib/bus-api.ts

@@ -4,6 +4,7 @@
  * Wraps the direct Telegram Bot API runtime so follower instances can route outbound calls through the bus leader
  */
 
+import { stripTelegramBusApiMetadata } from "./bus.ts";
 import type {
   TelegramAnswerGuestQueryOptions,
   TelegramApiCallOptions,
@@ -224,7 +225,7 @@ export function createTelegramBusAwareApiRuntime(
     },
     sendMessage(body: TelegramSendMessageBody): Promise<TelegramSentMessage> {
       return deps.ownsDirect()
-        ? deps.directRuntime.sendMessage(body)
+        ? deps.directRuntime.sendMessage(stripTelegramBusApiMetadata(body))
         : deps
             .callFollowerApi("call", ["sendMessage", body])
             .then(asSentMessage);

package/lib/bus-leader.ts

@@ -16,6 +16,7 @@ import {
   isTelegramBusEnvelopeAuthorized,
   getTelegramBusFollowerSocketPath,
   sendTelegramBusLocalEnvelope,
+  stripTelegramBusApiMetadata,
   type TelegramBusEnvelope,
   type TelegramBusFollowerRegistry,
   type TelegramBusFollowerView,
@@ -795,7 +796,9 @@ export function createTelegramBusLeaderApiProxy(
 ): (method: string, args: unknown[]) => Promise<unknown> {
   return async (method, args) => {
     if (method === "call") {
-      const body = args[1] as Record<string, unknown>;
+      const body = stripTelegramBusApiMetadata(
+        args[1] as Record<string, unknown>,
+      );
       try {
         return await deps.call(
           args[0] as string,

package/lib/bus.ts

@@ -145,6 +145,38 @@ export function getTelegramFollowerTargetOwnership(input: {
   return record?.instanceId ? { instanceId: record.instanceId } : undefined;
 }
 
+const TELEGRAM_BUS_AGGREGATE_DELIVERY_FIELD =
+  "__piTelegramAggregateDelivery";
+
+export function markTelegramBusAggregateDelivery<T extends Record<string, unknown>>(
+  body: T,
+): T {
+  return {
+    ...body,
+    [TELEGRAM_BUS_AGGREGATE_DELIVERY_FIELD]: true,
+  };
+}
+
+export function isTelegramBusAggregateDelivery(body: unknown): boolean {
+  return Boolean(
+    body &&
+      typeof body === "object" &&
+      !Array.isArray(body) &&
+      (body as Record<string, unknown>)[
+        TELEGRAM_BUS_AGGREGATE_DELIVERY_FIELD
+      ] === true,
+  );
+}
+
+export function stripTelegramBusApiMetadata<T extends Record<string, unknown>>(
+  body: T,
+): T {
+  if (!(TELEGRAM_BUS_AGGREGATE_DELIVERY_FIELD in body)) return body;
+  const clean = { ...body };
+  delete clean[TELEGRAM_BUS_AGGREGATE_DELIVERY_FIELD];
+  return clean;
+}
+
 export function isTelegramFollowerApiCallAllowed(input: {
   follower: TelegramBusFollowerView;
   method: string;
@@ -227,6 +259,12 @@ export function isTelegramFollowerApiCallAllowed(input: {
       return isBotCommandRegistration(input.args[1]);
     if (apiMethod === "sendChatAction")
       return isTargetChatScoped(input.args[1]);
+    if (apiMethod === "sendMessage" && isTelegramBusAggregateDelivery(input.args[1])) {
+      const body = input.args[1] as Record<string, unknown>;
+      return (
+        body.message_thread_id === undefined && isTargetChatScoped(body)
+      );
+    }
     if (apiMethod === "deleteMessage" || apiMethod === "editMessageText") {
       return isTargetMessageScoped(input.args[1]);
     }