@opentag/dispatcher 0.3.3 → 0.3.4

package/dist/index.js

@@ -16,7 +16,7 @@ import {
 } from "@opentag/slack";
 import { createTelegramSendMessageDraftPayload, createTelegramSendMessagePayload, parseTelegramThreadKey } from "@opentag/telegram";
 var DEFAULT_SLACK_SOURCE_RECEIPT_TIMEOUT_MS = 5e3;
-var DEFAULT_LARK_RECEIVED_REACTION = "OK";
+var DEFAULT_LARK_RECEIVED_REACTION = "Typing";
 function slackUpdateUriFrom(postMessageUri) {
   return postMessageUri.replace(/\/chat\.postMessage$/, "/chat.update");
 }
@@ -920,6 +920,16 @@ function shouldDeliverRunStatusUpdate(presentation, input) {
 function larkLifecycleStatusMessageKey(input) {
   return input.provider === "lark" ? `${input.runId}:status` : void 0;
 }
+function isTerminalRun(run) {
+  return ["succeeded", "failed", "cancelled", "interrupted", "timed_out"].includes(run.status);
+}
+function shouldUseDelayedLarkStatusCard(provider, options) {
+  return provider === "lark" && options.enabled !== false;
+}
+function safeExecutorLabel(executor) {
+  if (!executor || !/^[a-z0-9._-]{1,40}$/i.test(executor)) return "the selected agent";
+  return executor;
+}
 var CreateRunnerSchema = z.object({
   runnerId: z.string().min(1),
   name: z.string().min(1)
@@ -1992,7 +2002,7 @@ async function deliverAndAudit(input) {
     ...input.message.blocks ? { blocks: input.message.blocks } : {},
     ...input.message.rich ? { rich: input.message.rich } : {}
   });
-  await deliverCallbackDelivery({
+  return deliverCallbackDelivery({
     repo: input.repo,
     sink: input.sink,
     delivery,
@@ -2116,6 +2126,13 @@ function createDispatcherApp(input) {
   const sourceReceiptSink = input.sourceReceiptSink ?? noopSourceReceiptSink;
   const presentation = input.presentation ?? createDefaultCallbackPresentation();
   const callbackRetry = input.callbackRetry ?? {};
+  const larkStatusCardOptions = input.larkStatusCards ?? {};
+  const larkStatusCardDelayMs = larkStatusCardOptions.delayMs ?? 1e4;
+  const larkStatusCardMinUpdateIntervalMs = larkStatusCardOptions.minUpdateIntervalMs ?? 5e3;
+  const larkStatusCardNow = larkStatusCardOptions.now ?? (() => Date.now());
+  const setLarkStatusCardTimeout = larkStatusCardOptions.setTimeout ?? ((callback, delayMs) => globalThis.setTimeout(callback, delayMs));
+  const clearLarkStatusCardTimeout = larkStatusCardOptions.clearTimeout ?? ((handle) => globalThis.clearTimeout(handle));
+  const delayedLarkStatusCards = /* @__PURE__ */ new Map();
   const maxRequestBodyBytes = input.maxRequestBodyBytes ?? DEFAULT_MAX_REQUEST_BODY_BYTES;
   const runnerTokens = configuredRunnerTokens(input);
   const revokedRunnerTokenFingerprints = normalizeRevokedRunnerTokenFingerprints(input.revokedRunnerTokenFingerprints);
@@ -2178,6 +2195,145 @@ function createDispatcherApp(input) {
       message: "Run status callback suppressed by platform liveness strategy; use status or audit for details."
     });
   };
+  function delayedLarkStatusMessage(input2) {
+    if (input2.phase === "queued") return "Waiting for the local runner.";
+    if (input2.phase === "progress") return "OpenTag is still working.";
+    return `Running with ${safeExecutorLabel(input2.run.executor)}.`;
+  }
+  function delayedLarkStatusState(input2) {
+    if (input2.phase === "queued") return "queued";
+    return "running";
+  }
+  async function appendDelayedLarkStatusFailure(input2) {
+    await repo.appendRunEvent({
+      runId: input2.runId,
+      type: "callback.progress.failed",
+      payload: {
+        provider: "lark",
+        reason: "delayed_status_card",
+        error: input2.error instanceof Error ? input2.error.message : String(input2.error)
+      },
+      visibility: "audit",
+      importance: "low",
+      message: "Delayed Lark status card update failed."
+    });
+  }
+  async function deliverDelayedLarkStatusCard(input2) {
+    if (!shouldUseDelayedLarkStatusCard(input2.event.callback.provider, larkStatusCardOptions)) return false;
+    if (!input2.event.callback.threadKey) return false;
+    if (isTerminalRun(input2.run)) return false;
+    const statusMessageKey = larkLifecycleStatusMessageKey({ provider: input2.event.callback.provider, runId: input2.run.id });
+    if (!statusMessageKey) return false;
+    const state = delayedLarkStatusCards.get(input2.run.id) ?? { cardCreated: false };
+    delayedLarkStatusCards.set(input2.run.id, state);
+    if (!input2.createIfMissing && !state.cardCreated) return false;
+    const now = larkStatusCardNow();
+    const phaseChanged = state.lastPhase !== input2.phase;
+    const intervalElapsed = !state.lastUpdateAt || now - state.lastUpdateAt >= larkStatusCardMinUpdateIntervalMs;
+    if (!input2.createIfMissing && !phaseChanged && !intervalElapsed) return false;
+    const statusPresentation = presentation.runStatusPresentation({
+      runId: input2.run.id,
+      state: delayedLarkStatusState({ run: input2.run, phase: input2.phase }),
+      message: delayedLarkStatusMessage({ run: input2.run, phase: input2.phase }),
+      nextAction: "Use /status here for active-run and queue state, or wait for the final result.",
+      detailVisibility: "source_thread"
+    });
+    const rendered = presentation.render({
+      provider: input2.event.callback.provider,
+      presentation: statusPresentation
+    });
+    const delivered = await deliverAndAudit({
+      repo,
+      sink: callbackSink,
+      retry: callbackRetry,
+      message: {
+        runId: input2.run.id,
+        kind: "progress",
+        provider: input2.event.callback.provider,
+        uri: input2.event.callback.uri,
+        body: rendered.body,
+        ...input2.event.target.agentId ? { agentId: input2.event.target.agentId } : {},
+        threadKey: input2.event.callback.threadKey,
+        ...rendered.blocks?.length ? { blocks: rendered.blocks } : {},
+        ...rendered.rich ? { rich: rendered.rich } : {},
+        statusMessageKey
+      }
+    });
+    if (!delivered) return false;
+    state.cardCreated = true;
+    state.lastPhase = input2.phase;
+    state.lastUpdateAt = now;
+    return true;
+  }
+  function scheduleDelayedLarkStatusCard(input2) {
+    if (!shouldUseDelayedLarkStatusCard(input2.event.callback.provider, larkStatusCardOptions)) return;
+    if (!input2.event.callback.threadKey) return;
+    if (larkStatusCardDelayMs < 0) return;
+    const existing = delayedLarkStatusCards.get(input2.run.id);
+    if (existing?.timer || existing?.cardCreated) return;
+    const state = existing ?? { cardCreated: false };
+    const timer = setLarkStatusCardTimeout(() => {
+      delete state.timer;
+      void (async () => {
+        try {
+          const latestRun = await repo.getRun({ runId: input2.run.id });
+          if (!latestRun || isTerminalRun(latestRun.run)) {
+            delayedLarkStatusCards.delete(input2.run.id);
+            return;
+          }
+          const phase = latestRun.run.status === "queued" ? "queued" : "running";
+          await deliverDelayedLarkStatusCard({
+            run: latestRun.run,
+            event: input2.event,
+            phase,
+            createIfMissing: true
+          });
+        } catch (error) {
+          await appendDelayedLarkStatusFailure({ runId: input2.run.id, error });
+        }
+      })();
+    }, larkStatusCardDelayMs);
+    if (timer && typeof timer === "object" && "unref" in timer && typeof timer.unref === "function") {
+      timer.unref();
+    }
+    state.timer = timer;
+    delayedLarkStatusCards.set(input2.run.id, state);
+  }
+  function cancelPendingDelayedLarkStatusCard(runId) {
+    const state = delayedLarkStatusCards.get(runId);
+    if (!state?.timer) return;
+    clearLarkStatusCardTimeout(state.timer);
+    delete state.timer;
+  }
+  function clearDelayedLarkStatusCard(runId) {
+    cancelPendingDelayedLarkStatusCard(runId);
+    delayedLarkStatusCards.delete(runId);
+  }
+  async function patchDelayedLarkStatusCard(input2) {
+    let state = delayedLarkStatusCards.get(input2.run.id);
+    if (!state?.cardCreated) {
+      const statusMessageKey = larkLifecycleStatusMessageKey({ provider: input2.event.callback.provider, runId: input2.run.id });
+      const externalMessageId = statusMessageKey && input2.event.callback.threadKey ? await repo.findCallbackExternalMessageId({
+        runId: input2.run.id,
+        provider: input2.event.callback.provider,
+        threadKey: input2.event.callback.threadKey,
+        statusMessageKey
+      }) : void 0;
+      if (!externalMessageId) return;
+      state = state ?? { cardCreated: true };
+      state.cardCreated = true;
+      delayedLarkStatusCards.set(input2.run.id, state);
+    }
+    try {
+      await deliverDelayedLarkStatusCard({
+        run: input2.run,
+        event: input2.event,
+        phase: input2.phase
+      });
+    } catch (error) {
+      await appendDelayedLarkStatusFailure({ runId: input2.run.id, error });
+    }
+  }
   async function deliverPromotedFollowUpAcknowledgement(input2) {
     if (!presentation.shouldDeliverAcknowledgement(input2.event.callback.provider)) return;
     const acknowledgementPresentation = presentation.acknowledgementPresentation({ runId: input2.run.id });
@@ -2691,6 +2847,9 @@ function createDispatcherApp(input) {
         ...parsed.event.target.agentId ? { agentId: parsed.event.target.agentId } : {}
       }
     });
+    if (sourceReceiptDelivery.delivered) {
+      scheduleDelayedLarkStatusCard({ run, event: parsed.event });
+    }
     const shouldDeliverAcknowledgement = presentation.shouldDeliverAcknowledgement(parsed.event.callback.provider) || shouldDeliverSourceReceipt(parsed.event.callback.provider) && !sourceReceiptDelivery.delivered;
     if (shouldDeliverAcknowledgement) {
       const acknowledgementPresentation = presentation.acknowledgementPresentation({ runId: run.id });
@@ -3169,6 +3328,11 @@ function createDispatcherApp(input) {
     } else if (presentation.shouldDeliverStatusUpdate(provider)) {
       await appendSuppressedRunStatusCallback({ runId, provider, state: "running" });
     }
+    await patchDelayedLarkStatusCard({
+      run: stored.run,
+      event: stored.event,
+      phase: "running"
+    });
     return c.json({ ok: true });
   });
   app.post("/v1/runs/:runId/progress", async () => {
@@ -3237,6 +3401,11 @@ function createDispatcherApp(input) {
         message: "Progress callback suppressed by platform liveness strategy; use status or audit for details."
       });
     }
+    await patchDelayedLarkStatusCard({
+      run: stored.run,
+      event: stored.event,
+      phase: "progress"
+    });
     return c.json({ ok: true });
   });
   app.post("/v1/runs/:runId/complete", async () => {
@@ -3260,6 +3429,7 @@ function createDispatcherApp(input) {
     if (outcome === "duplicate") return c.json({ ok: true, replayed: true });
     const stored = await repo.getRun({ runId });
     if (!stored) return c.json({ error: "run_not_found" }, 404);
+    cancelPendingDelayedLarkStatusCard(runId);
     const receiptContext = await actionReceiptContextForFinal({
       event: stored.event,
       result: parsed.result,
@@ -3322,6 +3492,7 @@ function createDispatcherApp(input) {
         ...finalCallback.rich ? { rich: finalCallback.rich } : {}
       }
     });
+    clearDelayedLarkStatusCard(runId);
     const shouldPromoteFollowUp = parsed.result.conclusion !== "needs_human" && parsed.result.conclusion !== "cancelled";
     const promotedFollowUp = shouldPromoteFollowUp ? await promoteNextFollowUpAfterTerminalRun({ activeRunId: runId }) : null;
     return c.json({