@vellumai/plugin-api 0.11.6 → 0.11.7-staging.1

package/index.d.ts

@@ -148,14 +148,29 @@ declare const AssistantConfigSchema: z.ZodObject<{
         stt: z.ZodDefault<z.ZodObject<{
             provider: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<{
                 vellum: "vellum";
+                "openai-whisper": "openai-whisper";
                 deepgram: "deepgram";
-                "deepgram-flux": "deepgram-flux";
                 "google-gemini": "google-gemini";
-                "openai-whisper": "openai-whisper";
                 xai: "xai";
             }>>;
             language: z.ZodDefault<z.ZodString>;
             providers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
+            roles: z.ZodDefault<z.ZodRecord<z.ZodEnum<{
+                watch: "watch";
+                liveVoice: "liveVoice";
+                telephony: "telephony";
+                dictation: "dictation";
+                batch: "batch";
+            }> & z.core.$partial, z.ZodObject<{
+                provider: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<{
+                    vellum: "vellum";
+                    "openai-whisper": "openai-whisper";
+                    deepgram: "deepgram";
+                    "google-gemini": "google-gemini";
+                    xai: "xai";
+                }>>;
+                model: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>>;
         tts: z.ZodDefault<z.ZodObject<{
             provider: z.ZodDefault<z.ZodEnum<{
@@ -181,9 +196,9 @@ declare const AssistantConfigSchema: z.ZodObject<{
                     referenceId: z.ZodDefault<z.ZodString>;
                     chunkLength: z.ZodDefault<z.ZodNumber>;
                     format: z.ZodDefault<z.ZodEnum<{
+                        opus: "opus";
                         mp3: "mp3";
                         wav: "wav";
-                        opus: "opus";
                     }>>;
                     latency: z.ZodDefault<z.ZodEnum<{
                         balanced: "balanced";
@@ -194,9 +209,9 @@ declare const AssistantConfigSchema: z.ZodObject<{
                 deepgram: z.ZodDefault<z.ZodObject<{
                     model: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
                     format: z.ZodDefault<z.ZodEnum<{
+                        opus: "opus";
                         mp3: "mp3";
                         wav: "wav";
-                        opus: "opus";
                     }>>;
                     languageVoices: z.ZodOptional<z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<{
                         [k: string]: string;
@@ -280,6 +295,24 @@ declare const AssistantConfigSchema: z.ZodObject<{
                 "your-own": "your-own";
             }>>;
         }, z.core.$strip>>;
+        "monday-oauth": z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                managed: "managed";
+                "your-own": "your-own";
+            }>>;
+        }, z.core.$strip>>;
+        "eventbrite-oauth": z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                managed: "managed";
+                "your-own": "your-own";
+            }>>;
+        }, z.core.$strip>>;
+        "calendly-oauth": z.ZodDefault<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                managed: "managed";
+                "your-own": "your-own";
+            }>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     memory: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
@@ -528,10 +561,6 @@ declare const AssistantConfigSchema: z.ZodObject<{
         }, 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>;
@@ -600,10 +629,10 @@ declare const AssistantConfigSchema: z.ZodObject<{
             model: z.ZodOptional<z.ZodString>;
             maxTokens: z.ZodOptional<z.ZodNumber>;
             effort: z.ZodOptional<z.ZodEnum<{
+                none: "none";
                 low: "low";
                 medium: "medium";
                 high: "high";
-                none: "none";
                 xhigh: "xhigh";
                 max: "max";
             }>>;
@@ -673,6 +702,7 @@ declare const AssistantConfigSchema: z.ZodObject<{
                 profile: z.ZodString;
                 weight: z.ZodNumber;
             }, z.core.$strip>>>;
+            fallbackProfile: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
         profileOrder: z.ZodDefault<z.ZodArray<z.ZodString>>;
         callSites: z.ZodDefault<z.ZodRecord<z.ZodEnum<{
@@ -723,10 +753,10 @@ declare const AssistantConfigSchema: z.ZodObject<{
             model: z.ZodOptional<z.ZodString>;
             maxTokens: z.ZodOptional<z.ZodNumber>;
             effort: z.ZodOptional<z.ZodEnum<{
+                none: "none";
                 low: "low";
                 medium: "medium";
                 high: "high";
-                none: "none";
                 xhigh: "xhigh";
                 max: "max";
             }>>;
@@ -1060,7 +1090,7 @@ declare const AssistantConfigSchema: z.ZodObject<{
             turnEnd: z.ZodDefault<z.ZodObject<{
                 enabled: z.ZodDefault<z.ZodBoolean>;
             }, z.core.$strip>>;
-            model: z.ZodDefault<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
             eotThreshold: z.ZodDefault<z.ZodNumber>;
             eagerEotThreshold: z.ZodOptional<z.ZodNumber>;
             eotTimeoutMs: z.ZodDefault<z.ZodNumber>;
@@ -1097,6 +1127,12 @@ declare const AssistantConfigSchema: z.ZodObject<{
             mention_then_thread: "mention_then_thread";
         }>>;
     }, z.core.$strip>>;
+    discord: z.ZodDefault<z.ZodObject<{
+        botUserId: z.ZodDefault<z.ZodString>;
+        botUsername: z.ZodDefault<z.ZodString>;
+        applicationId: z.ZodDefault<z.ZodString>;
+        inviteUrl: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
     a2a: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
@@ -1435,8 +1471,8 @@ declare const AssistantEventEnvelopeSchema: z.ZodObject<{
         }>;
         source: z.ZodEnum<{
             timeout: "timeout";
-            system: "system";
             button: "button";
+            system: "system";
             inline_nl: "inline_nl";
             auto_deny: "auto_deny";
         }>;
@@ -2679,11 +2715,11 @@ declare const AssistantEventPublishOptionsSchema: z.ZodObject<{
         a2a: "a2a";
         discord: "discord";
         plugin: "plugin";
+        web: "web";
+        ios: "ios";
         macos: "macos";
         windows: "windows";
-        ios: "ios";
         cli: "cli";
-        web: "web";
         "chrome-extension": "chrome-extension";
         route: "route";
     }>>;
@@ -2926,8 +2962,8 @@ declare const AssistantEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }>;
     source: z.ZodEnum<{
         timeout: "timeout";
-        system: "system";
         button: "button";
+        system: "system";
         inline_nl: "inline_nl";
         auto_deny: "auto_deny";
     }>;
@@ -4157,6 +4193,19 @@ declare interface CliCommandHelp {
     subcommands?: CliSubcommandHelp[];
 }
 
+/**
+ * Client OS surfaces — the value set for the message-body `clientOs` field.
+ *
+ * This is deliberately SEPARATE from {@link INTERFACE_IDS}: `clientOs`
+ * describes which OS the user's device runs, not which transport the turn
+ * arrived on. `"android"` (and `"ios"` for a mobile browser) are real OS
+ * surfaces but not transports — they must never answer transport questions
+ * (`supportsHostProxy`, `isInteractiveInterface`), so they live here rather
+ * than polluting the interface vocabulary. Drives only the per-turn
+ * `client_os` context line (e.g. app-builder mobile-first for `ios`/`android`).
+ */
+declare const CLIENT_OS_VALUES: readonly ["web", "ios", "macos", "windows", "android"];
+
 declare interface ClientEntry extends BaseSubscriberEntry {
     type: "client";
     clientId: string;
@@ -4185,6 +4234,8 @@ declare interface ClientEntry extends BaseSubscriberEntry {
     webPresence?: ClientWebPresence;
 }
 
+declare type ClientOs = (typeof CLIENT_OS_VALUES)[number];
+
 declare interface ClientPresence {
     state: DesktopPresenceState;
     /** When the daemon last heard from the client. Drives staleness. */
@@ -4320,7 +4371,7 @@ export declare interface ConversationRow {
     originInterface: string | null;
     forkParentConversationId: string | null;
     forkParentMessageId: string | null;
-    /** `"reference"` on referential forks; `"cloning"` or null on copied ones. */
+    /** `"reference"` on referential forks; null on copied ones. */
     forkStrategy: string | null;
     isAutoTitle: number;
     scheduleJobId: string | null;
@@ -4550,11 +4601,11 @@ export declare function getDocument(documentId: string): Promise<IndexedDocument
 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
- * alphabetically). Metadata-only entries without a provider, model, or mix are
- * not routing targets, so plugins never see them. Disabled profiles are
- * included and flagged via
+ * List the workspace inference profiles a plugin can route to, in the order a
+ * user-facing model picker presents them (`llm.profileOrder` first, then the
+ * rest alphabetically). Managed backup routes are internal and omitted.
+ * Metadata-only entries without a provider, model, or mix are not routing
+ * targets, so plugins never see them. Disabled profiles are included and flagged via
  * {@link ModelProfileInfo.isDisabled}; weighted "mix" profiles are included and
  * flagged via {@link ModelProfileInfo.isMix}, since a mix is itself a valid
  * routing target (it resolves to one constituent per conversation).
@@ -4943,6 +4994,12 @@ declare interface LiveVoiceAssistantTextDeltaServerFrame extends LiveVoiceServer
 declare interface LiveVoiceBusyServerFrame extends LiveVoiceServerFrameBase {
     readonly type: "busy";
     readonly activeSessionId: string;
+    /**
+     * Absent from daemons that predate it, and from a holder that revealed
+     * neither field, so a client must degrade to the unspecific copy rather
+     * than assume.
+     */
+    readonly holder?: LiveVoiceSessionHolder;
 }
 
 export declare interface LiveVoiceConnection {
@@ -5087,6 +5144,23 @@ declare interface LiveVoiceReadyServerFrame extends LiveVoiceServerFrameBase {
      * (older daemons) means "manual".
      */
     readonly turnDetection?: LiveVoiceTurnDetectionMode;
+    /**
+     * Whether this daemon will accept `text` frames on the session. Absent
+     * (older daemons) means no, which is what lets a client that asked for
+     * `textInput` fall back rather than type into a socket that would answer
+     * every typed turn with an `unknown_type` error.
+     */
+    readonly textInput?: boolean;
+    /**
+     * Whether the session's speech-to-text leg is live. Absent means yes, which
+     * is the only thing an older daemon can have meant: it rejects a session it
+     * cannot transcribe, so every session it readies can hear.
+     *
+     * False is reachable only for a client that declared `textInput`, and tells
+     * it to present the session as typed rather than draw a microphone that
+     * will never hear anything.
+     */
+    readonly audioInput?: boolean;
 }
 
 export declare type LiveVoiceServerFrame = LiveVoiceReadyServerFrame | LiveVoiceBusyServerFrame | LiveVoiceSpeechStartedServerFrame | LiveVoiceUtteranceEndServerFrame | LiveVoiceUtteranceDiscardedServerFrame | LiveVoiceSttPartialServerFrame | LiveVoiceSttFinalServerFrame | LiveVoiceThinkingServerFrame | LiveVoiceActivityServerFrame | LiveVoiceAssistantTextDeltaServerFrame | LiveVoiceTtsAudioServerFrame | LiveVoiceTtsDoneServerFrame | LiveVoiceTurnCancelledServerFrame | LiveVoiceMinimizeRoomServerFrame | LiveVoiceMetricsServerFrame | LiveVoiceArchivedServerFrame | LiveVoiceErrorServerFrame;
@@ -5100,6 +5174,27 @@ declare type LiveVoiceServerFrameType = (typeof _LIVE_VOICE_SERVER_FRAME_TYPES)[
 
 export declare type LiveVoiceSessionCloseReason = "client_end" | "error" | "websocket_close" | "transport_closed" | "client_timeout" | "forced_end" | "manager_shutdown";
 
+/**
+ * Where the session holding the daemon's single live-voice slot is running,
+ * as much of it as the daemon knows.
+ *
+ * Display only: it is what lets a client refused a session say where the one
+ * that blocked it is. Nothing routes, authorizes, or decides capability on
+ * it, and every field is optional, so a holder that names neither its surface
+ * nor a conversation is simply less specific.
+ */
+declare interface LiveVoiceSessionHolder {
+    /**
+     * The OS surface the holder is running on, from its `start` frame. A
+     * {@link ClientOs} carries no transport meaning by contract (see
+     * `channels/types.ts`), which is exactly right for a label: it says which
+     * device the user should go looking on, and answers nothing else.
+     */
+    readonly client?: ClientOs;
+    /** The conversation the holder is talking in, once it has one. */
+    readonly conversationId?: string;
+}
+
 /**
  * Emitted when the server VAD detects user speech. The client MUST
  * immediately stop local TTS playback — this doubles as the flush-tail-audio
@@ -5278,8 +5373,8 @@ declare const messageMetadataSchema: z.ZodObject<{
         discord: "discord";
         plugin: "plugin";
     }>>;
-    userMessageInterface: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"phone" | "telegram" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "plugin" | "macos" | "windows" | "ios" | "cli" | "web" | "chrome-extension" | "route" | null, string>> & z.ZodType<"phone" | "telegram" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "plugin" | "macos" | "windows" | "ios" | "cli" | "web" | "chrome-extension" | "route", string, z.core.$ZodTypeInternals<"phone" | "telegram" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "plugin" | "macos" | "windows" | "ios" | "cli" | "web" | "chrome-extension" | "route", string>>>;
-    assistantMessageInterface: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"phone" | "telegram" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "plugin" | "macos" | "windows" | "ios" | "cli" | "web" | "chrome-extension" | "route" | null, string>> & z.ZodType<"phone" | "telegram" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "plugin" | "macos" | "windows" | "ios" | "cli" | "web" | "chrome-extension" | "route", string, z.core.$ZodTypeInternals<"phone" | "telegram" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "plugin" | "macos" | "windows" | "ios" | "cli" | "web" | "chrome-extension" | "route", string>>>;
+    userMessageInterface: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"phone" | "telegram" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "plugin" | "web" | "ios" | "macos" | "windows" | "cli" | "chrome-extension" | "route" | null, string>> & z.ZodType<"phone" | "telegram" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "plugin" | "web" | "ios" | "macos" | "windows" | "cli" | "chrome-extension" | "route", string, z.core.$ZodTypeInternals<"phone" | "telegram" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "plugin" | "web" | "ios" | "macos" | "windows" | "cli" | "chrome-extension" | "route", string>>>;
+    assistantMessageInterface: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"phone" | "telegram" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "plugin" | "web" | "ios" | "macos" | "windows" | "cli" | "chrome-extension" | "route" | null, string>> & z.ZodType<"phone" | "telegram" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "plugin" | "web" | "ios" | "macos" | "windows" | "cli" | "chrome-extension" | "route", string, z.core.$ZodTypeInternals<"phone" | "telegram" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "plugin" | "web" | "ios" | "macos" | "windows" | "cli" | "chrome-extension" | "route", string>>>;
     client: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     clientOsFromRequest: z.ZodOptional<z.ZodBoolean>;
     subagentNotification: z.ZodOptional<z.ZodObject<{
@@ -5925,6 +6020,15 @@ export declare interface ProviderResponse {
     model: string;
     /** Provider that actually produced this response, which may differ from a wrapper provider name. */
     actualProvider?: string;
+    /**
+     * Inference profile key that actually governed this response when a
+     * wrapper re-routed the request away from the caller's own resolution
+     * (`RetryProvider`'s fallback-route escalation). `UsageTrackingProvider`
+     * prefers this over re-resolving from the original request options, so a
+     * successful fallback serve is attributed to the backup profile rather
+     * than the failed primary's. Absent on the normal (non-rerouted) path.
+     */
+    actualInferenceProfile?: string;
     /**
      * Base URL the provider's HTTP client actually resolved to for this request,
      * read from the live SDK client instance rather than re-derived from config.
@@ -6174,6 +6278,8 @@ export declare interface ResolvedSkillEntry {
     avoidWhen?: string[];
     /** True when the skill is pinned into the memory selector pool every turn. */
     alwaysCandidate?: boolean;
+    /** Host operating systems on which this skill may be used. */
+    platforms?: SkillPlatform[];
     /** True for locally installed skills; false for remote catalog entries. */
     installed: boolean;
     /** Where the installed skill comes from. Unset for remote catalog entries. */
@@ -6445,6 +6551,18 @@ export declare interface SendMessageConfig {
      * request.
      */
     forceOverrideProfile?: boolean;
+    /**
+     * True when the caller appended {@link NATIVE_WEB_SEARCH_TOOL_NAME} purely
+     * to activate the route's provider-native web search, rather than passing an
+     * app-executed search tool of the same name (which is what runs when a
+     * search backend like Brave or the platform search proxy is configured).
+     * Only the caller can tell those apart, and a route change after that
+     * decision has to: `RetryProvider` drops the tool on a backup that runs no
+     * native search, and must not touch it when the daemon executes it itself.
+     * A resolution/routing-time concern only; stripped before any provider wire
+     * request.
+     */
+    nativeWebSearchSentinel?: boolean;
     /**
      * Per-conversation seed for deterministic `mix`-profile expansion. The agent
      * loop sets this to the conversation id so every resolver call this send
@@ -6480,6 +6598,14 @@ export declare interface SendMessageConfig {
      * JSON request bodies.
      */
     usageAttributionHeaders?: Record<string, string>;
+    /**
+     * Per-request HTTP headers merged onto the transport. `RetryProvider`
+     * stamps these for providers that need support-lookup headers (OpenCode
+     * `x-opencode-session` / `x-opencode-request`). Provider clients pass
+     * them through SDK request options only and must never include this
+     * object in provider JSON request bodies.
+     */
+    requestHeaders?: Record<string, string>;
     /**
      * Controls local usage-ledger writes for attributed provider calls.
      * Defaults to `auto`; conversation paths that aggregate usage separately
@@ -6602,6 +6728,8 @@ export declare interface ShutdownContext {
  */
 declare type ShutdownReason = "shutdown" | "uninstall" | "disable" | "reload";
 
+declare const SKILL_PLATFORM_VALUES: readonly ["macos", "windows", "linux"];
+
 declare interface SkillInstallMeta {
     origin: "vellum" | "clawhub" | "skillssh" | "custom";
     installedAt: string;
@@ -6617,6 +6745,8 @@ declare interface SkillInstallMeta {
     lastUsedAt?: string;
 }
 
+declare type SkillPlatform = (typeof SKILL_PLATFORM_VALUES)[number];
+
 /**
  * Origin of a skill in the merged catalog.
  *
@@ -6817,28 +6947,33 @@ export declare type SttErrorCategory =
 | "provider-error";
 
 /**
- * Provider-agnostic speech-to-text domain types for daemon transcription.
+ * Catalog identity for a daemon-hosted STT backend.
  *
- * These types define the boundary between callers that need audio transcription
- * and the concrete STT provider implementations. The goal is to let daemon
- * callsites program against a single typed interface so that provider swaps are
- * localized to the adapter layer.
+ * This is the key capability is stored under, NOT the set of values a user may
+ * put in `services.stt.provider`. A provider that offers more than one model
+ * family with genuinely different capabilities gets a row per family, because
+ * the catalog is a capability matrix and those capabilities differ. Users
+ * select the family with `services.stt.providers.<id>.model`, and
+ * {@link resolveSttCatalogKey} maps that pair onto the row.
  *
- * Two execution modes are supported:
- * - **Batch** — a single audio buffer is sent and a final transcript returned.
- * - **Streaming** — audio chunks are sent over a persistent session, and the
- *   provider emits partial/final transcript events in real time.
- */
-/**
- * Canonical provider identifiers for daemon-hosted STT backends.
- * Extend this union as new providers are integrated.
+ * Keeping the two apart bounds the user-facing surface: adding a model family
+ * costs a catalog row and nothing else, while adding a provider id costs an
+ * enum entry, a settings-picker row, and a place in every predicate that
+ * classifies providers.
  */
 export declare type SttProviderId = "openai-whisper" | "deepgram"
 /**
 * Deepgram's Flux conversational speech model. Shares the `deepgram`
 * credential and is streaming-only: Flux has no batch endpoint.
 */
-| "deepgram-flux" | "google-gemini" | "xai" | "vellum";
+| "deepgram-flux" | "google-gemini" | "xai" | "vellum"
+/**
+* Managed Flux: the same conversational model as `deepgram-flux`, reached
+* through the platform's speech relay instead of a Deepgram key. Dials the
+* relay's STT v2 endpoint asking for native Flux frames, so it keeps the
+* turn events the relay's default v1-shaped translation drops.
+*/
+| "vellum-flux";
 
 /** The streaming session has closed (no more events will be emitted). */
 export declare interface SttStreamServerClosedEvent {
@@ -7284,6 +7419,12 @@ export declare interface ToolContext {
      * @legacy
      */
     requesterIdentifier?: string;
+    /**
+     * Contact ID of the requester's member record. Approval resolution looks
+     * up this contact's auto-approve ceiling from the gateway at use time.
+     * @legacy
+     */
+    requesterContactId?: string;
     /**
      * Preferred display name for the requester.
      * @legacy
@@ -7323,6 +7464,8 @@ export declare interface ToolContext {
      * @legacy
      */
     transportInterface?: InterfaceId;
+    /** Operating system reported by the client for the current turn. */
+    clientOs?: ClientOs;
     /**
      * The per-turn inference-profile override the agent loop is currently
      * running under, propagated through tool context so subagent-spawn tools
@@ -7423,6 +7566,13 @@ declare const ToolDefinitionSchema: z.ZodObject<{
         sandbox: "sandbox";
         host: "host";
     }>>;
+    supportedClientOs: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        web: "web";
+        ios: "ios";
+        macos: "macos";
+        windows: "windows";
+        android: "android";
+    }>>>;
     execute: z.ZodOptional<z.ZodCustom<(input: Record<string, unknown>, context: ToolContext) => Promise<ToolExecutionResult>, (input: Record<string, unknown>, context: ToolContext) => Promise<ToolExecutionResult>>>;
     exclusive: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;

package/package.json

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