@vellumai/plugin-api 0.11.2 → 0.11.3-staging.2

package/index.d.ts

@@ -76,6 +76,37 @@ export declare type AgentLoopExitReason =
 /** An unhandled error ended the turn. */
 | "error";
 
+declare type AnsweredQuestion = z.infer<typeof AnsweredQuestionSchema>;
+
+declare const AnsweredQuestionSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    questions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        question: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        options: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        freeTextPlaceholder: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    responses: z.ZodArray<z.ZodObject<{
+        questionId: z.ZodString;
+        decision: z.ZodEnum<{
+            option: "option";
+            free_text: "free_text";
+            skipped: "skipped";
+        }>;
+        optionId: z.ZodOptional<z.ZodString>;
+        text: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    overall: z.ZodEnum<{
+        completed: "completed";
+        closed: "closed";
+    }>;
+}, z.core.$strip>;
+
 /**
  * How {@link listConversations} (and friends) treats archived rows.
  *
@@ -120,7 +151,7 @@ declare const AssistantConfigSchema: z.ZodObject<{
                 "openai-whisper": "openai-whisper";
                 xai: "xai";
             }>>;
-            language: z.ZodOptional<z.ZodString>;
+            language: z.ZodDefault<z.ZodString>;
             providers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
         }, z.core.$strip>>;
         tts: z.ZodDefault<z.ZodObject<{
@@ -484,6 +515,11 @@ declare const AssistantConfigSchema: z.ZodObject<{
             }, z.core.$strip>>;
         }, z.core.$strip>>;
         retrospective: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            forkStrategy: z.ZodDefault<z.ZodEnum<{
+                cloning: "cloning";
+                reference: "reference";
+            }>>;
             timeThresholdMs: z.ZodDefault<z.ZodNumber>;
             messageThreshold: z.ZodDefault<z.ZodNumber>;
             minCooldownMs: z.ZodDefault<z.ZodNumber>;
@@ -1070,6 +1106,7 @@ declare const AssistantConfigSchema: z.ZodObject<{
         botId: z.ZodDefault<z.ZodString>;
         botUsername: z.ZodDefault<z.ZodString>;
         apiBaseUrl: z.ZodDefault<z.ZodString>;
+        registeredWebhookUrl: z.ZodOptional<z.ZodString>;
         deliverAuthBypass: z.ZodDefault<z.ZodBoolean>;
         timeoutMs: z.ZodDefault<z.ZodNumber>;
         maxRetries: z.ZodDefault<z.ZodNumber>;
@@ -1162,6 +1199,18 @@ declare const AssistantConfigSchema: z.ZodObject<{
         journalRetentionDays: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
     plugins: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    pluginUpdates: z.ZodDefault<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            auto: "auto";
+            manual: "manual";
+        }>>;
+        strategy: z.ZodDefault<z.ZodEnum<{
+            theirs: "theirs";
+            ours: "ours";
+            overwrite: "overwrite";
+        }>>;
+        checkIntervalMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
     legacyTelemetryOptOut: z.ZodOptional<z.ZodBoolean>;
     legacyDiagnosticsOptOut: z.ZodOptional<z.ZodBoolean>;
     maxStepsPerSession: z.ZodDefault<z.ZodNumber>;
@@ -1306,8 +1355,8 @@ declare const AssistantEventEnvelopeSchema: z.ZodObject<{
         id: z.ZodString;
         conversationId: z.ZodString;
         status: z.ZodEnum<{
-            cancelled: "cancelled";
             completed: "completed";
+            cancelled: "cancelled";
             failed: "failed";
         }>;
         exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
@@ -2258,6 +2307,34 @@ declare const AssistantEventEnvelopeSchema: z.ZodObject<{
                 mayRequireJavaScript: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
+        answeredQuestion: z.ZodOptional<z.ZodObject<{
+            requestId: z.ZodString;
+            questions: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                question: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                options: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                freeTextPlaceholder: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            responses: z.ZodArray<z.ZodObject<{
+                questionId: z.ZodString;
+                decision: z.ZodEnum<{
+                    option: "option";
+                    free_text: "free_text";
+                    skipped: "skipped";
+                }>;
+                optionId: z.ZodOptional<z.ZodString>;
+                text: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            overall: z.ZodEnum<{
+                completed: "completed";
+                closed: "closed";
+            }>;
+        }, z.core.$strip>>;
         errorCode: z.ZodOptional<z.ZodString>;
         completedAt: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>, z.ZodObject<{
@@ -2474,6 +2551,12 @@ export declare class AssistantEventHub {
      * delivery to remaining subscribers.
      */
     publish(event: AssistantEventEnvelope, options?: AssistantEventPublishOptions): Promise<void>;
