musistudio/claude-code-router · error · Error

duration must be between ${constraints.durationMinimum} and

Error message

duration must be between ${constraints.durationMinimum} and ${constraints.durationMaximum} seconds for ${target.protocol}.

What it means

Thrown when the protocol defines a duration range (durationMinimum/durationMaximum) and the supplied duration falls outside it. This applies to providers with a continuous allowed range rather than a discrete list.

Source

Thrown at packages/core/src/media/service.ts:161

      prompt: requiredPrompt(args.prompt)
    };
    const modelPlan = this.mediaModelPlan("image-edit", modelInput);
    return this.submitAndWait("image-edit", request, modelPlan, optionalString(args.idempotency_key));
  }

  videoStart(args: Record<string, unknown>, modelInput: MediaModelInput): PublicMediaJob {
    const modelPlan = this.mediaModelPlan("video-generate", modelInput);
    const target = resolveProviderMediaTarget(this.requireConfig(), modelPlan.modelSelector, "video-generate");
    const constraints = videoGenerationConstraints(target.protocol);
    const durationValue = numberValue(args.duration) ?? constraints.defaultDuration;
    if (durationValue === undefined) throw new Error(`duration is required for ${target.protocol}.`);
    if (!Number.isInteger(durationValue)) throw new Error("duration must be an integer number of seconds.");
    if (constraints.durations && !constraints.durations.includes(durationValue)) {
      throw new Error(`duration must be one of ${constraints.durations.join(", ")} seconds for ${target.protocol}.`);
    }
    if (constraints.durationMinimum !== undefined && constraints.durationMaximum !== undefined &&
      (durationValue < constraints.durationMinimum || durationValue > constraints.durationMaximum)) {
      throw new Error(`duration must be between ${constraints.durationMinimum} and ${constraints.durationMaximum} seconds for ${target.protocol}.`);
    }
    const resolution = optionalString(args.resolution) ?? constraints.defaultResolution;
    if (!resolution) throw new Error(`resolution is required for ${target.protocol}.`);
    if (!constraints.resolutions.includes(resolution)) {
      throw new Error(`resolution must be one of ${constraints.resolutions.join(", ")} for ${target.protocol}.`);
    }
    const aspectRatio = optionalString(args.aspect_ratio);
    if (constraints.requiredParameters.includes("aspect_ratio") && !aspectRatio) {
      throw new Error(`aspect_ratio is required for ${target.protocol}.`);
    }
    if (aspectRatio && !constraints.aspectRatios.includes(aspectRatio)) {
      throw new Error(`aspect_ratio must be one of ${constraints.aspectRatios.join(", ")} for ${target.protocol}.`);
    }
    const request: VideoGenerateRequest = {
      aspectRatio,
      duration: durationValue,
      images: args.images === undefined && args.image === undefined ? [] : this.validateImages(args.images ?? args.image, 1, 7),
      prompt: requiredPrompt(args.prompt),

View on GitHub (pinned to 99f24806c6)

Solutions

1. Clamp duration into the range stated in the error message
2. Use videoGenerationConstraints(protocol).durationMinimum/Maximum to drive input limits in the UI
3. Offer the provider's default when the user's value is out of range instead of failing

Example fix

// before
media.videoStart({ prompt, duration: 30 }, modelInput);

// after
const c = videoGenerationConstraints(protocol);
const duration = Math.min(Math.max(userDuration, c.durationMinimum!), c.durationMaximum!);
media.videoStart({ prompt, duration }, modelInput);

const c = videoGenerationConstraints(protocol);
const duration = Math.min(Math.max(durationValue, c.durationMinimum ?? durationValue), c.durationMaximum ?? durationValue);

const isInRangeDuration = (d: number, c: VideoConstraints): boolean =>
  c.durationMinimum === undefined || c.durationMaximum === undefined ||
  (d >= c.durationMinimum && d <= c.durationMaximum);

When it happens

Trigger: Passing a duration below durationMinimum or above durationMaximum, e.g. 2 seconds on a 5–10 second protocol or 30 on a 5–10 second protocol.

Common situations: User-facing duration sliders without provider-aware bounds; defaults carried over from a different provider; trying to generate very long clips beyond provider limits.

Related errors

• duration is required for ${target.protocol}.
• duration must be an integer number of seconds.
• duration must be one of ${constraints.durations.join(", ")}
• resolution is required for ${target.protocol}.
• resolution must be one of ${constraints.resolutions.join(",

AI-assisted analysis of musistudio/claude-code-router@99f24806c6 (2026-08-27). Data as JSON: /api/errors/dc0822b0ba828897. Report an issue: GitHub.