@nodaro/shared 1.10.0 → 1.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodaro/shared",
-  "version": "1.10.0",
+  "version": "1.12.0",
   "description": "Shared types, model catalog, wire contracts, and structural vocabularies for the Nodaro platform and SDK.",
   "type": "module",
   "license": "Apache-2.0",

package/src/__tests__/credit-identifiers.test.ts

@@ -313,31 +313,31 @@ describe("buildVideoCreditModelIdentifier", () => {
   // --- Duration tiers for kling-3.0 ---
   describe("kling-3.0 duration tiers", () => {
     it("5s duration returns :5s tier", () => {
-      expect(buildVideoCreditModelIdentifier("kling-3.0", 5)).toBe("kling-3.0:5s")
+      expect(buildVideoCreditModelIdentifier("kling-3.0", 5, false)).toBe("kling-3.0:5s")
     })
 
     it("3s duration falls into 5s tier", () => {
-      expect(buildVideoCreditModelIdentifier("kling-3.0", 3)).toBe("kling-3.0:5s")
+      expect(buildVideoCreditModelIdentifier("kling-3.0", 3, false)).toBe("kling-3.0:5s")
     })
 
     it("10s duration returns :10s tier", () => {
-      expect(buildVideoCreditModelIdentifier("kling-3.0", 10)).toBe("kling-3.0:10s")
+      expect(buildVideoCreditModelIdentifier("kling-3.0", 10, false)).toBe("kling-3.0:10s")
     })
 
     it("7s duration falls into 10s tier", () => {
-      expect(buildVideoCreditModelIdentifier("kling-3.0", 7)).toBe("kling-3.0:10s")
+      expect(buildVideoCreditModelIdentifier("kling-3.0", 7, false)).toBe("kling-3.0:10s")
     })
 
     it("15s duration returns :15s tier", () => {
-      expect(buildVideoCreditModelIdentifier("kling-3.0", 15)).toBe("kling-3.0:15s")
+      expect(buildVideoCreditModelIdentifier("kling-3.0", 15, false)).toBe("kling-3.0:15s")
     })
 
     it("duration exceeding max tier clamps to last tier (20s -> 15s)", () => {
-      expect(buildVideoCreditModelIdentifier("kling-3.0", 20)).toBe("kling-3.0:15s")
+      expect(buildVideoCreditModelIdentifier("kling-3.0", 20, false)).toBe("kling-3.0:15s")
     })
 
     it("duration exceeding max tier clamps to last tier (100s -> 15s)", () => {
-      expect(buildVideoCreditModelIdentifier("kling-3.0", 100)).toBe("kling-3.0:15s")
+      expect(buildVideoCreditModelIdentifier("kling-3.0", 100, false)).toBe("kling-3.0:15s")
     })
   })
 
@@ -351,6 +351,18 @@ describe("buildVideoCreditModelIdentifier", () => {
       expect(buildVideoCreditModelIdentifier("kling", 5, true)).toBe("kling:5s:audio")
     })
 
+    it("kling-3.0 + sound UNDEFINED appends :audio (model default is audio ON)", () => {
+      // The provider layer generates audio when the caller expressed no intent
+      // (models.ts extraParams.sound: true + kling3-client `?? true`). Billing
+      // must mirror that via capability defaultOn — reserving the no-audio
+      // tier against an audio-on generation was a silent under-bill.
+      expect(buildVideoCreditModelIdentifier("kling-3.0", 5, undefined)).toBe("kling-3.0:5s:audio")
+    })
+
+    it("kling (2.6) + sound UNDEFINED does not append :audio (model default is OFF)", () => {
+      expect(buildVideoCreditModelIdentifier("kling", 5, undefined)).toBe("kling:5s")
+    })
+
     it("kling-3.0 + sound=false does not append :audio", () => {
       expect(buildVideoCreditModelIdentifier("kling-3.0", 5, false)).toBe("kling-3.0:5s")
     })
@@ -407,7 +419,7 @@ describe("buildVideoCreditModelIdentifier", () => {
   // --- String duration parsing ---
   describe("duration parsing", () => {
     it('string duration "10" is parsed as number 10', () => {
-      expect(buildVideoCreditModelIdentifier("kling-3.0", "10")).toBe("kling-3.0:10s")
+      expect(buildVideoCreditModelIdentifier("kling-3.0", "10", false)).toBe("kling-3.0:10s")
     })
 
     it('string duration "5" works', () => {
@@ -415,19 +427,19 @@ describe("buildVideoCreditModelIdentifier", () => {
     })
 
     it("NaN duration defaults to 5", () => {
-      expect(buildVideoCreditModelIdentifier("kling-3.0", "abc")).toBe("kling-3.0:5s")
+      expect(buildVideoCreditModelIdentifier("kling-3.0", "abc", false)).toBe("kling-3.0:5s")
     })
 
     it("undefined duration defaults to 5", () => {
-      expect(buildVideoCreditModelIdentifier("kling-3.0")).toBe("kling-3.0:5s")
+      expect(buildVideoCreditModelIdentifier("kling-3.0", undefined, false)).toBe("kling-3.0:5s")
     })
 
     it("0 duration falls into first tier", () => {
-      expect(buildVideoCreditModelIdentifier("kling-3.0", 0)).toBe("kling-3.0:5s")
+      expect(buildVideoCreditModelIdentifier("kling-3.0", 0, false)).toBe("kling-3.0:5s")
     })
 
     it("1 duration falls into first tier", () => {
-      expect(buildVideoCreditModelIdentifier("kling-3.0", 1)).toBe("kling-3.0:5s")
+      expect(buildVideoCreditModelIdentifier("kling-3.0", 1, false)).toBe("kling-3.0:5s")
     })
   })
 

package/src/__tests__/video-analysis-pricing.test.ts

@@ -7,6 +7,7 @@ import {
 } from "../video-analysis-pricing.js"
 import {
   VIDEO_ANALYSIS_LLM_MODELS, VIDEO_ANALYSIS_TIERS, VIDEO_ANALYSIS_TIER_ORDER,
+  VIDEO_ANALYSIS_MIXED_TIERS,
   DEFAULT_VIDEO_ANALYSIS_TIER, DEFAULT_VIDEO_ANALYSIS_MODEL, resolveVideoAnalysisModel,
 } from "../llm-models.js"
 
@@ -43,26 +44,51 @@ describe("video-analysis-pricing", () => {
     expect(VIDEO_ANALYSIS_LLM_MODELS).toEqual(["gemini-3-flash", "gemini-3.1-pro"])
   })
 
-  it("tier layer: every tier maps to a real model AND every model is tier-reachable (no vendor leak)", () => {
+  it("tier layer: every model-backed tier maps to a real model AND every model is tier-reachable (no vendor leak)", () => {
     // Adding a video-analysis model without a tier would silently leave it
     // unreachable / unnamed — this fails until a tier decision is made.
     const tierTargets = Object.values(VIDEO_ANALYSIS_TIERS)
     for (const m of tierTargets) expect(VIDEO_ANALYSIS_LLM_MODELS).toContain(m)
     for (const m of VIDEO_ANALYSIS_LLM_MODELS) expect(tierTargets).toContain(m)
-    expect(new Set(VIDEO_ANALYSIS_TIER_ORDER)).toEqual(new Set(Object.keys(VIDEO_ANALYSIS_TIERS)))
+    // TIER_ORDER = model-backed tiers + mixed roll-plan tiers, exactly.
+    expect(new Set(VIDEO_ANALYSIS_TIER_ORDER)).toEqual(
+      new Set([...Object.keys(VIDEO_ANALYSIS_TIERS), ...VIDEO_ANALYSIS_MIXED_TIERS]),
+    )
+    // Mixed tiers are SENTINELS, never model ids — a mixed id leaking into the
+    // model list would break the roll-plan dispatch in the analysis engine.
+    for (const t of VIDEO_ANALYSIS_MIXED_TIERS) expect(VIDEO_ANALYSIS_LLM_MODELS).not.toContain(t)
   })
 
-  it("resolveVideoAnalysisModel: tier → model, raw model passthrough, default pro on empty/unknown", () => {
+  it("resolveVideoAnalysisModel: tier → model, mixed → sentinel, raw model passthrough, default pro on empty/unknown", () => {
     expect(DEFAULT_VIDEO_ANALYSIS_TIER).toBe("pro")
     expect(DEFAULT_VIDEO_ANALYSIS_MODEL).toBe("gemini-3.1-pro")
     expect(resolveVideoAnalysisModel("pro")).toBe("gemini-3.1-pro")
     expect(resolveVideoAnalysisModel("fast")).toBe("gemini-3-flash")
+    expect(resolveVideoAnalysisModel("mixed")).toBe("mixed") // roll-plan sentinel passthrough
+    expect(resolveVideoAnalysisModel("mixed-fast")).toBe("mixed-fast")
     expect(resolveVideoAnalysisModel("gemini-3-flash")).toBe("gemini-3-flash") // raw passthrough
     expect(resolveVideoAnalysisModel(undefined)).toBe("gemini-3.1-pro") // default → pro
     expect(resolveVideoAnalysisModel("")).toBe("gemini-3.1-pro")
     expect(resolveVideoAnalysisModel("nonsense")).toBe("gemini-3.1-pro") // unknown → default, never throws
   })
 
+  it("mixed tiers price under ONE shared credit family (video-analysis:mixed:*)", () => {
+    // Both variants are the identical compute plan — a per-variant price split
+    // would be a phantom distinction and double the admin surface.
+    for (const bucketSec of VIDEO_ANALYSIS_DURATION_BUCKETS) {
+      expect(buildVideoAnalysisCreditId("mixed", bucketSec)).toBe(`video-analysis:mixed:${bucketSec}s`)
+      expect(buildVideoAnalysisCreditId("mixed-fast", bucketSec)).toBe(`video-analysis:mixed:${bucketSec}s`)
+      const credits = VIDEO_ANALYSIS_BUCKET_CREDITS[`video-analysis:mixed:${bucketSec}s`]
+      expect(credits, `missing mixed entry for ${bucketSec}s`).toBeDefined()
+      expect(Number.isInteger(credits)).toBe(true)
+      // Sanity: mixed (3 fast + 2 pro rolls + refine) must never price below
+      // the pro tier it supersets.
+      expect(credits).toBeGreaterThanOrEqual(
+        VIDEO_ANALYSIS_BUCKET_CREDITS[`video-analysis:gemini-3.1-pro:${bucketSec}s`],
+      )
+    }
+  })
+
   // Full drift-detection against the live $-formula lives in
   // backend/src/lib/pricing/__tests__/video-analysis-cost.test.ts (this
   // package cannot see the formula post-S5). This is a lightweight shape

package/src/__tests__/video-audio-capability.test.ts

@@ -22,15 +22,33 @@ describe("getVideoAudioCapability", () => {
     }
   })
 
-  it("returns ambient (sound toggle, cost-affecting) for Kling", () => {
+  it("returns native_speech (sound toggle, cost-affecting) for KIE Kling", () => {
+    // Probe-verified 2026-07-16: scripted quoted dialogue comes back verbatim
+    // with articulated lips on the KIE path for BOTH kling (2.6) and kling-3.0.
     for (const m of ["kling", "kling-3.0"]) {
       const cap = getVideoAudioCapability(m)
-      expect(cap.mode, m).toBe("ambient")
+      expect(cap.mode, m).toBe("native_speech")
       expect(cap.field, m).toBe("sound")
       expect(cap.affectsCost, m).toBe(true)
     }
   })
 
+  it("returns native_speech (generateAudio lever, flat-priced) for kling-3-omni", () => {
+    const cap = getVideoAudioCapability("kling-3-omni")
+    expect(cap.mode).toBe("native_speech")
+    expect(cap.field).toBe("generateAudio")
+    // Audio is priced into the Replicate flat per-duration rate — no :audio composite.
+    expect(cap.affectsCost).toBeUndefined()
+    expect(cap.defaultOn).toBe(true)
+  })
+
+  it("defaultOn mirrors each model's own config default", () => {
+    // kling-3.0 generates audio unless explicitly disabled (models.ts
+    // extraParams.sound: true + kling3-client `?? true`); kling 2.6 defaults off.
+    expect(getVideoAudioCapability("kling-3.0").defaultOn).toBe(true)
+    expect(getVideoAudioCapability("kling").defaultOn).toBeUndefined()
+  })
+
   it("returns audio_driven for Seedance 2.0", () => {
     for (const m of ["seedance-2", "seedance-2-fast"]) {
       const cap = getVideoAudioCapability(m)
@@ -66,6 +84,7 @@ describe("videoModelSupportsAudio", () => {
   it("is true for any model with an audio mode, false for silent", () => {
     expect(videoModelSupportsAudio("veo3")).toBe(true)
     expect(videoModelSupportsAudio("kling-3.0")).toBe(true)
+    expect(videoModelSupportsAudio("kling-3-omni")).toBe(true)
     expect(videoModelSupportsAudio("seedance-2")).toBe(true)
     expect(videoModelSupportsAudio("seedance")).toBe(true)
     expect(videoModelSupportsAudio("minimax")).toBe(false)
@@ -80,9 +99,12 @@ describe("videoModelCanSpeakDialogue", () => {
     expect(videoModelCanSpeakDialogue("seedance-2")).toBe(true)
     expect(videoModelCanSpeakDialogue("seedance-2-fast")).toBe(true)
     expect(videoModelCanSpeakDialogue("seedance-2-mini")).toBe(true)
+    // Kling 2.6 / 3.0 / Omni speak scripted dialogue natively (probe-verified
+    // 2026-07-16) — the Story→Video auto-pick uses in-model speech + revoice.
+    expect(videoModelCanSpeakDialogue("kling")).toBe(true)
+    expect(videoModelCanSpeakDialogue("kling-3.0")).toBe(true)
+    expect(videoModelCanSpeakDialogue("kling-3-omni")).toBe(true)
     // ambient-only models are NOT dialogue-capable — their audio is SFX/ambient
-    expect(videoModelCanSpeakDialogue("kling")).toBe(false)
-    expect(videoModelCanSpeakDialogue("kling-3.0")).toBe(false)
     expect(videoModelCanSpeakDialogue("seedance")).toBe(false)
     expect(videoModelCanSpeakDialogue("minimax")).toBe(false)
     expect(videoModelCanSpeakDialogue(undefined)).toBe(false)
@@ -101,10 +123,16 @@ describe("seedance-2-mini is a full Seedance 2 family member", () => {
 })
 
 describe("VIDEO_AUDIO_CAPABILITY internal consistency", () => {
-  it("every Kling AUDIO_ADDON provider is ambient + affectsCost", () => {
+  it("every AUDIO_ADDON provider is cost-affecting on the canonical `sound` lever", () => {
+    // The billing-critical invariant: the `:audio` surcharge keys off `sound`,
+    // so every surcharged model must declare audio, be marked cost-affecting,
+    // and carry its toggle on that exact field (applyVideoAudioToggle then
+    // refuses the generateAudio alias for these, making a billed/generated
+    // divergence structurally impossible).
     for (const m of AUDIO_ADDON_PROVIDERS) {
       const cap = getVideoAudioCapability(m)
-      expect(cap.mode, m).toBe("ambient")
+      expect(cap.mode, m).not.toBe("none")
+      expect(cap.field, m).toBe("sound")
       expect(cap.affectsCost, m).toBe(true)
     }
   })

package/src/credit-identifiers.ts

@@ -18,6 +18,7 @@ import {
   MOTION_DURATION_TIERS,
   T2I_TO_I2I_VARIANT,
   isVeoProvider,
+  getVideoAudioCapability,
 } from "./model-constants.js"
 import { isFlux2Model } from "./flux2-pricing.js"
 import { MODEL_CATALOG } from "./model-catalog.js"
@@ -227,8 +228,13 @@ export function buildVideoCreditModelIdentifier(
   const tier = tiers.find(t => durationSec <= t.maxSeconds) ?? tiers[tiers.length - 1]
   let identifier = `${effectiveProvider}:${tier.suffix}`
 
-  // Append audio suffix if applicable
-  if (AUDIO_ADDON_PROVIDERS.has(effectiveProvider) && sound) {
+  // Append audio suffix if applicable. When the caller expressed no intent
+  // (sound === undefined), fall back to the model's own default (capability
+  // `defaultOn` — kling-3.0 generates audio unless explicitly disabled), so an
+  // intent-less request is billed for the audio it actually produces instead
+  // of reserving the cheaper no-audio tier against an audio-on generation.
+  const soundOn = sound ?? (getVideoAudioCapability(effectiveProvider).defaultOn === true)
+  if (AUDIO_ADDON_PROVIDERS.has(effectiveProvider) && soundOn) {
     identifier += ":audio"
   }
 

package/src/index.ts

@@ -255,11 +255,15 @@ export {
   VIDEO_ANALYSIS_LLM_MODELS,
   VIDEO_ANALYSIS_TIERS,
   type VideoAnalysisTier,
+  type VideoAnalysisModelTier,
+  VIDEO_ANALYSIS_MIXED_TIERS,
+  type VideoAnalysisMixedTier,
   VIDEO_ANALYSIS_TIER_ORDER,
   DEFAULT_VIDEO_ANALYSIS_TIER,
   DEFAULT_VIDEO_ANALYSIS_MODEL,
   VIDEO_ANALYSIS_TIER_LABELS,
   isVideoAnalysisTier,
+  isVideoAnalysisMixedTier,
   resolveVideoAnalysisModel,
   LLM_FEATURE_DEFAULTS,
   LLM_MODALITY_CAPS,

package/src/llm-models.ts

@@ -396,26 +396,53 @@ export const VIDEO_ANALYSIS_LLM_MODELS: string[] = LLM_MODELS
  * so adding a video model forces a tier decision instead of silently leaking.
  */
 export const VIDEO_ANALYSIS_TIERS = { fast: "gemini-3-flash", pro: "gemini-3.1-pro" } as const
-export type VideoAnalysisTier = keyof typeof VIDEO_ANALYSIS_TIERS
+export type VideoAnalysisModelTier = keyof typeof VIDEO_ANALYSIS_TIERS
+/**
+ * MIXED tiers — advanced multi-engine analysis plans whose identifier resolves
+ * to an engine-plan SENTINEL consumed by the analysis engine, never to a single
+ * model id. Two variants, same price (one shared `video-analysis:mixed:*`
+ * credit family): `mixed` targets maximum result quality; `mixed-fast` targets
+ * run-to-run output consistency. What each plan does internally is deliberately
+ * NOT published here (Apache irrevocability; only the wire vocabulary below is
+ * contract — the engine lives in the private analysis plugin).
+ */
+export const VIDEO_ANALYSIS_MIXED_TIERS = ["mixed", "mixed-fast"] as const
+export type VideoAnalysisMixedTier = (typeof VIDEO_ANALYSIS_MIXED_TIERS)[number]
 /** UI/listing order — recommended (pro) first. */
-export const VIDEO_ANALYSIS_TIER_ORDER = ["pro", "fast"] as const
+export const VIDEO_ANALYSIS_TIER_ORDER = ["pro", "fast", "mixed", "mixed-fast"] as const
+export type VideoAnalysisTier = (typeof VIDEO_ANALYSIS_TIER_ORDER)[number]
 export const DEFAULT_VIDEO_ANALYSIS_TIER: VideoAnalysisTier = "pro"
 export const DEFAULT_VIDEO_ANALYSIS_MODEL: string = VIDEO_ANALYSIS_TIERS[DEFAULT_VIDEO_ANALYSIS_TIER]
 /** Neutral, vendor-free display labels for the UI. */
-export const VIDEO_ANALYSIS_TIER_LABELS: Record<VideoAnalysisTier, string> = { fast: "Fast", pro: "Pro" }
+export const VIDEO_ANALYSIS_TIER_LABELS: Record<VideoAnalysisTier, string> = {
+  fast: "Fast",
+  pro: "Pro",
+  mixed: "Mixed",
+  "mixed-fast": "Mixed (consistent)",
+}
 
 export function isVideoAnalysisTier(v: string): v is VideoAnalysisTier {
-  return Object.prototype.hasOwnProperty.call(VIDEO_ANALYSIS_TIERS, v)
+  return (VIDEO_ANALYSIS_TIER_ORDER as readonly string[]).includes(v)
+}
+
+export function isVideoAnalysisMixedTier(v: string): v is VideoAnalysisMixedTier {
+  return (VIDEO_ANALYSIS_MIXED_TIERS as readonly string[]).includes(v)
 }
 
 /**
- * Resolve a user-supplied tier (`"fast"`/`"pro"`) OR a raw internal model id to
- * the internal analysis model id. Empty/unknown → the default tier's model.
- * Real model ids pass through (back-compat for existing stored `llmModel`
- * values); anything else falls back to the default rather than erroring.
+ * Resolve a user-supplied tier OR a raw internal model id to the analysis
+ * ENGINE IDENTIFIER carried in the worker payload:
+ *  - model-backed tiers ("fast"/"pro") → the internal model id;
+ *  - mixed tiers ("mixed"/"mixed-fast") → the sentinel ITSELF (the engine
+ *    expands it to a multi-model roll plan);
+ *  - raw model ids pass through (back-compat for stored `llmModel` values);
+ *  - empty/unknown → the default tier's model (never an error).
  */
 export function resolveVideoAnalysisModel(input?: string | null): string {
-  if (input && isVideoAnalysisTier(input)) return VIDEO_ANALYSIS_TIERS[input]
+  if (input && isVideoAnalysisMixedTier(input)) return input
+  if (input && Object.prototype.hasOwnProperty.call(VIDEO_ANALYSIS_TIERS, input)) {
+    return VIDEO_ANALYSIS_TIERS[input as VideoAnalysisModelTier]
+  }
   if (input && VIDEO_ANALYSIS_LLM_MODELS.includes(input)) return input
   return DEFAULT_VIDEO_ANALYSIS_MODEL
 }

package/src/model-catalog.ts

@@ -1839,6 +1839,26 @@ const VIDEO_MODELS: Record<string, ModelCatalogEntry> = {
       { identifier: "video-analysis:gemini-3.1-pro:600s", credits: 11, note: "10-min ceiling" },
     ],
   },
+  // Both mixed tiers are variants of the same advanced multi-engine analysis
+  // and share this ONE credit family (videoAnalysisCreditSegment maps both;
+  // plan internals live in the private analysis plugin).
+  "mixed-video-analysis": {
+    id: "mixed-video-analysis",
+    kind: "video",
+    modes: ["video-analysis"] as const,
+    family: "Nodaro",
+    label: "Video Analysis (Mixed)",
+    series: "Video Analysis",
+    description: "Our most advanced analysis tier — multiple analysis engines combined into one result for maximum completeness and accuracy. Billed per duration bucket.",
+    useCases: ["video-analysis", "shot-list", "premium", "most-complete"],
+    pricing: [
+      { identifier: "video-analysis:mixed", credits: 14, note: "10-min ceiling (no duration given)" },
+      { identifier: "video-analysis:mixed:60s", credits: 3 },
+      { identifier: "video-analysis:mixed:180s", credits: 4 },
+      { identifier: "video-analysis:mixed:360s", credits: 9 },
+      { identifier: "video-analysis:mixed:600s", credits: 14, note: "10-min ceiling" },
+    ],
+  },
 }
 
 // =============================================================================

package/src/model-constants.ts

@@ -1393,8 +1393,13 @@ export const AUDIO_ADDON_PROVIDERS = new Set([
  *                     lip-synced spoken dialogue. Toggle is offered; the
  *                     pipeline still uses TTS + lip-sync for dialogue.
  *   "native_speech" — bakes spoken dialogue + lip movement from the prompt
- *                     (VEO 3.x). The pipeline injects the dialogue line, enables
- *                     audio, and revoices the clip to the character's saved voice.
+ *                     (VEO 3.x always-on; Kling 2.6/3.0 behind the `sound`
+ *                     toggle — probe-verified 2026-07-16: scripted lines come
+ *                     back word-for-word with articulated lips on the KIE
+ *                     path, matching the official Kling 2.6 audio guide and
+ *                     Kling 3.0 prompting docs). The pipeline injects the
+ *                     dialogue line, enables audio, and revoices the clip to
+ *                     the character's saved voice.
  *   "audio_driven"  — lip-syncs to a supplied reference-audio track (Seedance
  *                     2.0 multimodal). The pipeline synthesises the character's
  *                     voice first, feeds it as reference audio, and skips the
@@ -1410,6 +1415,14 @@ export interface VideoAudioCapability {
   alwaysOn?: boolean
   /** Enabling audio raises the credit cost (Kling — see AUDIO_ADDON_PROVIDERS). */
   affectsCost?: boolean
+  /**
+   * The model generates audio when the caller expresses NO intent (its own
+   * config default is on — kling-3.0's `sound: true`, kling-3-omni's
+   * `generate_audio: true`). The `:audio` credit suffix mirrors this default
+   * so an intent-less request is billed for the audio it actually produces
+   * (see buildVideoCreditModelIdentifier). Absent ⇒ default off.
+   */
+  defaultOn?: boolean
 }
 
 /**
@@ -1426,9 +1439,22 @@ export const VIDEO_AUDIO_CAPABILITY: Record<string, VideoAudioCapability> = {
   veo3: { mode: "native_speech", alwaysOn: true },
   "veo3.1": { mode: "native_speech", alwaysOn: true },
   veo3_lite: { mode: "native_speech", alwaysOn: true },
-  // Kling 2.6 / 3.0 — ambient sound/SFX toggle; not lip-synced speech. Cost-affecting.
-  kling: { mode: "ambient", field: "sound", affectsCost: true },
-  "kling-3.0": { mode: "ambient", field: "sound", affectsCost: true },
+  // Kling 2.6 / 3.0 — native spoken dialogue + lip sync behind the `sound`
+  // toggle (probe-verified on the KIE path 2026-07-16: scripted quoted lines
+  // are spoken verbatim with articulated lips; the official Kling 2.6 audio
+  // guide documents speech/dialogue/narration/singing with [Character@Voice]
+  // binding, zh+en voices). Cost-affecting: `:audio` credit suffix.
+  // kling-3.0's model default is sound ON (kie models.ts extraParams +
+  // kling3-client `?? true`) → defaultOn keeps billing aligned with what an
+  // intent-less request actually generates; kling 2.6 defaults OFF.
+  kling: { mode: "native_speech", field: "sound", affectsCost: true },
+  "kling-3.0": { mode: "native_speech", field: "sound", affectsCost: true, defaultOn: true },
+  // Kling 3.0 Omni (Replicate kwaivgi/kling-v3-omni-video) — the Omni tier's
+  // headline feature IS native dialogue (per-character voices, unified audio
+  // timeline). Lever is Replicate's `generate_audio` (default true in our
+  // provider config → defaultOn); audio is priced into the flat per-duration
+  // rate, so NOT cost-affecting (no :audio composite).
+  "kling-3-omni": { mode: "native_speech", field: "generateAudio", defaultOn: true },
   // Seedance 1.x — optional ambient audio (generate_audio); not dialogue.
   seedance: { mode: "ambient", field: "generateAudio" },
   // Seedance 2.0 — multimodal; lip-syncs to a supplied reference-audio track.
@@ -1457,11 +1483,11 @@ export function videoModelSupportsAudio(model: string | undefined): boolean {
 
 /**
  * True when the model can produce lip-synced spoken DIALOGUE — either natively
- * (VEO) or driven by a supplied audio track (Seedance 2.0). Drives the Story→Video
- * dialogue auto-pick: in-model speech + character revoice (VEO) / character-voiced
- * reference audio (Seedance 2.0) vs. the TTS + separate-lip-sync fallback.
- * Ambient-only models (Kling, Seedance 1.x) return `false` — their audio is SFX,
- * not speech.
+ * (VEO 3.x, Kling 2.6/3.0/Omni) or driven by a supplied audio track (Seedance
+ * 2.0). Drives the Story→Video dialogue auto-pick: in-model speech + character
+ * revoice (VEO, Kling) / character-voiced reference audio (Seedance 2.0) vs.
+ * the TTS + separate-lip-sync fallback. Ambient-only models (Seedance 1.x)
+ * return `false` — their audio is SFX, not speech.
  */
 export function videoModelCanSpeakDialogue(model: string | undefined): boolean {
   const mode = getVideoAudioCapability(model).mode

package/src/video-analysis-pricing.ts

@@ -54,6 +54,24 @@ export const VIDEO_ANALYSIS_BUCKET_CREDITS: Record<string, number> = {
   "video-analysis:gemini-3.1-pro:180s": 3,
   "video-analysis:gemini-3.1-pro:360s": 7,
   "video-analysis:gemini-3.1-pro:600s": 11,
+  // Mixed tiers (`mixed` + `mixed-fast`) share ONE credit family — they are
+  // variants of the same engine plan (plan internals live in the private
+  // analysis plugin). Admin-tunable via model_pricing like every other row.
+  "video-analysis:mixed:60s": 3,
+  "video-analysis:mixed:180s": 4,
+  "video-analysis:mixed:360s": 9,
+  "video-analysis:mixed:600s": 14,
+}
+
+/**
+ * The credit-id MODEL SEGMENT for an engine identifier: both mixed-tier
+ * sentinels share the `mixed` price family (same engine plan); everything
+ * else prices under its own identifier. Single source of truth — used by
+ * `buildVideoAnalysisCreditId` below, so route/orchestrator/UI callers can
+ * never diverge on where a sentinel prices.
+ */
+export function videoAnalysisCreditSegment(modelOrSentinel: string): string {
+  return modelOrSentinel === "mixed-fast" ? "mixed" : modelOrSentinel
 }
 
 export function pickVideoAnalysisBucket(durationSec: number): number {
@@ -65,7 +83,7 @@ export function buildVideoAnalysisCreditId(model: string, durationSec?: number):
   const bucket = durationSec !== undefined && durationSec > 0
     ? pickVideoAnalysisBucket(Math.min(durationSec, VIDEO_ANALYSIS_MAX_DURATION_SEC))
     : VIDEO_ANALYSIS_MAX_DURATION_SEC // unknown → ceiling composite (the ONLY silent-ceiling path)
-  return `video-analysis:${model}:${bucket}s`
+  return `video-analysis:${videoAnalysisCreditSegment(model)}:${bucket}s`
 }
 
 export function bucketSecondsFromCreditId(creditId: string): number | null {