@vibedev-si/dsh-vibedev 0.2.6 → 0.2.7

package/THIRD-PARTY-NOTICES.txt

@@ -1,4 +1,4 @@
-THIRD-PARTY NOTICES · @vibedev-si/dsh-vibedev 0.2.6
+THIRD-PARTY NOTICES · @vibedev-si/dsh-vibedev 0.2.7
 
 This package bundles code from the projects below. Each is used under the licence that
 follows its name; the licence texts are reproduced as the projects ship them.

package/lib/gateway/catalog.d.ts

@@ -71,6 +71,13 @@ export interface VideoCapabilities {
     readonly minReferenceVideoSeconds?: number;
     readonly maxReferenceVideoSeconds?: number;
     readonly maxTotalReferenceVideoSeconds?: number;
+    /**
+     * Declared limits on a reference AUDIO's own measured length. They are read
+     * from the model, never assumed: a lane that declares nothing is not held to
+     * another lane's range (some providers take 1–15 s, others take minutes).
+     */
+    readonly minReferenceAudioSeconds?: number;
+    readonly maxReferenceAudioSeconds?: number;
     /** References must be relayed through the gateway media library. */
     readonly gatewayRelayRequired?: boolean;
 }

package/lib/gateway/errors.d.ts

@@ -19,6 +19,19 @@ export interface MediaErrorDetails {
     readonly retryAfterMs?: number;
     /** The gateway was full and created nothing (a busy 429/503). */
     readonly busy?: boolean;
+    /**
+     * The gateway's structured submission state: `rejected` (the provider refused
+     * the request; nothing exists under the key), `unknown` (the gateway cannot
+     * tell whether the provider received it) or `accepted` (a task exists).
+     * Absent on the older protocol, where the status is all there is.
+     */
+    readonly submissionState?: string;
+    /**
+     * What the gateway asks next: `none` (do not try again), `reconcile` (settle
+     * the same key's outcome, do not create a task) or `retry`. `retryable` alone
+     * only says recovery is still needed; it never means "create another task".
+     */
+    readonly retryAction?: string;
     /** On a task-limit refusal: tasks in progress and the account's limit. */
     readonly active?: number;
     readonly limit?: number;
@@ -48,6 +61,8 @@ export interface GatewayFailure {
     readonly message?: string;
     readonly field?: string;
     readonly retryable?: boolean;
+    readonly submissionState?: string;
+    readonly retryAction?: string;
     readonly rechargeUrl?: string;
     readonly active?: number;
     readonly limit?: number;

package/lib/index.js

@@ -297,11 +297,15 @@ function parseGatewayFailure(body) {
 		availableCny: amount$1(source.available_cny),
 		pendingCny: amount$1(source.pending_cny)
 	};
+	const submissionState = text$7(source.submission_state) ?? text$7(root.submission_state);
+	const retryAction = text$7(source.retry_action) ?? text$7(root.retry_action);
 	return {
 		...code === void 0 ? {} : { code },
 		...message === void 0 ? {} : { message },
 		...field === void 0 ? {} : { field },
 		...typeof source.retryable === "boolean" ? { retryable: source.retryable } : {},
+		...submissionState === void 0 ? {} : { submissionState: submissionState.toLowerCase() },
+		...retryAction === void 0 ? {} : { retryAction: retryAction.toLowerCase() },
 		...rechargeUrl === void 0 ? {} : { rechargeUrl },
 		...Object.fromEntries(Object.entries({
 			...numbers,
@@ -3345,6 +3349,8 @@ function parseVideoCapabilities(raw) {
 		["maxAssetBytes", "max_asset_bytes"],
 		["minReferenceVideoSeconds", "min_reference_video_duration_seconds"],
 		["maxReferenceVideoSeconds", "max_reference_video_duration_seconds"],
+		["minReferenceAudioSeconds", "min_reference_audio_duration_seconds"],
+		["maxReferenceAudioSeconds", "max_reference_audio_duration_seconds"],
 		["maxTotalReferenceVideoSeconds", "max_total_reference_video_duration_seconds"]
 	]) {
 		const value = positive(field(raw, snake));
@@ -4524,7 +4530,7 @@ function startTaskJob(runtime, exec, record) {
 /**
 * Submit a task and start its report. An unconfirmed submission is not an
 * error here: the agent must not resubmit it, so it is reported like any
-* other task while the tracker resends it under the same key.
+* other task while the tracker settles that one submission under the same key.
 * @param runtime - the media runtime.
 * @param exec - the tool call.
 * @param draft - the task to submit.
@@ -4548,7 +4554,7 @@ async function submitTask(runtime, exec, draft) {
 	};
 }
 /** The sentence about an unconfirmed submission. */
-const UNCONFIRMED_NOTE = "The gateway did not confirm the submission; dsh-vibedev keeps resending it for a few minutes under the same request key, so it cannot be created twice. Do not submit it again.";
+const UNCONFIRMED_NOTE = "The gateway did not confirm the submission; dsh-vibedev keeps settling that same submission under the same request key for a few minutes, so no second task can be created from it. Do not submit it again.";
 /**
 * Wait for a task in the tool call itself, for hosts without background jobs.
 * @param runtime - the media runtime.
@@ -4934,6 +4940,7 @@ function describeVideoModel(model) {
 	const limits = [];
 	if (video.minReferenceVideoSeconds !== void 0 || video.maxReferenceVideoSeconds !== void 0) limits.push(`each reference video ${video.minReferenceVideoSeconds ?? 0}-${video.maxReferenceVideoSeconds ?? "∞"} s`);
 	if (video.maxTotalReferenceVideoSeconds !== void 0) limits.push(`reference videos at most ${video.maxTotalReferenceVideoSeconds} s in total`);
+	if (video.minReferenceAudioSeconds !== void 0 || video.maxReferenceAudioSeconds !== void 0) limits.push(`each reference audio ${video.minReferenceAudioSeconds ?? 0}-${video.maxReferenceAudioSeconds ?? "∞"} s`);
 	if (video.combinations !== void 0) limits.push(`allowed combinations: ${video.combinations.map((c) => [
 		c.duration === void 0 ? "" : `${c.duration}s`,
 		c.ratio ?? "",
@@ -5091,12 +5098,15 @@ function referenceByteLimit(model, input) {
 	return Math.min(kindMax ?? Infinity, video.maxAssetBytes ?? Infinity, MEDIA_LIBRARY_MAX_BYTES);
 }
 /**
-* Check reference video durations once the gateway has measured them.
+* Check the measured lengths of the reference media once the gateway has
+* measured them. A reference's OWN length is what is checked — never the
+* requested output duration — and only against the limits that model declares.
 * @param model - the video model.
 * @param videos - the uploaded reference videos, in order.
+* @param audios - the uploaded reference audios, in order.
 * @throws {@link MediaError} when a clip or the total is outside the model's limits.
 */
-function checkReferenceDurations(model, videos) {
+function checkReferenceDurations(model, videos, audios = []) {
 	const video = model.video ?? {};
 	let totalMs = 0;
 	for (const [index, clip] of videos.entries()) {
@@ -5110,6 +5120,16 @@ function checkReferenceDurations(model, videos) {
 		totalMs += clip.durationMs;
 	}
 	if (video.maxTotalReferenceVideoSeconds !== void 0 && totalMs / 1e3 > video.maxTotalReferenceVideoSeconds) throw new MediaError(`The reference videos add up to ${(totalMs / 1e3).toFixed(2)} s; ${model.id} takes at most ${video.maxTotalReferenceVideoSeconds} s in total.`, "REFERENCE_TOTAL_TOO_LONG", { field: "reference_videos" });
+	const audioLimits = video.minReferenceAudioSeconds !== void 0 || video.maxReferenceAudioSeconds !== void 0;
+	for (const [index, clip] of audios.entries()) {
+		if (clip.durationMs === void 0) {
+			if (audioLimits) throw new MediaError(`The gateway could not measure the length of reference audio ${index + 1} ("${clip.source}"), so ${model.id}'s length limits cannot be checked. Export it as a standard MP3 or WAV and try again.`, "REFERENCE_DURATION_UNKNOWN", { field: "reference_audios" });
+			continue;
+		}
+		const seconds = clip.durationMs / 1e3;
+		if (video.minReferenceAudioSeconds !== void 0 && seconds < video.minReferenceAudioSeconds) throw new MediaError(`Reference audio ${index + 1} ("${clip.source}") is ${seconds.toFixed(2)} s; ${model.id} needs at least ${video.minReferenceAudioSeconds} s of reference audio.`, "REFERENCE_AUDIO_TOO_SHORT", { field: "reference_audios" });
+		if (video.maxReferenceAudioSeconds !== void 0 && seconds > video.maxReferenceAudioSeconds) throw new MediaError(`Reference audio ${index + 1} ("${clip.source}") is ${seconds.toFixed(2)} s; ${model.id} takes at most ${video.maxReferenceAudioSeconds} s of reference audio per clip. Trim it first, or use a shorter excerpt.`, "REFERENCE_AUDIO_TOO_LONG", { field: "reference_audios" });
+	}
 }
 /**
 * The `/v1/videos` body for a plan whose inputs are uploaded. The gateway reads
@@ -5260,7 +5280,12 @@ async function prepareVideoTask(runtime, call, request, save) {
 		bytes: item.media.data.byteLength,
 		...assets[index]?.durationMs === void 0 ? {} : { durationMs: assets[index]?.durationMs }
 	}] : []);
-	checkReferenceDurations(model, videos);
+	checkReferenceDurations(model, videos, loaded.flatMap((item, index) => item.input === "referenceAudios" ? [{
+		source: item.media.source,
+		mime: item.media.mime,
+		bytes: item.media.data.byteLength,
+		...assets[index]?.durationMs === void 0 ? {} : { durationMs: assets[index]?.durationMs }
+	}] : []));
 	const urls = {};
 	for (const [index, item] of loaded.entries()) {
 		const asset = assets[index];
@@ -5898,13 +5923,21 @@ function parseAudioTask(body) {
 * background job, so a task keeps being followed after its job is stopped and
 * after the host restarts.
 *
-* Money rules: a task record is removed only when the first submission was
-* refused outright, so nothing can exist under its key. Every answer that
-* leaves the outcome open (no answer, a gateway error, a 409) keeps the record,
-* and the same request is resent under the same key, which returns the
-* original task when there is one. A resend that is refused outright is
-* retried only briefly, so a refused request is not created later behind the
-* user's back.
+* Money rules, and the rule that one operation creates at most one task:
+*
+* - A submission is settled by the gateway's structured verdict
+*   (`submission_state` and `retry_action`) first, and only by the HTTP status
+*   when it sends none. `rejected`/`retry_action: none` is final: the reason is
+*   saved and nothing is sent again — not by the tool, not by the background
+*   loop, not after a restart. `retryable` on its own never authorizes creating
+*   another task.
+* - An unknown outcome keeps the record and settles it under the SAME key and
+*   the SAME body, which the gateway answers with the original task when there
+*   is one. A new key is minted only for a new request the user asks for.
+* - Once a gateway task id is known the task is only polled; a failed poll
+*   never submits anything.
+* - A refusal that left nothing under the key ends the record as failed with
+*   the gateway's own reason, so the person sees why.
 * @module dsh-vibedev/tasks/tracker
 */
 const SPECS = {
@@ -5945,34 +5978,74 @@ const SUBMIT_TIMEOUT_MS = 3e5;
 const SUBMISSION_AMBIGUOUS = "VIDEO_SUBMISSION_AMBIGUOUS";
 /** The same key was sent with a different body: a plugin bug, never retried. */
 const KEY_CONFLICT = /_IDEMPOTENCY_CONFLICT$/;
+/** Structured verdicts the gateway sends; an unknown word falls back to the older protocol. */
+const REJECTED_STATES = /* @__PURE__ */ new Set([
+	"rejected",
+	"refused",
+	"denied"
+]);
+const RECONCILE_STATES = /* @__PURE__ */ new Set(["unknown", "accepted"]);
+/** `retry_action` values that keep the same key: a lookup of this submission, never a new one. */
+const SAME_KEY_ACTIONS = /* @__PURE__ */ new Set([
+	"reconcile",
+	"retry_same_key",
+	"retry_same"
+]);
 /**
-* Whether a failed submission may still have created the task: no answer, an
-* unreadable answer, a gateway error that is not "busy", or a 409 such as
-* `VIDEO_SUBMISSION_IN_PROGRESS` (an earlier attempt is still being submitted).
+* What a failed submission means.
+*
+* The two STOP rules are read before anything that would keep the operation
+* alive, so no verdict can talk the plugin into sending a refused request
+* again: `retry_action: none` (the provider refused it) and
+* `VIDEO_SUBMISSION_AMBIGUOUS` (the gateway's key answers this forever) end the
+* operation even when the same answer also says the outcome is unknown.
+*
+* After those, the gateway's structured verdict decides, and only when it
+* sends none do the HTTP status and the older codes. `retryable` says recovery
+* is still needed; it never authorizes creating another task.
 * @param error - the failure.
-* @returns true when the same key should be sent again.
+* @returns how it may be taken further.
 */
-function outcomeUnknown(error) {
-	if (!(error instanceof MediaError)) return false;
-	if (NO_ANSWER_CODES.has(error.code)) return true;
-	if (error.code === SUBMISSION_AMBIGUOUS || KEY_CONFLICT.test(error.code)) return false;
-	const status = error.details.status;
-	return status === 409 || status !== void 0 && status >= 500 && error.details.busy !== true;
+function submissionRecovery(error) {
+	if (!(error instanceof MediaError)) return "rejected";
+	const { submissionState, retryAction, status, busy, retryable } = error.details;
+	if (retryAction === "none") return "rejected";
+	if (error.code === SUBMISSION_AMBIGUOUS || KEY_CONFLICT.test(error.code)) return "rejected";
+	if (submissionState !== void 0 && REJECTED_STATES.has(submissionState)) return "rejected";
+	if (retryAction !== void 0 && SAME_KEY_ACTIONS.has(retryAction)) return "reconcile";
+	if (retryAction === "retry") return "wait";
+	if (submissionState !== void 0 && RECONCILE_STATES.has(submissionState)) return "reconcile";
+	if (NO_ANSWER_CODES.has(error.code)) return "reconcile";
+	if (busy === true) return "wait";
+	if (status !== void 0 && status >= 400 && status < 500) return status === 409 ? "reconcile" : "rejected";
+	if (status !== void 0 && status >= 500) return retryable === false ? "rejected" : "reconcile";
+	return "rejected";
 }
 /**
-* The record of a submission the gateway settled for good without a task.
+* The failure to record when a submission is refused for good.
+*
+* None of these tells the person to generate again: in the two cases where the
+* provider may already hold the request, a new generation would be a second
+* paid task, so the wording asks them to check the records first.
 * @param error - the failure.
-* @returns the failure to record, or undefined when the error is not one of these.
+* @returns the code and message to keep with the task.
 */
-function settledWithoutTask(error) {
-	if (!(error instanceof MediaError)) return void 0;
+function terminalFailure(error) {
+	if (!(error instanceof MediaError)) return {
+		code: "SUBMISSION_REJECTED",
+		message: messageOf(error)
+	};
 	if (error.code === SUBMISSION_AMBIGUOUS) return {
 		code: error.code,
-		message: "The gateway could not confirm the submission with the provider, so it created no task and charged nothing. Submit the request again if it is still wanted."
+		message: "The gateway could not confirm this submission with the provider, so it created no task and charged nothing, and this request key will answer the same way. If the provider did receive it, that task is not visible here. Check the task list and the account usage before generating the same thing again."
 	};
 	if (KEY_CONFLICT.test(error.code)) return {
 		code: error.code,
-		message: "The gateway refused the request: its key was already used for a different request. Nothing was charged; submit it again."
+		message: "The gateway refused the request: its key was already used for a different request. Nothing was charged. Check the task list for the earlier request before generating again."
+	};
+	return {
+		code: error.code,
+		message: error.message
 	};
 }
 function sleepFor(ms, signal) {
@@ -6085,8 +6158,14 @@ var TaskTracker = class {
 					await this.releaseClaim(draft.id);
 					throw error;
 				}
-				const settled = settledWithoutTask(error);
-				if (settled !== void 0) {
+				const recovery = submissionRecovery(error);
+				if (recovery === "rejected") {
+					const settled = terminalFailure(error);
+					if (!unknown) {
+						this.dropClaim(draft.id);
+						await this.options.store.remove(draft.id);
+						throw error;
+					}
 					await this.finish(draft.id, {
 						status: "failed",
 						error: settled
@@ -6094,14 +6173,10 @@ var TaskTracker = class {
 					await this.releaseClaim(draft.id);
 					throw new MediaError(settled.message, settled.code, { retryable: false }, { cause: error });
 				}
-				if (!outcomeUnknown(error)) {
-					if (!unknown) {
-						this.dropClaim(draft.id);
-						await this.options.store.remove(draft.id);
-						throw error;
-					}
-					lastError = error;
-					break;
+				if (!unknown && recovery === "wait") {
+					this.dropClaim(draft.id);
+					await this.options.store.remove(draft.id);
+					throw error;
 				}
 				unknown = true;
 				lastError = error;
@@ -6129,7 +6204,7 @@ var TaskTracker = class {
 			}
 		}
 		this.followQuietly(draft.id);
-		throw new MediaError(`The VibeDev gateway did not confirm the request (${messageOf(lastError)}). dsh-vibedev keeps resending it for a few minutes under the same request key, so it cannot be created twice, and saves the result if it runs. Check media_tasks for task ${draft.id}; do not submit the same request again.`, "SUBMISSION_UNCONFIRMED", { retryable: false });
+		throw new MediaError(`The VibeDev gateway did not confirm the request (${messageOf(lastError)}). dsh-vibedev keeps settling it under the same request key for a few minutes — that key can only ever answer with the one task it may have created — and saves the result if it runs. Check media_tasks for task ${draft.id}; do not submit the same request again.`, "SUBMISSION_UNCONFIRMED", { retryable: false });
 	}
 	/**
 	* Follow a recorded task until it ends or the tracker is disposed. A task
@@ -6295,24 +6370,25 @@ var TaskTracker = class {
 			await this.update(record.id, { progress: "waiting for a VibeDev sign-in" });
 			return 6e4;
 		}
-		const settled = submitting ? settledWithoutTask(error) : void 0;
-		if (settled !== void 0) {
-			await this.finish(record.id, {
-				status: "failed",
-				error: settled
-			});
-			return;
-		}
-		if (submitting && !outcomeUnknown(error) && status !== void 0 && status >= 400 && status < 500) {
-			if (this.now() - record.createdAt < (this.options.refusalGraceMs ?? 18e4)) return 3e4;
-			await this.finish(record.id, {
-				status: "failed",
-				error: {
-					code: code ?? `HTTP_${status}`,
-					message: messageOf(error)
-				}
-			});
-			return;
+		if (submitting) {
+			if (submissionRecovery(error) === "rejected") {
+				await this.finish(record.id, {
+					status: "failed",
+					error: terminalFailure(error)
+				});
+				return;
+			}
+			if (failures >= CONSECUTIVE_FAILURE_LIMIT) {
+				await this.finish(record.id, {
+					status: "failed",
+					error: {
+						code: code ?? "SUBMISSION_FAILED",
+						message: `The submission could not be settled ${failures} times in a row: ${messageOf(error)}`
+					}
+				});
+				return;
+			}
+			return Math.min(6e4, 5e3 * 2 ** Math.min(failures - 1, 4));
 		}
 		if (status === 402) {
 			await this.update(record.id, { progress: "paused: the VibeDev balance is used up; top up to receive the result" });

package/lib/tasks/tracker.d.ts

@@ -5,13 +5,21 @@
  * background job, so a task keeps being followed after its job is stopped and
  * after the host restarts.
  *
- * Money rules: a task record is removed only when the first submission was
- * refused outright, so nothing can exist under its key. Every answer that
- * leaves the outcome open (no answer, a gateway error, a 409) keeps the record,
- * and the same request is resent under the same key, which returns the
- * original task when there is one. A resend that is refused outright is
- * retried only briefly, so a refused request is not created later behind the
- * user's back.
+ * Money rules, and the rule that one operation creates at most one task:
+ *
+ * - A submission is settled by the gateway's structured verdict
+ *   (`submission_state` and `retry_action`) first, and only by the HTTP status
+ *   when it sends none. `rejected`/`retry_action: none` is final: the reason is
+ *   saved and nothing is sent again — not by the tool, not by the background
+ *   loop, not after a restart. `retryable` on its own never authorizes creating
+ *   another task.
+ * - An unknown outcome keeps the record and settles it under the SAME key and
+ *   the SAME body, which the gateway answers with the original task when there
+ *   is one. A new key is minted only for a new request the user asks for.
+ * - Once a gateway task id is known the task is only polled; a failed poll
+ *   never submits anything.
+ * - A refusal that left nothing under the key ends the record as failed with
+ *   the gateway's own reason, so the person sees why.
  * @module dsh-vibedev/tasks/tracker
  */
 import type { GatewayHttp } from '../gateway/http.js';
@@ -27,13 +35,12 @@ export interface TrackerOptions {
     readonly sleep?: (ms: number, signal: AbortSignal) => Promise<void>;
     /** Give up on a task this long after it was created. Defaults to 3 hours. */
     readonly maxAgeMs?: number;
-    /** An unconfirmed submission is resent until it is this old. Defaults to 5 minutes. */
-    readonly resendWindowMs?: number;
     /**
-     * A resend refused outright is retried until the task is this old, in case
-     * an earlier attempt is still being created. Defaults to 3 minutes.
+     * How long an unconfirmed submission is reconciled under its own key before
+     * the task is given up. Defaults to 5 minutes: this settles what became of
+     * that one submission, it never creates another task.
      */
-    readonly refusalGraceMs?: number;
+    readonly resendWindowMs?: number;
     /** Download attempts for a finished task before its links are reported instead. Defaults to 5. */
     readonly downloadAttempts?: number;
     /** The largest output downloaded. Defaults to 2 GiB. */
@@ -42,13 +49,34 @@ export interface TrackerOptions {
     readonly claimStaleMs?: number;
 }
 /**
- * Whether a failed submission may still have created the task: no answer, an
- * unreadable answer, a gateway error that is not "busy", or a 409 such as
- * `VIDEO_SUBMISSION_IN_PROGRESS` (an earlier attempt is still being submitted).
+ * How a failed submission may be taken further.
+ *
+ * - `rejected`: the request is refused for good (a parameter refusal, a
+ *   provider-side rejection, a key conflict); nothing exists under the key and
+ *   nothing may be created again for this operation.
+ * - `reconcile`: the outcome is unknown — the same key and the same body are
+ *   sent again only to settle what became of that one submission. This never
+ *   mints a new key and never asks the provider for a new task.
+ * - `wait`: nothing was created and the same request may be sent later (busy,
+ *   rate limited, no balance); the key stays the same.
+ */
+export type SubmissionRecovery = 'rejected' | 'reconcile' | 'wait';
+/**
+ * What a failed submission means.
+ *
+ * The two STOP rules are read before anything that would keep the operation
+ * alive, so no verdict can talk the plugin into sending a refused request
+ * again: `retry_action: none` (the provider refused it) and
+ * `VIDEO_SUBMISSION_AMBIGUOUS` (the gateway's key answers this forever) end the
+ * operation even when the same answer also says the outcome is unknown.
+ *
+ * After those, the gateway's structured verdict decides, and only when it
+ * sends none do the HTTP status and the older codes. `retryable` says recovery
+ * is still needed; it never authorizes creating another task.
  * @param error - the failure.
- * @returns true when the same key should be sent again.
+ * @returns how it may be taken further.
  */
-export declare function outcomeUnknown(error: unknown): boolean;
+export declare function submissionRecovery(error: unknown): SubmissionRecovery;
 /**
  * The live progress line of a running task.
  * @param task - the gateway's view.

package/lib/tools/common.d.ts

@@ -58,7 +58,7 @@ export interface Submitted {
 /**
  * Submit a task and start its report. An unconfirmed submission is not an
  * error here: the agent must not resubmit it, so it is reported like any
- * other task while the tracker resends it under the same key.
+ * other task while the tracker settles that one submission under the same key.
  * @param runtime - the media runtime.
  * @param exec - the tool call.
  * @param draft - the task to submit.

package/lib/video/plan.d.ts

@@ -78,12 +78,15 @@ export declare function checkReferenceFile(model: MediaModel, input: VideoInput,
  */
 export declare function referenceByteLimit(model: MediaModel, input: VideoInput): number;
 /**
- * Check reference video durations once the gateway has measured them.
+ * Check the measured lengths of the reference media once the gateway has
+ * measured them. A reference's OWN length is what is checked — never the
+ * requested output duration — and only against the limits that model declares.
  * @param model - the video model.
  * @param videos - the uploaded reference videos, in order.
+ * @param audios - the uploaded reference audios, in order.
  * @throws {@link MediaError} when a clip or the total is outside the model's limits.
  */
-export declare function checkReferenceDurations(model: MediaModel, videos: readonly ReferenceMedia[]): void;
+export declare function checkReferenceDurations(model: MediaModel, videos: readonly ReferenceMedia[], audios?: readonly ReferenceMedia[]): void;
 /**
  * The `/v1/videos` body for a plan whose inputs are uploaded. The gateway reads
  * one vocabulary and translates it per provider.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibedev-si/dsh-vibedev",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "VibeDev 账号与模型：在 DeepSeek Harness 里登录 VibeDev，与 DeepSeek 账号并存，使用 VibeDev 网关的模型（Claude、GPT 等），并生成图片、视频、音乐和播客 · VibeDev account and models for DeepSeek Harness: sign in to VibeDev next to the DeepSeek account and use the VibeDev gateway's models (Claude, GPT and more), plus image, video, music and podcast generation",
   "type": "module",
   "main": "lib/index.js",