@agent-native/core 0.98.5 → 0.98.6

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;

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

@@ -38,6 +38,23 @@ 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 }
+>();
 
 export interface SlackAdapterOptions {
   /** Resolve the bot token for the exact Slack installation. */
@@ -356,6 +373,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> {
@@ -1070,6 +1095,93 @@ 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,
+        memberType: 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;
+  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 +1193,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 +1207,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 +1298,9 @@ 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 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;
@@ -1231,17 +1343,15 @@ 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",
+      memberType:
+        identity?.memberType ??
+        (isExternal ? "external" : isGuest ? "guest" : "member"),
       verified: true,
     },
     contextMessages: hydratedMessages,

package/corpus/core/src/integrations/identity-links-store.ts

@@ -0,0 +1,210 @@
+/**
+ * Durable links between a verified provider identity and an Agent Native user.
+ * Provider credentials and raw provider payloads never belong in this table.
+ */
+
+import { randomUUID } from "node:crypto";
+
+import {
+  getDbExec,
+  intType,
+  isPostgres,
+  isUniqueViolation,
+  retryOnDdlRace,
+} from "../db/client.js";
+import { ensureIndexExists, ensureTableExists } from "../db/ddl-guard.js";
+
+const TABLE = "integration_identity_links";
+let _initPromise: Promise<void> | undefined;
+
+export interface IntegrationIdentityLink {
+  id: string;
+  platform: string;
+  tenantId: string;
+  externalUserId: string;
+  userEmail: string;
+  orgId: string;
+  createdAt: number;
+  updatedAt: number;
+}
+
+function createSql(): string {
+  const integer = intType();
+  return `CREATE TABLE IF NOT EXISTS ${TABLE} (
+    id TEXT PRIMARY KEY,
+    platform TEXT NOT NULL,
+    tenant_id TEXT NOT NULL,
+    external_user_id TEXT NOT NULL,
+    user_email TEXT NOT NULL,
+    org_id TEXT NOT NULL,
+    created_at ${integer} NOT NULL,
+    updated_at ${integer} NOT NULL
+  )`;
+}
+
+const INDEXES = [
+  [
+    "idx_integration_identity_links_external",
+    `CREATE UNIQUE INDEX IF NOT EXISTS idx_integration_identity_links_external
+      ON ${TABLE}(platform, tenant_id, external_user_id)`,
+  ],
+  [
+    "idx_integration_identity_links_account",
+    `CREATE INDEX IF NOT EXISTS idx_integration_identity_links_account
+      ON ${TABLE}(org_id, user_email)`,
+  ],
+] as const;
+
+async function ensureTable(): Promise<void> {
+  if (!_initPromise) {
+    _initPromise = (async () => {
+      const client = getDbExec();
+      if (isPostgres()) {
+        await ensureTableExists(TABLE, createSql());
+        for (const [name, sql] of INDEXES) {
+          await ensureIndexExists(name, sql);
+        }
+        return;
+      }
+      await retryOnDdlRace(() => client.execute(createSql()));
+      for (const [, sql] of INDEXES) {
+        await retryOnDdlRace(() => client.execute(sql));
+      }
+    })().catch((error) => {
+      _initPromise = undefined;
+      throw error;
+    });
+  }
+  return _initPromise;
+}
+
+function required(value: string, name: string): string {
+  const normalized = value.trim();
+  if (!normalized) throw new Error(`${name} is required`);
+  if (normalized.length > 512) throw new Error(`${name} is too long`);
+  return normalized;
+}
+
+function normalizePlatform(value: string): string {
+  return required(value, "platform").toLowerCase();
+}
+
+function normalizeEmail(value: string): string {
+  const normalized = required(value, "userEmail").toLowerCase();
+  if (!normalized.includes("@")) throw new Error("userEmail must be an email");
+  return normalized;
+}
+
+function rowToLink(row: Record<string, unknown>): IntegrationIdentityLink {
+  return {
+    id: String(row.id),
+    platform: String(row.platform),
+    tenantId: String(row.tenant_id),
+    externalUserId: String(row.external_user_id),
+    userEmail: String(row.user_email),
+    orgId: String(row.org_id),
+    createdAt: Number(row.created_at ?? 0),
+    updatedAt: Number(row.updated_at ?? 0),
+  };
+}
+
+async function selectByExternalIdentity(
+  platform: string,
+  tenantId: string,
+  externalUserId: string,
+): Promise<IntegrationIdentityLink | null> {
+  await ensureTable();
+  const { rows } = await getDbExec().execute({
+    sql: `SELECT * FROM ${TABLE}
+      WHERE platform = ? AND tenant_id = ? AND external_user_id = ?
+      LIMIT 1`,
+    args: [platform, tenantId, externalUserId],
+  });
+  return rows[0] ? rowToLink(rows[0] as Record<string, unknown>) : null;
+}
+
+function matchesVerifiedLink(
+  row: IntegrationIdentityLink,
+  input: { userEmail: string; orgId: string },
+): boolean {
+  return row.userEmail === input.userEmail && row.orgId === input.orgId;
+}
+
+/** Persist a verified mapping and fail closed if it changes identity later. */
+export async function upsertVerifiedIntegrationIdentity(input: {
+  platform: string;
+  tenantId: string;
+  externalUserId: string;
+  userEmail: string;
+  orgId: string;
+}): Promise<IntegrationIdentityLink> {
+  const platform = normalizePlatform(input.platform);
+  const tenantId = required(input.tenantId, "tenantId");
+  const externalUserId = required(input.externalUserId, "externalUserId");
+  const userEmail = normalizeEmail(input.userEmail);
+  const orgId = required(input.orgId, "orgId");
+  const existing = await selectByExternalIdentity(
+    platform,
+    tenantId,
+    externalUserId,
+  );
+
+  if (existing) {
+    if (!matchesVerifiedLink(existing, { userEmail, orgId })) {
+      throw new Error(
+        "This provider identity is already linked to a different Agent Native account.",
+      );
+    }
+    const updatedAt = Date.now();
+    await getDbExec().execute({
+      sql: `UPDATE ${TABLE} SET updated_at = ? WHERE id = ?`,
+      args: [updatedAt, existing.id],
+    });
+    return { ...existing, updatedAt };
+  }
+
+  const id = randomUUID();
+  const now = Date.now();
+  try {
+    await getDbExec().execute({
+      sql: `INSERT INTO ${TABLE} (
+        id, platform, tenant_id, external_user_id, user_email, org_id,
+        created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        id,
+        platform,
+        tenantId,
+        externalUserId,
+        userEmail,
+        orgId,
+        now,
+        now,
+      ],
+    });
+  } catch (error) {
+    if (!isUniqueViolation(error)) throw error;
+    const raced = await selectByExternalIdentity(
+      platform,
+      tenantId,
+      externalUserId,
+    );
+    if (!raced || !matchesVerifiedLink(raced, { userEmail, orgId })) {
+      throw new Error(
+        "This provider identity is already linked to a different Agent Native account.",
+      );
+    }
+    return raced;
+  }
+
+  return {
+    id,
+    platform,
+    tenantId,
+    externalUserId,
+    userEmail,
+    orgId,
+    createdAt: now,
+    updatedAt: now,
+  };
+}

package/corpus/core/src/integrations/identity.ts

@@ -0,0 +1,132 @@
+import { getDbExec } from "../db/client.js";
+import { upsertVerifiedIntegrationIdentity } from "./identity-links-store.js";
+import {
+  getActiveIntegrationInstallationByKey,
+  getActiveIntegrationInstallationForTenant,
+} from "./installations-store.js";
+import { slackInstallationKey } from "./slack-oauth.js";
+import type { IncomingMessage, IntegrationExecutionContext } from "./types.js";
+
+function serviceOwner(platform: string): string {
+  return `integration@${platform}`;
+}
+
+function normalizedEmail(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const email = value.trim().toLowerCase();
+  if (!email || email.length > 320 || !email.includes("@")) return null;
+  return email;
+}
+
+async function resolveSlackInstallation(incoming: IncomingMessage) {
+  const teamId =
+    typeof incoming.platformContext.teamId === "string"
+      ? incoming.platformContext.teamId
+      : incoming.tenantId;
+  const enterpriseId =
+    typeof incoming.platformContext.enterpriseId === "string"
+      ? incoming.platformContext.enterpriseId
+      : undefined;
+  const apiAppId =
+    typeof incoming.platformContext.apiAppId === "string"
+      ? incoming.platformContext.apiAppId
+      : undefined;
+  if (apiAppId && (teamId || enterpriseId)) {
+    const byKey = await getActiveIntegrationInstallationByKey(
+      "slack",
+      slackInstallationKey({ teamId, enterpriseId, apiAppId }),
+    );
+    if (byKey) return byKey;
+  }
+  return teamId || enterpriseId
+    ? getActiveIntegrationInstallationForTenant(
+        "slack",
+        teamId ?? enterpriseId!,
+      )
+    : null;
+}
+
+async function isMemberOfOrg(email: string, orgId: string): Promise<boolean> {
+  try {
+    const { rows } = await getDbExec().execute({
+      sql: `SELECT 1 FROM org_members
+        WHERE org_id = ? AND LOWER(email) = ?
+        LIMIT 1`,
+      args: [orgId, email],
+    });
+    return rows.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Resolve the default integration principal.
+ *
+ * Slack DMs become a user principal only after the adapter has verified the
+ * sender email and the email is already a member of the managed installation's
+ * Agent Native organization. Shared channels deliberately stay service-scoped
+ * so a channel message cannot borrow one participant's private permissions.
+ */
+export async function resolveDefaultIntegrationExecutionContext(
+  incoming: IncomingMessage,
+): Promise<IntegrationExecutionContext> {
+  const installation =
+    incoming.platform === "slack"
+      ? await resolveSlackInstallation(incoming)
+      : null;
+
+  if (incoming.platform !== "slack" || incoming.conversationType !== "dm") {
+    return {
+      ownerEmail: serviceOwner(incoming.platform),
+      orgId: installation?.orgId ?? null,
+      principalType: "service",
+      ...(installation?.id ? { installationId: installation.id } : {}),
+    };
+  }
+
+  const email = normalizedEmail(incoming.senderEmail);
+  if (
+    !email ||
+    incoming.senderVerified !== true ||
+    !incoming.senderId ||
+    !incoming.tenantId
+  ) {
+    throw new Error(
+      "Slack DM sender identity could not be verified; refusing to run with a service principal.",
+    );
+  }
+  if (
+    incoming.actorTrust?.memberType === "guest" ||
+    incoming.actorTrust?.memberType === "external"
+  ) {
+    throw new Error(
+      "External or guest Slack members cannot use personal Agent Native permissions.",
+    );
+  }
+  if (!installation?.orgId) {
+    throw new Error(
+      "Slack workspace is not connected to an Agent Native organization.",
+    );
+  }
+
+  if (!(await isMemberOfOrg(email, installation.orgId))) {
+    throw new Error(
+      "Slack DM sender is not a member of the connected Agent Native organization.",
+    );
+  }
+
+  const link = await upsertVerifiedIntegrationIdentity({
+    platform: incoming.platform,
+    tenantId: incoming.tenantId,
+    externalUserId: incoming.senderId,
+    userEmail: email,
+    orgId: installation.orgId,
+  });
+  return {
+    ownerEmail: link.userEmail,
+    orgId: link.orgId,
+    principalType: "user",
+    installationId: installation.id,
+  };
+}

package/corpus/core/src/integrations/index.ts

@@ -18,6 +18,12 @@ export type {
 } from "./types.js";
 export { assertPlatformCapability } from "./types.js";
 
+export { resolveDefaultIntegrationExecutionContext } from "./identity.js";
+export {
+  upsertVerifiedIntegrationIdentity,
+  type IntegrationIdentityLink,
+} from "./identity-links-store.js";
+
 export {
   BUILT_IN_INTEGRATION_CATALOG,
   INTEGRATION_CATEGORIES,