qlogicagent 2.13.4 → 2.13.5

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

@@ -0,0 +1,384 @@
+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

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

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

@@ -0,0 +1,103 @@
+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

@@ -0,0 +1,73 @@
+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 {};