@vellumai/plugin-api 0.10.7-dev.202607092039.003f549 → 0.10.7-dev.202607092235.9deedf4

package/index.d.ts

@@ -60,6 +60,40 @@ declare interface AcpSessionUsage {
     outputTokens?: number;
 }
 
+/**
+ * Append a message to a conversation. This is the low-level insert: it
+ * persists and indexes the row only — it does not project the message into
+ * the conversation's disk view and does not notify connected clients, so
+ * background/internal writes stay silent. A user-visible append pairs this
+ * with `syncMessageToDisk` and a client notification, as the host's own
+ * out-of-pipeline writers do.
+ */
+export declare function addMessage(conversationId: string, role: MessageRole, content: string, options?: AddMessageOptions): Promise<AddMessageResult>;
+
+/**
+ * Persist a message and run post-insert side effects (memory indexing,
+ * attention projection). Delegates the core insert + retry logic to
+ * {@link insertMessageCore}.
+ */
+declare function addMessage_2(conversationId: string, role: MessageRole, content: string, options?: AddMessageOptions): Promise<InsertedMessage>;
+
+/** Options for {@link addMessage}. Only `skipIndexing` and `clientMessageId`
+ *  have defaults; `metadata` is genuinely optional. */
+declare interface AddMessageOptions {
+    metadata?: Record<string, unknown>;
+    skipIndexing?: boolean;
+    /** Client-generated nonce for idempotent inserts. When provided,
+     *  duplicate inserts for the same `(conversationId, clientMessageId)`
+     *  pair are silently skipped. */
+    clientMessageId?: string;
+    /** Pre-assigned message ID. When omitted, one is generated
+     *  internally. Pass the same value as `requestId` for user turns so
+     *  the persisted row ID matches the runtime correlation ID. */
+    id?: string;
+}
+
+declare type AddMessageResult = Awaited<ReturnType<addMessage_2>>;
+
 /**
  * Why an agent turn reached a terminal state. Supplied to the `stop` hook via
  * {@link StopContext.exitReason} and emitted on the `agent_loop_exit` event,
@@ -200,6 +234,19 @@ declare interface AppUpdatePreviewResponse {
     appId: string;
 }
 
+/**
+ * How {@link listConversations} (and friends) treats archived rows.
+ *
+ * - `"active"` — exclude rows with a non-null `archivedAt`. The default
+ *   for sidebar lists, restore, CLI pickers, and anything user-facing.
+ * - `"archived"` — return ONLY archived rows. Powers the Archive page
+ *   so it does not have to pull the entire conversation history and
+ *   filter client-side.
+ * - `"all"` — include both. Reserved for migrations and back-compat
+ *   call sites that genuinely want everything in one query.
+ */
+declare type ArchiveStatusFilter = "active" | "archived" | "all";
+
 declare type AssistantActivityStateEvent = z.infer<typeof AssistantActivityStateEventSchema>;
 
 declare const AssistantActivityStateEventSchema: z.ZodObject<{
@@ -1207,6 +1254,7 @@ declare const AssistantConfigSchema: z.ZodObject<{
                 high: "high";
             }>>;
             telephonyStreaming: z.ZodDefault<z.ZodBoolean>;
+            utteranceEndMs: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strip>>;
         callerIdentity: z.ZodDefault<z.ZodObject<{
             allowPerCallOverride: z.ZodDefault<z.ZodBoolean>;
@@ -1227,6 +1275,7 @@ declare const AssistantConfigSchema: z.ZodObject<{
             speechEnergyThreshold: z.ZodDefault<z.ZodNumber>;
             silenceThresholdMs: z.ZodDefault<z.ZodNumber>;
             maxTurnDurationMs: z.ZodDefault<z.ZodNumber>;
+            bargeInMinSpeechMs: z.ZodDefault<z.ZodNumber>;
         }, z.core.$strip>>;
         maxSessionDurationSeconds: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
@@ -1725,6 +1774,13 @@ declare interface BookmarkSummary {
     createdAt: number;
 }
 
+/**
+ * Build a model-facing excerpt of stored message content around a query,
+ * preserving external-content envelopes so third-party boundaries stay
+ * visible.
+ */
+export declare function buildMessageExcerpt(rawContent: string, query: string): Promise<string>;
+
 declare interface BundleAppResponse {
     type: "bundle_app_response";
     bundlePath: string;
@@ -2131,6 +2187,9 @@ declare interface ContextCompacted {
     summaryHadMemoryEcho?: boolean;
 }
 
+/** How a conversation was created / its execution mode. */
+declare type ConversationCreateType = "standard" | "background" | "scheduled";
+
 /**
  * The full `conversation-deleted` context a hook receives — the dispatching
  * call site's {@link ConversationDeletedInputContext} plus the
@@ -2298,6 +2357,41 @@ declare const ConversationNoticeEventSchema: z.ZodObject<{
     errorCategory: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 
+export declare interface ConversationRow {
+    id: string;
+    title: string | null;
+    createdAt: number;
+    updatedAt: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalEstimatedCost: number;
+    contextSummary: string | null;
+    contextCompactedMessageCount: number;
+    contextCompactedAt: number | null;
+    historyStrippedAt: number | null;
+    slackContextCompactionWatermarkTs: string | null;
+    slackContextCompactionWatermarkAt: number | null;
+    conversationType: string;
+    source: string;
+    memoryScopeId: string;
+    originChannel: string | null;
+    originInterface: string | null;
+    forkParentConversationId: string | null;
+    forkParentMessageId: string | null;
+    isAutoTitle: number;
+    scheduleJobId: string | null;
+    lastMessageAt: number | null;
+    archivedAt: number | null;
+    surfacedAt: number | null;
+    inferenceProfile: string | null;
+    /** Parsed plugin-id list scoping this chat; null = default (all globally-enabled). */
+    enabledPlugins: string[] | null;
+    inferenceProfileSessionId: string | null;
+    inferenceProfileExpiresAt: number | null;
+    lastNotifiedInferenceProfile: string | null;
+    processingStartedAt: number | null;
+}
+
 declare interface ConversationsClearResponse {
     type: "conversations_clear_response";
     cleared: number;
@@ -2336,6 +2430,9 @@ declare const ConversationTitleUpdatedEventSchema: z.ZodObject<{
 
 declare type ConversationType = "standard" | "background" | "scheduled";
 
+/** Read-side alias of {@link ConversationCreateType}. */
+declare type ConversationType_2 = ConversationCreateType;
+
 declare interface CopyBlockSurfaceData {
     text: string;
     label?: string;
@@ -2346,6 +2443,15 @@ declare interface CustomSlimSkill extends SlimSkillBase {
     origin: "custom";
 }
 
+/**
+ * Delete a conversation, yielding the event loop between row batches, and
+ * enqueue vector-store cleanup for the memory segments and summaries the
+ * delete cascaded away — the same vector-cleanup pairing the host's delete
+ * route performs, so facade callers never leave semantic vectors behind. The lexical-index
+ * purge runs inside the delete itself via the persistence hook.
+ */
+export declare function deleteConversation(id: string): Promise<void>;
+
 declare type _DiagnosticsServerMessages = EnvVarsResponse | DictationResponse;
 
 declare interface DictationResponse {
@@ -2580,6 +2686,8 @@ declare const ErrorEventSchema: z.ZodObject<{
     conversationId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 
+export declare function extractTextFromStoredMessageContent(raw: string): string;
+
 export declare interface FileContent {
     type: "file";
     source: MediaSource_2;
@@ -2723,6 +2831,18 @@ export declare function getConfiguredProvider(callSite: LLMCallSite, opts?: {
     forceOverrideProfile?: boolean;
 }): Promise<Provider | null>;
 
+/** Look up a conversation row by id. */
+export declare function getConversation(id: string): Promise<ConversationRow | null>;
+
+/**
+ * Absolute path of a conversation's disk-view directory under the workspace
+ * naming scheme (timestamp-first, derived from id + creation time).
+ */
+export declare function getConversationDirPath(id: string, createdAtMs: number): Promise<string>;
+
+/** All messages of a conversation in insertion order. */
+export declare function getMessages(conversationId: string): Promise<MessageRow[]>;
+
 /**
  * List the workspace inference profiles a plugin can route to, in the order the
  * `/model` picker presents them (`llm.profileOrder` first, then the rest
@@ -2804,6 +2924,9 @@ declare interface GuardianDecisionPrompt {
     executionTarget?: "sandbox" | "host";
 }
 
+/** Whether the text tokenizes to at least one lexical search token. */
+export declare function hasLexicalTokens(text: string): Promise<boolean>;
+
 declare interface HeartbeatAlert {
     type: "heartbeat_alert";
     title: string;
@@ -3409,6 +3532,18 @@ export declare interface InitContext {
     assistantVersion: string;
 }
 
+/** Shape returned by {@link insertMessageCore} and its public wrappers. */
+declare interface InsertedMessage {
+    id: string;
+    conversationId: string;
+    role: MessageRole;
+    content: string;
+    createdAt: number;
+    metadata?: string;
+    clientMessageId?: string;
+    deduplicated: boolean;
+}
+
 declare interface IntegrationConnectResult {
     type: "integration_connect_result";
     integrationId: string;
@@ -3453,6 +3588,9 @@ declare const INTERFACE_IDS: readonly ["macos", "ios", "cli", "telegram", "phone
 
 declare type InterfaceId = (typeof INTERFACE_IDS)[number];
 
+/** Whether the conversation currently has a turn in flight. */
+export declare function isConversationProcessing(id: string): Promise<boolean>;
+
 /**
  * Provider stop-reason classification.
  *
@@ -3486,6 +3624,9 @@ export declare function isMaxTokensStopReason(stopReason: string | null | undefi
  */
 export declare function listCatalogSkills(): Promise<ResolvedSkillEntry[]>;
 
+/** List conversation rows, newest first. */
+export declare function listConversations(limit?: number, conversationType?: ConversationType_2, offset?: number, archiveStatus?: ArchiveStatusFilter, originChannel?: string): Promise<ConversationRow[]>;
+
 /**
  * The locally installed skill catalog with resolved states. Includes every
  * catalog entry — skills dropped by flag gating or the bundled allowlist are
@@ -3659,6 +3800,124 @@ declare const MessageDequeuedEventSchema: z.ZodObject<{
     requestId: z.ZodString;
 }, z.core.$strip>;
 
+declare type MessageLexicalSearchResult = Awaited<ReturnType<searchMessageIdsLexical_2>>[number];
+
+declare interface MessageLexicalSearchResult_2 {
+    messageId: string;
+    score: number;
+}
+
+/**
+ * Plugin-facing facade over the host conversation store: reads and writes on
+ * conversations and their message history, plus the lexical message-search
+ * surface. Every operation takes explicit parameters and resolves nothing
+ * from config, so the wrappers are pure pass-throughs.
+ *
+ * The store modules are loaded via dynamic `import()` inside each wrapper —
+ * they carry the DB/drizzle import graph and are among the most
+ * partial-mocked modules in the test suite, so importing this module (which
+ * every `@vellumai/plugin-api` consumer does transitively) must not force
+ * their named exports to resolve at instantiation. All type imports above are
+ * erased at compile time. Async for that reason, including the wrappers whose
+ * underlying functions are synchronous.
+ */
+declare type MessageMetadata = ReturnType<parseMessageMetadata_2>;
+
+/** Validated shape of a persisted message's `metadata` column. */
+declare type MessageMetadata_2 = z.infer<typeof messageMetadataSchema>;
+
+declare const messageMetadataSchema: z.ZodObject<{
+    userMessageChannel: z.ZodOptional<z.ZodEnum<{
+        vellum: "vellum";
+        telegram: "telegram";
+        phone: "phone";
+        whatsapp: "whatsapp";
+        slack: "slack";
+        email: "email";
+        platform: "platform";
+        a2a: "a2a";
+    }>>;
+    assistantMessageChannel: z.ZodOptional<z.ZodEnum<{
+        vellum: "vellum";
+        telegram: "telegram";
+        phone: "phone";
+        whatsapp: "whatsapp";
+        slack: "slack";
+        email: "email";
+        platform: "platform";
+        a2a: "a2a";
+    }>>;
+    userMessageInterface: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "macos" | "ios" | "cli" | "web" | "chrome-extension" | null, string>> & z.ZodType<"telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "macos" | "ios" | "cli" | "web" | "chrome-extension", string, z.core.$ZodTypeInternals<"telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "macos" | "ios" | "cli" | "web" | "chrome-extension", string>>>;
+    assistantMessageInterface: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "macos" | "ios" | "cli" | "web" | "chrome-extension" | null, string>> & z.ZodType<"telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "macos" | "ios" | "cli" | "web" | "chrome-extension", string, z.core.$ZodTypeInternals<"telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "macos" | "ios" | "cli" | "web" | "chrome-extension", string>>>;
+    client: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    subagentNotification: z.ZodOptional<z.ZodObject<{
+        subagentId: z.ZodString;
+        label: z.ZodString;
+        status: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            running: "running";
+            aborted: "aborted";
+        }>;
+        error: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+        objective: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    acpNotification: z.ZodOptional<z.ZodObject<{
+        acpSessionId: z.ZodString;
+        agent: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    provenanceTrustClass: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        guardian: "guardian";
+        trusted_contact: "trusted_contact";
+        unverified_contact: "unverified_contact";
+    }>>;
+    provenanceSourceChannel: z.ZodOptional<z.ZodEnum<{
+        vellum: "vellum";
+        telegram: "telegram";
+        phone: "phone";
+        whatsapp: "whatsapp";
+        slack: "slack";
+        email: "email";
+        platform: "platform";
+        a2a: "a2a";
+    }>>;
+    provenanceGuardianExternalUserId: z.ZodOptional<z.ZodString>;
+    provenanceRequesterIdentifier: z.ZodOptional<z.ZodString>;
+    automated: z.ZodOptional<z.ZodBoolean>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    backgroundToolCompletion: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        toolName: z.ZodString;
+        conversationId: z.ZodString;
+        command: z.ZodString;
+        startedAt: z.ZodNumber;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            failed: "failed";
+        }>;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        output: z.ZodString;
+        completedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    forkSourceMessageId: z.ZodOptional<z.ZodString>;
+    imageSourcePaths: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    attachmentStoredPaths: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    memoryInjectedBlock: z.ZodOptional<z.ZodString>;
+    memoryV3InjectedBlock: z.ZodOptional<z.ZodString>;
+    turnContextBlock: z.ZodOptional<z.ZodString>;
+    pkbSystemReminderBlock: z.ZodOptional<z.ZodString>;
+    workspaceBlock: z.ZodOptional<z.ZodString>;
+    nowScratchpadBlock: z.ZodOptional<z.ZodString>;
+    pkbContextBlock: z.ZodOptional<z.ZodString>;
+    memoryV2StaticBlock: z.ZodOptional<z.ZodString>;
+    backgroundTurnBlock: z.ZodOptional<z.ZodString>;
+    channelCapabilitiesBlock: z.ZodOptional<z.ZodString>;
+    nonInteractiveContextBlock: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+
 declare type MessageQueuedDeletedEvent = z.infer<typeof MessageQueuedDeletedEventSchema>;
 
 declare const MessageQueuedDeletedEventSchema: z.ZodObject<{
@@ -3685,6 +3944,19 @@ declare const MessageRequestCompleteEventSchema: z.ZodObject<{
     runStillActive: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 
+/** Allowed values for the `role` column on `messages`. */
+declare type MessageRole = "user" | "assistant" | "system";
+
+declare interface MessageRow {
+    id: string;
+    conversationId: string;
+    role: string;
+    content: string;
+    createdAt: number;
+    metadata: string | null;
+    clientMessageId: string | null;
+}
+
 declare type _MessagesServerMessages = UserMessageEchoEvent | AssistantTurnStartEvent | AssistantTextDeltaEvent | AssistantThinkingDeltaEvent | ToolUseStartEvent | ToolUsePreviewStartEvent | ToolOutputChunkEvent | ToolInputDelta | ToolResultEvent | ConfirmationRequestEvent | SecretRequestEvent | QuestionRequestEvent | MessageCompleteEvent | ErrorEvent_2 | MessageQueuedEvent | MessageDequeuedEvent | MessageRequestCompleteEvent | MessageQueuedDeletedEvent | MessageSteered | SuggestionResponse | ConfirmationStateChanged | AssistantActivityStateEvent | ConversationInferenceProfileUpdated | InteractionResolvedEvent;
 
 declare interface MessageSteered {
@@ -3901,6 +4173,19 @@ declare interface OwnerInfo {
  */
 declare type OwnerKind = "default" | "skill" | "mcp" | "plugin" | "workspace";
 
+/** Parse a stored message-metadata JSON string; undefined when absent/invalid. */
+export declare function parseMessageMetadata(metadataJson: string | null): Promise<MessageMetadata>;
+
+/**
+ * Parse a persisted message's metadata JSON against {@link messageMetadataSchema}
+ * — the single source of truth for its shape — returning the validated fields,
+ * or `undefined` when the column is absent, not valid JSON, or fails validation.
+ * The single place the raw JSON.parse + safeParse dance lives, so callers read
+ * typed fields (e.g. `provenanceTrustClass`, `automated`, `subagentNotification`)
+ * instead of re-implementing it.
+ */
+declare function parseMessageMetadata_2(metadataJson: string | null): MessageMetadata_2 | undefined;
+
 declare interface PartnerAudit {
     risk: RiskLevel_2;
     alerts?: number;
@@ -4618,6 +4903,36 @@ declare interface SchedulesListResponse {
 
 declare type _SchedulesServerMessages = SchedulesListResponse | HeartbeatAlert | HeartbeatConversationCreated | HeartbeatConfigResponse | HeartbeatRunsListResponse | HeartbeatRunNowResponse | HeartbeatChecklistResponse | HeartbeatChecklistWriteResponse | FilingConfigResponse | FilingRunNowResponse;
 
+/** Sparse lexical search over stored message text; ranked message-id hits. */
+export declare function searchMessageIdsLexical(query: string, limit: number, opts?: {
+    conversationId?: string;
+}): Promise<MessageLexicalSearchResult[]>;
+
+/**
+ * Resolve message-id candidates for `query` from the Qdrant lexical index,
+ * ranked by sparse similarity score (highest first).
+ *
+ * This is a **pure lexical candidate generator**: it returns the top-`limit`
+ * message ids by sparse score with NO visibility, source, or
+ * active-conversation filtering (the only scoping it applies is the optional
+ * `conversationId` restriction). Those exclusions (active conversation,
+ * private conversations, non-message sources) live in SQL at the read sites.
+ *
+ * Callers that apply such post-retrieval SQL filters MUST over-fetch: pass an
+ * inflated `limit` (the `QDRANT_RECALL_CANDIDATE_MULTIPLIER` /
+ * `QDRANT_SEARCH_CANDIDATE_LIMIT` pattern the read sites use) and re-limit
+ * after filtering in SQL. Applying the caller's real limit here first would
+ * let excluded rows consume the candidate slots and drop valid visible
+ * matches below the fold.
+ *
+ * @param query          free-text search query
+ * @param limit          maximum number of candidates to return
+ * @param opts.conversationId  restrict results to a single conversation
+ */
+declare function searchMessageIdsLexical_2(query: string, limit: number, opts?: {
+    conversationId?: string;
+}): Promise<MessageLexicalSearchResult_2[]>;
+
 /**
  * Result vocabulary for a secret prompt: how the value is delivered and the
  * outcome of the prompt. Kept in a leaf module (no runtime dependencies) so
@@ -5085,6 +5400,23 @@ declare interface StopInputContext {
     readonly exitReason: AgentLoopExitReason;
 }
 
+/**
+ * Coerce stored message content into a single human-readable text string,
+ * dropping non-text blocks (images, tool calls, tool results, thinking,
+ * …). Used by call sites that want only the spoken text — sweep-model
+ * context, RAG backfill, bookmark previews. For richer renderings that
+ * include tool metadata, use {@link extractTextFromStoredMessageContent}
+ * instead.
+ *
+ * Handles the two on-disk shapes:
+ *   - Modern rows: JSON-serialized `ContentBlock[]`
+ *   - Legacy rows: plain string
+ *
+ * Parse failures fall back to returning the raw input trimmed (the
+ * legacy-string path).
+ */
+export declare function stringifyMessageContent(stored: string): string;
+
 declare interface SubagentDetailResponse {
     type: "subagent_detail_response";
     subagentId: string;
@@ -5171,6 +5503,9 @@ declare const SyncChangedEventSchema: z.ZodObject<{
 
 declare type _SyncInvalidationServerMessages = SyncChangedEvent;
 
+/** Re-sync one persisted message into the conversation's disk view. */
+export declare function syncMessageToDisk(conversationId: string, messageId: string, createdAtMs: number): Promise<void>;
+
 declare interface TableCellValue {
     text: string;
     icon?: string;
@@ -5987,6 +6322,9 @@ declare interface UnpublishPageResponse {
     error?: string;
 }
 
+/** Merge the given keys into a message's metadata JSON. */
+export declare function updateMessageMetadata(messageId: string, updates: Record<string, unknown>): Promise<void>;
+
 declare type _UpgradesServerMessages = ServiceGroupUpdateStarting | ServiceGroupUpdateProgress | ServiceGroupUpdateComplete;
 
 declare type UsageAttributionProfileSource = "call_site" | "conversation" | "active" | "default" | "unknown";

package/index.js

@@ -2,15 +2,30 @@
 const api = globalThis[Symbol.for("vellum.plugin-api")] ?? {};
 export const HOOKS = api.HOOKS;
 export const RiskLevel = api.RiskLevel;
+export const addMessage = api.addMessage;
 export const assistantEventHub = api.assistantEventHub;
+export const buildMessageExcerpt = api.buildMessageExcerpt;
+export const deleteConversation = api.deleteConversation;
 export const doesSupportVision = api.doesSupportVision;
 export const embedAndUpsert = api.embedAndUpsert;
+export const extractTextFromStoredMessageContent = api.extractTextFromStoredMessageContent;
 export const getAssistantName = api.getAssistantName;
 export const getConfiguredProvider = api.getConfiguredProvider;
+export const getConversation = api.getConversation;
+export const getConversationDirPath = api.getConversationDirPath;
+export const getMessages = api.getMessages;
 export const getModelProfiles = api.getModelProfiles;
+export const hasLexicalTokens = api.hasLexicalTokens;
+export const isConversationProcessing = api.isConversationProcessing;
 export const isMaxTokensStopReason = api.isMaxTokensStopReason;
 export const listCatalogSkills = api.listCatalogSkills;
+export const listConversations = api.listConversations;
 export const listInstalledSkills = api.listInstalledSkills;
+export const parseMessageMetadata = api.parseMessageMetadata;
 export const resolveMediaSourceData = api.resolveMediaSourceData;
 export const resolveUserName = api.resolveUserName;
+export const searchMessageIdsLexical = api.searchMessageIdsLexical;
 export const selectedBackendSupportsMultimodal = api.selectedBackendSupportsMultimodal;
+export const stringifyMessageContent = api.stringifyMessageContent;
+export const syncMessageToDisk = api.syncMessageToDisk;
+export const updateMessageMetadata = api.updateMessageMetadata;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/plugin-api",
-  "version": "0.10.7-dev.202607092039.003f549",
+  "version": "0.10.7-dev.202607092235.9deedf4",
   "description": "Public TypeScript authoring contract for Vellum assistant plugins.",
   "license": "MIT",
   "type": "module",