qlogicagent 2.13.3 → 2.13.5

package/dist/cli/media-file-api-service.js

@@ -0,0 +1,143 @@
+import { createGeminiFileApi, isVolcengineFileTransport as defaultIsVolcengineFileTransport, resolveMediaApiKey, } from "./provider-core-facade.js";
+function toVolcengineUploadPurpose(_purpose) {
+    return "user_data";
+}
+export function createMediaFileApiService(deps = {}) {
+    const createGeminiApi = deps.createGeminiFileApi ?? createGeminiFileApi;
+    const isVolcengineFileTransport = deps.isVolcengineFileTransport ?? defaultIsVolcengineFileTransport;
+    const resolveProvider = (context) => {
+        if (context.mediaClient) {
+            for (const [, config] of Object.entries(context.mediaProviders)) {
+                if (!config)
+                    continue;
+                const transport = context.mediaClient.getTransport(config.provider);
+                const apiKey = resolveMediaApiKey(context.mediaApiKeys, config.provider);
+                if (isVolcengineFileTransport(transport) && apiKey) {
+                    return { id: config.provider, type: "volcengine" };
+                }
+            }
+        }
+        if (context.mediaApiKeys.google) {
+            return { id: "google", type: "gemini" };
+        }
+        return undefined;
+    };
+    const requireProvider = (context) => {
+        const provider = resolveProvider(context);
+        if (!provider) {
+            throw new Error("No file API provider available. Configure a media provider with Files API support (e.g. Volcengine, Google).");
+        }
+        return provider;
+    };
+    const requireVolcengineTransport = (context, providerId) => {
+        const transport = context.mediaClient?.getTransport(providerId);
+        if (!isVolcengineFileTransport(transport)) {
+            throw new Error(`File API only supported via Volcengine or Google provider. Current: ${providerId}`);
+        }
+        return transport;
+    };
+    const requireApiKey = (context, providerId) => {
+        const apiKey = resolveMediaApiKey(context.mediaApiKeys, providerId);
+        if (!apiKey) {
+            throw new Error(`No API key for file API provider: ${providerId}`);
+        }
+        return apiKey;
+    };
+    return {
+        resolveProvider,
+        uploadFile: async (context, input) => {
+            const fileProvider = requireProvider(context);
+            if (fileProvider.type === "gemini") {
+                const api = createGeminiApi();
+                const apiKey = context.mediaApiKeys.google;
+                const fileInfo = await api.uploadFile(input.buffer, apiKey, {
+                    mimeType: input.mimeType,
+                    displayName: input.filename,
+                });
+                const processed = fileInfo.state === "PROCESSING"
+                    ? await api.waitForProcessing(fileInfo.name, apiKey)
+                    : fileInfo;
+                return {
+                    fileId: processed.name,
+                    url: processed.uri,
+                    filename: input.filename,
+                    bytes: input.bytes,
+                    provider: "google",
+                };
+            }
+            const transport = requireVolcengineTransport(context, fileProvider.id);
+            const apiKey = requireApiKey(context, fileProvider.id);
+            const result = await transport.uploadFile(new Blob([input.buffer]), apiKey, {
+                purpose: toVolcengineUploadPurpose(input.purpose),
+                filename: input.filename,
+            });
+            let url = result.url ?? result.fileId ?? result.id;
+            try {
+                const fileInfo = await transport.getFile(result.id, apiKey);
+                if (typeof fileInfo.url === "string" && fileInfo.url) {
+                    url = fileInfo.url;
+                }
+            }
+            catch {
+                // getFile may fail for freshly uploaded files; the upload itself succeeded.
+            }
+            return {
+                fileId: result.id,
+                url,
+                filename: input.filename,
+                bytes: input.bytes,
+                provider: fileProvider.id,
+            };
+        },
+        queryFile: async (context, fileId) => {
+            const fileProvider = requireProvider(context);
+            if (fileProvider.type === "gemini") {
+                const data = await createGeminiApi().getFile(fileId, context.mediaApiKeys.google);
+                return normalizeGeminiFile(data);
+            }
+            const transport = requireVolcengineTransport(context, fileProvider.id);
+            const data = await transport.getFile(fileId, requireApiKey(context, fileProvider.id));
+            return normalizeVolcengineFile(data, fileId);
+        },
+        listFiles: async (context, limit) => {
+            const fileProvider = requireProvider(context);
+            if (fileProvider.type === "gemini") {
+                const result = await createGeminiApi().listFiles(context.mediaApiKeys.google, { pageSize: limit });
+                return result.files.map(normalizeGeminiFile);
+            }
+            const transport = requireVolcengineTransport(context, fileProvider.id);
+            const data = await transport.listFiles(requireApiKey(context, fileProvider.id), { limit });
+            return (data.data ?? []).map((file) => normalizeVolcengineFile(file));
+        },
+        deleteFile: async (context, fileId) => {
+            const fileProvider = requireProvider(context);
+            if (fileProvider.type === "gemini") {
+                await createGeminiApi().deleteFile(fileId, context.mediaApiKeys.google);
+                return;
+            }
+            const transport = requireVolcengineTransport(context, fileProvider.id);
+            await transport.deleteFile(fileId, requireApiKey(context, fileProvider.id));
+        },
+    };
+}
+export const defaultMediaFileApiService = createMediaFileApiService();
+function normalizeGeminiFile(file) {
+    return {
+        id: file.name,
+        filename: file.displayName ?? "",
+        bytes: Number(file.sizeBytes ?? 0),
+        status: file.state?.toLowerCase() ?? "unknown",
+        createdAt: file.createTime,
+        url: file.uri,
+    };
+}
+function normalizeVolcengineFile(file, fallbackId = "") {
+    return {
+        id: String(file.id ?? fallbackId),
+        filename: String(file.filename ?? ""),
+        bytes: Number(file.bytes ?? 0),
+        status: String(file.status ?? "unknown"),
+        createdAt: file.created_at ? String(file.created_at) : undefined,
+        url: file.url ? String(file.url) : undefined,
+    };
+}

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

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

