@automagik/omni 2.260901.1 → 2.260901.2

package/dist/index.js

@@ -12312,6 +12312,7 @@ var init_types3 = __esm(() => {
     "batch-job.cancelled",
     "batch-job.failed",
     "agent.state.changed",
+    "agent.run.cancel_requested",
     "agent.task.created",
     "agent.task.updated",
     "agent.task.completed",
@@ -128288,7 +128289,7 @@ import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "@automagik/omni",
-  version: "2.260901.1",
+  version: "2.260901.2",
   description: "LLM-optimized CLI for Omni",
   type: "module",
   bin: {

package/dist/server/index.js

@@ -174,6 +174,7 @@ var init_types2 = __esm(() => {
     "batch-job.cancelled",
     "batch-job.failed",
     "agent.state.changed",
+    "agent.run.cancel_requested",
     "agent.task.created",
     "agent.task.updated",
     "agent.task.completed",
@@ -36795,7 +36796,7 @@ function ensureCleanup() {
   }
 }
 function startAck(plugin2, ackProvider, instanceId, chatId, messageId, channel2, config2) {
-  const noopHandle = { remove() {} };
+  const noopHandle = { remove() {}, release() {} };
   if (config2.reactionAck !== "on") {
     return noopHandle;
   }
@@ -36830,6 +36831,12 @@ function startAck(plugin2, ackProvider, instanceId, chatId, messageId, channel2,
       if (ackProvider) {
         ackProvider.removeAck(instanceId, chatId, messageId, emoji).catch(() => {});
       }
+    },
+    release() {
+      if (removed)
+        return;
+      removed = true;
+      clearTimeout(timer);
     }
   };
 }
@@ -242894,7 +242901,7 @@ var init_sentry_scrub = __esm(() => {
 var require_package7 = __commonJS((exports, module) => {
   module.exports = {
     name: "@omni/api",
-    version: "2.260901.1",
+    version: "2.260901.2",
     type: "module",
     exports: {
       ".": {
@@ -343539,14 +343546,16 @@ var init_loader2 = __esm(() => {
 class MessageDebouncer {
   buffers = new Map;
   timers = new Map;
-  inFlight = new Set;
+  inFlight = new Map;
   firstBufferedAt = new Map;
   lastConfig = new Map;
   onFlush;
   now;
-  constructor(onFlush, now = Date.now) {
+  options;
+  constructor(onFlush, now = Date.now, options = {}) {
     this.onFlush = onFlush;
     this.now = now;
+    this.options = options;
   }
   getChatKey(instanceId, chatId) {
     return `${instanceId}:${chatId}`;
@@ -343559,8 +343568,19 @@ class MessageDebouncer {
     if (!this.firstBufferedAt.has(chatKey))
       this.firstBufferedAt.set(chatKey, this.now());
     this.lastConfig.set(chatKey, config4);
-    if (this.inFlight.has(chatKey))
+    if (this.inFlight.has(chatKey)) {
+      const blockingTraceId = this.inFlight.get(chatKey);
+      const queuePosition = buffer3.length;
+      log89.info("agent_dispatch_queued", {
+        instanceId,
+        chatId,
+        traceId: message2.metadata.traceId,
+        queuePosition,
+        blockingTraceId
+      });
+      this.options.onQueuedBehindActiveRun?.({ instanceId, chatId, message: message2, queuePosition, blockingTraceId });
       return;
+    }
     this.restartTimer(chatKey, config4);
   }
   hasPending(instanceId, chatId) {
@@ -343621,7 +343641,7 @@ class MessageDebouncer {
       clearTimeout(timer2);
     if (!messages4?.length)
       return;
-    this.inFlight.add(chatKey);
+    this.inFlight.set(chatKey, messages4[0]?.metadata.traceId);
     try {
       await this.onFlush(chatKey, messages4);
     } catch (error3) {
@@ -345473,6 +345493,51 @@ async function fetchChatMetadata(services, instanceId, chatId, chatType, trusted
     return {};
   }
 }
+function runAbortKey(instanceId, chatId, threadId2) {
+  return `${instanceId}:${chatId}:${threadId2 ?? ""}`;
+}
+async function cancelActiveAgentRun(instanceId, chatId, reason, opts) {
+  let entry = activeRunAborts.get(runAbortKey(instanceId, chatId, opts?.threadId));
+  if (!entry && opts?.threadId) {
+    entry = activeRunAborts.get(runAbortKey(instanceId, chatId));
+  }
+  if (!entry) {
+    log91.info("Agent run cancel requested but nothing in flight", {
+      instanceId,
+      chatId,
+      threadId: opts?.threadId,
+      reason
+    });
+    return false;
+  }
+  if (opts?.requestedAt !== undefined && entry.startedAt > opts.requestedAt) {
+    log91.info("Agent run cancel ignored \u2014 run started after the stop request", {
+      instanceId,
+      chatId,
+      threadId: opts?.threadId,
+      startedAt: entry.startedAt,
+      requestedAt: opts.requestedAt,
+      reason
+    });
+    return false;
+  }
+  log91.info("Cancelling in-flight agent run", {
+    instanceId,
+    chatId,
+    threadId: opts?.threadId,
+    reason,
+    hasActiveStream: !!entry.sender
+  });
+  entry.controller.abort();
+  if (entry.sender) {
+    try {
+      await (entry.sender.cancel ? entry.sender.cancel() : entry.sender.abort());
+    } catch (err2) {
+      log91.warn("Stream sender cancel failed during run cancellation", { instanceId, chatId, error: String(err2) });
+    }
+  }
+  return true;
+}
 async function routeStreamDelta(sender, delta) {
   switch (delta.phase) {
     case "thinking":
@@ -345693,6 +345758,10 @@ async function dispatchViaStreamingProvider(services, instance4, messages4, trig
   const sender = resolved.createSender(instance4.id, chatId, replyToId, chatType, { formatMode });
   const streamKey = `${instance4.id}:${chatId}`;
   activeStreams.set(streamKey, sender);
+  const cancelController = new AbortController;
+  const runKey = runAbortKey(instance4.id, chatId, rawThreadId);
+  activeRunAborts.set(runKey, { controller: cancelController, startedAt: Date.now(), sender });
+  trigger.abortSignal = cancelController.signal;
   const streamDispatchStart = Date.now();
   try {
     const generator = resolved.provider.triggerStream(trigger);
@@ -345707,8 +345776,12 @@ async function dispatchViaStreamingProvider(services, instance4, messages4, trig
         attributes: { provider_type: resolved.provider.schema }
       });
     }
-    return streamResult;
+    return cancelController.signal.aborted ? true : streamResult;
   } catch (err2) {
+    if (cancelController.signal.aborted) {
+      log91.info("Streaming dispatch cancelled by user", { instanceId: instance4.id, chatId, traceId });
+      return true;
+    }
     log91.error("Streaming dispatch failed, falling back", {
       instanceId: instance4.id,
       chatId,
@@ -345721,6 +345794,7 @@ async function dispatchViaStreamingProvider(services, instance4, messages4, trig
     return false;
   } finally {
     activeStreams.delete(streamKey);
+    activeRunAborts.delete(runKey);
   }
 }
 function formatMediaContent(msg) {
@@ -345919,6 +345993,38 @@ async function dispatchViaTurnBasedProvider(services, instance4, provider, trigg
   });
   return true;
 }
+function resolveReplySuppression(flags) {
+  if (flags.handoffTriggered)
+    return "handoff_triggered";
+  if (flags.errorHandoffDone)
+    return "error_handoff";
+  if (flags.supersededByNewerInbound)
+    return "superseded_by_newer_inbound";
+  if (flags.runCancelled)
+    return "run_cancelled_by_user";
+  return null;
+}
+async function triggerProviderWithCancellation(provider, trigger, spanAttributes, instanceId, chatId, traceId) {
+  const cancelController = new AbortController;
+  const runKey = runAbortKey(instanceId, chatId, trigger.source.threadId);
+  activeRunAborts.set(runKey, { controller: cancelController, startedAt: Date.now() });
+  try {
+    const result = await withLifecycleSpan("omni.dispatch_to_agno", spanAttributes, () => provider.trigger({
+      ...trigger,
+      abortSignal: cancelController.signal,
+      traceContext: activeProviderTraceContext() ?? trigger.traceContext
+    }));
+    return { result, cancelled: cancelController.signal.aborted };
+  } catch (err2) {
+    if (cancelController.signal.aborted) {
+      log91.info("Agent run cancelled by user during dispatch", { instanceId, chatId, traceId });
+      return null;
+    }
+    throw err2;
+  } finally {
+    activeRunAborts.delete(runKey);
+  }
+}
 async function dispatchViaProvider(services, instance4, messages4, triggerType, channel5, chatId, senderId, personId, senderName, traceId, rawEvent, db2, extraContextMessages, senderAgentId) {
   const provider = await getAgentProvider(services, instance4, db2);
   if (!provider)
@@ -345988,11 +346094,14 @@ async function dispatchViaProvider(services, instance4, messages4, triggerType,
     }
     const correlationId = messages4[0]?.metadata.correlationId;
     const dispatchStart = Date.now();
-    const result = await withLifecycleSpan("omni.dispatch_to_agno", buildLifecycleSpanAttributes({
+    const triggerOutcome = await triggerProviderWithCancellation(provider, trigger, buildLifecycleSpanAttributes({
       ...lifecycleBase,
       stage: "dispatch_to_agno",
       extra: { trigger_type: triggerType, provider_id: provider.id, provider_schema: provider.schema }
-    }), () => provider.trigger({ ...trigger, traceContext: activeProviderTraceContext() ?? trigger.traceContext }));
+    }), instance4.id, chatId, traceId);
+    if (!triggerOutcome)
+      return true;
+    const { result, cancelled: runCancelled } = triggerOutcome;
     const dispatchDurationMs = Date.now() - dispatchStart;
     if (sentryEnabled()) {
       exports_public_api2.count("agent.dispatch", 1, { attributes: { provider_type: provider.schema } });
@@ -346005,7 +346114,13 @@ async function dispatchViaProvider(services, instance4, messages4, triggerType,
     const handoffTriggered = chatAfterRun?.settings?.agentPaused === true;
     const supersededByNewerInbound = !handoffTriggered && isReplySuperseded(instance4, chatId);
     const errorHandoffDone = await maybeTriggerErrorHandoff(services, db2, channel5, instance4, chatId, result?.metadata.customerErrorBlocked === true, handoffTriggered, messages4[0]?.metadata.trustedTenantId);
-    if (result && result.parts.length > 0 && !handoffTriggered && !errorHandoffDone && !supersededByNewerInbound) {
+    const suppressReason = resolveReplySuppression({
+      handoffTriggered,
+      errorHandoffDone,
+      supersededByNewerInbound,
+      runCancelled
+    });
+    if (result && result.parts.length > 0 && !suppressReason) {
       const selfChat = isSelfChat(chatId, instance4.ownerIdentifier);
       const rawParts = selfChat ? result.parts.map((p2) => `${BOT_PREFIX}${p2}`) : result.parts;
       const parts = await Promise.all(rawParts.map((part) => executeBeforeMessageWriteHooks(instance4.id, chatId, part)));
@@ -346021,13 +346136,9 @@ async function dispatchViaProvider(services, instance4, messages4, triggerType,
       }), () => sendResponseParts(channel5, instance4.id, chatId, parts, getSplitDelayConfig(instance4), _fmtMode, replyTo, correlationId, senderAgentId));
       recordJourneyCheckpoint(correlationId, "T9", JOURNEY_STAGES.T9);
       await forwardToChainedInstance(instance4, parts, correlationId, messages4);
-    } else if (handoffTriggered) {
-      log91.info("Agent response suppressed \u2014 handoff triggered during run", {
-        instanceId: instance4.id,
-        chatId
-      });
-    } else if (supersededByNewerInbound) {
-      log91.info("Agent response discarded \u2014 superseded by newer inbound", {
+    } else if (suppressReason) {
+      log91.info("Agent response suppressed", {
+        reason: suppressReason,
         instanceId: instance4.id,
         chatId,
         parts: result?.parts.length ?? 0,
@@ -346370,6 +346481,34 @@ function buildAckConfig(instance4) {
     ackTimeoutMs: inst.ackTimeoutMs ?? 30000
   };
 }
+function takeQueuedAck(chatKey) {
+  const entry = queuedMessageAcks.get(chatKey);
+  queuedMessageAcks.delete(chatKey);
+  return entry?.handle;
+}
+async function ackQueuedMessage(info2) {
+  const chatKey = `${info2.instanceId}:${info2.chatId}`;
+  try {
+    const existing = queuedMessageAcks.get(chatKey);
+    if (existing && Date.now() - existing.at < QUEUED_ACK_TIMEOUT_MS)
+      return;
+    const instance4 = info2.message.metadata.resolvedInstance;
+    const messageId = info2.message.payload.externalId;
+    if (!instance4 || !messageId)
+      return;
+    const entry = { at: Date.now() };
+    queuedMessageAcks.set(chatKey, entry);
+    const channel5 = info2.message.metadata.channelType ?? instance4.channel;
+    const plugin10 = await getPlugin(channel5) ?? null;
+    entry.handle = startAck(plugin10, createPluginAckProvider(plugin10), instance4.id, info2.chatId, messageId, channel5, {
+      ...buildAckConfig(instance4),
+      ackTimeoutMs: QUEUED_ACK_TIMEOUT_MS
+    });
+  } catch (error3) {
+    queuedMessageAcks.delete(chatKey);
+    log91.debug("Failed to ack queued message", { chatId: info2.chatId, error: String(error3) });
+  }
+}
 async function dispatchToAgent(services, instance4, msgs, triggerType, channel5, chatId, senderId, personId, senderName, traceId, senderAgentId, perThreadExtraContext, db2) {
   const firstMsg = msgs[0];
   if (!firstMsg)
@@ -347463,10 +347602,13 @@ async function setupAgentDispatcher(eventBus, services, db2) {
       }
     }
   }, 60000);
-  const debouncer = new MessageDebouncer(async (_chatKey, messages4) => {
+  const onDebouncedFlush = async (chatKey, messages4) => {
+    const queuedAck = takeQueuedAck(chatKey);
     const firstMsg = messages4[0];
-    if (!firstMsg)
+    if (!firstMsg) {
+      queuedAck?.remove();
       return;
+    }
     const instanceId = firstMsg.metadata.instanceId;
     let instance4;
     if (firstMsg.metadata.resolvedInstance) {
@@ -347475,6 +347617,7 @@ async function setupAgentDispatcher(eventBus, services, db2) {
       const baseInstance = await runDispatchDb(db2, firstMsg.metadata.trustedTenantId, () => agentRunner.getInstanceWithProvider(instanceId));
       if (!baseInstance) {
         log91.warn("Instance not found for debounced messages", { instanceId });
+        queuedAck?.remove();
         return;
       }
       const externalChatId = firstMsg.payload.chatId;
@@ -347484,13 +347627,19 @@ async function setupAgentDispatcher(eventBus, services, db2) {
     }
     const msgContext = buildMessageContext(firstMsg.payload, instance4);
     const triggerType = classifyMessageTrigger(msgContext);
-    if (await shouldSkipViaGate(triggerType, firstMsg, instance4, messages4, services))
+    if (await shouldSkipViaGate(triggerType, firstMsg, instance4, messages4, services)) {
+      queuedAck?.remove();
       return;
+    }
     if (firstMsg.metadata.journeyTracked && firstMsg.metadata.correlationId) {
       const tracker = getJourneyTracker();
       tracker.recordCheckpoint(firstMsg.metadata.correlationId, "T5", JOURNEY_STAGES.T5);
     }
+    queuedAck?.release();
     await processAgentResponse(services, instance4, messages4, triggerType, db2, eventBus);
+  };
+  const debouncer = new MessageDebouncer(onDebouncedFlush, Date.now, {
+    onQueuedBehindActiveRun: (info2) => void ackQueuedMessage(info2)
   });
   activeMessageDebouncer = debouncer;
   try {
@@ -347656,7 +347805,24 @@ async function setupAgentDispatcher(eventBus, services, db2) {
       queue: "agent-dispatcher-media",
       startFrom: "new"
     });
-    log91.info("Agent dispatcher initialized (message + reaction + reaction-removed + media triggers)");
+    await eventBus.subscribe("agent.run.cancel_requested", async (event) => {
+      const payload = event.payload;
+      try {
+        await cancelActiveAgentRun(payload.instanceId, payload.chatId, payload.reason, {
+          threadId: payload.threadId,
+          requestedAt: payload.requestedAt
+        });
+      } catch (error3) {
+        log91.error("Error cancelling agent run", {
+          instanceId: payload.instanceId,
+          chatId: payload.chatId,
+          error: String(error3)
+        });
+      }
+    }, {
+      startFrom: "new"
+    });
+    log91.info("Agent dispatcher initialized (message + reaction + reaction-removed + media + cancel triggers)");
   } catch (error3) {
     log91.error("Failed to set up agent dispatcher", { error: String(error3) });
     clearInterval(mediaCleanupInterval);
@@ -347710,7 +347876,7 @@ async function setupAgentDispatcher(eventBus, services, db2) {
     log91.info("Agent dispatcher shutdown complete");
   };
 }
-var import_api32, log91, agentDispatchLimiter, _natsGenieProviderCtor, QUOTED_MESSAGE_MAX_CHARS = 4000, DM_HISTORY_LIMIT = 20, LIFECYCLE_PREVIEW_MAX_CHARS = 160, LIFECYCLE_SENSITIVE_KEY_PARTS, PRESENCE_DEFAULT_MIN_MS = 5000, PRESENCE_DEFAULT_MAX_WAIT_MS = 30000, activeMessageDebouncer = null, DEFAULT_DISPATCH_ERROR_MESSAGE = "Opa, tive um probleminha aqui \uD83D\uDE05 Pode mandar de novo?", DEFAULT_ERROR_HANDOFF_MESSAGE = "T\xF4 com um probleminha t\xE9cnico aqui agora. Logo algu\xE9m do time vai entrar em contato com voc\xEA.", TRANSIENT_DISPATCH_ERROR_PATTERNS, TRANSIENT_DISPATCH_RETRY_DELAYS_MS, CHANNEL_MESSAGE_LIMITS, DEFAULT_MESSAGE_LIMIT = 4000, MEDIA_BASE_PATH3, MEDIA_ICONS, MEDIA_WAIT_NULL, mediaCompletions, mediaResultCache, MEDIA_WAIT_TIMEOUT_MS = 30000, DEFAULT_SEND_MEDIA_PATH_TYPES, BOT_PREFIX = "\uD83E\uDD16 ", activeStreams, sessionActivityStore, PROC_REACT_START, PROC_REACT_DONE = "\u2705", providerCache, openclawClientPool, _openClawClientCtor, nullFilterWarnedInstances, ACTIVE_OWNER_IDENTIFIER_CACHE_TTL_MS = 1e4, cachedActiveOwnerIdentifiers = null, cachedActiveOwnerIdentifiersAt = 0, tenantCachedActiveOwnerIdentifiers, DEFAULT_GATE_MODEL = "gemini-3-flash-preview", GATE_TIMEOUT_MS = 3000, setupAgentResponder;
+var import_api32, log91, agentDispatchLimiter, _natsGenieProviderCtor, QUOTED_MESSAGE_MAX_CHARS = 4000, DM_HISTORY_LIMIT = 20, LIFECYCLE_PREVIEW_MAX_CHARS = 160, LIFECYCLE_SENSITIVE_KEY_PARTS, PRESENCE_DEFAULT_MIN_MS = 5000, PRESENCE_DEFAULT_MAX_WAIT_MS = 30000, activeMessageDebouncer = null, DEFAULT_DISPATCH_ERROR_MESSAGE = "Opa, tive um probleminha aqui \uD83D\uDE05 Pode mandar de novo?", DEFAULT_ERROR_HANDOFF_MESSAGE = "T\xF4 com um probleminha t\xE9cnico aqui agora. Logo algu\xE9m do time vai entrar em contato com voc\xEA.", TRANSIENT_DISPATCH_ERROR_PATTERNS, TRANSIENT_DISPATCH_RETRY_DELAYS_MS, CHANNEL_MESSAGE_LIMITS, DEFAULT_MESSAGE_LIMIT = 4000, MEDIA_BASE_PATH3, MEDIA_ICONS, MEDIA_WAIT_NULL, mediaCompletions, mediaResultCache, MEDIA_WAIT_TIMEOUT_MS = 30000, DEFAULT_SEND_MEDIA_PATH_TYPES, BOT_PREFIX = "\uD83E\uDD16 ", activeStreams, activeRunAborts, sessionActivityStore, PROC_REACT_START, PROC_REACT_DONE = "\u2705", queuedMessageAcks, QUEUED_ACK_TIMEOUT_MS = 120000, providerCache, openclawClientPool, _openClawClientCtor, nullFilterWarnedInstances, ACTIVE_OWNER_IDENTIFIER_CACHE_TTL_MS = 1e4, cachedActiveOwnerIdentifiers = null, cachedActiveOwnerIdentifiersAt = 0, tenantCachedActiveOwnerIdentifiers, DEFAULT_GATE_MODEL = "gemini-3-flash-preview", GATE_TIMEOUT_MS = 3000, setupAgentResponder;
 var init_agent_dispatcher = __esm(() => {
   init_src2();
   init_src();
@@ -347767,8 +347933,10 @@ var init_agent_dispatcher = __esm(() => {
   mediaResultCache = new Map;
   DEFAULT_SEND_MEDIA_PATH_TYPES = ["image", "video", "document"];
   activeStreams = new Map;
+  activeRunAborts = new Map;
   sessionActivityStore = new InMemorySessionActivityStore;
   PROC_REACT_START = { audio: "\uD83C\uDFA7", image: "\uD83D\uDC40", video: "\uD83D\uDC40", document: "\uD83D\uDC40" };
+  queuedMessageAcks = new Map;
   providerCache = new Map;
   openclawClientPool = new Map;
   _openClawClientCtor = OpenClawClient;
@@ -385208,6 +385376,23 @@ async function checkBoltHealth(connection) {
   }
 }
 
+// ../channel-slack/src/handlers/agent-sessions.ts
+function setupAgentSessionHandlers(app, instanceId, callbacks, logger5) {
+  app.event("agent_session_stopped", async ({ event }) => {
+    const evt = event;
+    const channelId = evt.channel;
+    if (!channelId)
+      return;
+    const threadTs = evt.thread_ts;
+    const userId = evt.user;
+    const eventTs = evt.event_ts;
+    const streamingMessageTs = Array.isArray(evt.streaming_message_ts) ? evt.streaming_message_ts : [];
+    logger5.info("Agent session stopped by user", { instanceId, channelId, threadTs, userId, streamingMessageTs });
+    await callbacks.onSessionStopped(instanceId, { channelId, threadTs, userId, streamingMessageTs, eventTs });
+  });
+  logger5.info("Agent session handlers registered", { instanceId });
+}
+
 // ../channel-slack/src/handlers/commands.ts
 function setupCommandHandlers(app, instanceId, commandNames, callbacks, logger5) {
   for (const commandName of commandNames) {
@@ -385687,10 +385872,62 @@ function setupReactionHandlers2(app, instanceId, botUserId, callbacks, logger5)
 
 // ../channel-slack/src/handlers/typing.ts
 var CLEAR_STATUS = "";
+var AGENT_API_UNAVAILABLE_ERRORS = new Set([
+  "unknown_method",
+  "feature_disabled",
+  "method_deprecated",
+  "missing_scope",
+  "not_allowed_token_type"
+]);
+var agentApiUnavailable = new WeakSet;
+function slackErrorCode(err2) {
+  return err2?.data?.error;
+}
 async function setSlackThreadStatus(params) {
   const { client, channelId, threadTs, status, loadingMessages, logger: logger5, instanceId } = params;
-  if (!threadTs)
-    return false;
+  if (!threadTs) {
+    logger5.debug("setSlackThreadStatus: skipped, no thread timestamp", {
+      instanceId,
+      channelId,
+      reason: "no_thread_ts",
+      clearing: status.length === 0
+    });
+    return { delivered: false };
+  }
+  const clearing = status.length === 0;
+  const logContext = {
+    instanceId,
+    channelId,
+    threadTs,
+    clearing,
+    statusLength: status.length,
+    loadingMessageCount: loadingMessages?.length ?? 0
+  };
+  if (typeof client.apiCall === "function" && !agentApiUnavailable.has(client)) {
+    try {
+      await client.apiCall("agents.sessions.setStatus", {
+        channel_id: channelId,
+        thread_ts: threadTs,
+        status: clearing ? "active" : "processing"
+      });
+      return { delivered: true, method: "agents.sessions.setStatus" };
+    } catch (err2) {
+      const code = slackErrorCode(err2);
+      if (code && AGENT_API_UNAVAILABLE_ERRORS.has(code)) {
+        agentApiUnavailable.add(client);
+        logger5.info("agents.sessions.setStatus unavailable, falling back to assistant.threads.setStatus", {
+          instanceId,
+          channelId,
+          error: code
+        });
+      } else {
+        logger5.warn("agents.sessions.setStatus failed, trying legacy fallback", {
+          ...logContext,
+          error: String(err2)
+        });
+      }
+    }
+  }
   const payload = {
     channel_id: channelId,
     thread_ts: threadTs,
@@ -385698,27 +385935,19 @@ async function setSlackThreadStatus(params) {
     ...loadingMessages?.length ? { loading_messages: loadingMessages } : {}
   };
   try {
-    const clientAny = client;
-    if (typeof clientAny.assistant?.threads?.setStatus === "function") {
-      await clientAny.assistant.threads.setStatus(payload);
-      return true;
+    const legacyClient = client;
+    if (typeof legacyClient.assistant?.threads?.setStatus === "function") {
+      await legacyClient.assistant.threads.setStatus(payload);
+      return { delivered: true, method: "assistant.threads.setStatus" };
     }
-    if (typeof clientAny.apiCall === "function") {
-      await clientAny.apiCall("assistant.threads.setStatus", payload);
-      return true;
+    if (typeof legacyClient.apiCall === "function") {
+      await legacyClient.apiCall("assistant.threads.setStatus", payload);
+      return { delivered: true, method: "assistant.threads.setStatus" };
     }
   } catch (err2) {
-    logger5.warn("setSlackThreadStatus: failed", {
-      instanceId,
-      channelId,
-      threadTs,
-      clearing: status.length === 0,
-      statusLength: status.length,
-      loadingMessageCount: loadingMessages?.length ?? 0,
-      error: String(err2)
-    });
+    logger5.warn("setSlackThreadStatus: failed", { ...logContext, error: String(err2) });
   }
-  return false;
+  return { delivered: false, method: "assistant.threads.setStatus" };
 }
 async function clearTypingStatus(params) {
   return setSlackThreadStatus({ ...params, status: CLEAR_STATUS });
@@ -385893,6 +386122,7 @@ function createSlackStreamSender(options) {
   let finalized = false;
   let pendingContent;
   let throttleTimer;
+  let lastContent = "";
   function formatText(text) {
     return formatMode === "passthrough" ? text : markdownToMrkdwn(text);
   }
@@ -385951,6 +386181,8 @@ function createSlackStreamSender(options) {
     }
   }
   async function finalize(text) {
+    if (finalized)
+      return;
     finalized = true;
     if (throttleTimer) {
       clearTimeout(throttleTimer);
@@ -385976,31 +386208,60 @@ function createSlackStreamSender(options) {
       await sendInitial(chunk);
     }
   }
+  async function deleteDraft() {
+    if (draftTs && !finalized) {
+      try {
+        await client.chat.delete({ channel: channelId, ts: draftTs });
+      } catch {}
+    }
+    finalized = true;
+  }
+  async function cancelKeepingPartial() {
+    if (finalized)
+      return;
+    if (lastContent.trim()) {
+      await finalize(lastContent);
+      return;
+    }
+    await deleteDraft();
+  }
   if (streamMode === "off") {
     return {
       async onThinkingDelta(_delta) {},
       async onContentDelta(_delta) {},
       async onFinal(delta) {
-        await sendInitial(delta.content);
+        if (finalized)
+          return;
         finalized = true;
+        await sendInitial(delta.content);
       },
       async onError(delta) {
-        await sendInitial(`Error: ${delta.error}`);
+        if (finalized)
+          return;
         finalized = true;
+        await sendInitial(`Error: ${delta.error}`);
       },
       async abort() {
         finalized = true;
+      },
+      async cancel() {
+        finalized = true;
       }
     };
   }
   if (streamMode === "status_final") {
     return {
       async onThinkingDelta(_delta) {
+        if (finalized)
+          return;
         if (!draftTs) {
           await sendInitial("_Thinking..._");
         }
       },
-      async onContentDelta(_delta) {
+      async onContentDelta(delta) {
+        if (finalized)
+          return;
+        lastContent = delta.content;
         if (!draftTs) {
           await sendInitial("_Thinking..._");
         }
@@ -386012,17 +386273,17 @@ function createSlackStreamSender(options) {
         await finalize(`Error: ${delta.error}`);
       },
       async abort() {
-        if (draftTs && !finalized) {
-          try {
-            await client.chat.delete({ channel: channelId, ts: draftTs });
-          } catch {}
-        }
-        finalized = true;
+        await deleteDraft();
+      },
+      async cancel() {
+        await cancelKeepingPartial();
       }
     };
   }
   return {
     async onThinkingDelta(delta) {
+      if (finalized)
+        return;
       const text = `_${delta.thinking}_`;
       if (!draftTs) {
         await sendInitial(text);
@@ -386031,7 +386292,10 @@ function createSlackStreamSender(options) {
       }
     },
     async onContentDelta(delta) {
+      if (finalized)
+        return;
       const text = delta.content;
+      lastContent = text;
       if (!draftTs) {
         await sendInitial(text);
       } else {
@@ -386045,12 +386309,10 @@ function createSlackStreamSender(options) {
       await finalize(`Error: ${delta.error}`);
     },
     async abort() {
-      if (draftTs && !finalized) {
-        try {
-          await client.chat.delete({ channel: channelId, ts: draftTs });
-        } catch {}
-      }
-      finalized = true;
+      await deleteDraft();
+    },
+    async cancel() {
+      await cancelKeepingPartial();
     }
   };
 }
@@ -386142,6 +386404,8 @@ function createNativeStreamSender(options) {
     async onContentDelta(delta) {
       if (fallback)
         return fallback.onContentDelta(delta);
+      if (stopped)
+        return;
       const content = delta.content;
       if (!content)
         return;
@@ -386168,6 +386432,11 @@ function createNativeStreamSender(options) {
       if (fallback)
         return fallback.abort();
       await stopStream();
+    },
+    async cancel() {
+      if (fallback)
+        return fallback.cancel ? fallback.cancel() : fallback.abort();
+      await stopStream();
     }
   };
 }
@@ -386561,6 +386830,10 @@ class SlackPlugin extends BaseChannelPlugin {
       async abort() {
         await base2.abort();
         cleanup();
+      },
+      async cancel() {
+        await (base2.cancel ? base2.cancel() : base2.abort());
+        cleanup();
       }
     };
   }
@@ -386568,29 +386841,43 @@ class SlackPlugin extends BaseChannelPlugin {
     await this.sendPresenceStatus(instanceId, chatId, duration === 0 ? "paused" : "typing", duration);
   }
   async sendPresenceStatus(instanceId, chatId, type, duration, options) {
-    const method = "assistant.threads.setStatus";
+    const nominalMethod = "agents.sessions.setStatus";
     const connection = this.connections.get(instanceId);
     if (!connection)
-      return { delivered: false, method, reason: "not_connected" };
+      return { delivered: false, method: nominalMethod, reason: "not_connected" };
     const threadTs = options?.threadId ?? this.activeThreads.get(`${instanceId}:${chatId}`);
-    if (!threadTs)
-      return { delivered: false, method, reason: "no_active_thread" };
+    if (!threadTs) {
+      this.logger.debug("Slack presence status skipped", {
+        instanceId,
+        chatId,
+        type,
+        reason: "no_active_thread"
+      });
+      return { delivered: false, method: nominalMethod, reason: "no_active_thread" };
+    }
     const shouldClear = type === "paused";
     const status = shouldClear ? "" : options?.status ?? (type === "recording" ? "is recording..." : "is typing...");
     const timerKey = this.presenceStatusTimerKey(instanceId, chatId, threadTs);
-    const delivered = status === "" ? await clearTypingStatus({
+    const statusResult = status === "" ? await clearTypingStatus({
       client: connection.actingClient,
       channelId: chatId,
       threadTs,
-      logger: this.logger
+      logger: this.logger,
+      instanceId
     }) : await setSlackThreadStatus({
       client: connection.actingClient,
       channelId: chatId,
       threadTs,
       status,
       loadingMessages: options?.loadingMessages,
-      logger: this.logger
+      logger: this.logger,
+      instanceId
     });
+    const { delivered, method } = statusResult;
+    const usedLegacy = method === "assistant.threads.setStatus";
+    const sessionStatus = shouldClear ? "active" : "processing";
+    const appliedStatus = !delivered || usedLegacy ? status : sessionStatus;
+    const appliedLoadingMessages = !delivered || usedLegacy ? options?.loadingMessages : undefined;
     if (delivered) {
       this.clearPresenceStatusTimer(timerKey);
     }
@@ -386616,12 +386903,18 @@ class SlackPlugin extends BaseChannelPlugin {
       this.presenceStatusTimers.set(timerKey, timer);
       timer.unref?.();
     }
-    return delivered ? { delivered: true, method, threadId: threadTs, status, loadingMessages: options?.loadingMessages } : {
-      delivered: false,
+    return delivered ? {
+      delivered: true,
       method,
       threadId: threadTs,
-      status,
-      loadingMessages: options?.loadingMessages,
+      status: appliedStatus,
+      loadingMessages: appliedLoadingMessages
+    } : {
+      delivered: false,
+      method: method ?? nominalMethod,
+      threadId: threadTs,
+      status: appliedStatus,
+      loadingMessages: appliedLoadingMessages,
       reason: "slack_status_failed"
     };
   }
@@ -386942,6 +387235,37 @@ class SlackPlugin extends BaseChannelPlugin {
       break;
     }
   }
+  async handleAgentSessionStopped(instanceId, connection, args) {
+    const parsedEventTs = args.eventTs ? Number.parseFloat(args.eventTs) : Number.NaN;
+    const requestedAt = Number.isFinite(parsedEventTs) ? Math.round(parsedEventTs * 1000) : Date.now();
+    try {
+      await this.eventBus.publish("agent.run.cancel_requested", {
+        instanceId,
+        chatId: args.channelId,
+        threadId: args.threadTs,
+        requestedBy: args.userId,
+        requestedAt,
+        reason: "user_stop"
+      }, {
+        instanceId,
+        channelType: this.id,
+        source: `channel:${this.id}`
+      });
+    } catch (err2) {
+      this.logger.error("Failed to publish agent.run.cancel_requested", {
+        instanceId,
+        chatId: args.channelId,
+        error: String(err2)
+      });
+    }
+    await clearTypingStatus({
+      client: connection.actingClient,
+      channelId: args.channelId,
+      threadTs: args.threadTs ?? this.activeThreads.get(`${instanceId}:${args.channelId}`),
+      logger: this.logger,
+      instanceId
+    });
+  }
   trackActiveThread(instanceId, channelId, threadTs) {
     this.activeThreads.set(`${instanceId}:${channelId}`, threadTs);
   }
@@ -387059,6 +387383,11 @@ class SlackPlugin extends BaseChannelPlugin {
         await this.handleReactionReceived(instId, messageId, chatId, userId, emoji, action);
       }
     }, this.logger);
+    setupAgentSessionHandlers(connection.app, instanceId, {
+      onSessionStopped: async (instId, args) => {
+        await this.handleAgentSessionStopped(instId, connection, args);
+      }
+    }, this.logger);
     setupInteractionHandlers2(connection.app, instanceId, {
       onInteraction: async (_instId, payload) => {
         await this.handleInteraction(payload);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automagik/omni",
-  "version": "2.260901.1",
+  "version": "2.260901.2",
   "description": "LLM-optimized CLI for Omni",
   "type": "module",
   "bin": {