@agent-native/core 0.98.5 → 0.98.7

package/dist/collab/routes.d.ts

@@ -41,9 +41,9 @@ export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import
  * Body: { text: string, fieldName?: string, requestSource?: string }
  */
 export declare const postCollabText: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
+    text?: undefined;
     ok?: undefined;
     error: string;
-    text?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/integrations/adapters/slack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slack.d.ts","sourceRoot":"","sources":["../../../src/integrations/adapters/slack.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EAQhB,MAAM,aAAa,CAAC;AAcrB,MAAM,WAAW,mBAAmB;IAClC,8DAA8D;IAC9D,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC7E,kEAAkE;IAClE,cAAc,CAAC,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACjE,oEAAoE;IACpE,oBAAoB,CAAC,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACxE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAC1B,OAAO,GAAE,mBAAwB,GAChC,eAAe,CA2fjB"}
+{"version":3,"file":"slack.d.ts","sourceRoot":"","sources":["../../../src/integrations/adapters/slack.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EAQhB,MAAM,aAAa,CAAC;AAwDrB,MAAM,WAAW,mBAAmB;IAClC,8DAA8D;IAC9D,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC7E,kEAAkE;IAClE,cAAc,CAAC,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACjE,oEAAoE;IACpE,oBAAoB,CAAC,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACxE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAC1B,OAAO,GAAE,mBAAwB,GAChC,eAAe,CAgjBjB"}

package/dist/integrations/adapters/slack.js

@@ -18,6 +18,36 @@ 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;
+const slackIdentityCache = new Map();
+// 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();
+/** Returns true when a deduped notice should send now, claiming the slot. */
+function claimSlackSystemNoticeSlot(key, ttlMs = SLACK_SYSTEM_NOTICE_DEDUPE_TTL_MS) {
+    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;
+}
 /**
  * Create a Slack platform adapter.
  *
@@ -194,7 +224,10 @@ export function slackAdapter(options = {}) {
                     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,
@@ -283,6 +316,12 @@ export function slackAdapter(options = {}) {
                 return incoming;
             return hydrateSlackContext(token, incoming);
         },
+        async hydrateIncomingIdentity(incoming) {
+            const token = await resolveBotToken(incoming);
+            if (!token)
+                return incoming;
+            return hydrateSlackIdentity(token, incoming);
+        },
         async startRunProgress(incoming) {
             const token = await resolveBotToken(incoming);
             if (!token)
@@ -375,6 +414,45 @@ export function slackAdapter(options = {}) {
                 throw err;
             }
         },
+        async sendSystemNotice(incoming, text, opts) {
+            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, target) {
             const targetContext = {
                 platform: "slack",
@@ -873,6 +951,88 @@ async function slackJson(token, method, params, timeoutMs = 2_000) {
         return null;
     }
 }
+function slackIdentityCacheKey(incoming) {
+    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, incoming) {
+    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 = 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, incoming) {
+    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, incoming) {
     const channelId = incoming.platformContext.channelId;
     const threadTs = incoming.platformContext.threadTs;
@@ -880,7 +1040,7 @@ async function hydrateSlackContext(token, incoming) {
     if (typeof channelId !== "string" || typeof threadTs !== "string") {
         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,
@@ -894,7 +1054,7 @@ async function hydrateSlackContext(token, incoming) {
         }),
         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
     // a DM. Treat it only as a context hint: Slack requires us to prove the bot
@@ -968,9 +1128,7 @@ async function hydrateSlackContext(token, incoming) {
             };
         })
         : [];
-    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;
@@ -1006,19 +1164,20 @@ async function hydrateSlackContext(token, incoming) {
     const hydratedFiles = hydratedMessages.flatMap((message) => message.files ?? []);
     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: {