qlogicagent 2.13.5 → 2.13.6

package/dist/cli/media-capability-schema.js

@@ -1,384 +0,0 @@
-const FALLBACK_MODES = {
-    image: ["text2image", "img2img"],
-    video: ["text2video", "img2video", "video2video", "edit", "merge", "upscale"],
-    music: ["text2music", "cover"],
-    tts: ["text2speech"],
-    "3d": ["text2_3d", "img2_3d"],
-    stt: ["speech2text"],
-    voice_clone: ["voice_clone"],
-};
-export function normalizeMediaCapabilitySchema(mediaType, rawCapabilities) {
-    const raw = isRecord(rawCapabilities) ? rawCapabilities : {};
-    const rawLimits = isRecord(raw.limits) ? raw.limits : {};
-    const rawFeatures = isRecord(raw.features) ? raw.features : {};
-    const rawDurationSeconds = isRecord(rawLimits.durationSeconds) ? rawLimits.durationSeconds : {};
-    const operations = stringArray(raw.operations) ?? [];
-    const explicitModes = stringArray(raw.modes) ?? [];
-    const declaredModes = unique([
-        ...operations.flatMap((operation) => operationToModes(mediaType, operation)),
-        ...explicitModes.flatMap((mode) => operationToModes(mediaType, mode)),
-    ]);
-    const modes = declaredModes.length > 0
-        ? declaredModes
-        : (FALLBACK_MODES[mediaType] ?? []);
-    const source = declaredModes.length > 0 ? "declared" : "fallback";
-    return {
-        mediaType,
-        modes,
-        declaredModes,
-        source,
-        raw,
-        limits: {
-            sizes: stringArray(rawLimits.sizes) ?? stringArray(raw.sizes),
-            resolutions: stringArray(rawLimits.resolutions) ?? stringArray(raw.resolutions),
-            aspectRatios: stringArray(rawLimits.aspectRatios) ?? stringArray(raw.aspectRatios),
-            fps: numberArray(rawLimits.fps) ?? numberArray(raw.fps),
-            durationSeconds: {
-                min: numberValue(rawDurationSeconds.min) ?? numberValue(raw.minDurationSeconds),
-                max: numberValue(rawDurationSeconds.max) ?? numberValue(raw.maxDurationSeconds),
-            },
-            maxReferenceImages: limitValue(rawLimits.maxReferenceImages ?? raw.maxReferenceImages, defaultReferenceImageLimit(mediaType, modes)),
-            maxReferenceVideos: limitValue(rawLimits.maxReferenceVideos ?? raw.maxReferenceVideos, defaultReferenceVideoLimit(modes)),
-            maxReferenceAudios: limitValue(rawLimits.maxReferenceAudios ?? raw.maxReferenceAudios, defaultReferenceAudioLimit(modes)),
-            maxSourceVideos: limitValue(rawLimits.maxSourceVideos ?? raw.maxSourceVideos, undefined),
-            maxOutputs: limitValue(rawLimits.maxOutputs ?? raw.maxOutputs, undefined),
-            voices: stringArray(rawLimits.voices) ?? stringArray(raw.voices),
-            maxCharacters: numberValue(rawLimits.maxCharacters) ?? numberValue(raw.maxCharacters),
-            formats: stringArray(rawLimits.formats) ?? stringArray(raw.formats),
-            outputFormats: stringArray(rawLimits.outputFormats) ?? stringArray(raw.outputFormats),
-        },
-        features: {
-            transparentBackground: booleanValue(rawFeatures.transparentBackground) ?? booleanValue(raw.transparentBackground),
-            generateAudio: booleanValue(rawFeatures.generateAudio) ?? booleanValue(raw.supportsGenerateAudio) ?? booleanValue(raw.generateAudio),
-            returnLastFrame: booleanValue(rawFeatures.returnLastFrame) ?? booleanValue(raw.supportsReturnLastFrame) ?? booleanValue(raw.returnLastFrame),
-            serviceTiers: stringArray(rawFeatures.serviceTiers) ?? stringArray(raw.serviceTiers),
-            videoTools: stringArray(rawFeatures.videoTools) ?? stringArray(raw.videoTools),
-        },
-    };
-}
-export function resolveMediaCapabilityDecision(request, schema) {
-    const mode = inferRequestedMode(request);
-    const modeLabel = mediaModeLabel(mode);
-    if (!schema.modes.includes(mode)) {
-        return { allowed: false, mode, reason: `${schema.mediaType} model does not support ${modeLabel}` };
-    }
-    const checks = [
-        checkStringMember("size", request.size, schema.limits.sizes),
-        checkStringMember("resolution", request.resolution, schema.limits.resolutions),
-        checkStringMember("aspect ratio", request.aspectRatio, schema.limits.aspectRatios),
-        checkNumberMember("fps", request.fps, schema.limits.fps),
-        checkNumberMaximum("duration", request.duration, schema.limits.durationSeconds?.max, "s"),
-        checkNumberMinimum("duration", request.duration, schema.limits.durationSeconds?.min, "s"),
-        checkCount("reference image", referenceImageCount(request), schema.limits.maxReferenceImages),
-        checkCount("reference video", request.referenceVideos?.length ?? 0, schema.limits.maxReferenceVideos),
-        checkCount("reference audio", request.referenceAudios?.length ?? 0, schema.limits.maxReferenceAudios),
-        checkCount("source video", request.sourceVideos?.length ?? 0, schema.limits.maxSourceVideos),
-        checkNumberMaximum("outputs", request.n, schema.limits.maxOutputs),
-        checkStringMember("voice", request.voice, schema.limits.voices),
-        checkTextMaximum("text", request.text, schema.limits.maxCharacters),
-        checkStringMember("audio format", request.audioFormat, schema.limits.formats),
-        checkStringMember("output format", request.outputFormat, schema.limits.outputFormats),
-        checkStringMember("service tier", request.serviceTier, schema.features.serviceTiers),
-        checkVideoTools(request.videoTools, schema.features.videoTools),
-        request.generateAudio && !schema.features.generateAudio ? "current video model does not support generated audio" : null,
-        request.returnLastFrame && !schema.features.returnLastFrame ? "current video model does not support returning the last frame" : null,
-    ];
-    const failed = checks.find((check) => !!check);
-    if (failed)
-        return { allowed: false, mode, reason: failed };
-    return { allowed: true, mode };
-}
-export function buildMediaToolParameterSchema(toolName, baseSchema, capability) {
-    const schema = cloneSchema(baseSchema);
-    const properties = getProperties(schema);
-    if (!properties)
-        return schema;
-    switch (toolName) {
-        case "image_generate":
-            if (!capability.modes.includes("img2img"))
-                delete properties.image_url;
-            applyStringEnum(properties.size, capability.limits.sizes);
-            applyNumberMaximum(properties.n, capability.limits.maxOutputs);
-            break;
-        case "video_generate":
-            if (!capability.modes.includes("img2video"))
-                delete properties.image_url;
-            if (!capability.modes.includes("video2video") && !capability.modes.includes("multimodal_reference")) {
-                delete properties.reference_videos;
-            }
-            if ((capability.limits.maxReferenceAudios ?? 0) <= 0)
-                delete properties.reference_audios;
-            else
-                applyNumberMaximum(properties.reference_audios, capability.limits.maxReferenceAudios, "maxItems");
-            if (!capability.features.generateAudio)
-                delete properties.generate_audio;
-            if (!capability.features.returnLastFrame)
-                delete properties.return_last_frame;
-            if (!capability.features.serviceTiers?.length)
-                delete properties.service_tier;
-            if (!capability.features.videoTools?.length)
-                delete properties.video_tools;
-            applyStringEnum(properties.resolution, capability.limits.resolutions);
-            applyStringEnum(properties.aspect_ratio, capability.limits.aspectRatios);
-            applyNumberEnum(properties.fps, capability.limits.fps);
-            applyNumberMaximum(properties.duration, capability.limits.durationSeconds?.max);
-            applyNumberMinimum(properties.duration, capability.limits.durationSeconds?.min);
-            break;
-        case "video_edit":
-            applyNumberMaximum(properties.source_videos, capability.limits.maxSourceVideos, "maxItems");
-            applyNumberMaximum(properties.reference_images, capability.limits.maxReferenceImages, "maxItems");
-            applyStringEnum(properties.resolution, capability.limits.resolutions);
-            applyStringEnum(properties.aspect_ratio, capability.limits.aspectRatios);
-            applyNumberMaximum(properties.duration, capability.limits.durationSeconds?.max);
-            applyNumberMinimum(properties.duration, capability.limits.durationSeconds?.min);
-            break;
-        case "tts":
-            applyStringEnum(properties.voice, capability.limits.voices);
-            applyNumberMaximum(properties.text, capability.limits.maxCharacters, "maxLength");
-            break;
-        case "music_generate":
-            if (!capability.modes.includes("cover"))
-                delete properties.cover_audio_url;
-            applyNumberMaximum(properties.duration, capability.limits.durationSeconds?.max);
-            applyStringEnum(properties.audio_format, capability.limits.formats);
-            break;
-        case "three_d_generate":
-            if (!capability.modes.includes("img2_3d"))
-                delete properties.image_url;
-            applyStringEnum(properties.output_format, capability.limits.outputFormats);
-            break;
-    }
-    return schema;
-}
-function inferRequestedMode(request) {
-    switch (request.mediaType) {
-        case "image":
-            return request.imageUrl || (request.referenceImages?.length ?? 0) > 0 ? "img2img" : "text2image";
-        case "video":
-            if (request.operation === "edit" || request.operation === "merge" || request.operation === "upscale" || request.operation === "extend") {
-                return request.operation;
-            }
-            if ((request.imageRoles?.includes("first_frame") && request.imageRoles.includes("last_frame"))
-                || (request.referenceImages?.length ?? 0) >= 2) {
-                return "first_last_frame";
-            }
-            if ((request.referenceAudios?.length ?? 0) > 0)
-                return "multimodal_reference";
-            if ((request.referenceVideos?.length ?? 0) > 0 || (request.sourceVideos?.length ?? 0) > 0)
-                return "video2video";
-            if (request.imageUrl || (request.referenceImages?.length ?? 0) > 0)
-                return "img2video";
-            return "text2video";
-        case "music":
-        case "music_realtime":
-            return request.audioUrl ? "cover" : "text2music";
-        case "tts":
-            return "text2speech";
-        case "3d":
-            return request.imageUrl ? "img2_3d" : "text2_3d";
-        case "stt":
-            return "speech2text";
-        case "voice_clone":
-            return "voice_clone";
-        default:
-            return "text2image";
-    }
-}
-function operationToModes(mediaType, operation) {
-    const op = operation.trim().toLowerCase().replace(/-/g, "_");
-    switch (op) {
-        case "text2image":
-        case "text_to_image":
-        case "t2i":
-            return ["text2image"];
-        case "img2img":
-        case "image2image":
-        case "image_to_image":
-        case "i2i":
-            return ["img2img"];
-        case "inpainting":
-        case "outpainting":
-            return [op];
-        case "text2video":
-        case "text_to_video":
-        case "t2v":
-            return ["text2video"];
-        case "img2video":
-        case "image2video":
-        case "image_to_video":
-        case "i2v":
-            return ["img2video"];
-        case "firstlastframe":
-        case "first_last_frame":
-        case "first_last_frames":
-            return ["first_last_frame"];
-        case "video2video":
-        case "video_to_video":
-        case "v2v":
-            return ["video2video"];
-        case "multimodal":
-        case "multimodal_reference":
-            return ["multimodal_reference"];
-        case "edit":
-        case "merge":
-        case "upscale":
-        case "extend":
-            return [op];
-        case "text2music":
-        case "text_to_music":
-            return ["text2music"];
-        case "cover":
-        case "realtime":
-            return [op];
-        case "text2speech":
-        case "text_to_speech":
-        case "tts":
-            return ["text2speech"];
-        case "voice_clone":
-        case "voiceclone":
-            return ["voice_clone"];
-        case "text2_3d":
-        case "text_to_3d":
-            return ["text2_3d"];
-        case "img2_3d":
-        case "image2_3d":
-        case "image_to_3d":
-            return ["img2_3d"];
-        case "speech2text":
-        case "stt":
-            return ["speech2text"];
-        default:
-            return mediaType === "image" ? [] : [];
-    }
-}
-function defaultReferenceImageLimit(mediaType, modes) {
-    if (mediaType === "image" && modes.includes("img2img"))
-        return 1;
-    if (mediaType === "video" && (modes.includes("img2video") || modes.includes("first_last_frame") || modes.includes("multimodal_reference")))
-        return 1;
-    if (mediaType === "3d" && modes.includes("img2_3d"))
-        return 1;
-    return undefined;
-}
-function defaultReferenceVideoLimit(modes) {
-    return modes.includes("video2video") || modes.includes("multimodal_reference") ? 3 : undefined;
-}
-function defaultReferenceAudioLimit(modes) {
-    return modes.includes("multimodal_reference") ? 3 : undefined;
-}
-function mediaModeLabel(mode) {
-    switch (mode) {
-        case "img2img": return "image-to-image";
-        case "img2video": return "image-to-video";
-        case "video2video": return "video-to-video";
-        case "first_last_frame": return "first/last-frame video";
-        case "multimodal_reference": return "multimodal reference video";
-        case "img2_3d": return "image-to-3D";
-        case "text2speech": return "text-to-speech";
-        default: return mode;
-    }
-}
-function checkStringMember(label, value, allowed) {
-    if (!value || !allowed?.length)
-        return null;
-    return allowed.some((item) => item.toLowerCase() === value.toLowerCase())
-        ? null
-        : `${label} ${value} is not supported; supported values: ${allowed.join(", ")}`;
-}
-function checkNumberMember(label, value, allowed) {
-    if (value === undefined || !allowed?.length)
-        return null;
-    return allowed.includes(value) ? null : `${label} ${value} is not supported; supported values: ${allowed.join(", ")}`;
-}
-function checkNumberMaximum(label, value, max, suffix = "") {
-    if (value === undefined || max === undefined)
-        return null;
-    return value <= max ? null : `${label} ${value}${suffix} exceeds supported maximum ${max}${suffix}`;
-}
-function checkNumberMinimum(label, value, min, suffix = "") {
-    if (value === undefined || min === undefined)
-        return null;
-    return value >= min ? null : `${label} ${value}${suffix} is below supported minimum ${min}${suffix}`;
-}
-function checkTextMaximum(label, value, max) {
-    if (value === undefined || max === undefined)
-        return null;
-    return value.length <= max ? null : `${label} length ${value.length} exceeds supported maximum ${max}`;
-}
-function checkCount(label, count, max) {
-    if (count <= 0 || max === undefined)
-        return null;
-    return count <= max ? null : `${label} count ${count} exceeds supported maximum ${max}`;
-}
-function checkVideoTools(value, allowed) {
-    if (!value?.length)
-        return null;
-    if (!allowed?.length)
-        return "current video model does not support video tools";
-    const unsupported = value.filter((item) => !allowed.some((candidate) => candidate.toLowerCase() === item.toLowerCase()));
-    return unsupported.length === 0 ? null : `video tool ${unsupported[0]} is not supported; supported values: ${allowed.join(", ")}`;
-}
-function referenceImageCount(request) {
-    return (request.imageUrl ? 1 : 0) + (request.referenceImages?.length ?? 0);
-}
-function cloneSchema(schema) {
-    return JSON.parse(JSON.stringify(schema));
-}
-function getProperties(schema) {
-    const properties = schema.properties;
-    return isRecord(properties) ? properties : undefined;
-}
-function applyStringEnum(property, values) {
-    if (!property || !values?.length)
-        return;
-    property.enum = values;
-}
-function applyNumberEnum(property, values) {
-    if (!property || !values?.length)
-        return;
-    property.enum = values;
-}
-function applyNumberMaximum(property, value, key = "maximum") {
-    if (!property || value === undefined)
-        return;
-    property[key] = value;
-}
-function applyNumberMinimum(property, value) {
-    if (!property || value === undefined)
-        return;
-    property.minimum = value;
-}
-function isRecord(value) {
-    return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function stringArray(value) {
-    if (!Array.isArray(value))
-        return undefined;
-    const out = value.filter((item) => typeof item === "string" && item.trim().length > 0);
-    return out.length ? out : undefined;
-}
-function numberArray(value) {
-    if (!Array.isArray(value))
-        return undefined;
-    const out = value.filter((item) => typeof item === "number" && Number.isFinite(item));
-    return out.length ? out : undefined;
-}
-function numberValue(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-function limitValue(value, fallback) {
-    const n = numberValue(value);
-    return n !== undefined ? n : fallback;
-}
-function booleanValue(value) {
-    return typeof value === "boolean" ? value : undefined;
-}
-function unique(items) {
-    const out = [];
-    for (const item of items ?? []) {
-        if (item === undefined || out.includes(item))
-            continue;
-        out.push(item);
-    }
-    return out;
-}

package/dist/cli/media-capability-schema.test.d.ts

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

package/dist/cli/media-capability-schema.test.js

@@ -1,103 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildMediaToolParameterSchema, normalizeMediaCapabilitySchema, resolveMediaCapabilityDecision, } from "./media-capability-schema.js";
-import { IMAGE_GENERATE_TOOL_SCHEMA } from "../skills/tools/image-generate-tool.js";
-import { VIDEO_GENERATE_TOOL_SCHEMA } from "../skills/tools/video-generate-tool.js";
-describe("media capability schema", () => {
-    it("normalizes legacy image operations and rejects unsupported img2img requests", () => {
-        const schema = normalizeMediaCapabilitySchema("image", {
-            type: "image",
-            operations: ["text2image"],
-            sizes: ["1024x1024"],
-        });
-        expect(schema.modes).toEqual(["text2image"]);
-        const decision = resolveMediaCapabilityDecision({
-            mediaType: "image",
-            model: "text-only-image",
-            prompt: "restyle this",
-            imageUrl: "https://example.test/ref.png",
-        }, schema);
-        expect(decision.allowed).toBe(false);
-        expect(decision.mode).toBe("img2img");
-        expect(decision.reason).toContain("does not support image-to-image");
-    });
-    it("accepts declared image sizes and rejects undeclared dimensions", () => {
-        const schema = normalizeMediaCapabilitySchema("image", {
-            type: "image",
-            operations: ["text2image", "img2img"],
-            sizes: ["1024x1024", "1792x1024"],
-        });
-        expect(resolveMediaCapabilityDecision({
-            mediaType: "image",
-            model: "image-model",
-            prompt: "city",
-            size: "1792x1024",
-        }, schema).allowed).toBe(true);
-        const rejected = resolveMediaCapabilityDecision({
-            mediaType: "image",
-            model: "image-model",
-            prompt: "city",
-            size: "512x512",
-        }, schema);
-        expect(rejected.allowed).toBe(false);
-        expect(rejected.reason).toContain("size 512x512");
-    });
-    it("builds a narrowed image tool schema from the current model capabilities", () => {
-        const schema = normalizeMediaCapabilitySchema("image", {
-            type: "image",
-            operations: ["text2image"],
-            sizes: ["1024x1024"],
-        });
-        const toolSchema = buildMediaToolParameterSchema("image_generate", IMAGE_GENERATE_TOOL_SCHEMA, schema);
-        const properties = toolSchema.properties;
-        expect(properties.image_url).toBeUndefined();
-        expect(properties.size.enum).toEqual(["1024x1024"]);
-    });
-    it("builds a narrowed video tool schema from reference and resolution limits", () => {
-        const schema = normalizeMediaCapabilitySchema("video", {
-            type: "video",
-            operations: ["text2video"],
-            maxDurationSeconds: 8,
-            resolutions: ["720p"],
-            aspectRatios: ["16:9"],
-            fps: [24],
-        });
-        const toolSchema = buildMediaToolParameterSchema("video_generate", VIDEO_GENERATE_TOOL_SCHEMA, schema);
-        const properties = toolSchema.properties;
-        expect(properties.image_url).toBeUndefined();
-        expect(properties.reference_videos).toBeUndefined();
-        expect(properties.reference_audios).toBeUndefined();
-        expect(properties.generate_audio).toBeUndefined();
-        expect(properties.return_last_frame).toBeUndefined();
-        expect(properties.resolution.enum).toEqual(["720p"]);
-        expect(properties.duration.maximum).toBe(8);
-    });
-    it("normalizes upstream provider-core modes, limits, and features", () => {
-        const schema = normalizeMediaCapabilitySchema("video", {
-            type: "video",
-            modes: ["text2video", "img2video"],
-            limits: {
-                durationSeconds: { min: 4, max: 8 },
-                resolutions: ["720P"],
-                maxReferenceImages: 1,
-            },
-            features: {
-                generateAudio: true,
-                returnLastFrame: true,
-            },
-        });
-        expect(schema.modes).toEqual(["text2video", "img2video"]);
-        expect(schema.limits.durationSeconds).toEqual({ min: 4, max: 8 });
-        expect(schema.limits.resolutions).toEqual(["720P"]);
-        expect(schema.features.generateAudio).toBe(true);
-        expect(schema.features.returnLastFrame).toBe(true);
-        expect(resolveMediaCapabilityDecision({
-            mediaType: "video",
-            model: "video-model",
-            prompt: "camera move",
-            duration: 8,
-            resolution: "720P",
-            generateAudio: true,
-            returnLastFrame: true,
-        }, schema).allowed).toBe(true);
-    });
-});

package/dist/cli/media-file-api-service.d.ts

@@ -1,73 +0,0 @@
-import { type MediaCapability, type VolcengineFileTransport } from "./provider-core-facade.js";
-export interface MediaFileApiProvider {
-    id: string;
-    type: "volcengine" | "gemini";
-}
-export interface MediaFileServiceContext {
-    mediaClient: {
-        getTransport(providerId: string): unknown;
-    } | undefined;
-    mediaProviders: Partial<Record<MediaCapability, {
-        provider: string;
-        model: string;
-    }>>;
-    mediaApiKeys: Record<string, string>;
-}
-export interface MediaFileUploadInput {
-    buffer: Buffer;
-    filename: string;
-    mimeType: string;
-    bytes: number;
-    purpose?: string;
-}
-export interface MediaFileUploadResult {
-    fileId: string;
-    url?: string;
-    filename: string;
-    bytes: number;
-    provider: string;
-}
-export interface MediaFileInfo {
-    id: string;
-    filename: string;
-    bytes: number;
-    status: string;
-    createdAt?: string;
-    url?: string;
-}
-interface GeminiFileInfo {
-    name: string;
-    uri?: string;
-    state?: string;
-    displayName?: string;
-    sizeBytes?: string | number;
-    createTime?: string;
-}
-interface GeminiFileApiClient {
-    uploadFile(buffer: Buffer, apiKey: string, options: {
-        mimeType: string;
-        displayName: string;
-    }): Promise<GeminiFileInfo>;
-    waitForProcessing(fileName: string, apiKey: string): Promise<GeminiFileInfo>;
-    getFile(fileId: string, apiKey: string): Promise<GeminiFileInfo>;
-    listFiles(apiKey: string, options: {
-        pageSize: number;
-    }): Promise<{
-        files: GeminiFileInfo[];
-    }>;
-    deleteFile(fileId: string, apiKey: string): Promise<void>;
-}
-export interface MediaFileApiServiceDeps {
-    createGeminiFileApi?: () => GeminiFileApiClient;
-    isVolcengineFileTransport?: (transport: unknown) => transport is VolcengineFileTransport;
-}
-export interface MediaFileApiService {
-    resolveProvider(context: MediaFileServiceContext): MediaFileApiProvider | undefined;
-    uploadFile(context: MediaFileServiceContext, input: MediaFileUploadInput): Promise<MediaFileUploadResult>;
-    queryFile(context: MediaFileServiceContext, fileId: string): Promise<MediaFileInfo>;
-    listFiles(context: MediaFileServiceContext, limit: number): Promise<MediaFileInfo[]>;
-    deleteFile(context: MediaFileServiceContext, fileId: string): Promise<void>;
-}
-export declare function createMediaFileApiService(deps?: MediaFileApiServiceDeps): MediaFileApiService;
-export declare const defaultMediaFileApiService: MediaFileApiService;
-export {};