@vellumai/plugin-api 0.10.11-dev.202607222029.495c516 → 0.10.11-dev.202607222226.fdf0e3d

package/index.d.ts

@@ -1658,37 +1658,30 @@ declare interface BaseSubscriberEntry {
     connectionId: string;
 }
 
-declare interface BookmarkCreated {
-    type: "bookmark.created";
-    bookmark: BookmarkSummary;
-}
+declare type BookmarkCreatedEvent = z.infer<typeof BookmarkCreatedEventSchema>;
 
-declare interface BookmarkDeleted {
-    type: "bookmark.deleted";
-    messageId: string;
-}
+declare const BookmarkCreatedEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"bookmark.created">;
+    bookmark: z.ZodObject<{
+        id: z.ZodString;
+        messageId: z.ZodString;
+        conversationId: z.ZodString;
+        conversationTitle: z.ZodNullable<z.ZodString>;
+        messagePreview: z.ZodString;
+        messageRole: z.ZodString;
+        messageCreatedAt: z.ZodNumber;
+        createdAt: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 
-declare type _BookmarksServerMessages = BookmarkCreated | BookmarkDeleted;
+declare type BookmarkDeletedEvent = z.infer<typeof BookmarkDeletedEventSchema>;
 
-/**
- * Wire-shape representation of a bookmark, joined with the bookmarked
- * message and its parent conversation. Dates are emitted as
- * unix-millisecond integers, and the message preview is capped to keep
- * the list payload bounded.
- */
-declare interface BookmarkSummary {
-    id: string;
-    messageId: string;
-    conversationId: string;
-    conversationTitle: string | null;
-    messagePreview: string;
-    /** "user" | "assistant" — kept as a free-form string so it round-trips raw. */
-    messageRole: string;
-    /** Unix milliseconds. */
-    messageCreatedAt: number;
-    /** Unix milliseconds. */
-    createdAt: number;
-}
+declare const BookmarkDeletedEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"bookmark.deleted">;
+    messageId: z.ZodString;
+}, z.core.$strip>;
+
+declare type _BookmarksServerMessages = BookmarkCreatedEvent | BookmarkDeletedEvent;
 
 /**
  * Build a model-facing excerpt of stored message content around a query,
@@ -4068,49 +4061,53 @@ declare const LLMCallSiteEnum: z.ZodEnum<{
 
 declare type MediaSource_2 = Base64MediaSource | WorkspaceRefMediaSource;
 
-declare interface MemoryRecalled {
-    type: "memory_recalled";
-    provider: string;
-    model: string;
-    degradation?: MemoryRecalledDegradation;
-    semanticHits: number;
-    tier1Count: number;
-    tier2Count: number;
-    hybridSearchLatencyMs: number;
-    sparseVectorUsed: boolean;
-    mergedCount: number;
-    selectedCount: number;
-    injectedTokens: number;
-    latencyMs: number;
-    topCandidates: MemoryRecalledCandidateDebug[];
-}
-
-declare interface MemoryRecalledCandidateDebug {
-    key: string;
-    type: string;
-    kind: string;
-    finalScore: number;
-    semantic: number;
-    recency: number;
-}
+declare type MemoryRecalledEvent = z.infer<typeof MemoryRecalledEventSchema>;
 
-declare interface MemoryRecalledDegradation {
-    semanticUnavailable: boolean;
-    reason: string;
-    fallbackSources: string[];
-}
+declare const MemoryRecalledEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"memory_recalled">;
+    provider: z.ZodString;
+    model: z.ZodString;
+    degradation: z.ZodOptional<z.ZodObject<{
+        semanticUnavailable: z.ZodBoolean;
+        reason: z.ZodString;
+        fallbackSources: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    semanticHits: z.ZodNumber;
+    tier1Count: z.ZodNumber;
+    tier2Count: z.ZodNumber;
+    hybridSearchLatencyMs: z.ZodNumber;
+    sparseVectorUsed: z.ZodBoolean;
+    mergedCount: z.ZodNumber;
+    selectedCount: z.ZodNumber;
+    injectedTokens: z.ZodNumber;
+    latencyMs: z.ZodNumber;
+    topCandidates: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        type: z.ZodString;
+        kind: z.ZodString;
+        finalScore: z.ZodNumber;
+        semantic: z.ZodNumber;
+        recency: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 
-declare type _MemoryServerMessages = MemoryRecalled | MemoryStatus;
+declare type _MemoryServerMessages = MemoryRecalledEvent | MemoryStatusEvent;
 
-declare interface MemoryStatus {
-    type: "memory_status";
-    enabled: boolean;
-    degraded: boolean;
-    degradation?: MemoryRecalledDegradation;
-    reason?: string;
-    provider?: string;
-    model?: string;
-}
+declare type MemoryStatusEvent = z.infer<typeof MemoryStatusEventSchema>;
+
+declare const MemoryStatusEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"memory_status">;
+    enabled: z.ZodBoolean;
+    degraded: z.ZodBoolean;
+    degradation: z.ZodOptional<z.ZodObject<{
+        semanticUnavailable: z.ZodBoolean;
+        reason: z.ZodString;
+        fallbackSources: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    reason: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 
 export declare interface Message {
     role: "user" | "assistant";
@@ -6562,6 +6559,14 @@ export declare interface ToolContext {
      * @legacy
      */
     requesterChatId?: string;
+    /**
+     * Channel-native id (`ts` for Slack) of the inbound message that started
+     * the current turn. Lets tool-grant escalations link approval cards to
+     * the exact triggering message.
+     */
+    sourceMessageId?: string;
+    /** Channel-native thread id of that message, when it arrived in a thread. */
+    sourceThreadId?: string;
     /**
      * Human-readable identifier for the requester (e.g., @username).
      * @legacy

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/plugin-api",
-  "version": "0.10.11-dev.202607222029.495c516",
+  "version": "0.10.11-dev.202607222226.fdf0e3d",
   "description": "Public TypeScript authoring contract for Vellum assistant plugins.",
   "license": "MIT",
   "type": "module",