@agent-native/core 0.98.5 → 0.98.7

package/corpus/core/src/a2a/task-store.ts

@@ -200,11 +200,12 @@ export async function getA2ATaskDispatchState(id: string): Promise<{
   statusState: string;
   metadata: Record<string, unknown> | undefined;
   updatedAt: number;
+  createdAt: number;
 } | null> {
   await ensureTable();
   const client = getDbExec();
   const { rows } = await client.execute({
-    sql: `SELECT id, status_state, metadata, updated_at FROM a2a_tasks WHERE id = ?`,
+    sql: `SELECT id, status_state, metadata, created_at, updated_at FROM a2a_tasks WHERE id = ?`,
     args: [id],
   });
   const row = rows[0] as any;
@@ -214,6 +215,7 @@ export async function getA2ATaskDispatchState(id: string): Promise<{
     statusState: row.status_state as string,
     metadata: row.metadata ? JSON.parse(row.metadata as string) : undefined,
     updatedAt: Number(row.updated_at ?? 0),
+    createdAt: Number(row.created_at ?? 0),
   };
 }
 
@@ -269,10 +271,21 @@ export async function resetStuckA2ATaskForRetry(
   return affected !== 0;
 }
 
+/**
+ * Fail a processing task once it is stuck. Two independent conditions can
+ * trigger this, either of which alone is sufficient:
+ *   - `updated_at <= processingCutoff`: no heartbeat/progress touch in a
+ *     while — the processor likely died.
+ *   - `created_at <= createdAtCutoff` — a hard wall on total run time. A
+ *     hung await inside a still-alive process keeps `updated_at` fresh via
+ *     the liveness heartbeat forever, so staleness alone never trips; age
+ *     since creation is the only bound that catches it.
+ */
 export async function failStuckA2ATask(
   id: string,
   processingCutoff: number,
   reason: string,
+  createdAtCutoff?: number,
 ): Promise<boolean> {
   await ensureTable();
   const client = getDbExec();
@@ -282,6 +295,10 @@ export async function failStuckA2ATask(
     role: "agent",
     parts: [{ type: "text", text: reason }],
   };
+  const ageCondition =
+    createdAtCutoff !== undefined
+      ? `AND (updated_at <= ? OR created_at <= ?)`
+      : `AND updated_at <= ?`;
   const result = await client.execute({
     sql: `UPDATE a2a_tasks
             SET status_state = 'failed',
@@ -290,8 +307,53 @@ export async function failStuckA2ATask(
                 updated_at = ?
           WHERE id = ?
             AND status_state = 'processing'
-            AND updated_at <= ?`,
-    args: [JSON.stringify(message), timestamp, now, id, processingCutoff],
+            ${ageCondition}`,
+    args:
+      createdAtCutoff !== undefined
+        ? [
+            JSON.stringify(message),
+            timestamp,
+            now,
+            id,
+            processingCutoff,
+            createdAtCutoff,
+          ]
+        : [JSON.stringify(message), timestamp, now, id, processingCutoff],
+  });
+  const affected = getAffectedRowCount(result);
+  return affected !== 0;
+}
+
+/**
+ * Fail a queued (submitted/working) task whose age since creation exceeds
+ * `createdAtCutoff` — the dispatch-retry loop kept throttling/refiring
+ * without ever reaching `processing`. Mirrors `failStuckA2ATask` but is
+ * gated on the queued state set and on `created_at` (queued tasks have no
+ * heartbeat, so staleness of `updated_at` isn't a meaningful signal here).
+ */
+export async function failStuckQueuedA2ATask(
+  id: string,
+  createdAtCutoff: number,
+  reason: string,
+): Promise<boolean> {
+  await ensureTable();
+  const client = getDbExec();
+  const now = Date.now();
+  const timestamp = new Date().toISOString();
+  const message: Message = {
+    role: "agent",
+    parts: [{ type: "text", text: reason }],
+  };
+  const result = await client.execute({
+    sql: `UPDATE a2a_tasks
+            SET status_state = 'failed',
+                status_message = ?,
+                status_timestamp = ?,
+                updated_at = ?
+          WHERE id = ?
+            AND status_state IN ('submitted', 'working')
+            AND created_at <= ?`,
+    args: [JSON.stringify(message), timestamp, now, id, createdAtCutoff],
   });
   const affected = getAffectedRowCount(result);
   return affected !== 0;
@@ -361,6 +423,69 @@ export async function updateTask(
   return task;
 }
 
+/**
+ * Persist the terminal result produced by the async processor, but only while
+ * that processor still owns a task in `processing`. A tasks/get request may
+ * fail an over-lifetime processor while its handler is still running; the
+ * handler cannot be canceled reliably, so this compare-and-set is what keeps
+ * its eventual completion (or error) from overwriting the timeout result.
+ */
+export async function settleProcessingA2ATask(
+  id: string,
+  update: {
+    state: "completed" | "failed";
+    message?: Message;
+    artifacts?: Artifact[];
+  },
+): Promise<Task | null> {
+  await ensureTable();
+  const client = getDbExec();
+
+  const { rows } = await client.execute({
+    sql: `SELECT * FROM a2a_tasks WHERE id = ?`,
+    args: [id],
+  });
+  if (rows.length === 0) return null;
+
+  const task = taskFromRow(rows[0]);
+  const now = Date.now();
+  task.status = {
+    state: update.state,
+    message: update.message ?? task.status.message,
+    timestamp: new Date().toISOString(),
+  };
+  if (update.message && task.history) {
+    task.history.push(update.message);
+  }
+  if (update.artifacts) {
+    task.artifacts = [...(task.artifacts ?? []), ...update.artifacts];
+  }
+
+  const result = await client.execute({
+    sql: `UPDATE a2a_tasks
+            SET status_state = ?,
+                status_message = ?,
+                status_timestamp = ?,
+                history = ?,
+                artifacts = ?,
+                updated_at = ?
+          WHERE id = ?
+            AND status_state = 'processing'`,
+    args: [
+      task.status.state,
+      task.status.message ? JSON.stringify(task.status.message) : null,
+      task.status.timestamp,
+      JSON.stringify(task.history),
+      JSON.stringify(task.artifacts),
+      now,
+      id,
+    ],
+  });
+  const affected = getAffectedRowCount(result);
+  if (affected === 0) return null;
+  return task;
+}
+
 export async function updateTaskStatusMessage(
   id: string,
   message: Message,

package/corpus/core/src/client/session-replay.ts

@@ -65,6 +65,8 @@ interface RrwebRecordModule {
 interface SessionReplayState {
   active: boolean;
   startPromise: Promise<SessionReplayStartResult> | null;
+  /** Invalidates deferred recorder startup when stop is requested mid-start. */
+  startGeneration: number;
   replayId: string | null;
   startedAtMs: number | null;
   sequence: number;
@@ -432,6 +434,7 @@ function getState(): SessionReplayState {
     g[SESSION_REPLAY_STATE_KEY] = {
       active: false,
       startPromise: null,
+      startGeneration: 0,
       replayId: null,
       startedAtMs: null,
       sequence: 0,
@@ -464,6 +467,7 @@ function getState(): SessionReplayState {
   state.pendingFlushReason ??= null;
   state.pendingFlushWaiters ??= [];
   state.awaitingFullSnapshot ??= false;
+  state.startGeneration ??= 0;
   return state;
 }
 
@@ -1054,12 +1058,14 @@ const REPLAY_RESOURCE_TAGS = new Set([
   "audio",
   "track",
   "input",
+  "object",
   "link",
 ]);
 const NO_REPLAY_RESOURCE_ATTRIBUTES = new Set<string>();
 const REPLAY_SRC_ATTRIBUTES = new Set(["src"]);
 const REPLAY_SRCSET_ATTRIBUTES = new Set(["src", "srcset"]);
 const REPLAY_VIDEO_ATTRIBUTES = new Set(["src", "poster"]);
+const REPLAY_OBJECT_ATTRIBUTES = new Set(["data"]);
 const REPLAY_HREF_ATTRIBUTES = new Set(["href"]);
 
 function replayAttributeString(
@@ -1101,6 +1107,8 @@ function replayPreservedResourceAttributes(
     case "audio":
     case "track":
       return REPLAY_SRC_ATTRIBUTES;
+    case "object":
+      return REPLAY_OBJECT_ATTRIBUTES;
     case "input":
       return node.type === "image"
         ? REPLAY_SRC_ATTRIBUTES
@@ -1452,12 +1460,12 @@ class ReplayUploadHttpError extends Error {
   }
 }
 
-/** 4xx statuses where retrying the exact same batch can never succeed --
- * e.g. a 409 chunk-sequence/checksum conflict, or a 400 the server will
- * reject again. 408 (timeout) and 429 (rate limit) are excluded because a
- * later retry can plausibly succeed. */
+/** 4xx statuses where retrying the exact same batch can never succeed.
+ * Keep this deliberately narrow: 401/403/404 can be temporary during auth or
+ * deploy transitions, and stopping forever on one of those would silently
+ * black out the rest of a long-lived SPA session. */
 function isDefinitiveReplayUploadClientError(status: number): boolean {
-  return status >= 400 && status < 500 && status !== 408 && status !== 429;
+  return status === 400 || status === 409 || status === 413 || status === 422;
 }
 
 async function sendReplayUpload(
@@ -1903,6 +1911,31 @@ async function restartSessionReplayAfterConflict(
   state: SessionReplayState,
   options: NormalizedSessionReplayOptions,
   sessionId: string,
+): Promise<SessionReplayStartResult> {
+  // Share the public-start mutex. A consumer may call start in the await gap
+  // after the rejected recorder stops; both paths must converge on one rrweb
+  // instance rather than racing two fresh identities.
+  if (state.startPromise) return state.startPromise;
+
+  const startGeneration = ++state.startGeneration;
+  let startPromise: Promise<SessionReplayStartResult>;
+  startPromise = restartSessionReplayAfterConflictInternal(
+    state,
+    options,
+    sessionId,
+    startGeneration,
+  ).finally(() => {
+    if (state.startPromise === startPromise) state.startPromise = null;
+  });
+  state.startPromise = startPromise;
+  return startPromise;
+}
+
+async function restartSessionReplayAfterConflictInternal(
+  state: SessionReplayState,
+  options: NormalizedSessionReplayOptions,
+  sessionId: string,
+  startGeneration: number,
 ): Promise<SessionReplayStartResult> {
   if (options.shouldStart && !options.shouldStart()) {
     return { started: false, reason: "disabled", sessionId, sampled: true };
@@ -1932,6 +1965,7 @@ async function restartSessionReplayAfterConflict(
     sessionId,
     true,
     initialProperties,
+    startGeneration,
   );
 }
 
@@ -2879,6 +2913,11 @@ export async function startSessionReplay(
   }
   if (state.startPromise) return state.startPromise;
 
+  // This is a new caller-initiated recording episode. A prior episode's
+  // conflict-loop guard must not prevent this one from recovering once.
+  state.automaticConflictRestartAttempted = false;
+  const startGeneration = ++state.startGeneration;
+
   let startPromise: Promise<SessionReplayStartResult>;
   startPromise = startSessionReplayRecorder(
     state,
@@ -2886,6 +2925,7 @@ export async function startSessionReplay(
     sessionId,
     sampled,
     initialProperties,
+    startGeneration,
   ).finally(() => {
     if (state.startPromise === startPromise) {
       state.startPromise = null;
@@ -2901,6 +2941,7 @@ async function startSessionReplayRecorder(
   sessionId: string,
   sampled: boolean,
   initialProperties: Record<string, unknown> | undefined,
+  startGeneration: number,
 ): Promise<SessionReplayStartResult> {
   if (state.active && state.replayId) {
     return {
@@ -2918,6 +2959,9 @@ async function startSessionReplayRecorder(
   } catch {
     return { started: false, reason: "import-failed", sessionId, sampled };
   }
+  if (state.startGeneration !== startGeneration) {
+    return { started: false, reason: "disabled", sessionId, sampled };
+  }
   if (normalized.shouldStart && !normalized.shouldStart()) {
     return { started: false, reason: "disabled", sessionId, sampled };
   }
@@ -2950,6 +2994,20 @@ async function startSessionReplayRecorder(
       };
     }
   }
+  // stopSessionReplay may be called while the duplicate-tab probe is waiting.
+  // Recheck both cancellation and the caller's live eligibility before rrweb
+  // is activated so a deferred start cannot escape a route/auth teardown.
+  if (
+    state.startGeneration !== startGeneration ||
+    (normalized.shouldStart && !normalized.shouldStart())
+  ) {
+    try {
+      replayChannel?.close();
+    } catch {
+      // best-effort cleanup
+    }
+    return { started: false, reason: "disabled", sessionId, sampled };
+  }
   state.options = normalized;
   state.replayId = replaySession.replayId;
   state.startedAtMs = replaySession.startedAtMs;
@@ -3049,6 +3107,10 @@ async function startSessionReplayRecorder(
 
 export async function stopSessionReplay(reason = "manual"): Promise<void> {
   const state = getState();
+  // Invalidate an import/probe that has not set `active` yet. Without this,
+  // stop during the duplicated-tab claim window was a no-op and rrweb started
+  // after the caller believed recording had been disabled.
+  state.startGeneration += 1;
   if (!state.active) return;
   // Restore console/fetch/XHR before tearing down the recorder: the restore
   // flushes any pending collapsed console duplicate, which must still be able

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

@@ -38,6 +38,48 @@ const SLACK_PERMALINK_TIMEOUT_MS = 1_000;
 const SLACK_CONTEXT_MESSAGE_LIMIT = 15;
 const SLACK_CONTEXT_TEXT_LIMIT = 2_000;
 const SLACK_CALM_PROGRESS_THRESHOLD_SECONDS = 30;
+const SLACK_IDENTITY_TIMEOUT_MS = 1_000;
+const SLACK_IDENTITY_CACHE_TTL_MS = 10 * 60 * 1_000;
+// Failed users.info lookups only get a short negative TTL: a transient Slack
+// API blip must not fail-close a sender's identity (and DMs) for 10 minutes.
+const SLACK_IDENTITY_NEGATIVE_CACHE_TTL_MS = 30 * 1_000;
+const SLACK_IDENTITY_CACHE_MAX_ENTRIES = 1_000;
+
+interface SlackUserIdentity {
+  email: string | null;
+  name: string | null;
+  memberType: "owner" | "admin" | "member" | "guest" | "external" | "unknown";
+}
+
+const slackIdentityCache = new Map<
+  string,
+  { identity: SlackUserIdentity | null; expiresAt: number }
+>();
+
+// Deduped system notices send at most once per key per TTL so senders are
+// informed without being spammed per message. Callers pick the window: the
+// anonymous-tier heads-up uses the default day-long TTL; decline replies pass
+// a short TTL so a persistent condition still reminds the sender occasionally.
+const SLACK_SYSTEM_NOTICE_DEDUPE_TTL_MS = 24 * 60 * 60 * 1_000;
+const SLACK_SYSTEM_NOTICE_CACHE_MAX_ENTRIES = 1_000;
+const slackSystemNoticeCache = new Map<string, number>();
+
+/** Returns true when a deduped notice should send now, claiming the slot. */
+function claimSlackSystemNoticeSlot(
+  key: string,
+  ttlMs = SLACK_SYSTEM_NOTICE_DEDUPE_TTL_MS,
+): boolean {
+  const now = Date.now();
+  const expiresAt = slackSystemNoticeCache.get(key);
+  if (expiresAt && expiresAt > now) return false;
+  if (expiresAt) slackSystemNoticeCache.delete(key);
+  if (slackSystemNoticeCache.size >= SLACK_SYSTEM_NOTICE_CACHE_MAX_ENTRIES) {
+    const oldestKey = slackSystemNoticeCache.keys().next().value;
+    if (oldestKey) slackSystemNoticeCache.delete(oldestKey);
+  }
+  slackSystemNoticeCache.set(key, now + ttlMs);
+  return true;
+}
 
 export interface SlackAdapterOptions {
   /** Resolve the bot token for the exact Slack installation. */
@@ -247,7 +289,10 @@ export function slackAdapter(
           triggerKind: isDm ? "dm" : isMention ? "mention" : "thread_reply",
           conversationType: isDm ? "dm" : "unknown",
           tenantId: teamId,
-          actorTrust: { memberType: "unknown", verified: true },
+          // The signed Slack envelope authenticates the workspace, not the
+          // sender's membership tier. `users.info` hydration below is the
+          // authority that may promote this to a verified member.
+          actorTrust: { memberType: "unknown", verified: false },
           platformContext: {
             channelId: e.channel,
             channelType: e.channel_type,
@@ -356,6 +401,14 @@ export function slackAdapter(
       return hydrateSlackContext(token, incoming);
     },
 
+    async hydrateIncomingIdentity(
+      incoming: IncomingMessage,
+    ): Promise<IncomingMessage> {
+      const token = await resolveBotToken(incoming);
+      if (!token) return incoming;
+      return hydrateSlackIdentity(token, incoming);
+    },
+
     async startRunProgress(
       incoming: IncomingMessage,
     ): Promise<PlatformRunProgress | null> {
@@ -468,6 +521,48 @@ export function slackAdapter(
       }
     },
 
+    async sendSystemNotice(
+      incoming: IncomingMessage,
+      text: string,
+      opts?: { dedupeKey?: string; dedupeTtlMs?: number },
+    ): Promise<void> {
+      if (!text.trim()) return;
+      const dedupeKey = opts?.dedupeKey;
+      if (
+        dedupeKey &&
+        !claimSlackSystemNoticeSlot(dedupeKey, opts?.dedupeTtlMs)
+      ) {
+        return;
+      }
+      try {
+        const token = await resolveBotToken(incoming);
+        if (!token) {
+          if (dedupeKey) slackSystemNoticeCache.delete(dedupeKey);
+          return;
+        }
+        const channelId = incoming.platformContext.channelId;
+        if (typeof channelId !== "string" || !channelId) {
+          if (dedupeKey) slackSystemNoticeCache.delete(dedupeKey);
+          return;
+        }
+        const threadTs =
+          typeof incoming.platformContext.threadTs === "string"
+            ? incoming.platformContext.threadTs
+            : undefined;
+        await postFresh(token, channelId, threadTs, {
+          text,
+          unfurl_links: false,
+          unfurl_media: false,
+          mrkdwn: true,
+        });
+      } catch (error) {
+        // A failed delivery did not inform the sender, so release the slot and
+        // allow the next message to retry instead of suppressing notices for a day.
+        if (dedupeKey) slackSystemNoticeCache.delete(dedupeKey);
+        throw error;
+      }
+    },
+
     async sendMessageToTarget(
       message: OutgoingMessage,
       target: OutboundTarget,
@@ -1070,6 +1165,102 @@ async function slackJson(
   }
 }
 
+function slackIdentityCacheKey(incoming: IncomingMessage): string | null {
+  const teamId = incoming.platformContext.teamId;
+  const senderId = incoming.senderId;
+  if (typeof senderId !== "string" || !senderId.trim()) return null;
+  return `${typeof teamId === "string" && teamId ? teamId : "unknown"}:${senderId}`;
+}
+
+async function resolveSlackUserIdentity(
+  token: string,
+  incoming: IncomingMessage,
+): Promise<SlackUserIdentity | null> {
+  const cacheKey = slackIdentityCacheKey(incoming);
+  if (!cacheKey) return null;
+  const cached = slackIdentityCache.get(cacheKey);
+  if (cached && cached.expiresAt > Date.now()) return cached.identity;
+  if (cached) slackIdentityCache.delete(cacheKey);
+
+  const user = await slackJson(
+    token,
+    "users.info",
+    { user: incoming.senderId! },
+    SLACK_IDENTITY_TIMEOUT_MS,
+  );
+  const profile = user?.user?.profile;
+  const identity: SlackUserIdentity | null = user?.user
+    ? {
+        email:
+          typeof profile?.email === "string" && profile.email.trim()
+            ? profile.email.trim().toLowerCase()
+            : null,
+        name:
+          typeof profile?.real_name === "string" && profile.real_name.trim()
+            ? profile.real_name.trim()
+            : typeof profile?.display_name === "string" &&
+                profile.display_name.trim()
+              ? profile.display_name.trim()
+              : typeof user.user.real_name === "string" &&
+                  user.user.real_name.trim()
+                ? user.user.real_name.trim()
+                : typeof user.user.name === "string" && user.user.name.trim()
+                  ? user.user.name.trim()
+                  : null,
+        // is_stranger marks Slack Connect DM participants from another
+        // workspace; they must map to "external", never "member".
+        memberType:
+          user.user.is_stranger || user.user.is_ultra_restricted
+            ? "external"
+            : user.user.is_restricted
+              ? "guest"
+              : user.user.is_owner
+                ? "owner"
+                : user.user.is_admin
+                  ? "admin"
+                  : "member",
+      }
+    : null;
+  if (slackIdentityCache.size >= SLACK_IDENTITY_CACHE_MAX_ENTRIES) {
+    const oldestKey = slackIdentityCache.keys().next().value;
+    if (oldestKey) slackIdentityCache.delete(oldestKey);
+  }
+  slackIdentityCache.set(cacheKey, {
+    identity,
+    expiresAt:
+      Date.now() +
+      (identity
+        ? SLACK_IDENTITY_CACHE_TTL_MS
+        : SLACK_IDENTITY_NEGATIVE_CACHE_TTL_MS),
+  });
+  return identity;
+}
+
+async function hydrateSlackIdentity(
+  token: string,
+  incoming: IncomingMessage,
+): Promise<IncomingMessage> {
+  const identity = await resolveSlackUserIdentity(token, incoming);
+  if (!identity) {
+    return {
+      ...incoming,
+      senderVerified: false,
+      actorTrust: { memberType: "unknown", verified: false },
+    };
+  }
+  return {
+    ...incoming,
+    ...(identity.name ? { senderName: identity.name } : {}),
+    ...(identity.email
+      ? { senderEmail: identity.email, senderVerified: true }
+      : { senderVerified: false }),
+    actorTrust: {
+      memberType: identity.memberType,
+      verified: true,
+    },
+  };
+}
+
 async function hydrateSlackContext(
   token: string,
   incoming: IncomingMessage,
@@ -1081,7 +1272,7 @@ async function hydrateSlackContext(
     return incoming;
   }
 
-  const [thread, history, pins, conversation, user] = await Promise.all([
+  const [thread, history, pins, conversation, identity] = await Promise.all([
     slackJson(token, "conversations.replies", {
       channel: channelId,
       ts: threadTs,
@@ -1095,7 +1286,7 @@ async function hydrateSlackContext(
     }),
     slackJson(token, "pins.list", { channel: channelId }),
     slackJson(token, "conversations.info", { channel: channelId }),
-    senderId ? slackJson(token, "users.info", { user: senderId }) : null,
+    senderId ? resolveSlackUserIdentity(token, incoming) : null,
   ]);
 
   // Agent View can attach the Slack surface the user is currently viewing to
@@ -1186,9 +1377,7 @@ async function hydrateSlackContext(
       })
     : [];
 
-  const profile = user?.user?.profile;
-  const isGuest = user?.user?.is_restricted === true;
-  const isExternal = user?.user?.is_ultra_restricted === true;
+  const profile = identity;
   const isPrivate = conversation?.channel?.is_private === true;
   const isExternalShared = conversation?.channel?.is_ext_shared === true;
   const isMpim = conversation?.channel?.is_mpim === true;
@@ -1231,19 +1420,20 @@ async function hydrateSlackContext(
   );
   return {
     ...incoming,
-    ...(typeof profile?.display_name === "string" && profile.display_name
-      ? { senderName: profile.display_name }
-      : typeof profile?.real_name === "string" && profile.real_name
-        ? { senderName: profile.real_name }
-        : {}),
-    ...(typeof profile?.email === "string"
+    ...(profile?.name ? { senderName: profile.name } : {}),
+    ...(profile?.email
       ? { senderEmail: profile.email, senderVerified: true }
-      : {}),
+      : { senderVerified: false }),
     conversationType,
-    actorTrust: {
-      memberType: isExternal ? "external" : isGuest ? "guest" : "member",
-      verified: true,
-    },
+    // Conversation hydration must not promote a caller when users.info was
+    // unavailable. Preserve the result of the earlier identity-only hydration
+    // unless this request independently resolved the Slack user.
+    actorTrust: identity
+      ? { memberType: identity.memberType, verified: true }
+      : (incoming.actorTrust ?? {
+          memberType: "unknown",
+          verified: false,
+        }),
     contextMessages: hydratedMessages,
     ...(hydratedFiles.length ? { files: hydratedFiles.slice(0, 20) } : {}),
     platformContext: {