@vellumai/assistant 0.11.7 → 0.11.8-staging.1

package/node_modules/@vellumai/gateway-client/src/guardian-request-contract.ts

@@ -189,10 +189,11 @@ export const GUARDIAN_REQUESTS_IPC_METHODS = {
   decide: "guardian_requests_decide",
   expire: "guardian_requests_expire",
   expireInteractionBound: "guardian_requests_expire_interaction_bound",
-  sweepExpired: "guardian_requests_sweep_expired",
+  listExpiredPending: "guardian_requests_list_expired_pending",
   createDelivery: "guardian_requests_create_delivery",
   updateDelivery: "guardian_requests_update_delivery",
   listDeliveries: "guardian_requests_list_deliveries",
+  listDeliveriesByChat: "guardian_requests_list_deliveries_by_chat",
   getByDestinationMessage: "guardian_requests_get_by_destination_message",
   listPendingByDestination: "guardian_requests_list_pending_by_destination",
   listPendingByScope: "guardian_requests_list_pending_by_scope",
@@ -201,6 +202,32 @@ export const GUARDIAN_REQUESTS_IPC_METHODS = {
   getByPendingQuestion: "guardian_requests_get_by_pending_question",
 } as const;
 
+/**
+ * The delivery-row statuses this codebase writes and matches on.
+ *
+ * `GuardianRequestDeliverySchema.status` stays a plain `z.string()` rather
+ * than an enum built from these: the column is persisted, so a row written
+ * by a different build must still read rather than throw on parse. These
+ * constants exist so a call site names a value instead of spelling it, not
+ * to close the set.
+ *
+ * `pending` is the creation default; `sent` and `failed` carry the
+ * notification delivery result the recorder maps in; `expired` is stamped
+ * when the request itself expires; `withdrawn` is the daemon's per-surface
+ * receipt that a card was durably withdrawn, which the gateway's
+ * per-request expire preserves and a retrying withdrawal skips.
+ */
+export const DELIVERY_STATUS = {
+  pending: "pending",
+  sent: "sent",
+  failed: "failed",
+  expired: "expired",
+  withdrawn: "withdrawn",
+} as const;
+
+export type DeliveryStatus =
+  (typeof DELIVERY_STATUS)[keyof typeof DELIVERY_STATUS];
+
 export type GuardianRequestsIpcMethod =
   (typeof GUARDIAN_REQUESTS_IPC_METHODS)[keyof typeof GUARDIAN_REQUESTS_IPC_METHODS];
 
@@ -418,7 +445,7 @@ const OUTCOME_TYPES_BY_DECISION_STATUS: Record<
 /**
  * Request for `guardian_requests_decide` (status CAS + optional ACL outcome).
  * Decisions only resolve a pending request to approved/denied — expiry has
- * `guardian_requests_expire`/`_sweep_expired` — so a malformed call can never
+ * `guardian_requests_expire`/`_list_expired_pending`, so a malformed call can never
  * apply an `aclOutcome` while leaving the request decidable again. The
  * outcome type must agree with the status: activation/minting only on
  * approval, seeding/blocking only on denial.
@@ -508,26 +535,22 @@ export type ExpireInteractionBoundIpcResponse = z.infer<
   typeof ExpireInteractionBoundIpcResponseSchema
 >;
 
-/** Request for `guardian_requests_sweep_expired` (`now` defaults gateway-side). */
-export const SweepExpiredGuardianRequestsIpcParamsSchema = z.object({
-  now: z.number().optional(),
-});
-
-export type SweepExpiredGuardianRequestsIpcParams = z.infer<
-  typeof SweepExpiredGuardianRequestsIpcParamsSchema
->;
-
 /**
- * Response for `guardian_requests_sweep_expired`: the full expired rows, so
- * the daemon's card-withdrawal/notification fan-out never needs a follow-up
- * read that could fail after the status flip and strand the side effects.
+ * Request for `guardian_requests_list_expired_pending` (`now` defaults
+ * gateway-side; `limit` bounds the batch and is capped gateway-side).
+ * Read-only: the rows stay `pending` until the daemon has run each one's
+ * expiry side effects and confirms with `guardian_requests_expire`, so a
+ * lost response leaves the work discoverable by the next sweep round
+ * instead of silently done. Past-deadline pending rows are undecidable
+ * either way: every decision path checks `expiresAt` before any write.
  */
-export const SweepExpiredGuardianRequestsIpcResponseSchema = z.object({
-  expired: z.array(GuardianRequestSchema),
+export const ListExpiredPendingGuardianRequestsIpcParamsSchema = z.object({
+  now: z.number().optional(),
+  limit: z.number().optional(),
 });
 
-export type SweepExpiredGuardianRequestsIpcResponse = z.infer<
-  typeof SweepExpiredGuardianRequestsIpcResponseSchema
+export type ListExpiredPendingGuardianRequestsIpcParams = z.infer<
+  typeof ListExpiredPendingGuardianRequestsIpcParamsSchema
 >;
 
 // ---------------------------------------------------------------------------
@@ -575,6 +598,22 @@ export type ListGuardianRequestDeliveriesIpcParams = z.infer<
   typeof ListGuardianRequestDeliveriesIpcParamsSchema
 >;
 
+/**
+ * Request for `guardian_requests_list_deliveries_by_chat`: every
+ * delivery row addressed to one channel-native chat, whatever request it
+ * belongs to. Lets transcript importers recognize guardian card
+ * messages (by their recorded message id) as delivery projections
+ * rather than conversation content.
+ */
+export const ListGuardianRequestDeliveriesByChatIpcParamsSchema = z.object({
+  channel: z.string().min(1),
+  chatId: z.string().min(1),
+});
+
+export type ListGuardianRequestDeliveriesByChatIpcParams = z.infer<
+  typeof ListGuardianRequestDeliveriesByChatIpcParamsSchema
+>;
+
 /** Response for `guardian_requests_list_deliveries`. */
 export const GuardianRequestDeliveryListIpcResponseSchema = z.array(
   GuardianRequestDeliverySchema,
@@ -640,13 +679,15 @@ export type ListPendingGuardianRequestsByScopeIpcParams = z.infer<
 
 /**
  * Request for `guardian_requests_in_scope`: is a decision from this
- * conversation allowed for the request (source match, or delivery match
- * optionally narrowed by `channel`)?
+ * conversation allowed for the request (source match, or delivery match)?
+ * Deliberately not narrowed by delivery channel: `destinationConversationId`
+ * is always an internal conversation id, and every delivery's paired
+ * conversation renders the same actionable in-app card, so a match on any
+ * delivery row legitimizes the conversation.
  */
 export const GuardianRequestInScopeIpcParamsSchema = z.object({
   requestId: z.string().min(1),
   conversationId: z.string().min(1),
-  channel: z.string().optional(),
 });
 
 export type GuardianRequestInScopeIpcParams = z.infer<

package/node_modules/@vellumai/gateway-client/src/inbound-contract.ts

@@ -139,6 +139,11 @@ export const SourceMetadataSchema = z
      * "not provided", never as a decision.
      */
     trustVerdict: TrustVerdictSchema.optional(),
+    /**
+     * The platform named no actor for this event; the actor id is the
+     * channel's synthetic system identity, never an identity claim.
+     */
+    actorUnattributed: z.boolean().optional(),
 
     // Email-specific fields
     /**
@@ -172,6 +177,15 @@ export const RuntimeInboundPayloadSchema = z.object({
   /** The named event family; absent only on replayed retry payloads,
    *  where resolveInboundEventKind derives it from the legacy fields. */
   eventKind: z.enum(INBOUND_EVENT_KINDS).optional(),
+  /** Structured reaction payload; replayed retry payloads carry the
+   *  callbackData string form resolveInboundReactionPayload reads. */
+  reaction: z
+    .object({
+      op: z.enum(["added", "removed"]),
+      emoji: z.string(),
+      targetMessageId: z.string(),
+    })
+    .optional(),
   isEdit: z.boolean().optional(),
   callbackQueryId: z.string().optional(),
   callbackData: z.string().optional(),

package/node_modules/@vellumai/gateway-client/src/inbound-event-kind.ts

@@ -73,3 +73,56 @@ export function inboundEventRefersToAnotherMessage(
 ): boolean {
   return kind !== "message";
 }
+
+/** The structured payload of a reaction event. */
+export interface InboundReactionPayload {
+  op: "added" | "removed";
+  /**
+   * The emoji as the channel names it: Slack a colon-name ("+1"), Telegram
+   * and Discord the unicode character, a Discord custom emoji its name.
+   * Decision vocabulary is product policy resolved in the daemon, never
+   * normalized here.
+   */
+  emoji: string;
+  /**
+   * Provider id of the message reacted to, in the same namespace as
+   * `source.messageId`.
+   */
+  targetMessageId: string;
+}
+
+/**
+ * The one reader of a reaction event's payload. A structured `reaction`
+ * field wins; a replayed retry payload persisted before the field carries
+ * the `"reaction:<emoji>"` / `"reaction_removed:<emoji>"` string in
+ * `callbackData` with the target on `sourceMetadata.messageId`, and is
+ * parsed here alone. Returns null when the event is not a reaction or
+ * names no emoji or target.
+ */
+export function resolveInboundReactionPayload(fields: {
+  eventKind?: string;
+  reaction?: InboundReactionPayload;
+  callbackData?: string;
+  sourceMetadata?: { messageId?: string };
+}): InboundReactionPayload | null {
+  if (fields.reaction) {
+    const { op, emoji, targetMessageId } = fields.reaction;
+    return emoji.length > 0 && targetMessageId.length > 0
+      ? { op, emoji, targetMessageId }
+      : null;
+  }
+  const cb = fields.callbackData;
+  const target = fields.sourceMetadata?.messageId;
+  if (cb === undefined || target === undefined || target.length === 0) {
+    return null;
+  }
+  const removed = cb.startsWith("reaction_removed:");
+  const added = !removed && cb.startsWith("reaction:");
+  if (!added && !removed) {
+    return null;
+  }
+  const emoji = cb.slice(cb.indexOf(":") + 1);
+  return emoji.length > 0
+    ? { op: removed ? "removed" : "added", emoji, targetMessageId: target }
+    : null;
+}

package/node_modules/@vellumai/gateway-client/src/index.ts

@@ -88,8 +88,12 @@ export {
   inboundEventRefersToAnotherMessage,
   isInboundEventKind,
   resolveInboundEventKind,
+  resolveInboundReactionPayload,
+} from "./inbound-event-kind.js";
+export type {
+  InboundEventKind,
+  InboundReactionPayload,
 } from "./inbound-event-kind.js";
-export type { InboundEventKind } from "./inbound-event-kind.js";
 
 // Plugin admission-denied notice (gateway → plugin) — canned deny copy + envelope
 export {
@@ -260,12 +264,13 @@ export {
   GuardianRequestSourceTypeSchema,
   GuardianRequestStatusSchema,
   isGuardianRequestExpired,
+  ListGuardianRequestDeliveriesByChatIpcParamsSchema,
   ListGuardianRequestDeliveriesIpcParamsSchema,
   ListGuardianRequestsIpcParamsSchema,
   ListPendingGuardianRequestsByDestinationIpcParamsSchema,
   ListPendingGuardianRequestsByScopeIpcParamsSchema,
-  SweepExpiredGuardianRequestsIpcParamsSchema,
-  SweepExpiredGuardianRequestsIpcResponseSchema,
+  DELIVERY_STATUS,
+  ListExpiredPendingGuardianRequestsIpcParamsSchema,
   UpdateGuardianRequestDeliveryIpcParamsSchema,
   UpdateGuardianRequestIpcParamsSchema,
 } from "./guardian-request-contract.js";
@@ -275,6 +280,7 @@ export type {
   CreateGuardianRequestIpcParams,
   DecideGuardianRequestIpcParams,
   DecideGuardianRequestIpcResponse,
+  DeliveryStatus,
   ExpireGuardianRequestIpcParams,
   ExpireInteractionBoundIpcParams,
   ExpireInteractionBoundIpcResponse,
@@ -298,12 +304,12 @@ export type {
   GuardianRequestSourceType,
   GuardianRequestStatus,
   GuardianRequestWire,
+  ListGuardianRequestDeliveriesByChatIpcParams,
   ListGuardianRequestDeliveriesIpcParams,
   ListGuardianRequestsIpcParams,
   ListPendingGuardianRequestsByDestinationIpcParams,
   ListPendingGuardianRequestsByScopeIpcParams,
-  SweepExpiredGuardianRequestsIpcParams,
-  SweepExpiredGuardianRequestsIpcResponse,
+  ListExpiredPendingGuardianRequestsIpcParams,
   UpdateGuardianRequestDeliveryIpcParams,
   UpdateGuardianRequestIpcParams,
 } from "./guardian-request-contract.js";

package/node_modules/@vellumai/gateway-client/src/invite-contract.ts

@@ -84,6 +84,7 @@ export const INVITE_CODE_REDEMPTION_CHANNELS: ReadonlySet<string> = new Set([
   "whatsapp",
   "slack",
   "email",
+  "discord",
 ]);
 
 /** Whether invite code redemption is enabled for the given channel. */

package/node_modules/@vellumai/service-contracts/package.json

@@ -11,6 +11,7 @@
     "./client-metadata": "./src/client-metadata.ts",
     "./credential-rpc": "./src/credential-rpc.ts",
     "./ingress": "./src/ingress.ts",
+    "./no-response": "./src/no-response.ts",
     "./remote-web-pairing": "./src/remote-web-pairing.ts",
     "./twilio-ingress": "./src/twilio-ingress.ts",
     "./trust-rules": "./src/trust-rules.ts",

package/node_modules/@vellumai/service-contracts/src/channels.ts

@@ -66,6 +66,13 @@ export function isChannelId(value: unknown): value is ChannelId {
  * That irregularity is why this is stated rather than derived from the key,
  * and it is stated here because this file already owns what a channel is.
  *
+ * Both senses can hold a user token, which is the sharpest edge. The `slack`
+ * integration's persisted token *is* the installer's user token, held on its
+ * OAuth connection. `slack_channel` holds an optional `user_token` in the
+ * credential store, beside its bot and app tokens. Same words, different
+ * homes, and only the second is a credential-store key: a pasted token is
+ * always the channel's, because the integration's never leaves the exchange.
+ *
  * Deliberately only the key. What fields each credential requires is declared
  * once already, per service, in the gateway's credential specs; restating it
  * here would be a second copy of a different fact.

package/node_modules/@vellumai/service-contracts/src/index.ts

@@ -27,6 +27,7 @@ export * from "./handles.js";
 export * from "./rpc.js";
 export * from "./trust-rules.js";
 export * from "./ingress.js";
+export * from "./no-response.js";
 export * from "./remote-web-pairing.js";
 export * from "./twilio-ingress.js";
 export * from "./url-normalization.js";

package/node_modules/@vellumai/service-contracts/src/no-response.ts

@@ -0,0 +1,84 @@
+/**
+ * The `<no_response/>` sentinel: the cross-service convention for a turn
+ * that deliberately produces no user-visible reply.
+ *
+ * The model emits it, the daemon stamps and strips it, channel delivery
+ * suppresses it, and clients hold live-streamed prefixes of it back from
+ * display. One definition here keeps every consumer's parsing identical;
+ * a hand-rolled copy in any one of them is how the case-sensitivity of a
+ * regex drifts.
+ */
+
+/** Matches a message whose entire content is the sentinel. */
+const NO_RESPONSE_ONLY_RE = /^\s*<no_response\s*\/?>\s*$/i;
+
+/**
+ * Whether `text` is nothing but the sentinel: the whole reply is a
+ * deliberate non-response, as opposed to real content with an inline
+ * sentinel mixed in.
+ */
+export function isNoResponseOnlyText(text: string): boolean {
+  return NO_RESPONSE_ONLY_RE.test(text);
+}
+
+/** Matches every sentinel occurrence for stripping it out of mixed content. */
+export const NO_RESPONSE_INLINE_RE = /<no_response\s*\/?>/gi;
+
+/**
+ * Detection variant without the `g` flag: a `g`-flagged regex is stateful
+ * under `.test()` (it resumes from `lastIndex`), so reusing
+ * {@link NO_RESPONSE_INLINE_RE} for detection would alternate between
+ * matches and misses across calls.
+ */
+const NO_RESPONSE_MARKER_RE = new RegExp(NO_RESPONSE_INLINE_RE.source, "i");
+
+/** Whether `text` contains the sentinel anywhere. */
+export function containsNoResponseMarker(text: string): boolean {
+  return NO_RESPONSE_MARKER_RE.test(text);
+}
+
+/** Removes every sentinel occurrence, trimming the leftover whitespace. */
+export function stripNoResponseMarkers(text: string): string {
+  return text.replace(NO_RESPONSE_INLINE_RE, "").trim();
+}
+
+const NO_RESPONSE_SENTINEL_FORMS = [
+  "<no_response/>",
+  "<no_response />",
+  "<no_response>",
+] as const;
+
+/**
+ * Whether `text` could still grow into the sentinel, i.e. it is a leading
+ * substring of one of its forms. Holding on these keeps a slowly-streamed
+ * `<no_response/>` from surfacing as visible partial content.
+ */
+export function isPotentialNoResponsePrefix(text: string): boolean {
+  const lower = text.trim().toLowerCase();
+  if (lower.length === 0) {
+    return false;
+  }
+  return NO_RESPONSE_SENTINEL_FORMS.some((sentinel) =>
+    sentinel.startsWith(lower),
+  );
+}
+
+/**
+ * Whether `text` carries user-visible content worth acting on now. Returns
+ * `false` for empty text, the standalone sentinel, and any prefix that could
+ * still complete into one; returns `true` once real content remains after
+ * stripping inline sentinels.
+ */
+export function hasDeliverableAssistantText(text: string): boolean {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    return false;
+  }
+  if (NO_RESPONSE_ONLY_RE.test(trimmed)) {
+    return false;
+  }
+  if (isPotentialNoResponsePrefix(trimmed)) {
+    return false;
+  }
+  return stripNoResponseMarkers(trimmed).length > 0;
+}