package/dist/cli/media-file-api-service.test.js

@@ -0,0 +1,119 @@
+import { describe, expect, it, vi } from "vitest";
+import { createMediaFileApiService } from "./media-file-api-service.js";
+describe("createMediaFileApiService", () => {
+    it("uploads through the configured Volcengine file transport", async () => {
+        const transport = {
+            uploadFile: vi.fn(async (_blob, _apiKey, options) => ({
+                id: `uploaded-${options.filename}`,
+            })),
+            getFile: vi.fn(async () => ({
+                id: "uploaded-demo.png",
+                filename: "demo.png",
+                bytes: 42,
+                status: "ready",
+                url: "https://files.example/demo.png",
+            })),
+            listFiles: vi.fn(),
+            deleteFile: vi.fn(),
+        };
+        const context = {
+            mediaClient: {
+                getTransport: (providerId) => providerId === "volcengine" ? transport : undefined,
+            },
+            mediaProviders: {
+                image: { provider: "volcengine", model: "doubao-image" },
+            },
+            mediaApiKeys: { volcengine: "volc-key" },
+        };
+        const service = createMediaFileApiService({
+            isVolcengineFileTransport: (candidate) => candidate === transport,
+        });
+        await expect(service.uploadFile(context, {
+            buffer: Buffer.from("demo"),
+            filename: "demo.png",
+            mimeType: "image/png",
+            bytes: 4,
+            purpose: "media_reference",
+        })).resolves.toEqual({
+            fileId: "uploaded-demo.png",
+            url: "https://files.example/demo.png",
+            filename: "demo.png",
+            bytes: 4,
+            provider: "volcengine",
+        });
+        expect(transport.uploadFile).toHaveBeenCalledWith(expect.any(Blob), "volc-key", {
+            purpose: "user_data",
+            filename: "demo.png",
+        });
+    });
+    it("does not resolve Doubao media provider aliases to the canonical Volcengine key", async () => {
+        const transport = {
+            uploadFile: vi.fn(async () => ({ id: "uploaded-alias.png" })),
+            getFile: vi.fn(async () => ({ id: "uploaded-alias.png", filename: "alias.png" })),
+            listFiles: vi.fn(async () => ({ data: [] })),
+            deleteFile: vi.fn(async () => { }),
+        };
+        const context = {
+            mediaClient: {
+                getTransport: (providerId) => providerId === "doubao" ? transport : undefined,
+            },
+            mediaProviders: {
+                video: { provider: "doubao", model: "doubao-seedance" },
+            },
+            mediaApiKeys: { volcengine: "canonical-volc-key" },
+        };
+        const service = createMediaFileApiService({
+            isVolcengineFileTransport: (candidate) => candidate === transport,
+        });
+        expect(service.resolveProvider(context)).toBeUndefined();
+        await expect(service.uploadFile(context, {
+            buffer: Buffer.from("demo"),
+            filename: "alias.png",
+            mimeType: "image/png",
+            bytes: 4,
+        })).rejects.toThrow("No file API provider available.");
+        expect(transport.uploadFile).not.toHaveBeenCalled();
+    });
+    it("uses Gemini file API when google key is available without a media transport", async () => {
+        const geminiApi = {
+            uploadFile: vi.fn(async () => ({
+                name: "files/demo",
+                uri: "gemini://files/demo",
+                state: "PROCESSING",
+            })),
+            waitForProcessing: vi.fn(async () => ({
+                name: "files/demo",
+                uri: "gemini://files/demo",
+                state: "ACTIVE",
+            })),
+            getFile: vi.fn(),
+            listFiles: vi.fn(),
+            deleteFile: vi.fn(),
+        };
+        const context = {
+            mediaClient: undefined,
+            mediaProviders: {},
+            mediaApiKeys: { google: "google-key" },
+        };
+        const service = createMediaFileApiService({
+            createGeminiFileApi: () => geminiApi,
+        });
+        await expect(service.uploadFile(context, {
+            buffer: Buffer.from("demo"),
+            filename: "demo.txt",
+            mimeType: "text/plain",
+            bytes: 4,
+        })).resolves.toEqual({
+            fileId: "files/demo",
+            url: "gemini://files/demo",
+            filename: "demo.txt",
+            bytes: 4,
+            provider: "google",
+        });
+        expect(geminiApi.uploadFile).toHaveBeenCalledWith(Buffer.from("demo"), "google-key", {
+            mimeType: "text/plain",
+            displayName: "demo.txt",
+        });
+        expect(geminiApi.waitForProcessing).toHaveBeenCalledWith("files/demo", "google-key");
+    });
+});

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

