@vellumai/plugin-api 0.11.2-dev.202608071221.2563112 → 0.11.2-dev.202608071425.368249e

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";
@@ -1092,6 +1093,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>>;
@@ -4813,14 +4823,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" | "flux";
     /** Which floor-holding ack actually spoke during the turn, if any. */
     readonly ackSpoken?: "first_delta" | "tool_use";
     /**
@@ -6490,13 +6520,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";
@@ -6513,7 +6562,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.
@@ -6563,6 +6612,59 @@ export declare interface SttStreamServerPartialEvent {
     readonly confidence?: number;
 }
 
+/**
+ * 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/package.json

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