qlogicagent 2.13.5 → 2.13.6

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

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

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

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

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

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

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

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

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

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

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