@vibeframe/cli 0.115.5 → 0.115.6

package/dist/commands/_shared/status-jobs.d.ts

@@ -1,3 +1,4 @@
+import { type VideoJob } from "@vibeframe/ai-providers";
 import type { BuildAssetKind } from "./build-cache.js";
 import type { ReviewAction } from "./review-report.js";
 export type JobStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "unknown";
@@ -26,7 +27,10 @@ export interface JobRecord {
     command: string;
     provider: string;
     providerTaskId: string;
+    /** Kling task type; superseded by `providerJob` and kept for older records. */
     providerTaskType?: "text2video" | "image2video";
+    /** The provider's job handle, so a refresh polls exactly the job that was submitted. */
+    providerJob?: VideoJob;
     progress?: number;
     resultUrl?: string;
     beatId?: string;
@@ -60,6 +64,7 @@ export interface CreateJobRecordOptions {
     provider: string;
     providerTaskId: string;
     providerTaskType?: "text2video" | "image2video";
+    providerJob?: VideoJob;
     projectDir?: string;
     workingDirectory?: string;
     command: string;

package/dist/commands/_shared/video-jobs.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The CLI side of the video job contract: open a provider by name with the
+ * user's key, and turn local files into the image form it takes. Video
+ * executors, job records, and builds go through here instead of branching
+ * on provider names.
+ */
+import { type VideoGenerator, type VideoJob } from "@vibeframe/ai-providers";
+/** Env var holding each video provider's key. */
+export declare const VIDEO_PROVIDER_ENV: Readonly<Record<string, string>>;
+/** `fal` is the old name for `seedance`. */
+export declare function canonicalVideoProvider(provider: string): string;
+/** A video generator for `provider`, with the given key or the configured one. */
+export declare function openVideoGenerator(provider: string, apiKey?: string): Promise<VideoGenerator>;
+/**
+ * A job handle for a bare task ID (a user typed it, or an old job record
+ * predates stored handles). Providers that need more than the ID recover
+ * it themselves: Kling tries both task types, Seedance uses its model's app.
+ */
+export declare function jobFromTaskId(provider: string, taskId: string, opts?: {
+    model?: string;
+    taskType?: string;
+}): VideoJob;
+export declare function mimeTypeForPath(path: string, fallback: string): string;
+/** A local path, URL, or data URI as a URL or data URI (local files are inlined). */
+export declare function fileToUrlOrDataUri(input: string, fallbackMimeType: string): Promise<string>;
+/**
+ * An input image in the form `generator` takes: uploaded to the configured
+ * upload host for URL-only providers, inlined as a data URI otherwise.
+ *
+ * Remote URLs are never fetched here: an inline-only provider gets a usage
+ * error instead, so a tool call cannot make the CLI read an internal URL
+ * and forward its contents to a provider.
+ */
+export declare function videoImageInput(generator: VideoGenerator, input: string): Promise<string>;

package/dist/commands/ai-video.d.ts

@@ -1,21 +1,21 @@
 /**
  * @module ai-video
- * @description Library functions for video generation, status, cancel, and
- * extension. Powers the manifest tools `generate_video`,
- * `generate_video_status`, `generate_video_cancel`, `generate_video_extend`
- * (the user reaches these via `vibe generate video[-...]`).
- *
- * The legacy `vibe ai video / video-status / video-cancel / kling / kling-status /
- * video-extend` Commander registrations were removed alongside the dead
- * `commands/ai.ts` orchestrator (the `vibe ai *` namespace was never
- * `addCommand`'d to `program`).
+ * @description Video generation, status, cancel, and extension on the video
+ * job contract. Powers the manifest tools `generate_video`,
+ * `generate_video_cancel`, `generate_video_extend`, and job refreshes in
+ * `vibe status`; every provider goes through `VideoGenerator`, so nothing
+ * here branches on provider names.
  *
  * @see MODELS.md for AI model configuration
  */
+import { type ProviderErrorKind, type VideoJob, type VideoJobState } from "@vibeframe/ai-providers";
 export interface VideoGenerateOptions {
     prompt: string;
+    /** Default: the configured or first available video provider. */
     provider?: "grok" | "runway" | "kling" | "veo" | "seedance" | "fal" | "omni";
     image?: string;
+    /** Ending frame for providers that interpolate between two frames. */
+    endImage?: string;
     refImages?: string[];
     refVideos?: string[];
     refAudio?: string[];
@@ -34,21 +34,37 @@ export interface VideoGenerateOptions {
     output?: string;
     wait?: boolean;
     apiKey?: string;
+    /**
+     * Called as soon as the provider accepts the job, before waiting, so the
+     * caller can record it: a crash or timeout mid-wait then leaves a job that
+     * can still be polled and downloaded.
+     */
+    onSubmitted?: (job: VideoJob) => void | Promise<void>;
+    /** Called after every poll while waiting. */
+    onProgress?: (state: VideoJobState) => void;
+    /** Veo only: `allow_all` or `allow_adult`. */
+    personGeneration?: string;
 }
 export interface VideoGenerateResult {
     success: boolean;
     taskId?: string;
+    /** The provider job handle; store it to poll, cancel, or extend later. */
+    job?: VideoJob;
     status?: string;
     videoUrl?: string;
     duration?: number;
     outputPath?: string;
     provider?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeVideoGenerate(options: VideoGenerateOptions): Promise<VideoGenerateResult>;
 export interface VideoStatusOptions {
     taskId: string;
-    provider?: "grok" | "runway" | "kling" | "veo";
+    provider?: string;
+    /** The stored job handle; preferred over `taskId` + `taskType`. */
+    job?: VideoJob;
+    /** Kling task type, for a bare task ID. */
     taskType?: "text2video" | "image2video";
     wait?: boolean;
     output?: string;
@@ -63,20 +79,28 @@ export interface VideoStatusResult {
     duration?: number;
     outputPath?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeVideoStatus(options: VideoStatusOptions): Promise<VideoStatusResult>;
 export interface VideoCancelOptions {
     taskId: string;
+    /** Default: runway. */
+    provider?: string;
+    job?: VideoJob;
     apiKey?: string;
 }
 export interface VideoCancelResult {
     success: boolean;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeVideoCancel(options: VideoCancelOptions): Promise<VideoCancelResult>;
 export interface VideoExtendOptions {
+    /** The task ID of the video to extend (Veo: its operation name). */
     videoId: string;
-    provider?: "kling" | "veo";
+    /** Default: kling. */
+    provider?: string;
+    job?: VideoJob;
     prompt?: string;
     duration?: number;
     negative?: string;
@@ -88,10 +112,12 @@ export interface VideoExtendOptions {
 export interface VideoExtendResult {
     success: boolean;
     taskId?: string;
+    job?: VideoJob;
     status?: string;
     videoUrl?: string;
     duration?: number;
     outputPath?: string;
     error?: string;
+    errorKind?: ProviderErrorKind;
 }
 export declare function executeVideoExtend(options: VideoExtendOptions): Promise<VideoExtendResult>;

package/dist/commands/ai-video.network.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/generate/video-cancel.d.ts

@@ -1,8 +1,7 @@
 /**
  * @module generate/video-cancel
- * @description `vibe generate video-cancel` (hidden) — cancel in-flight Grok
- * or Runway video generation. Split out of `generate.ts` in v0.69 (Plan G
- * Phase 2).
+ * @description `vibe generate video-cancel` (hidden) — cancel an in-flight
+ * video job on a provider with a cancel API (Runway, Seedance, Gemini Omni).
  */
 import type { Command } from "commander";
 export declare function registerVideoCancelCommand(parent: Command): void;

package/dist/commands/generate/video-extend.d.ts

@@ -1,8 +1,8 @@
 /**
  * @module generate/video-extend
- * @description `vibe generate video-extend` (hidden) — extend video duration
- * via Kling or Veo (Gemini). Split out of `generate.ts` in v0.69 (Plan G
- * Phase 2).
+ * @description `vibe generate video-extend` (hidden) — extend a generated
+ * video from its last frame, on any provider that can (Kling, Grok classic,
+ * Gemini Omni, and Veo until 2026-10-22).
  */
 import type { Command } from "commander";
 export declare function registerVideoExtendCommand(parent: Command): void;

package/dist/commands/generate/video.d.ts

@@ -1,9 +1,10 @@
 /**
  * @module generate/video
  * @description `vibe generate video` (alias `vid`) — multi-provider video
- * generation. fal.ai (Seedance 2.0), Grok, Veo (Gemini), Kling, Runway,
- * plus Gemini Omni 1.1 Flash (`-p omni`).
- * Split out of `generate.ts` in v0.69 (Plan G Phase 2).
+ * generation (Seedance via fal.ai, Grok, Kling, Runway, Gemini Omni, and Veo
+ * until 2026-10-22). Validation, provider choice, and the dry run live here;
+ * generation itself is `executeVideoGenerate`, the same executor the MCP
+ * tool and builds use.
  */
 import type { Command } from "commander";
 export declare function registerVideoCommand(parent: Command): void;

package/dist/commands/output.d.ts

@@ -22,6 +22,8 @@ export interface StructuredError {
     retryWith?: string[];
     recoverable?: boolean;
     retryable: boolean;
+    /** The provider error kind (`auth`, `quota`, `likeness`, ...) when a provider call failed. */
+    errorKind?: string;
     /**
      * Structured context carried alongside the failure, so a refusal can hand
      * back the evidence it refused on instead of forcing a second call. Used by
@@ -32,6 +34,11 @@ export interface StructuredError {
 export declare function usageError(msg: string, suggestion?: string): StructuredError;
 export declare function authError(envVar: string, provider: string): StructuredError;
 export declare function apiError(msg: string, retryable?: boolean): StructuredError;
+/**
+ * The structured error for a failed provider call, chosen by its error kind
+ * (`ProviderError.kind`) instead of by matching provider wording.
+ */
+export declare function providerFailure(message: string, kind?: string): StructuredError;
 export declare function notFoundError(path: string): StructuredError;
 export declare function networkError(msg: string): StructuredError;
 export declare function generalError(msg: string, suggestion?: string): StructuredError;