@vellumai/plugin-api 0.11.3 → 0.11.4-staging.1

package/index.d.ts

@@ -147,6 +147,7 @@ declare const AssistantConfigSchema: z.ZodObject<{
             provider: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<{
                 vellum: "vellum";
                 deepgram: "deepgram";
+                "deepgram-flux": "deepgram-flux";
                 "google-gemini": "google-gemini";
                 "openai-whisper": "openai-whisper";
                 xai: "xai";
@@ -593,24 +594,7 @@ declare const AssistantConfigSchema: z.ZodObject<{
     }, z.core.$strip>>;
     llm: z.ZodDefault<z.ZodObject<{
         profiles: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
-            provider: z.ZodOptional<z.ZodEnum<{
-                openai: "openai";
-                anthropic: "anthropic";
-                gemini: "gemini";
-                fireworks: "fireworks";
-                together: "together";
-                poolside: "poolside";
-                openrouter: "openrouter";
-                "vercel-ai-gateway": "vercel-ai-gateway";
-                ollama: "ollama";
-                "openai-compatible": "openai-compatible";
-                litellm: "litellm";
-                minimax: "minimax";
-                atlascloud: "atlascloud";
-                baseten: "baseten";
-                vellum: "vellum";
-                chatgpt: "chatgpt";
-            }>>;
+            provider: z.ZodOptional<z.ZodString>;
             model: z.ZodOptional<z.ZodString>;
             maxTokens: z.ZodOptional<z.ZodNumber>;
             effort: z.ZodOptional<z.ZodEnum<{
@@ -725,31 +709,14 @@ declare const AssistantConfigSchema: z.ZodObject<{
             skillCategoryInference: "skillCategoryInference";
             inference: "inference";
             vision: "vision";
-            voiceFrontDecision: "voiceFrontDecision";
+            voiceProgressNarration: "voiceProgressNarration";
             voiceFrontDoor: "voiceFrontDoor";
             trustRuleSuggestion: "trustRuleSuggestion";
             homeGreeting: "homeGreeting";
             homeSuggestedPrompts: "homeSuggestedPrompts";
             workflowLeaf: "workflowLeaf";
         }> & z.core.$partial, z.ZodObject<{
-            provider: z.ZodOptional<z.ZodEnum<{
-                openai: "openai";
-                anthropic: "anthropic";
-                gemini: "gemini";
-                fireworks: "fireworks";
-                together: "together";
-                poolside: "poolside";
-                openrouter: "openrouter";
-                "vercel-ai-gateway": "vercel-ai-gateway";
-                ollama: "ollama";
-                "openai-compatible": "openai-compatible";
-                litellm: "litellm";
-                minimax: "minimax";
-                atlascloud: "atlascloud";
-                baseten: "baseten";
-                vellum: "vellum";
-                chatgpt: "chatgpt";
-            }>>;
+            provider: z.ZodOptional<z.ZodString>;
             model: z.ZodOptional<z.ZodString>;
             maxTokens: z.ZodOptional<z.ZodNumber>;
             effort: z.ZodOptional<z.ZodEnum<{
@@ -816,22 +783,7 @@ declare const AssistantConfigSchema: z.ZodObject<{
         advisorProfile: z.ZodOptional<z.ZodString>;
         defaultProvider: z.ZodCatch<z.ZodOptional<z.ZodObject<{
             provider: z.ZodEnum<{
-                openai: "openai";
-                anthropic: "anthropic";
-                gemini: "gemini";
-                fireworks: "fireworks";
-                together: "together";
-                poolside: "poolside";
-                openrouter: "openrouter";
-                "vercel-ai-gateway": "vercel-ai-gateway";
-                ollama: "ollama";
-                "openai-compatible": "openai-compatible";
-                litellm: "litellm";
-                minimax: "minimax";
-                atlascloud: "atlascloud";
-                baseten: "baseten";
-                vellum: "vellum";
-                chatgpt: "chatgpt";
+                [x: string]: string;
             }>;
             connectionName: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
@@ -1091,8 +1043,6 @@ declare const AssistantConfigSchema: z.ZodObject<{
             endpointDecisionTimeoutMs: z.ZodDefault<z.ZodNumber>;
             endpointExtensionMs: z.ZodDefault<z.ZodNumber>;
             endpointMaxExtensions: z.ZodDefault<z.ZodNumber>;
-            ackFirstDeltaTimeoutMs: z.ZodDefault<z.ZodNumber>;
-            ackGenerationTimeoutMs: z.ZodDefault<z.ZodNumber>;
             progress: z.ZodDefault<z.ZodObject<{
                 enabled: z.ZodDefault<z.ZodBoolean>;
                 opsThreshold: z.ZodDefault<z.ZodNumber>;
@@ -1103,6 +1053,15 @@ declare const AssistantConfigSchema: z.ZodObject<{
                 generationTimeoutMs: z.ZodDefault<z.ZodNumber>;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
+        flux: z.ZodDefault<z.ZodObject<{
+            turnEnd: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            model: z.ZodDefault<z.ZodString>;
+            eotThreshold: z.ZodDefault<z.ZodNumber>;
+            eagerEotThreshold: z.ZodOptional<z.ZodNumber>;
+            eotTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
         maxSessionDurationSeconds: z.ZodDefault<z.ZodNumber>;
         archiveAudio: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
@@ -1251,6 +1210,12 @@ declare const AssistantEventEnvelopeSchema: z.ZodObject<{
     seq: z.ZodOptional<z.ZodNumber>;
     emittedAt: z.ZodString;
     message: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"acp_auth_required">;
+        acpSessionId: z.ZodString;
+        authCode: z.ZodString;
+        agent: z.ZodString;
+        parentToolUseId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
         type: z.ZodLiteral<"acp_session_completed">;
         acpSessionId: z.ZodString;
         stopReason: z.ZodEnum<{
@@ -2671,6 +2636,7 @@ declare const AssistantEventPublishOptionsSchema: z.ZodObject<{
     }>>;
     targetClientId: z.ZodOptional<z.ZodString>;
     targetInterfaceId: z.ZodOptional<z.ZodEnum<{
+        plugin: "plugin";
         telegram: "telegram";
         phone: "phone";
         whatsapp: "whatsapp";
@@ -2702,6 +2668,12 @@ declare const AssistantEventPublishOptionsSchema: z.ZodObject<{
  * migration recipe.
  */
 declare const AssistantEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"acp_auth_required">;
+    acpSessionId: z.ZodString;
+    authCode: z.ZodString;
+    agent: z.ZodString;
+    parentToolUseId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
     type: z.ZodLiteral<"acp_session_completed">;
     acpSessionId: z.ZodString;
     stopReason: z.ZodEnum<{
@@ -4040,6 +4012,41 @@ declare interface BaseSubscriberEntry {
  */
 export declare function buildMessageExcerpt(rawContent: string, query: string): Promise<string>;
 
+/**
+ * Canonical channel-id vocabulary shared between the assistant daemon and the
+ * gateway.
+ *
+ * A "channel" is an external messaging surface an actor can reach the
+ * assistant through (Slack, Telegram, WhatsApp, phone, …) plus a couple of
+ * internal ids (`vellum` for native app conversations, `platform` for the
+ * internal control plane). This is the single source of truth for that set:
+ *
+ * One id, `plugin`, does not name a surface: it names *every* surface a plugin
+ * brings. A plugin channel's real identity is the plugin, which is workspace
+ * state and cannot be a compile-time union member, so the plugin name travels
+ * in `sourceMetadata.plugin` and is prefixed onto every external id the gateway
+ * forwards (`imessage:+15551234567`). Two plugins therefore share a channel
+ * row — one admission floor, one set of channel-wide defaults — while their
+ * conversations, contacts, and trust records stay disjoint. See
+ * `gateway/src/channels/plugin-inbound.ts` for what that concedes.
+ *
+ * the assistant adopts it wholesale as its `ChannelId`, and the gateway
+ * asserts its own (narrower) inbound list is a subset of it so the two sides
+ * cannot silently drift.
+ *
+ * Both packages depend on `@vellumai/service-contracts`, so hoisting the set
+ * here (rather than maintaining a copy on each side) means adding or renaming
+ * a channel happens in exactly one place.
+ *
+ * Note that a consumer may legitimately handle only a *subset* of these — the
+ * gateway, for example, never ingresses `platform`. Use a local list guarded
+ * by `satisfies readonly ChannelId[]` for those cases rather than redefining
+ * the union.
+ */
+declare const CHANNEL_IDS: readonly ["telegram", "phone", "vellum", "whatsapp", "slack", "email", "platform", "a2a", "discord", "plugin"];
+
+declare type ChannelId = (typeof CHANNEL_IDS)[number];
+
 export declare const CLI_COMMAND_HELP: readonly CliCommandHelp[];
 
 declare interface CliArgumentHelp {
@@ -4145,6 +4152,43 @@ declare type ConfiguredProviderOptions = Pick<ResolveCallSiteOpts, "overrideProf
 
 export declare type ContentBlock = TextContent | ThinkingContent | RedactedThinkingContent | ImageContent | FileContent | ToolUseContent | ToolResultContent | ServerToolUseContent | WebSearchToolResultContent | UiSurfaceContent;
 
+/**
+ * The chat a turn belongs to, in the channel's own terms.
+ *
+ * Supplied instead of a `conversationId` when the caller knows where the
+ * message came from but not which conversation that is. The pair resolves to
+ * the same conversation an inbound message on those coordinates would land
+ * in, because it resolves through the same binding.
+ *
+ * That sameness is the reason this exists at all. A caller could keep its own
+ * `externalChatId -> conversationId` map and pass the id, and turns would run
+ * in the right place. What it could not do is make the rest of the assistant
+ * agree: conversation reset is addressed by channel coordinates
+ * (`handleDeleteConversation`), the deny lanes attach an access-request card
+ * by them (`findInboundConversationId`), and the conversation and session
+ * APIs read the channel, chat name and sender off the external binding. A
+ * private map is a second name for the same conversation, and everything
+ * keyed on the public one quietly misses.
+ */
+export declare interface ConversationChannelAddress {
+    /** Channel the message arrived on. */
+    sourceChannel: ChannelId;
+    /** The chat, in the channel's own id space. */
+    externalChatId: string;
+    /**
+     * Thread within the chat, where the channel has threads. Only Slack and
+     * Telegram scope a conversation by thread; elsewhere this is carried as
+     * binding metadata and does not split the conversation.
+     */
+    externalThreadId?: string | null;
+    /** Human-readable chat name, for the conversation list. */
+    externalChatName?: string | null;
+    /** Who sent it, in the channel's id space. */
+    externalUserId?: string | null;
+    displayName?: string | null;
+    username?: string | null;
+}
+
 /** How a conversation was created / its execution mode. */
 declare type ConversationCreateType = "standard" | "background" | "scheduled";
 
@@ -4613,7 +4657,7 @@ declare interface InsertedMessage {
     deduplicated: boolean;
 }
 
-declare const INTERFACE_IDS: readonly ["macos", "ios", "cli", "telegram", "phone", "web", "whatsapp", "slack", "email", "chrome-extension", "a2a", "discord", "route"];
+declare const INTERFACE_IDS: readonly ["macos", "ios", "cli", "telegram", "phone", "web", "whatsapp", "slack", "email", "chrome-extension", "a2a", "discord", "route", "plugin"];
 
 declare type InterfaceId = (typeof INTERFACE_IDS)[number];
 
@@ -4834,14 +4878,34 @@ declare interface LiveVoiceMetricsServerFrame extends LiveVoiceServerFrameBase {
     /** End-of-speech (utterance_end, or ptt_release in manual mode) to first TTS audio. */
     readonly roundTripMs: number | null;
     readonly totalMs: number | null;
+    /**
+     * End-of-turn latency: the local VAD speech-stop mark to the moment the
+     * turn committed. Recorded on every committed turn, and measured from the
+     * same anchor whichever decider owned the boundary, so front-door and Flux
+     * turns are one comparable population. Absent on a turn that never
+     * committed and in push-to-talk mode, where there is no local VAD
+     * speech-stop mark.
+     */
+    readonly endpointCommitLatencyMs?: number;
     /**
      * Semantic-endpointing "hold" decisions taken during the turn. Present only
      * when the endpoint decider was consulted (otherwise the field is absent,
      * keeping frames unchanged).
      */
     readonly endpointHoldCount?: number;
-    /** Worst endpoint-decision latency observed during the turn. */
+    /**
+     * Worst endpoint-decision latency observed during the turn. It spans only
+     * the decider's own work, and the two deciders start it at different
+     * moments, so it is a diagnostic rather than a cross-path comparison: read
+     * `endpointCommitLatencyMs` for that.
+     */
     readonly endpointDecisionMaxLatencyMs?: number;
+    /**
+     * Which path decided the turn's endpoint: the front-door hold verdict or
+     * the STT provider's model-integrated end-of-turn. Present under the same
+     * condition as the two fields above.
+     */
+    readonly endpointDecisionSource?: "front-door" | "provider";
     /** Which floor-holding ack actually spoke during the turn, if any. */
     readonly ackSpoken?: "first_delta" | "tool_use";
     /**
@@ -5015,7 +5079,7 @@ declare const LLMCallSiteEnum: z.ZodEnum<{
     skillCategoryInference: "skillCategoryInference";
     inference: "inference";
     vision: "vision";
-    voiceFrontDecision: "voiceFrontDecision";
+    voiceProgressNarration: "voiceProgressNarration";
     voiceFrontDoor: "voiceFrontDoor";
     trustRuleSuggestion: "trustRuleSuggestion";
     homeGreeting: "homeGreeting";
@@ -5058,6 +5122,7 @@ declare type MessageMetadata_2 = z.infer<typeof messageMetadataSchema>;
 
 declare const messageMetadataSchema: z.ZodObject<{
     userMessageChannel: z.ZodOptional<z.ZodEnum<{
+        plugin: "plugin";
         vellum: "vellum";
         platform: "platform";
         telegram: "telegram";
@@ -5069,6 +5134,7 @@ declare const messageMetadataSchema: z.ZodObject<{
         discord: "discord";
     }>>;
     assistantMessageChannel: z.ZodOptional<z.ZodEnum<{
+        plugin: "plugin";
         vellum: "vellum";
         platform: "platform";
         telegram: "telegram";
@@ -5079,8 +5145,8 @@ declare const messageMetadataSchema: z.ZodObject<{
         a2a: "a2a";
         discord: "discord";
     }>>;
-    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>>>;
+    userMessageInterface: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"plugin" | "telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "macos" | "ios" | "cli" | "web" | "chrome-extension" | "route" | null, string>> & z.ZodType<"plugin" | "telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "macos" | "ios" | "cli" | "web" | "chrome-extension" | "route", string, z.core.$ZodTypeInternals<"plugin" | "telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "macos" | "ios" | "cli" | "web" | "chrome-extension" | "route", string>>>;
+    assistantMessageInterface: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<"plugin" | "telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "macos" | "ios" | "cli" | "web" | "chrome-extension" | "route" | null, string>> & z.ZodType<"plugin" | "telegram" | "phone" | "whatsapp" | "slack" | "email" | "a2a" | "discord" | "macos" | "ios" | "cli" | "web" | "chrome-extension" | "route", string, z.core.$ZodTypeInternals<"plugin" | "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<{
@@ -5108,6 +5174,7 @@ declare const messageMetadataSchema: z.ZodObject<{
     }>>;
     model: z.ZodOptional<z.ZodString>;
     provenanceSourceChannel: z.ZodOptional<z.ZodEnum<{
+        plugin: "plugin";
         vellum: "vellum";
         platform: "platform";
         telegram: "telegram";
@@ -5804,7 +5871,7 @@ export declare const REFUSAL_FALLBACK_TEXT = "Sorry \u2014 I wasn't able to gene
 /** Remove one document from the calling plugin's index. */
 export declare function removeDocument(documentId: string): Promise<void>;
 
-declare type ResolutionFallbackReason = "missing" | "disabled" | "incomplete";
+declare type ResolutionFallbackReason = "missing" | "disabled" | "incomplete" | "unresolvable";
 
 /**
  * Resolves a fully-specified `LLMConfigBase` for a given call site.
@@ -5860,6 +5927,15 @@ declare type ResolutionFallbackReason = "missing" | "disabled" | "incomplete";
  */
 declare interface ResolveCallSiteOpts {
     overrideProfile?: string;
+    /**
+     * Whether a profile's provider value can actually dispatch: a known
+     * vendor, or a connection entry row. Selection is pure and DB-blind, so
+     * dispatch-side callers supply this (see `dispatchProviderResolvable` in
+     * `connection-resolution.ts`); a profile failing it is unusable and
+     * selection falls through to the next rung, keeping model and transport
+     * coherent. When absent, every provider is assumed resolvable.
+     */
+    isResolvableProvider?: (provider: string) => boolean;
     /**
      * Float `overrideProfile` above the call-site layers for non-main-agent call
      * sites. Retained for API compatibility; under single-winner selection the
@@ -5966,6 +6042,21 @@ export declare function resolveMediaSourceData(source: MediaSource_2): {
     media_type: string;
 } | null;
 
+/**
+ * Resolve the redirect URI an authorization server should send the user
+ * back to.
+ *
+ * Takes no arguments on purpose: every caller shares one route, so there
+ * is nothing to vary. That is what makes the URI stable across callers and
+ * across attempts, which is what an exact-match `redirect_uri` check needs.
+ *
+ * @throws when no public ingress is configured and the assistant is not
+ *   connected to the platform. There is no URL that would work in that
+ *   case, and returning a plausible one produces an authorization request
+ *   whose callback silently never arrives.
+ */
+export declare function resolveOauthCallbackUrl(): Promise<string>;
+
 /**
  * Read the user's display name from the guardian's persona file
  * (`users/<slug>.md`, resolved via the guardian-delivery binding), falling
@@ -6022,9 +6113,22 @@ export declare function runConversationTurn(options: RunConversationTurnOptions)
 export declare interface RunConversationTurnOptions {
     /**
      * Conversation to run the turn in. If omitted, a new conversation is
-     * created (its ID is generated with `uuidv7` and returned in the result).
+     * created (its ID is generated with `uuidv7` and returned in the result),
+     * unless {@link RunConversationTurnOptions.channel} says which chat this
+     * belongs to, in which case that chat's conversation is used.
      */
     conversationId?: string;
+    /**
+     * The chat this turn belongs to, resolved to a conversation and bound to
+     * the channel. See {@link ConversationChannelAddress}.
+     *
+     * Ignored when `conversationId` is given: an explicit conversation is the
+     * caller saying which one, and re-resolving would overrule it. A caller
+     * that wants both the binding and a conversation of its own choosing is
+     * describing two different conversations, which is a bug worth surfacing
+     * as one rather than silently picking a winner.
+     */
+    channel?: ConversationChannelAddress;
     /**
      * User message content blocks for this turn. Text blocks become the
      * user message body; image/file blocks are resolved to inline
@@ -6511,13 +6615,32 @@ export declare type SttErrorCategory =
  * Canonical provider identifiers for daemon-hosted STT backends.
  * Extend this union as new providers are integrated.
  */
-export declare type SttProviderId = "openai-whisper" | "deepgram" | "google-gemini" | "xai" | "vellum";
+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";
 
 /** The streaming session has closed (no more events will be emitted). */
 export declare interface SttStreamServerClosedEvent {
     readonly type: "closed";
 }
 
+/**
+ * The provider's turn model speculates the user has finished, ahead of its
+ * committed end-of-turn decision. A {@link SttStreamServerTurnResumedEvent}
+ * retracts the speculation; a {@link SttStreamServerTurnEndEvent} confirms it.
+ *
+ * Emitted only by providers with model-integrated turn detection; providers
+ * without it never emit these.
+ */
+export declare interface SttStreamServerEagerTurnEndEvent {
+    readonly type: "eager-turn-end";
+    /** Transcript text as of the speculated turn end. */
+    readonly text: string;
+}
+
 /** An error occurred during streaming transcription. */
 export declare interface SttStreamServerErrorEvent {
     readonly type: "error";
@@ -6534,7 +6657,7 @@ export declare interface SttStreamServerErrorEvent {
  * and final transcripts, errors, and session lifecycle signals in a
  * type-safe manner.
  */
-export declare type SttStreamServerEvent = SttStreamServerPartialEvent | SttStreamServerFinalEvent | SttStreamServerFinalizedEvent | SttStreamServerErrorEvent | SttStreamServerClosedEvent;
+export declare type SttStreamServerEvent = SttStreamServerPartialEvent | SttStreamServerFinalEvent | SttStreamServerFinalizedEvent | SttStreamServerTurnStartEvent | SttStreamServerEagerTurnEndEvent | SttStreamServerTurnResumedEvent | SttStreamServerTurnEndEvent | SttStreamServerErrorEvent | SttStreamServerClosedEvent;
 
 /**
  * A final (committed) transcript — this segment will not be revised.
@@ -6600,6 +6723,59 @@ export declare interface SttStreamServerPartialEvent {
     readonly languages?: readonly string[];
 }
 
+/**
+ * The provider's turn model committed an end of turn: the user has finished
+ * speaking and a reply can be dispatched.
+ *
+ * Emitted only by providers with model-integrated turn detection; providers
+ * without it never emit these.
+ */
+export declare interface SttStreamServerTurnEndEvent {
+    readonly type: "turn-end";
+    /** Committed transcript text for the completed turn. */
+    readonly text: string;
+    /**
+     * Provider-emitted end-of-turn confidence in [0, 1]. Undefined when the
+     * provider does not surface a score.
+     */
+    readonly confidence?: number;
+    /**
+     * Provider's index for the turn being closed, matching the
+     * {@link SttStreamServerTurnStartEvent} that opened it. A consumer can
+     * compare it against the newest turn it has seen opened to tell an
+     * end-of-turn for the turn still in progress from one the provider has
+     * already superseded. Undefined when the provider does not number its
+     * turns.
+     */
+    readonly turnIndex?: number;
+}
+
+/**
+ * The user kept speaking after an {@link SttStreamServerEagerTurnEndEvent},
+ * retracting the speculated turn end.
+ *
+ * Emitted only by providers with model-integrated turn detection; providers
+ * without it never emit these.
+ */
+export declare interface SttStreamServerTurnResumedEvent {
+    readonly type: "turn-resumed";
+}
+
+/**
+ * The provider's turn model detected the start of a user turn.
+ *
+ * Emitted only by providers with model-integrated turn detection; providers
+ * without it never emit these.
+ */
+export declare interface SttStreamServerTurnStartEvent {
+    readonly type: "turn-start";
+    /**
+     * Provider's index for the turn being opened, monotonically increasing
+     * within a stream. Undefined when the provider does not number its turns.
+     */
+    readonly turnIndex?: number;
+}
+
 declare type SubscriberEntry = ClientEntry | ProcessEntry;
 
 /** Input shape for `subscribe()` — hub fills `active`, `connectedAt`, `lastActiveAt`, `connectionId` and defaults `filter`/`onEvict`. */

package/index.js

@@ -44,6 +44,7 @@ export const queryIndex = api.queryIndex;
 export const removeDocument = api.removeDocument;
 export const resolveCredential = api.resolveCredential;
 export const resolveMediaSourceData = api.resolveMediaSourceData;
+export const resolveOauthCallbackUrl = api.resolveOauthCallbackUrl;
 export const resolveUserName = api.resolveUserName;
 export const resolveWebhookUrl = api.resolveWebhookUrl;
 export const runConversationTurn = api.runConversationTurn;

package/package.json

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