+    /**
+     * Yield every active client entry with the given clientId. `subscribe`
+     * disposes any prior entries for the same clientId, so at most one entry
+     * matches.
+     */
+    private activeClientEntries;
     /**
      * Return the active client subscriber with the given clientId, or
      * `undefined` if no such subscriber exists.
@@ -2488,6 +2571,19 @@ export declare class AssistantEventHub {
      * authenticated user identity that opened the target client's SSE stream.
      */
     getActorPrincipalIdForClient(clientId: string): string | undefined;
+    /**
+     * Fill a missing `actorPrincipalId` on a live client subscription.
+     *
+     * Used by the SSE dev-bypass self-heal: when the guardian-delivery cache is
+     * cold at subscribe time, the registration lands without a principal; the
+     * route resolves it async and patches the record here. Keyed by
+     * `connectionId` (not clientId) so a reconnect race cannot patch the
+     * subscription that replaced the one being healed. No-op when the
+     * connection is gone or already carries a principal: this only fills a
+     * missing value, never overwrites one. The value must come from the
+     * daemon's own server-side guardian lookup, never from client input.
+     */
+    fillClientActorPrincipalId(connectionId: string, actorPrincipalId: string): void;
     /**
      * Returns true when at least one active subscriber would receive the given
      * event based on the same conversation matching rules as publish().
@@ -2517,6 +2613,12 @@ export declare class AssistantEventHub {
      * Touch a client subscriber — update `lastActiveAt`. Used by heartbeat.
      */
     touchClient(clientId: string): void;
+    /**
+     * Record the desktop presence state reported by a client. `reportedAt`
+     * always advances. Returns true when at least one active client entry
+     * matched.
+     */
+    setClientPresence(clientId: string, state: DesktopPresenceState): boolean;
     /**
      * Force-disconnect a client by disposing all subscribers for the given
      * `clientId`. Returns the number of disposed entries.
@@ -2694,8 +2796,8 @@ declare const AssistantEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     id: z.ZodString;
     conversationId: z.ZodString;
     status: z.ZodEnum<{
-        cancelled: "cancelled";
         completed: "completed";
+        cancelled: "cancelled";
         failed: "failed";
     }>;
     exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
@@ -3646,6 +3748,34 @@ declare const AssistantEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             mayRequireJavaScript: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    answeredQuestion: z.ZodOptional<z.ZodObject<{
+        requestId: z.ZodString;
+        questions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            question: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            options: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            freeTextPlaceholder: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        responses: z.ZodArray<z.ZodObject<{
+            questionId: z.ZodString;
+            decision: z.ZodEnum<{
+                option: "option";
+                free_text: "free_text";
+                skipped: "skipped";
+            }>;
+            optionId: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        overall: z.ZodEnum<{
+            completed: "completed";
+            closed: "closed";
+        }>;
+    }, z.core.$strip>>;
     errorCode: z.ZodOptional<z.ZodString>;
     completedAt: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
@@ -3944,6 +4074,17 @@ declare interface ClientEntry extends BaseSubscriberEntry {
      * service-token connections that have no principal.
      */
     actorPrincipalId?: string;
