@nodaro/shared 1.7.0 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodaro/shared",
-  "version": "1.7.0",
+  "version": "1.9.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__/llm-models.test.ts

@@ -3,11 +3,13 @@ import {
   LLM_MODEL_IDS,
   LLM_FEATURE_DEFAULTS,
   STRUCTURED_VISION_MODELS,
+  LLM_REASONING_EFFORTS,
   getLlmModel,
   getLlmTier,
   buildLlmCreditIdentifier,
   resolveLlmCreditId,
   motionGraphicsFeature,
+  effectiveReasoningEffort,
 } from "../llm-models.js"
 import type { LlmModelDef, LlmTier, LlmFeature } from "../llm-models.js"
 
@@ -21,8 +23,8 @@ import type { LlmModelDef, LlmTier, LlmFeature } from "../llm-models.js"
 // LLM_MODELS data integrity
 // ---------------------------------------------------------------------------
 describe("LLM_MODELS data integrity", () => {
-  it("should have exactly 7 models", () => {
-    expect(LLM_MODELS).toHaveLength(7)
+  it("should have exactly 13 models", () => {
+    expect(LLM_MODELS).toHaveLength(13)
   })
 
   it("each model has all required fields", () => {
@@ -57,14 +59,14 @@ describe("LLM_MODELS data integrity", () => {
     expect(new Set(ids).size).toBe(ids.length)
   })
 
-  it("has 2 economy, 2 standard, 3 premium models", () => {
+  it("has 3 economy, 4 standard, 6 premium models", () => {
     const tierCounts: Record<LlmTier, number> = { economy: 0, standard: 0, premium: 0 }
     for (const model of LLM_MODELS) {
       tierCounts[model.tier]++
     }
-    expect(tierCounts.economy).toBe(2)
-    expect(tierCounts.standard).toBe(2)
-    expect(tierCounts.premium).toBe(3)
+    expect(tierCounts.economy).toBe(3)
+    expect(tierCounts.standard).toBe(4)
+    expect(tierCounts.premium).toBe(6)
   })
 
   it("all three kieFormats are represented", () => {
@@ -111,6 +113,12 @@ describe("LLM_MODEL_IDS", () => {
       "gemini-3.1-pro",
       "claude-opus-4.7",
       "gpt-5.4",
+      "gpt-5.5",
+      "gpt-5.6-luna",
+      "gpt-5.6-terra",
+      "gpt-5.6-sol",
+      "claude-sonnet-5",
+      "claude-opus-4.8",
     ]
     expect(LLM_MODEL_IDS).toEqual(expected)
   })
@@ -420,6 +428,8 @@ describe("STRUCTURED_VISION_MODELS", () => {
         "claude-sonnet-4.6",
         "gemini-3-flash",
         "gemini-3.1-pro",
+        "claude-sonnet-5",
+        "claude-opus-4.8",
       ].sort(),
     )
   })
@@ -443,3 +453,78 @@ describe("STRUCTURED_VISION_MODELS", () => {
     }
   })
 })
+
+// ---------------------------------------------------------------------------
+// Reasoning effort registry (GPT-5.6 / Claude Sonnet 5 / Claude Opus 4.8)
+// grok-4.5 is DEFERRED — its chat endpoint is not live on the provider yet
+// (2026-07-13); its tests are intentionally omitted here.
+// ---------------------------------------------------------------------------
+describe("reasoning effort registry", () => {
+  it("every reasoningEfforts list is a subset of the superset, in ascending order", () => {
+    const rank = Object.fromEntries(LLM_REASONING_EFFORTS.map((e, i) => [e, i]))
+    for (const m of LLM_MODELS) {
+      for (const e of m.reasoningEfforts ?? []) expect(LLM_REASONING_EFFORTS).toContain(e)
+      const ranks = (m.reasoningEfforts ?? []).map((e) => rank[e])
+      expect([...ranks].sort((a, b) => a - b)).toEqual(ranks)
+    }
+  })
+  it("new models exist with expected tiers", () => {
+    expect(getLlmTier("gpt-5.6-luna")).toBe("economy")
+    expect(getLlmTier("gpt-5.6-terra")).toBe("standard")
+    expect(getLlmTier("gpt-5.6-sol")).toBe("premium")
+    expect(getLlmTier("claude-sonnet-5")).toBe("standard")
+    expect(getLlmTier("claude-opus-4.8")).toBe("premium")
+    expect(getLlmTier("gpt-5.5")).toBe("premium")
+  })
+})
+
+describe("effectiveReasoningEffort", () => {
+  it("passes through a supported level", () => {
+    expect(effectiveReasoningEffort("claude-sonnet-5", "max")).toBe("max")
+  })
+  it("clamps down to the highest supported level ≤ requested", () => {
+    expect(effectiveReasoningEffort("gpt-5.4", "xhigh")).toBe("high")
+  })
+  it("returns undefined when the model has no levels", () => {
+    expect(effectiveReasoningEffort("gemini-3-flash", "high")).toBeUndefined()
+  })
+  it("returns undefined for none on Claude (below its lowest level)", () => {
+    expect(effectiveReasoningEffort("claude-sonnet-5", "none")).toBeUndefined()
+  })
+  it("returns undefined for undefined/garbage input", () => {
+    expect(effectiveReasoningEffort("claude-sonnet-5", undefined)).toBeUndefined()
+    expect(effectiveReasoningEffort("claude-sonnet-5", "turbo")).toBeUndefined()
+  })
+})
+
+describe("buildLlmCreditIdentifier effort bump (xhigh/max only)", () => {
+  it("economy + max → standard (bare feature)", () => {
+    expect(buildLlmCreditIdentifier("llm-chat", "gpt-5.6-luna", "max")).toBe("llm-chat")
+  })
+  it("standard + xhigh → premium", () => {
+    expect(buildLlmCreditIdentifier("llm-chat", "gpt-5.6-terra", "xhigh")).toBe("llm-chat:premium")
+  })
+  it("premium + max stays premium", () => {
+    expect(buildLlmCreditIdentifier("llm-chat", "gpt-5.6-sol", "max")).toBe("llm-chat:premium")
+  })
+  it("high never bumps", () => {
+    expect(buildLlmCreditIdentifier("llm-chat", "claude-sonnet-5", "high")).toBe("llm-chat")
+  })
+  it("clamp on a partial-list standard model never bumps (sonnet-4.6 @ xhigh → high)", () => {
+    expect(buildLlmCreditIdentifier("llm-chat", "claude-sonnet-4.6", "xhigh")).toBe("llm-chat")
+  })
+  it("bump uses the CLAMPED effort (xhigh on a low/medium/high model clamps to high → no bump)", () => {
+    expect(buildLlmCreditIdentifier("llm-chat", "gpt-5.4", "xhigh")).toBe("llm-chat:premium")
+    // gpt-5.4 is premium anyway; the real clamp case:
+    expect(buildLlmCreditIdentifier("llm-chat", "gemini-3-flash", "max")).toBe("llm-chat:economy")
+  })
+  it("back-compat: no effort arg → identical to today for every model", () => {
+    for (const m of LLM_MODELS) {
+      const before = m.tier === "standard" ? "x" : `x:${m.tier}`
+      expect(buildLlmCreditIdentifier("x", m.id)).toBe(before)
+    }
+  })
+  it("resolveLlmCreditId reads reasoningEffort from the raw body", () => {
+    expect(resolveLlmCreditId("llm-chat", { llmModel: "gpt-5.6-terra", reasoningEffort: "max" })).toBe("llm-chat:premium")
+  })
+})

package/src/index.ts

@@ -92,6 +92,7 @@ export {
   SEED_SUPPORT,
   RENDERING_SPEED_SUPPORT,
   GUIDANCE_SCALE_SUPPORT,
+  SEEDANCE_2_PROVIDERS,
   SEEDANCE_2_REF_LIMITS,
   SEEDANCE_2_EXTEND_STITCH,
   NATIVE_ADAPTIVE_ASPECT,
@@ -251,16 +252,20 @@ export {
   VIDEO_ANALYSIS_LLM_MODELS,
   LLM_FEATURE_DEFAULTS,
   LLM_MODALITY_CAPS,
+  LLM_REASONING_EFFORTS,
+  EFFORT_TIER_BUMP,
   getLlmModel,
   getLlmTier,
   getLlmModalityCaps,
   buildLlmCreditIdentifier,
   resolveLlmCreditId,
   motionGraphicsFeature,
+  effectiveReasoningEffort,
   type LlmTier,
   type LlmFeature,
   type KieApiFormat,
   type LlmModelDef,
+  type LlmReasoningEffort,
 } from "./llm-models.js"
 
 export {

package/src/llm-models.ts

@@ -16,6 +16,12 @@
 export type LlmTier = "economy" | "standard" | "premium"
 export type KieApiFormat = "chat-completions" | "messages" | "responses"
 
+export const LLM_REASONING_EFFORTS = ["none", "low", "medium", "high", "xhigh", "max"] as const
+export type LlmReasoningEffort = (typeof LLM_REASONING_EFFORTS)[number]
+/** Levels that bill one tier up. `high` is the Claude-family server default — it never bumps. */
+export const EFFORT_TIER_BUMP: ReadonlySet<LlmReasoningEffort> = new Set(["xhigh", "max"])
+const EFFORT_RANK: Record<LlmReasoningEffort, number> = { none: 0, low: 1, medium: 2, high: 3, xhigh: 4, max: 5 }
+
 export interface LlmModelDef {
   id: string
   displayName: string
@@ -41,6 +47,12 @@ export interface LlmModelDef {
   structuredOutputMode?: "anthropic-tool" | "kie-response-format"
   /** If set, fallback to direct Anthropic SDK with this model ID when KIE.ai fails */
   directFallbackModel?: string
+  /** Effort levels this model accepts (ascending). Absent/empty = no effort lever, picker hidden. */
+  reasoningEfforts?: readonly LlmReasoningEffort[]
+  /** false = model rejects `temperature` (Claude 5-era, GPT-5.6). Absent = accepts. */
+  supportsTemperature?: false
+  /** Claude-only: KIE is the preferred routing, direct Anthropic the fallback. */
+  preferKie?: true
 }
 
 export const LLM_MODELS: readonly LlmModelDef[] = [
@@ -81,6 +93,7 @@ export const LLM_MODELS: readonly LlmModelDef[] = [
     supportsImages: true,
     maxOutputTokens: 16384,
     directFallbackModel: "claude-sonnet-4-6",
+    reasoningEfforts: ["low", "medium", "high", "max"],
   },
   {
     id: "gpt-5.2",
@@ -117,6 +130,9 @@ export const LLM_MODELS: readonly LlmModelDef[] = [
     supportsImages: true,
     maxOutputTokens: 16384,
     directFallbackModel: "claude-opus-4-7",
+    reasoningEfforts: ["low", "medium", "high", "xhigh", "max"],
+    supportsTemperature: false,
+    preferKie: true,
   },
   {
     id: "gpt-5.4",
@@ -128,6 +144,92 @@ export const LLM_MODELS: readonly LlmModelDef[] = [
     vendor: "openai",
     supportsImages: true,
     maxOutputTokens: 16384,
+    reasoningEfforts: ["low", "medium", "high"],
+  },
+  {
+    id: "gpt-5.5",
+    displayName: "GPT-5.5",
+    desc: "Previous flagship GPT, deep reasoning",
+    tier: "premium",
+    kieFormat: "responses",
+    kieSlugOrModel: "gpt-5-5",
+    vendor: "openai",
+    supportsImages: true,
+    maxOutputTokens: 16384,
+    reasoningEfforts: ["none", "low", "medium", "high", "xhigh", "max"],
+    supportsTemperature: false,
+  },
+  {
+    id: "gpt-5.6-luna",
+    displayName: "GPT-5.6 Luna",
+    desc: "Fastest GPT-5.6, high-volume workloads",
+    tier: "economy",
+    kieFormat: "responses",
+    kieSlugOrModel: "gpt-5-6-luna",
+    vendor: "openai",
+    supportsImages: true,
+    maxOutputTokens: 16384,
+    reasoningEfforts: ["none", "low", "medium", "high", "xhigh", "max"],
+    supportsTemperature: false,
+  },
+  {
+    id: "gpt-5.6-terra",
+    displayName: "GPT-5.6 Terra",
+    desc: "Balanced GPT-5.6 for production work",
+    tier: "standard",
+    kieFormat: "responses",
+    kieSlugOrModel: "gpt-5-6-terra",
+    vendor: "openai",
+    supportsImages: true,
+    maxOutputTokens: 16384,
+    reasoningEfforts: ["none", "low", "medium", "high", "xhigh", "max"],
+    supportsTemperature: false,
+  },
+  {
+    id: "gpt-5.6-sol",
+    displayName: "GPT-5.6 Sol",
+    desc: "Flagship GPT-5.6, deepest reasoning",
+    tier: "premium",
+    kieFormat: "responses",
+    kieSlugOrModel: "gpt-5-6-sol",
+    vendor: "openai",
+    supportsImages: true,
+    maxOutputTokens: 16384,
+    reasoningEfforts: ["none", "low", "medium", "high", "xhigh", "max"],
+    supportsTemperature: false,
+  },
+  // grok-4.5 deferred — KIE chat endpoint not yet live (2026-07-13); add entry + rate row + docs when it activates.
+  {
+    id: "claude-sonnet-5",
+    displayName: "Claude Sonnet 5",
+    desc: "Near-Opus quality at Sonnet cost",
+    tier: "standard",
+    kieFormat: "messages",
+    kieSlugOrModel: "claude-sonnet-5",
+    vendor: "anthropic",
+    structuredOutputMode: "anthropic-tool",
+    supportsImages: true,
+    maxOutputTokens: 16384,
+    directFallbackModel: "claude-sonnet-5",
+    reasoningEfforts: ["low", "medium", "high", "xhigh", "max"],
+    supportsTemperature: false,
+    preferKie: true,
+  },
+  {
+    id: "claude-opus-4.8",
+    displayName: "Claude Opus 4.8",
+    desc: "Most capable Claude, long-horizon work",
+    tier: "premium",
+    kieFormat: "messages",
+    kieSlugOrModel: "claude-opus-4-8",
+    vendor: "anthropic",
+    structuredOutputMode: "anthropic-tool",
+    supportsImages: true,
+    maxOutputTokens: 16384,
+    directFallbackModel: "claude-opus-4-8",
+    reasoningEfforts: ["low", "medium", "high", "xhigh", "max"],
+    supportsTemperature: false,
+    preferKie: true,
   },
 ] as const
 
@@ -201,6 +303,12 @@ export const LLM_MODALITY_CAPS: Record<string, { image: boolean; video: boolean;
   "claude-opus-4.7":   { image: true,  video: false, audio: false },
   "gpt-5.2":           { image: true,  video: false, audio: false },
   "gpt-5.4":           { image: true,  video: false, audio: false },
+  "gpt-5.5":           { image: true,  video: false, audio: false },
+  "gpt-5.6-luna":      { image: true,  video: false, audio: false },
+  "gpt-5.6-terra":     { image: true,  video: false, audio: false },
+  "gpt-5.6-sol":       { image: true,  video: false, audio: false },
+  "claude-sonnet-5":   { image: true,  video: false, audio: false },
+  "claude-opus-4.8":   { image: true,  video: false, audio: false },
 }
 
 /** Capability lookup with safe default — unknown models get image-only. */
@@ -217,26 +325,51 @@ export function getLlmTier(id: string): LlmTier {
   return getLlmModel(id)?.tier ?? "standard"
 }
 
+/** Highest level the model supports that is ≤ the requested level; undefined = treat as Auto. */
+export function effectiveReasoningEffort(
+  modelId: string | undefined,
+  requested?: string,
+): LlmReasoningEffort | undefined {
+  if (!requested || !(requested in EFFORT_RANK)) return undefined
+  const levels = getLlmModel(modelId ?? "")?.reasoningEfforts
+  if (!levels || levels.length === 0) return undefined
+  const req = requested as LlmReasoningEffort
+  let best: LlmReasoningEffort | undefined
+  for (const l of levels) {
+    if (EFFORT_RANK[l] <= EFFORT_RANK[req] && (best === undefined || EFFORT_RANK[l] > EFFORT_RANK[best])) best = l
+  }
+  return best
+}
+
 /**
  * Build a composite credit identifier for an LLM feature.
  * - economy tier → "ai-writer:economy"
  * - standard tier → "ai-writer" (no suffix — backward compatible)
  * - premium tier → "ai-writer:premium"
+ * A reasoning effort of "xhigh" or "max" (after clamping to what the model
+ * actually supports) bills one tier up (economy→standard, standard→premium;
+ * premium stays premium). `high` is the Claude-family server default and
+ * never bumps.
  */
-export function buildLlmCreditIdentifier(feature: string, modelId?: string): string {
+export function buildLlmCreditIdentifier(feature: string, modelId?: string, reasoningEffort?: string): string {
   if (!modelId) return feature
-  const tier = getLlmTier(modelId)
+  let tier = getLlmTier(modelId)
+  const eff = effectiveReasoningEffort(modelId, reasoningEffort)
+  if (eff !== undefined && EFFORT_TIER_BUMP.has(eff)) {
+    if (tier === "economy") tier = "standard"
+    else if (tier === "standard") tier = "premium"
+  }
   if (tier === "standard") return feature
   return `${feature}:${tier}`
 }
 
 /**
- * Resolve llmModel from raw body for creditGuard preHandler (before Zod parsing).
- * Returns the credit identifier for the given feature + optional model.
+ * Resolve llmModel (+ reasoningEffort) from raw body for creditGuard preHandler
+ * (before Zod parsing). Returns the credit identifier for the given feature.
  */
 export function resolveLlmCreditId(feature: string, body: unknown): string {
-  const llmModel = (body as Record<string, unknown>)?.llmModel as string | undefined
-  return buildLlmCreditIdentifier(feature, llmModel)
+  const b = body as Record<string, unknown> | undefined
+  return buildLlmCreditIdentifier(feature, b?.llmModel as string | undefined, b?.reasoningEffort as string | undefined)
 }
 
 /** Models capable of video-analysis: capability-derived, never hand-listed (route-enum-sync convention). */

package/src/model-constants.ts

@@ -1139,12 +1139,18 @@ export const SEEDANCE_2_REF_LIMITS = {
  * boundary clicks without shifting sync (combineVideos cut+crossfade path).
  */
 export const SEEDANCE_2_EXTEND_STITCH = {
-  /** Frames dropped from the END of the source clip. */
+  /** Frames dropped from the END of the source clip (smart-cut FALLBACK —
+   *  used only when the PSNR boundary matcher finds no genuine match). */
   trimTailFrames: 4,
-  /** Frames dropped from the START of the generated extension. */
+  /** Frames dropped from the START of the generated extension (smart-cut
+   *  fallback, see above). */
   trimHeadFrames: 3,
   /** Boundary audio fade length (seconds), timeline-preserving. */
   audioFadeSec: 0.15,
+  /** Seconds of the source's TAIL passed as the @video_1 reference —
+   *  spike-validated: a short tail keeps the model focused on continuing
+   *  the boundary motion instead of re-staging the whole clip. */
+  referenceTailSeconds: 1,
 } as const
 
 /**

package/src/node-mappable-fields.ts

@@ -15,6 +15,12 @@ export const NODE_MAPPABLE_FIELDS: Readonly<Record<string, readonly string[]>> =
   // for back-compat with un-migrated workflow JSON). Mirrors text-to-video so
   // fieldMappings/{} injection AND missing-ref detection work on the live node.
   "generate-video":      ["prompt", "negativePrompt"],
+  // Trimmed multi-segment stitch variant of generate-video — prompt only, no
+  // negativePrompt field on the node.
+  "generate-video-pro":  ["prompt"],
+  // Span-replace sibling of generate-video-pro — prompt only, no
+  // negativePrompt field on the node.
+  "edit-video-pro":      ["prompt"],
   "video-analysis":      ["analysisFocus", "youtubeUrl"],
   "video-to-video":      ["prompt"],
   "text-to-speech":      ["directText"],

package/src/producer-types.ts

@@ -30,6 +30,16 @@ export const VIDEO_PRODUCER_TYPES: ReadonlySet<string> = new Set([
   // through to the imageUrl/videoUrl/audioUrl/text default and downstream consumers
   // could silently misroute the output.
   "generate-video",
+  // Generate Video Pro — Seedance-2-family multi-segment stitch variant of
+  // generate-video (same "emits videoUrl" contract; a trimmed provider +
+  // handle set). Must mirror generate-video here or its output can't connect
+  // downstream (the recurring "cannot connect the outputs" bug class).
+  "generate-video-pro",
+  // Edit Video Pro — Seedance-2-family span-replace sibling of generate-
+  // video-pro (same "emits videoUrl" contract; source video + prompt in,
+  // ONE video out). Must mirror generate-video-pro here or its output can't
+  // connect downstream (the recurring "cannot connect the outputs" bug class).
+  "edit-video-pro",
   "upload-video",
   "youtube-video",
   "combine-videos",

package/src/selector.ts

@@ -706,7 +706,16 @@ export function applyRangeIndices(
   return result
 }
 
-/** mulberry32 PRNG — deterministic given a seed (any 32-bit signed integer). */
+/** mulberry32 PRNG — deterministic given a seed (any 32-bit signed integer).
+ *
+ * TWIN WARNING: backend/src/providers/video/audio-fx.ts carries its own
+ * private mulberry32 (cosmetically different — `>>> 0` seed masking — but the
+ * same sequence). The two are deliberately INDEPENDENT and both frozen: the
+ * audio-fx copy seeds every reverb impulse response that the committed
+ * characterization goldens (and every customer's rendered reverb waveform)
+ * are pinned to. Do NOT "deduplicate" them into one shared export or "sync"
+ * one to match the other — a change to either sequence is a silent behavior
+ * change in its domain. */
 function mulberry32(seed: number): () => number {
   let a = seed | 0
   return () => {