@agent-native/core 0.98.6 → 0.98.8

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/file-upload/actions/upload-image.d.ts

@@ -17,12 +17,12 @@ declare const _default: import("../../action.js").ActionDefinition<{
     id?: undefined;
     provider?: undefined;
 } | {
+    error?: undefined;
     configured?: undefined;
     connectPath?: undefined;
     url: string;
     id: string;
     provider: string;
-    error?: undefined;
 }>;
 export default _default;
 //# sourceMappingURL=upload-image.d.ts.map

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;AA+BrB,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,CAmgBjB"}
+{"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

@@ -25,6 +25,29 @@ const SLACK_IDENTITY_CACHE_TTL_MS = 10 * 60 * 1_000;
 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.
  *
@@ -201,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,
@@ -388,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);
+                    throw new Error("Slack bot token not configured for system notice");
+                }
+                const channelId = incoming.platformContext.channelId;
+                if (typeof channelId !== "string" || !channelId) {
+                    if (dedupeKey)
+                        slackSystemNoticeCache.delete(dedupeKey);
+                    throw new Error("Slack channel id missing for system notice");
+                }
+                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",
@@ -920,7 +985,9 @@ async function resolveSlackUserIdentity(token, incoming) {
                         : typeof user.user.name === "string" && user.user.name.trim()
                             ? user.user.name.trim()
                             : null,
-            memberType: user.user.is_ultra_restricted
+            // 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"
@@ -947,8 +1014,22 @@ async function resolveSlackUserIdentity(token, incoming) {
 }
 async function hydrateSlackIdentity(token, incoming) {
     const identity = await resolveSlackUserIdentity(token, incoming);
-    if (!identity)
-        return incoming;
+    if (!identity) {
+        // Context hydration can call users.info again after the webhook identity
+        // pass. A transient failure on that second lookup is not evidence that a
+        // previously verified sender became unverified; preserve the stronger
+        // identity instead of replacing it with a negative-cache result.
+        if (incoming.senderVerified === true &&
+            incoming.senderEmail?.trim() &&
+            incoming.actorTrust?.verified === true) {
+            return incoming;
+        }
+        return {
+            ...incoming,
+            senderVerified: false,
+            actorTrust: { memberType: "unknown", verified: false },
+        };
+    }
     return {
         ...incoming,
         ...(identity.name ? { senderName: identity.name } : {}),
@@ -1057,8 +1138,6 @@ async function hydrateSlackContext(token, incoming) {
         })
         : [];
     const profile = identity;
-    const isGuest = identity?.memberType === "guest";
-    const isExternal = identity?.memberType === "external";
     const isPrivate = conversation?.channel?.is_private === true;
     const isExternalShared = conversation?.channel?.is_ext_shared === true;
     const isMpim = conversation?.channel?.is_mpim === true;
@@ -1099,11 +1178,15 @@ async function hydrateSlackContext(token, incoming) {
             ? { senderEmail: profile.email, senderVerified: true }
             : { senderVerified: false }),
         conversationType,
-        actorTrust: {
-            memberType: identity?.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: {