@@ -0,0 +1,13 @@
+import type { FileDeleteToolDeps, FileQueryToolDeps, FileUploadToolDeps } from "../skills/tools/file-management-tool.js";
+import { type MediaFileApiService, type MediaFileServiceContext } from "./media-file-api-service.js";
+export interface MediaFileToolServiceOptions {
+    getContext(): MediaFileServiceContext;
+    resolvePath(filePath: string): string;
+    mediaFileApiService?: MediaFileApiService;
+    maxUploadBytes?: number;
+}
+export interface MediaFileToolService extends FileUploadToolDeps, FileQueryToolDeps, FileDeleteToolDeps {
+    isAvailable(): boolean;
+}
+export declare function createMediaFileToolService(options: MediaFileToolServiceOptions): MediaFileToolService;
+export declare function isMediaFileApiAvailable(context: MediaFileServiceContext, apiService?: MediaFileApiService): boolean;

package/dist/cli/media-file-tool-service.js

@@ -0,0 +1,63 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { defaultMediaFileApiService, } from "./media-file-api-service.js";
+export function createMediaFileToolService(options) {
+    const maxUploadBytes = options.maxUploadBytes ?? 100 * 1024 * 1024;
+    const apiService = options.mediaFileApiService ?? defaultMediaFileApiService;
+    return {
+        isAvailable: () => isMediaFileApiAvailable(options.getContext(), apiService),
+        uploadFile: async (params) => {
+            requireMediaFileApi(options.getContext(), apiService, "upload");
+            const resolved = options.resolvePath(params.filePath);
+            if (!fs.existsSync(resolved))
+                throw new Error(`File not found: ${resolved}`);
+            const stat = fs.statSync(resolved);
+            if (stat.size > maxUploadBytes) {
+                throw new Error(`File too large (${(stat.size / 1024 / 1024).toFixed(1)} MB). Max: ${(maxUploadBytes / 1024 / 1024).toFixed(0)} MB.`);
+            }
+            const buffer = await fs.promises.readFile(resolved);
+            const filename = path.basename(resolved);
+            const ext = path.extname(resolved).toLowerCase();
+            return apiService.uploadFile(options.getContext(), {
+                buffer: Buffer.from(buffer),
+                filename,
+                bytes: stat.size,
+                mimeType: EXTENSION_MIME_MAP[ext] ?? "application/octet-stream",
+                purpose: params.purpose ?? "media_reference",
+            });
+        },
+        queryFile: async (params) => {
+            requireMediaFileApi(options.getContext(), apiService, "query");
+            return apiService.queryFile(options.getContext(), params.fileId);
+        },
+        listFiles: async (params) => {
+            requireMediaFileApi(options.getContext(), apiService, "list");
+            return apiService.listFiles(options.getContext(), params.limit ?? 10);
+        },
+        deleteFile: async (params) => {
+            requireMediaFileApi(options.getContext(), apiService, "delete");
+            await apiService.deleteFile(options.getContext(), params.fileId);
+        },
+    };
+}
+export function isMediaFileApiAvailable(context, apiService = defaultMediaFileApiService) {
+    return !!apiService.resolveProvider(context);
+}
+function requireMediaFileApi(context, apiService, operation) {
+    if (isMediaFileApiAvailable(context, apiService))
+        return;
+    throw new Error(`No file ${operation} provider available. Configure a media provider with Files API support (e.g. Volcengine, Google).`);
+}
+const EXTENSION_MIME_MAP = {
+    ".pdf": "application/pdf", ".txt": "text/plain", ".html": "text/html", ".htm": "text/html",
+    ".css": "text/css", ".js": "text/javascript", ".ts": "text/plain", ".json": "application/json",
+    ".xml": "application/xml", ".csv": "text/csv", ".md": "text/markdown",
+    ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif",
+    ".webp": "image/webp", ".bmp": "image/bmp", ".svg": "image/svg+xml",
+    ".mp3": "audio/mpeg", ".wav": "audio/wav", ".ogg": "audio/ogg", ".flac": "audio/flac",
+    ".m4a": "audio/mp4", ".aac": "audio/aac",
+    ".mp4": "video/mp4", ".webm": "video/webm", ".avi": "video/x-msvideo", ".mov": "video/quicktime",
+    ".doc": "application/msword", ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xls": "application/vnd.ms-excel", ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+};

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

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

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

@@ -0,0 +1,106 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { generateMedia } from "./media-runtime-facade.js";
+import { configureTurnMedia } from "./turn-media-setup.js";
+import { getAllBaseTools, setMediaClientConfig } from "./tool-bootstrap.js";
+import { createLegacyToolCatalog } from "./tool-registry-adapter.js";
+import { getModelRegistry, resetModelRegistry } from "../runtime/infra/model-registry.js";
+function bindFakeKey(provider = "fake-media") {
+    const registry = getModelRegistry();
+    registry.addProvider(provider);
+    registry.addKey(provider, "fake-key");
+}
+function createMediaClient(params) {
+    return {
+        getTransport() {
+            return {
+                supportedTypes: [params.mediaType],
+                async generate(request) {
+                    params.onGenerate?.(request);
+                    return {
+                        mediaUrls: [`https://example.test/${params.mediaType}.out`],
+                        model: request.model,
+                    };
+                },
+            };
+        },
+        resolveModelById(provider, model) {
+            return {
+                providerId: provider,
+                mediaType: params.mediaType,
+                providerDef: { id: provider },
+                modelInfo: {
+                    id: model,
+                    name: model,
+                    mediaType: params.mediaType,
+                    mediaCapabilities: params.capabilities,
+                },
+            };
+        },
+        listMediaModels() {
+            return [];
+        },
+    };
+}
+describe("media runtime capability preflight", () => {
+    afterEach(() => {
+        setMediaClientConfig(undefined);
+        resetModelRegistry();
+    });
+    it("blocks unsupported media requests before calling the provider and emits an observable decision", async () => {
+        bindFakeKey();
+        let generateCalls = 0;
+        const notifications = [];
+        configureTurnMedia({
+            turnId: "turn-capability-test",
+            config: {
+                mediaProviders: {
+                    image: { provider: "fake-media", model: "text-only-image" },
+                },
+            },
+            host: {
+                mediaClient: createMediaClient({
+                    mediaType: "image",
+                    capabilities: { type: "image", operations: ["text2image"], sizes: ["1024x1024"] },
+                    onGenerate: () => { generateCalls += 1; },
+                }),
+                currentMediaApiKeys: null,
+                sendNotification(method, params) {
+                    notifications.push({ method, params });
+                },
+            },
+        });
+        await expect(generateMedia({
+            mediaType: "image",
+            model: "",
+            prompt: "restyle",
+            imageUrl: "https://example.test/ref.png",
+        })).rejects.toThrow("does not support image-to-image");
+        expect(generateCalls).toBe(0);
+        expect(notifications).toContainEqual({
+            method: "turn.media_capability_check",
+            params: expect.objectContaining({
+                turnId: "turn-capability-test",
+                mediaType: "image",
+                provider: "fake-media",
+                model: "text-only-image",
+                mode: "img2img",
+                allowed: false,
+            }),
+        });
+    });
+    it("narrows the image tool manifest to the current model capabilities", () => {
+        bindFakeKey();
+        getAllBaseTools({ workdir: process.cwd() });
+        setMediaClientConfig(createMediaClient({
+            mediaType: "image",
+            capabilities: { type: "image", operations: ["text2image"], sizes: ["1024x1024"] },
+        }), { "fake-media": "fake-key" }, undefined, { image: { provider: "fake-media", model: "text-only-image" } });
+        const tool = createLegacyToolCatalog()
+            .getToolManifest(true)
+            .find((entry) => entry.function.name === "image_generate");
+        expect(tool?.function.parameters).toBeTruthy();
+        const properties = tool.function.parameters.properties;
+        expect(properties.image_url).toBeUndefined();
+        expect(properties.size.enum).toEqual(["1024x1024"]);
+    });
+});

package/dist/cli/media-runtime-facade.d.ts

@@ -0,0 +1,51 @@
+import { type MediaCapability, type MediaClient, type MediaRequest, type MediaResult, type ProviderToolAPI } from "./provider-core-facade.js";
+import type { MediaFileServiceContext } from "./media-file-api-service.js";
+export interface MediaUsageCallbackEvent {
+    mediaType: string;
+    provider: string;
+    model: string;
+    billingUnit: string;
+    billingQuantity: number;
+}
+export interface MediaCapabilityCheckEvent {
+    mediaType: string;
+    provider: string;
+    model: string;
+    mode: string;
+    allowed: boolean;
+    reason?: string;
+    capabilities: {
+        modes: string[];
+        source: string;
+        limits: Record<string, unknown>;
+        features: Record<string, unknown>;
+    };
+}
+export declare function setProviderToolAPI(api: ProviderToolAPI | undefined): void;
+export declare function getProviderToolAPI(): ProviderToolAPI | undefined;
+export declare function setMediaClientConfig(client: MediaClient | undefined, apiKeys?: Record<string, string>, onMediaUsage?: (event: MediaUsageCallbackEvent) => void, providers?: Partial<Record<MediaCapability, {
+    provider: string;
+    model: string;
+}>>, onMediaProgress?: (taskId: string, mediaType: string, percent: number, status: string, provider?: string) => void, onMediaCapabilityCheck?: (event: MediaCapabilityCheckEvent) => void): void;
+export declare function getMediaRuntimeContext(): MediaFileServiceContext;
+export declare function runWithMediaOutputDir<T>(outputDir: string | undefined, fn: () => Promise<T>): Promise<T>;
+export declare function generateMedia(request: MediaRequest): Promise<MediaResult>;
+/**
+ * Ensure an image size satisfies the resolved model's minimum resolution.
+ * Only applies to models with a known minimum (Volcengine Seedream); everything
+ * else is returned unchanged so providers that require small sizes (e.g. OpenAI
+ * 1024×1024) keep working. Sub-minimum "WxH" sizes are scaled up preserving
+ * aspect ratio; anything unparseable falls back to the always-valid named "2K".
+ */
+export declare function normalizeImageSize(size: string | undefined, providerId: string | undefined, modelId: string | undefined): string | undefined;
+export declare function isMediaAvailable(mediaType: string): boolean;
+export declare function isMediaOperationAvailable(mediaType: string, operation: string): boolean;
+export declare function isMediaOperationDeclaredAvailable(mediaType: string, operation: string): boolean;
+export declare function generateMusicLyrics(prompt: string): Promise<string>;
+export declare function cancelMediaTask(params: {
+    taskId: string;
+    provider?: string;
+}): Promise<{
+    ok: boolean;
+    message: string;
+}>;