+    /**
+     * Last desktop presence reported by this client, for clients that report it.
+     * In-memory only, so consumers must fail open when it is absent.
+     */
+    presence?: ClientPresence;
+}
+
+declare interface ClientPresence {
+    state: DesktopPresenceState;
+    /** When the daemon last heard from the client. Drives staleness. */
+    reportedAt: Date;
 }
 
 declare interface CliOptionHelp {
@@ -4033,6 +4174,8 @@ export declare interface ConversationRow {
     originInterface: string | null;
     forkParentConversationId: string | null;
     forkParentMessageId: string | null;
+    /** `"reference"` on referential forks; `"cloning"` or null on copied ones. */
+    forkStrategy: string | null;
     isAutoTitle: number;
     scheduleJobId: string | null;
     lastMessageAt: number | null;
@@ -4102,6 +4245,14 @@ export declare class CredentialResolutionError extends Error {
  */
 export declare function deleteConversation(id: string): Promise<void>;
 
+/**
+ * The presence states a desktop client may report. Single runtime source: the
+ * stored type and the route's wire enum both derive from this tuple.
+ */
+declare const DESKTOP_PRESENCE_STATES: readonly ["active", "idle", "away"];
+
+declare type DesktopPresenceState = (typeof DESKTOP_PRESENCE_STATES)[number];
+
 declare interface DiffInfo {
     filePath: string;
     oldContent: string;
@@ -4190,6 +4341,14 @@ export declare function getConversation(id: string): Promise<ConversationRow | n
  */
 export declare function getConversationDirPath(id: string, createdAtMs: number): Promise<string>;
 
+/**
+ * The persisted `processing_started_at` stamp for a conversation, or null
+ * when the conversation is idle (or the row does not exist). Lets background
+ * consumers age-gate the processing flag: a stamp far in the past is a
+ * stranded flag (a swallowed turn-end clear), not a live turn.
+ */
+export declare function getConversationProcessingStartedAt(id: string): Promise<number | null>;
+
 /** Fetch one document from the calling plugin's index, or null. */
 export declare function getDocument(documentId: string): Promise<IndexedDocument | null>;
 
@@ -4512,7 +4671,13 @@ export declare function lastToolResultUserMessageIndex(history: Message[]): numb
  */
 export declare function listCatalogSkills(): Promise<ResolvedSkillEntry[]>;
 
-/** List conversation rows, newest first. */
+/**
+ * List conversation rows, newest first.
+ *
+ * The positional signature is part of the plugin API surface and stays
+ * stable; the underlying query takes a named filter, which this maps onto.
+ * Omitted arguments stay omitted so the query's own defaults apply.
+ */
 export declare function listConversations(limit?: number, conversationType?: ConversationType, offset?: number, archiveStatus?: ArchiveStatusFilter, originChannel?: string): Promise<ConversationRow[]>;
 
 /**
@@ -4607,6 +4772,19 @@ declare interface LiveVoiceErrorServerFrame extends LiveVoiceServerFrameBase {
     readonly type: "error";
     readonly code: LiveVoiceProtocolErrorCode;
     readonly message: string;
+    /**
+     * The client frame this error is about, when the failure was a parse or
+     * validation failure of a specific frame. Absent otherwise, and absent from
+     * daemons predating the field.
+     *
+     * It exists so an `unknown_type` is attributable. A client that sends more
+     * than one optional frame (today: `update_config` and `attach_image`) gets
+     * the same code for either, and without this has to assume which one was
+     * refused. The wrong assumption is silent in both directions: settings stop
+     * applying for a session, or a photo the user watched themselves take is
+     * dropped with nothing said.
+     */
+    readonly frameType?: string;
     /**
      * True when the session continues past the error (e.g. a transient
      * transcriber blip or one failed TTS segment). Absent (including on frames
@@ -4883,6 +5061,7 @@ declare const messageMetadataSchema: z.ZodObject<{
     userMessageInterface: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "macos" | "ios" | "cli" | "web" | "chrome-extension" | "route" | null, string>> & z.ZodType<"telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "macos" | "ios" | "cli" | "web" | "chrome-extension" | "route", string, z.core.$ZodTypeInternals<"telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "macos" | "ios" | "cli" | "web" | "chrome-extension" | "route", string>>>;
     assistantMessageInterface: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "macos" | "ios" | "cli" | "web" | "chrome-extension" | "route" | null, string>> & z.ZodType<"telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "macos" | "ios" | "cli" | "web" | "chrome-extension" | "route", string, z.core.$ZodTypeInternals<"telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "macos" | "ios" | "cli" | "web" | "chrome-extension" | "route", string>>>;
     client: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    clientOsFromRequest: z.ZodOptional<z.ZodBoolean>;
     subagentNotification: z.ZodOptional<z.ZodObject<{
         subagentId: z.ZodString;
         label: z.ZodString;
@@ -4933,8 +5112,8 @@ declare const messageMetadataSchema: z.ZodObject<{
         command: z.ZodString;
         startedAt: z.ZodNumber;
         status: z.ZodEnum<{
-            cancelled: "cancelled";
             completed: "completed";
+            cancelled: "cancelled";
             failed: "failed";
         }>;
         exitCode: z.ZodNullable<z.ZodNumber>;
@@ -5624,7 +5803,7 @@ declare type ResolutionFallbackReason = "missing" | "disabled" | "incomplete";
  *   3. `llm.callSites[callSite].profile` (the call site's named profile)
  *   4. `CALL_SITE_DEFAULTS[callSite].profile` intent resolved through
  *      `llm.defaultProvider`
- *   5. balanced intent through `llm.defaultProvider` — the code-owned anchor
+ *   5. balanced intent through `llm.defaultProvider`: the code-owned anchor
  *      for profileless call sites, or when nothing above is usable
  *
  * A winner must carry its own `provider` AND `model`: the base layer's schema
@@ -5767,12 +5946,31 @@ export declare function resolveMediaSourceData(source: MediaSource_2): {
 } | null;
 
 /**
- * Read the guardian's display name from `users/default.md`. We look for the
- * markdown-bold "Name" label (matching the IDENTITY.md convention) and fall
- * back to `null` on any miss; callers substitute a generic label.
+ * Read the user's display name from the guardian's persona file
+ * (`users/<slug>.md`, resolved via the guardian-delivery binding), falling
+ * back to `users/default.md`. Returns `null` on any miss; callers substitute
+ * a generic label.
+ *
+ * The guardian resolution reads the sync in-process guardian-delivery cache;
+ * callers in processes that do not otherwise warm it (memory worker) await
+ * `getGuardianDelivery` first.
  */
 export declare function resolveUserName(workspaceDir: string): string | null;
 
+/**
+ * Resolve the public URL a third party should deliver to for `path`.
+ *
+ * On the managed branches this registers a callback route with the platform,
+ * which is idempotent and matches what `assistant webhooks register` does.
+ *
+ * @throws when the plugin cannot be determined, when `path` is not one the
+ *   gateway would serve, or when no ingress is configured and the assistant is
+ *   not connected to the platform. That last case has no URL that would work,
+ *   and a plausible one would produce a vendor registration that silently
+ *   receives nothing.
+ */
+export declare function resolveWebhookUrl(options: WebhookUrlOptions): Promise<string>;
+
 export declare enum RiskLevel {
     Low = "low",
     Medium = "medium",
@@ -5992,12 +6190,32 @@ export declare interface SendMessageConfig {
      */
     logit_bias?: Record<string, number>;
     /**
-     * When true, the most recent user message's content varies across
-     * otherwise-identical turns (e.g. a per-turn memory block was injected into
-     * it). The provider places the primary long-TTL cache breakpoint on the most
-     * recent *stable* user message instead of the volatile latest one, so the
-     * cached prefix stays reusable across turns. Default false — existing
-     * behavior.
+     * When true, the TURN-STARTING user message carries content that will not
+     * recur byte-identically on the next turn, so a long-TTL breakpoint placed
+     * on it could never be read back across turns. The agent loop is the only
+     * producer: it sets the flag from the history it is about to send, when the
+     * turn-starting message carries a memory-v3 `<memory_spotlight>` block (the
+     * one injected block strip-and-replaced from every user message each turn).
+     *
+     * The flag describes the turn, not the request, so it holds for every
+     * request the turn makes, including tool-loop iterations, whose trailing
+     * tool-result message is user-role but carries no injected blocks.
+     *
+     * Consumed by the Anthropic client only, where it selects the TTL of the
+     * turn-start breakpoint: short instead of long. The block is still marked,
+     * so the turn's tool-loop iterations read the prefix back and each hit
+     * refreshes the entry; nothing is spent on a long-TTL entry whose bytes
+     * change before the next turn could reach it. Holding the flag steady across
+     * the turn is what keeps that one boundary on a single TTL; marking it at
+     * two would bill two writes for one reusable prefix.
+     *
+     * The OpenAI Responses transport ignores the flag and marks every markable
+     * user item: a volatile message is fixed within its own turn, so the write is
+     * prepaid once and read back by each tool-loop iteration.
+     *
+     * Default false. Providers that place no message-level breakpoints, or that
+     * key their cache on a request-level identifier rather than message bytes,
+     * can ignore it.
      */
     mutableLatestUserMessage?: boolean;
     /**
@@ -6685,6 +6903,14 @@ export declare interface ToolContext {
      * @legacy
      */
     overrideProfile?: string;
+    /**
+     * The firing's `cron_runs.id` when a schedule triggered this turn, `null`
+     * otherwise. Tools that spawn further LLM work (`subagent_spawn`,
+     * `subagent_message`) forward it so the delegated usage rows carry the same
+     * stamp and attribute to the firing rather than dropping out of schedule
+     * cost reporting.
+     */
+    cronRunId?: string | null;
     /**
      * The LLM call site of the turn currently executing this tool (`mainAgent`,
      * `heartbeatAgent`, scheduled work, etc.). `subagent_spawn` reads it to
@@ -6696,10 +6922,12 @@ export declare interface ToolContext {
     invokingCallSite?: LLMCallSite;
     /**
      * Canonical principal ID of the actor on whose behalf this tool invocation
-     * is running. Sourced from `conversation.trustContext.guardianPrincipalId`.
+     * is running — the turn's actor principal, falling back to the trust
+     * context's `guardianPrincipalId` (see `resolveTurnActorPrincipalId`).
      * Used by host proxies to bind cross-client targeted execution to the same
-     * authenticated user identity. May be undefined for legacy/internal flows
-     * with no resolved actor identity.
+     * authenticated user identity, so it must resolve to the SAME principal a
+     * desktop client registers with on its SSE stream. May be undefined for
+     * legacy/internal flows with no resolved actor identity.
      * @legacy
      */
     sourceActorPrincipalId?: string;
@@ -6860,6 +7088,14 @@ export declare interface ToolExecutionResult {
     /** Structured activity metadata for client rendering (web search, web fetch, etc).
      *  Populated by daemon-internal tools; plugins must not set this. */
     activityMetadata?: ToolActivityMetadata;
+    /**
+     * Typed side channel from the `ask_question` executor to the agent loop: the
+     * questions asked and the answers the user gave. The loop forwards it on the
+     * `tool_result` event and persists it on the tool_use block, so the answered
+     * card renders live and survives a history reopen instead of the decision
+     * disappearing with the interactive prompt. Set only by `ask_question`.
+     */
+    answeredQuestion?: AnsweredQuestion;
 }
 
 export declare interface ToolResultContent {
@@ -7104,6 +7340,38 @@ declare interface WebFetchMetadata {
 /** Provider that backed a `web_fetch` call. `default` is the built-in fetcher. */
 declare type WebFetchProviderId = "default" | "firecrawl";
 
+/**
+ * Public URL resolution for a plugin's own ingress route.
+ *
+ * A plugin that receives third-party webhooks has to tell the vendor where to
+ * deliver. Which URL is correct depends on how the assistant is reachable:
+ * a platform pod and a platform-connected assistant are served through a
+ * managed callback route, while a self-hosted deployment is served through its
+ * configured public ingress. `ingress.publicBaseUrl` alone does not decide it,
+ * because on a platform-connected assistant that value holds the Velay tunnel
+ * address, which is not where plugin routes are served.
+ *
+ * `resolveCallbackUrl` owns that decision for every caller in the codebase
+ * (`webhooks register`, the Telegram webhook manager). This exposes it to
+ * plugins so there is one implementation rather than one per plugin.
+ */
+export declare interface WebhookUrlOptions {
+    /**
+     * Route path within the plugin's namespace, such as `"events-photon"`.
+     * Relative, with no leading slash.
+     */
+    path: string;
+    /**
+     * Plugin whose namespace the route belongs to.
+     *
+     * Defaults to the plugin in context, which covers hooks and tools. Supply it
+     * explicitly from a plugin route handler, where no context is established.
+     */
+    plugin?: string;
+    /** Human-readable label for the platform's admin display. */
+    sourceIdentifier?: string;
+}
+
 declare interface WebSearchMetadata {
     query: string;
     provider: WebSearchProviderId;

package/index.js

@@ -21,6 +21,7 @@ export const getAssistantName = api.getAssistantName;
 export const getConfiguredProvider = api.getConfiguredProvider;
 export const getConversation = api.getConversation;
 export const getConversationDirPath = api.getConversationDirPath;
+export const getConversationProcessingStartedAt = api.getConversationProcessingStartedAt;
 export const getDocument = api.getDocument;
 export const getMessages = api.getMessages;
 export const getModelProfiles = api.getModelProfiles;
@@ -44,6 +45,7 @@ export const removeDocument = api.removeDocument;
 export const resolveCredential = api.resolveCredential;
 export const resolveMediaSourceData = api.resolveMediaSourceData;
 export const resolveUserName = api.resolveUserName;
+export const resolveWebhookUrl = api.resolveWebhookUrl;
 export const runConversationTurn = api.runConversationTurn;
 export const searchMessageIdsLexical = api.searchMessageIdsLexical;
 export const selectedBackendSupportsMultimodal = api.selectedBackendSupportsMultimodal;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/plugin-api",
-  "version": "0.11.2",
+  "version": "0.11.3-staging.2",
   "description": "Public TypeScript authoring contract for Vellum assistant plugins.",
   "license": "MIT",
   "type": "module",