@agent-native/core 0.94.2 → 0.95.0

package/corpus/core/src/integrations/a2a-continuation-processor.ts

@@ -18,7 +18,11 @@ import {
   type A2AContinuation,
 } from "./a2a-continuations-store.js";
 import { signInternalToken } from "./internal-token.js";
-import type { PlatformAdapter } from "./types.js";
+import type {
+  OutgoingMessage,
+  PlatformAdapter,
+  PlatformRunProgress,
+} from "./types.js";
 
 const PROCESSOR_PATH = `${FRAMEWORK_ROUTE_PREFIX}/integrations/process-a2a-continuation`;
 const TERMINAL_STATES = new Set(["completed", "failed", "canceled"]);
@@ -150,6 +154,8 @@ async function processClaimedContinuation(
     return;
   }
 
+  const progress = await resumeA2AContinuationProgress(continuation, adapter);
+
   const auth = await signContinuationToken(continuation);
   const client = new A2AClient(continuation.agentUrl, auth.apiKey, {
     requestTimeoutMs: POLL_REQUEST_TIMEOUT_MS,
@@ -162,6 +168,7 @@ async function processClaimedContinuation(
     while (Date.now() < deadline) {
       task = await client.getTask(continuation.a2aTaskId);
       if (TERMINAL_STATES.has(task.status.state)) break;
+      await reportA2AContinuationProgress(continuation, progress, task);
       await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
     }
   } catch (err) {
@@ -171,6 +178,7 @@ async function processClaimedContinuation(
           continuation,
           adapter,
           remotePollFailureReason(continuation),
+          progress,
         );
         return;
       }
@@ -182,6 +190,7 @@ async function processClaimedContinuation(
         continuation,
         adapter,
         err instanceof Error ? err.message : String(err),
+        progress,
       );
       return;
     }
@@ -190,24 +199,12 @@ async function processClaimedContinuation(
   }
 
   if (!task || !TERMINAL_STATES.has(task.status.state)) {
-    const recoverableArtifactText = extractRecoverableArtifactText(task);
-    if (recoverableArtifactText) {
-      await deliverAndCompleteA2AContinuation(
-        continuation,
-        adapter,
-        formatContinuationArtifactText(
-          recoverableArtifactText,
-          continuation.agentUrl,
-        ),
-      );
-      return;
-    }
-
     if (shouldStopPollingRemoteTask(continuation)) {
       await notifyAndFailA2AContinuation(
         continuation,
         adapter,
         remotePollFailureReason(continuation),
+        progress,
       );
       return;
     }
@@ -219,7 +216,7 @@ async function processClaimedContinuation(
     const reason =
       extractTaskText(task) ||
       `Remote A2A task ${continuation.a2aTaskId} ended with state ${task.status.state}`;
-    await notifyAndFailA2AContinuation(continuation, adapter, reason);
+    await notifyAndFailA2AContinuation(continuation, adapter, reason, progress);
     return;
   }
 
@@ -232,11 +229,64 @@ async function processClaimedContinuation(
       continuation,
       adapter,
       `Remote A2A task ${continuation.a2aTaskId} completed without text`,
+      progress,
     );
     return;
   }
 
-  await deliverAndCompleteA2AContinuation(continuation, adapter, text);
+  await deliverAndCompleteA2AContinuation(
+    continuation,
+    adapter,
+    text,
+    progress,
+  );
+}
+
+async function resumeA2AContinuationProgress(
+  continuation: A2AContinuation,
+  adapter: PlatformAdapter,
+): Promise<PlatformRunProgress | null> {
+  if (!continuation.progressRef || !adapter.resumeRunProgress) return null;
+  try {
+    const progress = await adapter.resumeRunProgress(
+      continuation.incoming,
+      continuation.progressRef,
+    );
+    if (!progress) return null;
+    await progress.onEvent({
+      type: "agent_call_progress",
+      agent: continuation.agentName,
+      state: "working",
+      elapsedSeconds: Math.max(
+        0,
+        Math.round((Date.now() - continuation.createdAt) / 1_000),
+      ),
+      detail: "Continuing in the background",
+    });
+    return progress;
+  } catch {
+    // A continuation still has a normal reply fallback. Do not log the
+    // opaque provider reference or the inbound message payload.
+    return null;
+  }
+}
+
+async function reportA2AContinuationProgress(
+  continuation: A2AContinuation,
+  progress: PlatformRunProgress | null,
+  task: Task,
+): Promise<void> {
+  if (!progress) return;
+  await progress.onEvent({
+    type: "agent_call_progress",
+    agent: continuation.agentName,
+    state: task.status.state,
+    elapsedSeconds: Math.max(
+      0,
+      Math.round((Date.now() - continuation.createdAt) / 1_000),
+    ),
+    detail: "Still working on the delegated request",
+  });
 }
 
 async function waitForContinuationDue(
@@ -262,6 +312,7 @@ async function notifyAndFailA2AContinuation(
   continuation: A2AContinuation,
   adapter: PlatformAdapter,
   reason: string,
+  progress: PlatformRunProgress | null = null,
 ): Promise<void> {
   const deliveryContinuation = await claimA2AContinuationDelivery(
     continuation.id,
@@ -273,11 +324,14 @@ async function notifyAndFailA2AContinuation(
     reason,
   );
   try {
+    const outgoing = adapter.formatAgentResponse(message);
     await withTimeout(
-      adapter.sendResponse(
-        adapter.formatAgentResponse(message),
-        deliveryContinuation.incoming,
-        { placeholderRef: deliveryContinuation.placeholderRef ?? undefined },
+      deliverA2AContinuationResponse(
+        adapter,
+        deliveryContinuation,
+        outgoing,
+        progress,
+        "error",
       ),
       PLATFORM_SEND_TIMEOUT_MS,
       `${deliveryContinuation.platform} failure notification timed out`,
@@ -296,6 +350,7 @@ async function deliverAndCompleteA2AContinuation(
   continuation: A2AContinuation,
   adapter: PlatformAdapter,
   text: string,
+  progress: PlatformRunProgress | null = null,
 ): Promise<void> {
   const deliveryContinuation = await claimA2AContinuationDelivery(
     continuation.id,
@@ -303,11 +358,14 @@ async function deliverAndCompleteA2AContinuation(
   if (!deliveryContinuation) return;
 
   try {
+    const outgoing = adapter.formatAgentResponse(text);
     await withTimeout(
-      adapter.sendResponse(
-        adapter.formatAgentResponse(text),
-        deliveryContinuation.incoming,
-        { placeholderRef: deliveryContinuation.placeholderRef ?? undefined },
+      deliverA2AContinuationResponse(
+        adapter,
+        deliveryContinuation,
+        outgoing,
+        progress,
+        "done",
       ),
       PLATFORM_SEND_TIMEOUT_MS,
       `${deliveryContinuation.platform} response delivery timed out`,
@@ -327,6 +385,42 @@ async function deliverAndCompleteA2AContinuation(
   await completeAfterSuccessfulDelivery(deliveryContinuation);
 }
 
+async function deliverA2AContinuationResponse(
+  adapter: PlatformAdapter,
+  continuation: A2AContinuation,
+  message: OutgoingMessage,
+  progress: PlatformRunProgress | null,
+  status: "done" | "error",
+): Promise<void> {
+  if (progress) {
+    try {
+      await progress.onEvent({
+        type: "agent_call",
+        agent: continuation.agentName,
+        status,
+      });
+      await progress.complete(message);
+      return;
+    } catch {
+      // A resumed Slack stream can no longer be finalized (for example when
+      // chat.stopStream rejects). Preserve the final answer with the same
+      // thread reply fallback used by the initial webhook run. Also ask the
+      // adapter to terminate the native stream: otherwise Slack can keep the
+      // task card in its working state after the thread fallback succeeds.
+      try {
+        await progress.fail?.(
+          "I couldn't update the live response, but I posted the final result in this thread.",
+        );
+      } catch {
+        // The thread reply below is still the authoritative final answer.
+      }
+    }
+  }
+  await adapter.sendResponse(message, continuation.incoming, {
+    placeholderRef: continuation.placeholderRef ?? undefined,
+  });
+}
+
 async function rescheduleAndRedispatchA2AContinuation(
   continuationId: string,
 ): Promise<void> {
@@ -524,13 +618,6 @@ function extractTaskText(task: Task): string {
     .join("\n");
 }
 
-function extractRecoverableArtifactText(task: Task | null): string {
-  if (!task?.status.message?.metadata?.agentNativeRecoverableArtifacts) {
-    return "";
-  }
-  return extractTaskText(task);
-}
-
 function formatContinuationArtifactText(
   text: string,
   agentUrl: string,

package/corpus/core/src/integrations/a2a-continuations-store.ts

@@ -10,7 +10,7 @@ import {
   ensureIndexExists,
 } from "../db/ddl-guard.js";
 import { isDuplicateColumnError } from "../db/migrations.js";
-import type { IncomingMessage } from "./types.js";
+import type { IncomingMessage, PlatformRunProgressRef } from "./types.js";
 
 let _initPromise: Promise<void> | undefined;
 const PROCESSING_STUCK_AFTER_MS = 5 * 60 * 1000;
@@ -28,6 +28,8 @@ function buildCreateSql(): string {
     external_thread_id TEXT NOT NULL,
     incoming_payload TEXT NOT NULL,
     placeholder_ref TEXT,
+    progress_ref TEXT,
+    progress_ref_claimed ${intType()} NOT NULL DEFAULT 0,
     owner_email TEXT NOT NULL,
     org_id TEXT,
     agent_name TEXT NOT NULL,
@@ -76,10 +78,25 @@ async function ensureTable(): Promise<void> {
           "dedupe_key",
           `ALTER TABLE integration_a2a_continuations ADD COLUMN IF NOT EXISTS dedupe_key TEXT`,
         );
+        await ensureColumnExists(
+          "integration_a2a_continuations",
+          "progress_ref",
+          `ALTER TABLE integration_a2a_continuations ADD COLUMN IF NOT EXISTS progress_ref TEXT`,
+        );
+        await ensureColumnExists(
+          "integration_a2a_continuations",
+          "progress_ref_claimed",
+          `ALTER TABLE integration_a2a_continuations ADD COLUMN IF NOT EXISTS progress_ref_claimed ${intType()} NOT NULL DEFAULT 0`,
+        );
+        await backfillProgressRefOwners(client);
         await ensureIndexExists(
           "idx_a2a_continuations_dedupe_key",
           `CREATE INDEX IF NOT EXISTS idx_a2a_continuations_dedupe_key ON integration_a2a_continuations(integration_task_id, agent_url, dedupe_key)`,
         );
+        await ensureIndexExists(
+          "idx_a2a_continuations_one_progress_owner",
+          `CREATE UNIQUE INDEX IF NOT EXISTS idx_a2a_continuations_one_progress_owner ON integration_a2a_continuations(integration_task_id) WHERE progress_ref_claimed = 1`,
+        );
         return;
       }
       // SQLite (local dev): keep existing behavior
@@ -101,11 +118,22 @@ async function ensureTable(): Promise<void> {
       );
       await addColumnIfMissing("a2a_auth_token", "TEXT");
       await addColumnIfMissing("dedupe_key", "TEXT");
+      await addColumnIfMissing("progress_ref", "TEXT");
+      await addColumnIfMissing(
+        "progress_ref_claimed",
+        `${intType()} NOT NULL DEFAULT 0`,
+      );
+      await backfillProgressRefOwners(client);
       await retryOnDdlRace(() =>
         client.execute(
           `CREATE INDEX IF NOT EXISTS idx_a2a_continuations_dedupe_key ON integration_a2a_continuations(integration_task_id, agent_url, dedupe_key)`,
         ),
       );
+      await retryOnDdlRace(() =>
+        client.execute(
+          `CREATE UNIQUE INDEX IF NOT EXISTS idx_a2a_continuations_one_progress_owner ON integration_a2a_continuations(integration_task_id) WHERE progress_ref_claimed = 1`,
+        ),
+      );
     })().catch((err) => {
       // Retry init on the next call after a failed startup.
       _initPromise = undefined;
@@ -128,6 +156,33 @@ async function addColumnIfMissing(name: string, definition: string) {
   }
 }
 
+async function backfillProgressRefOwners(
+  client: ReturnType<typeof getDbExec>,
+): Promise<void> {
+  await client.execute(`
+    UPDATE integration_a2a_continuations AS candidate
+    SET progress_ref_claimed = 1
+    WHERE candidate.progress_ref IS NOT NULL
+      AND candidate.status NOT IN ('completed', 'failed')
+      AND candidate.progress_ref_claimed = 0
+      AND NOT EXISTS (
+        SELECT 1
+        FROM integration_a2a_continuations AS owner
+        WHERE owner.integration_task_id = candidate.integration_task_id
+          AND owner.progress_ref_claimed = 1
+      )
+      AND candidate.id = (
+        SELECT selected.id
+        FROM integration_a2a_continuations AS selected
+        WHERE selected.integration_task_id = candidate.integration_task_id
+          AND selected.progress_ref IS NOT NULL
+          AND selected.status NOT IN ('completed', 'failed')
+        ORDER BY selected.created_at ASC, selected.id ASC
+        LIMIT 1
+      )
+  `);
+}
+
 export type A2AContinuationStatus =
   | "pending"
   | "processing"
@@ -142,6 +197,8 @@ export interface A2AContinuation {
   externalThreadId: string;
   incoming: IncomingMessage;
   placeholderRef: string | null;
+  progressRef: PlatformRunProgressRef | null;
+  progressRefClaimed: boolean;
   ownerEmail: string;
   orgId: string | null;
   agentName: string;
@@ -158,6 +215,44 @@ export interface A2AContinuation {
   completedAt: number | null;
 }
 
+const MAX_PROGRESS_REF_KIND_CHARS = 128;
+const MAX_PROGRESS_REF_STREAM_TS_CHARS = 256;
+
+/**
+ * Keep only the tiny, adapter-owned continuation reference. Invalid rows are
+ * treated as unavailable rather than throwing during a retry sweep.
+ */
+function parseProgressRef(value: unknown): PlatformRunProgressRef | null {
+  if (typeof value !== "string" || value.length === 0) return null;
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    const { kind, streamTs } = parsed as Record<string, unknown>;
+    if (
+      typeof kind !== "string" ||
+      typeof streamTs !== "string" ||
+      kind.length === 0 ||
+      streamTs.length === 0 ||
+      kind.length > MAX_PROGRESS_REF_KIND_CHARS ||
+      streamTs.length > MAX_PROGRESS_REF_STREAM_TS_CHARS
+    ) {
+      return null;
+    }
+    return { kind, streamTs };
+  } catch {
+    return null;
+  }
+}
+
+function serializeProgressRef(value: unknown): string | null {
+  const parsed = parseProgressRef(
+    typeof value === "string" ? value : JSON.stringify(value),
+  );
+  return parsed ? JSON.stringify(parsed) : null;
+}
+
 function rowToContinuation(row: Record<string, unknown>): A2AContinuation {
   return {
     id: row.id as string,
@@ -166,6 +261,8 @@ function rowToContinuation(row: Record<string, unknown>): A2AContinuation {
     externalThreadId: row.external_thread_id as string,
     incoming: JSON.parse(row.incoming_payload as string) as IncomingMessage,
     placeholderRef: (row.placeholder_ref as string | null) ?? null,
+    progressRef: parseProgressRef(row.progress_ref),
+    progressRefClaimed: Number(row.progress_ref_claimed ?? 0) === 1,
     ownerEmail: row.owner_email as string,
     orgId: (row.org_id as string | null) ?? null,
     agentName: row.agent_name as string,
@@ -190,6 +287,7 @@ export async function insertA2AContinuation(input: {
   externalThreadId: string;
   incoming: IncomingMessage;
   placeholderRef?: string | null;
+  progressRef?: PlatformRunProgressRef | null;
   ownerEmail: string;
   orgId?: string | null;
   agentName: string;
@@ -203,14 +301,15 @@ export async function insertA2AContinuation(input: {
   const now = Date.now();
   const id = `a2a-cont-${now}-${Math.random().toString(36).slice(2, 8)}`;
   const payload = JSON.stringify(input.incoming);
+  const progressRef = serializeProgressRef(input.progressRef);
 
   try {
     await client.execute({
       sql: `INSERT INTO integration_a2a_continuations
         (id, integration_task_id, platform, external_thread_id, incoming_payload,
-         placeholder_ref, owner_email, org_id, agent_name, agent_url, dedupe_key, a2a_task_id, a2a_auth_token,
+         placeholder_ref, progress_ref, progress_ref_claimed, owner_email, org_id, agent_name, agent_url, dedupe_key, a2a_task_id, a2a_auth_token,
          status, attempts, next_check_at, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       args: [
         id,
         input.integrationTaskId,
@@ -218,6 +317,8 @@ export async function insertA2AContinuation(input: {
         input.externalThreadId,
         payload,
         input.placeholderRef ?? null,
+        null,
+        0,
         input.ownerEmail,
         input.orgId ?? null,
         input.agentName,
@@ -232,7 +333,6 @@ export async function insertA2AContinuation(input: {
         now,
       ],
     });
-    return (await getA2AContinuation(id))!;
   } catch (err: any) {
     if (!isDuplicateContinuationError(err)) throw err;
     const existing = await findA2AContinuation(
@@ -240,7 +340,65 @@ export async function insertA2AContinuation(input: {
       input.agentUrl,
       input.a2aTaskId,
     );
-    if (existing) return existing;
+    if (existing) {
+      // A retry can reach this row after the original invocation created it
+      // without a resumable progress surface (or with one that has gone
+      // stale). Keep the most recent valid adapter reference for active work,
+      // but never resurrect short-lived delivery state after a terminal row
+      // has deliberately scrubbed it.
+      if (
+        progressRef &&
+        existing.status !== "completed" &&
+        existing.status !== "failed"
+      ) {
+        if (existing.progressRefClaimed) {
+          if (JSON.stringify(existing.progressRef) !== progressRef) {
+            await client.execute({
+              sql: `UPDATE integration_a2a_continuations
+                    SET progress_ref = ?, updated_at = ?
+                    WHERE id = ? AND status NOT IN ('completed', 'failed')
+                      AND progress_ref_claimed = 1
+                      AND (progress_ref IS NULL OR progress_ref <> ?)`,
+              args: [progressRef, now, existing.id, progressRef],
+            });
+          }
+        } else {
+          await claimA2AContinuationProgressRef(existing.id, progressRef);
+        }
+        return (await getA2AContinuation(existing.id)) ?? existing;
+      }
+      return existing;
+    }
+    throw err;
+  }
+
+  if (progressRef) {
+    await claimA2AContinuationProgressRef(id, progressRef);
+  }
+  return (await getA2AContinuation(id))!;
+}
+
+/**
+ * A native platform stream has one terminal completion. Claim it for a single
+ * downstream continuation, and retain the ownership marker after terminal
+ * cleanup scrubs the short-lived stream reference. The partial unique index
+ * makes concurrent downstream inserts safe across processes.
+ */
+async function claimA2AContinuationProgressRef(
+  id: string,
+  progressRef: string,
+): Promise<void> {
+  try {
+    await getDbExec().execute({
+      sql: `UPDATE integration_a2a_continuations
+            SET progress_ref = ?, progress_ref_claimed = 1
+            WHERE id = ? AND progress_ref_claimed = 0`,
+      args: [progressRef, id],
+    });
+  } catch (err) {
+    // A sibling continuation already owns this stream and will finalize it.
+    // This continuation still delivers through the normal response path.
+    if (isDuplicateContinuationError(err)) return;
     throw err;
   }
 }
@@ -462,7 +620,7 @@ export async function completeA2AContinuation(id: string): Promise<void> {
   await client.execute({
     sql: `UPDATE integration_a2a_continuations
           SET status = ?, updated_at = ?, completed_at = ?,
-              incoming_payload = ?, a2a_auth_token = NULL
+              incoming_payload = ?, a2a_auth_token = NULL, progress_ref = NULL
           WHERE id = ? AND status IN ('processing', 'delivering', 'completed')`,
     args: ["completed", now, now, "{}", id],
   });
@@ -478,7 +636,7 @@ export async function failA2AContinuation(
   await client.execute({
     sql: `UPDATE integration_a2a_continuations
           SET status = ?, updated_at = ?, error_message = ?,
-              incoming_payload = ?, a2a_auth_token = NULL
+              incoming_payload = ?, a2a_auth_token = NULL, progress_ref = NULL
           WHERE id = ? AND status <> 'completed'`,
     args: ["failed", now, errorMessage.slice(0, 2000), "{}", id],
   });

package/corpus/core/src/integrations/adapters/slack.ts

@@ -22,6 +22,7 @@ import type {
   IntegrationStatus,
   OutboundTarget,
   PlatformRunProgress,
+  PlatformRunProgressRef,
   IntegrationContextMessage,
   IntegrationFileReference,
 } from "../types.js";
@@ -359,6 +360,16 @@ export function slackAdapter(
       return startSlackRunProgress(token, incoming);
     },
 
+    async resumeRunProgress(
+      incoming: IncomingMessage,
+      ref: PlatformRunProgressRef,
+    ): Promise<PlatformRunProgress | null> {
+      if (!isSlackStreamProgressRef(ref)) return null;
+      const token = await resolveBotToken(incoming);
+      if (!token) return null;
+      return resumeSlackRunProgress(token, incoming, ref.streamTs);
+    },
+
     async sendResponse(
       message: OutgoingMessage,
       context: IncomingMessage,
@@ -1273,6 +1284,21 @@ async function postSlackJson(
   return data;
 }
 
+function streamFailureCode(error: unknown): string {
+  const message = error instanceof Error ? error.message.trim() : "";
+  return /^[a-z0-9_:-]{1,80}$/i.test(message) ? message : "unknown";
+}
+
+function streamChunkType(chunk: Record<string, unknown>): string {
+  const type = chunk.type;
+  return type === "task_update" ||
+    type === "plan_update" ||
+    type === "markdown_text" ||
+    type === "blocks"
+    ? type
+    : "unknown";
+}
+
 async function startSlackRunProgress(
   token: string,
   incoming: IncomingMessage,
@@ -1304,12 +1330,45 @@ async function startSlackRunProgress(
         },
       ],
     });
-  } catch {
+  } catch (error) {
+    console.warn("[slack] chat.startStream failed; using standard reply", {
+      errorCode: streamFailureCode(error),
+      isDirectMessage: incoming.conversationType === "dm",
+      hasRecipientTeam: Boolean(incoming.tenantId),
+      hasRecipientUser: Boolean(incoming.senderId),
+    });
     return null;
   }
 
   const streamTs = started.ts;
   if (typeof streamTs !== "string") return null;
+  return createSlackRunProgress(token, incoming, channel, threadTs, streamTs);
+}
+
+function isSlackStreamProgressRef(ref: PlatformRunProgressRef): boolean {
+  return (
+    ref.kind === "slack-stream" && /^\d{1,20}\.\d{1,9}$/.test(ref.streamTs)
+  );
+}
+
+async function resumeSlackRunProgress(
+  token: string,
+  incoming: IncomingMessage,
+  streamTs: string,
+): Promise<PlatformRunProgress | null> {
+  const channel = incoming.platformContext.channelId;
+  const threadTs = incoming.platformContext.threadTs;
+  if (typeof channel !== "string" || typeof threadTs !== "string") return null;
+  return createSlackRunProgress(token, incoming, channel, threadTs, streamTs);
+}
+
+function createSlackRunProgress(
+  token: string,
+  incoming: IncomingMessage,
+  channel: string,
+  threadTs: string,
+  streamTs: string,
+): PlatformRunProgress {
   const tasks = new Map<string, { title: string; status: string }>();
   const toolTaskIds = new Map<string, string>();
   const agentTaskIds = new Map<string, string>();
@@ -1328,12 +1387,22 @@ async function startSlackRunProgress(
     const now = Date.now();
     const write = async (value: Record<string, unknown>) => {
       lastWriteAt = Date.now();
-      await postSlackJson(token, "chat.appendStream", {
-        channel,
-        ts: streamTs,
-        markdown_text: "Progress updated.",
-        chunks: [value],
-      }).catch(() => {});
+      try {
+        await postSlackJson(token, "chat.appendStream", {
+          channel,
+          ts: streamTs,
+          markdown_text: "Progress updated.",
+          chunks: [value],
+        });
+      } catch (error) {
+        console.warn(
+          "[slack] chat.appendStream failed; progress may be stale",
+          {
+            chunkType: streamChunkType(value),
+            errorCode: streamFailureCode(error),
+          },
+        );
+      }
     };
     if (now - lastWriteAt >= 900) {
       await write(chunk);
@@ -1357,6 +1426,7 @@ async function startSlackRunProgress(
     `${prefix}:${explicit || ++sequence}`.slice(0, 240);
 
   return {
+    ref: { kind: "slack-stream", streamTs },
     async onEvent(event) {
       if (!cancelControl) {
         const context = getIntegrationRequestContext();