qlogicagent 2.13.5 → 2.13.7

package/dist/cli/turn-media-setup.js

@@ -1,71 +0,0 @@
-import { getModelRegistry } from "../runtime/infra/model-registry.js";
-import { createProviderToolAPIForSession } from "./provider-core-facade.js";
-import { setMediaClientConfig, setProviderToolAPI } from "./media-runtime-facade.js";
-const MEDIA_PURPOSES = [
-    { purpose: "imageGeneration", capability: "image" },
-    { purpose: "tts", capability: "tts" },
-    { purpose: "videoGeneration", capability: "video" },
-    { purpose: "musicGeneration", capability: "music" },
-    { purpose: "threeDGeneration", capability: "3d" },
-    { purpose: "stt", capability: "stt" },
-    { purpose: "voiceClone", capability: "voice_clone" },
-];
-export function deriveMediaProvidersFromBindings(registry) {
-    const providers = {};
-    for (const { purpose, capability } of MEDIA_PURPOSES) {
-        const binding = registry.getBinding(purpose);
-        if (!binding)
-            continue;
-        providers[capability] = {
-            provider: binding.provider,
-            model: binding.nativeModelId ?? binding.model,
-        };
-    }
-    return providers;
-}
-export function configureTurnMedia(params) {
-    const { host, config, turnId } = params;
-    let mediaUsageOrdinal = 0;
-    const registry = getModelRegistry();
-    const providerApiKeys = registry.snapshotProviderKeys();
-    host.currentMediaApiKeys = providerApiKeys;
-    const mediaProviders = {
-        ...deriveMediaProvidersFromBindings(registry),
-        ...config?.mediaProviders,
-    };
-    setMediaClientConfig(host.mediaClient, providerApiKeys, (event) => {
-        mediaUsageOrdinal += 1;
-        host.sessionState?.addMediaUsage(event.model, event.billingUnit, event.billingQuantity);
-        host.sendNotification("turn.media_usage", {
-            usageId: `${turnId}:media:${mediaUsageOrdinal}`,
-            turnId,
-            mediaType: event.mediaType,
-            provider: event.provider,
-            model: event.model,
-            billingUnit: event.billingUnit,
-            billingQuantity: event.billingQuantity,
-        });
-    }, mediaProviders, (taskId, mediaType, percent, status, provider) => {
-        host.sendNotification("turn.media_progress", {
-            turnId,
-            taskId,
-            mediaType: mediaType,
-            percent,
-            status,
-            ...(provider ? { provider } : {}),
-        });
-    }, (event) => {
-        host.sendNotification("turn.media_capability_check", {
-            turnId,
-            ...event,
-        });
-    });
-    const textModel = registry.getActiveModel("textGeneration");
-    if (textModel) {
-        setProviderToolAPI(createProviderToolAPIForSession(textModel.provider, textModel.apiKey));
-        textModel.keyHandle.release({ success: true });
-    }
-    else {
-        setProviderToolAPI(undefined);
-    }
-}

package/dist/cli/turn-media-setup.test.d.ts

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

package/dist/cli/turn-media-setup.test.js

@@ -1,280 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { generateMedia, runWithMediaOutputDir } from "./media-runtime-facade.js";
-import { configureTurnMedia, deriveMediaProvidersFromBindings } from "./turn-media-setup.js";
-import { getModelRegistry, resetModelRegistry } from "../runtime/infra/model-registry.js";
-function registryWithBindings(bindings) {
-    return {
-        getBinding(purpose) {
-            const binding = bindings[purpose];
-            return binding
-                ? {
-                    id: `${binding.provider}:${binding.model}`,
-                    provider: binding.provider,
-                    model: binding.model,
-                    nativeModelId: binding.nativeModelId,
-                }
-                : null;
-        },
-    };
-}
-describe("deriveMediaProvidersFromBindings", () => {
-    afterEach(() => {
-        resetModelRegistry();
-    });
-    it("uses purpose bindings as default media provider routing", () => {
-        const providers = deriveMediaProvidersFromBindings(registryWithBindings({
-            imageGeneration: {
-                provider: "volcengine",
-                model: "doubao-seedream-4-5",
-                nativeModelId: "doubao-seedream-4-5-251128",
-            },
-            tts: {
-                provider: "zhipu",
-                model: "glm-tts",
-            },
-            videoGeneration: {
-                provider: "volcengine",
-                model: "doubao-seedance-2-0-fast",
-                nativeModelId: "doubao-seedance-2-0-fast-251228",
-            },
-        }));
-        expect(providers).toMatchObject({
-            image: { provider: "volcengine", model: "doubao-seedream-4-5-251128" },
-            tts: { provider: "zhipu", model: "glm-tts" },
-            video: { provider: "volcengine", model: "doubao-seedance-2-0-fast-251228" },
-        });
-    });
-    it("emits a media usage notification when a configured media provider is charged", async () => {
-        const notifications = [];
-        const mediaUsages = [];
-        const registry = getModelRegistry();
-        registry.addProvider("fake-media");
-        registry.addKey("fake-media", "fake-key");
-        configureTurnMedia({
-            turnId: "turn-media-test",
-            config: {
-                mediaProviders: {
-                    image: { provider: "fake-media", model: "fake-image-model" },
-                },
-            },
-            host: {
-                mediaClient: {
-                    getTransport(providerId) {
-                        expect(providerId).toBe("fake-media");
-                        return {
-                            async generate(request) {
-                                return {
-                                    mediaUrls: ["https://example.test/image.webp"],
-                                    model: request.model,
-                                    billingUnit: "per_call",
-                                    billingQuantity: 1,
-                                };
-                            },
-                        };
-                    },
-                    listMediaModels() {
-                        return [];
-                    },
-                    resolveModelById(provider, model) {
-                        return {
-                            providerId: provider,
-                            modelInfo: {
-                                id: model,
-                                name: model,
-                                mediaCapabilities: { mediaType: "image" },
-                            },
-                        };
-                    },
-                },
-                currentMediaApiKeys: null,
-                sessionState: {
-                    addMediaUsage(model, billingUnit, quantity) {
-                        mediaUsages.push({ model, billingUnit, quantity });
-                    },
-                },
-                sendNotification(method, params) {
-                    notifications.push({ method, params });
-                },
-            },
-        });
-        const result = await generateMedia({ mediaType: "image", model: "", prompt: "pet" });
-        expect(result.provider).toBe("fake-media");
-        expect(mediaUsages).toEqual([{ model: "fake-image-model", billingUnit: "per_image", quantity: 1 }]);
-        expect(notifications).toContainEqual({
-            method: "turn.media_usage",
-            params: {
-                usageId: "turn-media-test:media:1",
-                turnId: "turn-media-test",
-                mediaType: "image",
-                provider: "fake-media",
-                model: "fake-image-model",
-                billingUnit: "per_image",
-                billingQuantity: 1,
-            },
-        });
-    });
-    it("passes the current session media directory to provider transports without changing the global cache env", async () => {
-        const registry = getModelRegistry();
-        registry.addProvider("fake-media");
-        registry.addKey("fake-media", "fake-key");
-        const outputDir = "F:\\workspace\\project\\.qlogicagent\\sessions\\session-1\\media";
-        const previousCacheDir = process.env.QLOGICAGENT_CACHE_DIR;
-        process.env.QLOGICAGENT_CACHE_DIR = "F:\\global-cache-should-not-be-used";
-        let seenOutputDir;
-        try {
-            configureTurnMedia({
-                turnId: "turn-media-output-dir-test",
-                config: {
-                    mediaProviders: {
-                        tts: { provider: "fake-media", model: "fake-tts-model" },
-                    },
-                },
-                host: {
-                    mediaClient: {
-                        getTransport(providerId) {
-                            expect(providerId).toBe("fake-media");
-                            return {
-                                async generate(request) {
-                                    seenOutputDir = request.outputDir;
-                                    return {
-                                        mediaUrls: ["file:///F:/workspace/project/.qlogicagent/sessions/session-1/media/tts/voice.wav"],
-                                        model: request.model,
-                                        billingUnit: "per_character",
-                                        billingQuantity: 5,
-                                    };
-                                },
-                            };
-                        },
-                        listMediaModels() {
-                            return [];
-                        },
-                        resolveModelById(provider, model) {
-                            return {
-                                providerId: provider,
-                                modelInfo: {
-                                    id: model,
-                                    name: model,
-                                    mediaCapabilities: { mediaType: "tts" },
-                                },
-                            };
-                        },
-                    },
-                    currentMediaApiKeys: null,
-                    sendNotification() { },
-                },
-            });
-            await runWithMediaOutputDir(outputDir, () => generateMedia({
-                mediaType: "tts",
-                model: "",
-                prompt: "hello",
-                text: "hello",
-            }));
-            expect(seenOutputDir).toBe(outputDir);
-            expect(process.env.QLOGICAGENT_CACHE_DIR).toBe("F:\\global-cache-should-not-be-used");
-        }
-        finally {
-            if (previousCacheDir === undefined) {
-                delete process.env.QLOGICAGENT_CACHE_DIR;
-            }
-            else {
-                process.env.QLOGICAGENT_CACHE_DIR = previousCacheDir;
-            }
-        }
-    });
-    it("rejects empty media URL results for image generation", async () => {
-        const registry = getModelRegistry();
-        registry.addProvider("fake-media");
-        registry.addKey("fake-media", "fake-key");
-        configureTurnMedia({
-            turnId: "turn-empty-media-test",
-            config: {
-                mediaProviders: {
-                    image: { provider: "fake-media", model: "fake-image-model" },
-                },
-            },
-            host: {
-                mediaClient: {
-                    getTransport() {
-                        return {
-                            async generate() {
-                                return {
-                                    mediaUrls: [],
-                                    model: "fake-image-model",
-                                    billingUnit: "per_call",
-                                    billingQuantity: 1,
-                                };
-                            },
-                        };
-                    },
-                    listMediaModels() {
-                        return [];
-                    },
-                    resolveModelById() {
-                        return undefined;
-                    },
-                },
-                currentMediaApiKeys: null,
-                sendNotification() { },
-            },
-        });
-        await expect(generateMedia({ mediaType: "image", model: "", prompt: "pet" }))
-            .rejects.toThrow("returned no media URLs");
-    });
-    it("does not fail over to another image provider when the configured provider fails", async () => {
-        const registry = getModelRegistry();
-        registry.addProvider("primary-media");
-        registry.addKey("primary-media", "primary-key");
-        registry.addProvider("secondary-media");
-        registry.addKey("secondary-media", "secondary-key");
-        let secondaryCalls = 0;
-        configureTurnMedia({
-            turnId: "turn-strict-media-test",
-            config: {
-                mediaProviders: {
-                    image: { provider: "primary-media", model: "primary-image-model" },
-                },
-            },
-            host: {
-                mediaClient: {
-                    getTransport(providerId) {
-                        if (providerId === "primary-media") {
-                            return {
-                                async generate() {
-                                    throw new Error("primary reference image rejected");
-                                },
-                            };
-                        }
-                        if (providerId === "secondary-media") {
-                            return {
-                                async generate() {
-                                    secondaryCalls += 1;
-                                    return {
-                                        mediaUrls: ["https://example.test/secondary.webp"],
-                                        model: "secondary-image-model",
-                                        billingUnit: "per_call",
-                                        billingQuantity: 1,
-                                    };
-                                },
-                            };
-                        }
-                        return undefined;
-                    },
-                    listMediaModels() {
-                        return [{
-                                providerId: "secondary-media",
-                                modelInfo: { id: "secondary-image-model", mediaType: "image" },
-                            }];
-                    },
-                    resolveModelById() {
-                        return undefined;
-                    },
-                },
-                currentMediaApiKeys: null,
-                sendNotification() { },
-            },
-        });
-        await expect(generateMedia({ mediaType: "image", model: "", prompt: "pet" }))
-            .rejects.toThrow("Configured media provider primary-media failed for image: primary reference image rejected");
-        expect(secondaryCalls).toBe(0);
-    });
-});

package/dist/cli/turn-permission-sync.d.ts

@@ -1,6 +0,0 @@
-import type { PermissionEngineConfig, PermissionMode, PermissionRuleEntry } from "../runtime/ports/index.js";
-export interface TurnPermissionRuleEngine {
-    setMode(mode: PermissionMode): void;
-    replaceRules(rules: PermissionRuleEntry[]): void;
-}
-export declare function syncTurnPermissionConfig(ruleEngine: TurnPermissionRuleEngine, rawPermissions: unknown): PermissionEngineConfig;

package/dist/cli/turn-permission-sync.js

@@ -1,7 +0,0 @@
-import { parseRuntimePermissionConfig } from "./permission-runtime-service.js";
-export function syncTurnPermissionConfig(ruleEngine, rawPermissions) {
-    const permConfig = parseRuntimePermissionConfig(rawPermissions);
-    ruleEngine.setMode(permConfig.mode);
-    ruleEngine.replaceRules(permConfig.rules);
-    return permConfig;
-}

package/dist/cli/turn-permission-sync.test.d.ts

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

package/dist/cli/turn-permission-sync.test.js

@@ -1,20 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { syncTurnPermissionConfig } from "./turn-permission-sync.js";
-describe("syncTurnPermissionConfig", () => {
-    it("syncs the incoming permission mode and persistent rules", () => {
-        const ruleEngine = {
-            setMode: vi.fn(),
-            replaceRules: vi.fn(),
-        };
-        const parsed = syncTurnPermissionConfig(ruleEngine, {
-            mode: "auto",
-            rules: [{ pattern: "write", behavior: "allow" }],
-        });
-        expect(parsed).toEqual({
-            mode: "auto",
-            rules: [{ pattern: "write", behavior: "allow" }],
-        });
-        expect(ruleEngine.setMode).toHaveBeenCalledWith("auto");
-        expect(ruleEngine.replaceRules).toHaveBeenCalledWith([{ pattern: "write", behavior: "allow" }]);
-    });
-});

package/dist/cli/turn-project-router.d.ts

@@ -1,22 +0,0 @@
-export interface TurnProjectRoutingHost {
-    getActiveProjectRoot(): string;
-    setActiveWorkdir(workdir: string): void;
-    log(message: string): void;
-    sendNotification(method: string, params: Record<string, unknown>): void;
-}
-export interface StaleProjectHintContext {
-    activeProjectName?: string;
-    projectNames: string[];
-}
-export interface TurnProjectRoutingResult {
-    sessionProjectRoot: string;
-    sessionProjectId?: string;
-    projectHintStale: boolean;
-    staleProjectHintContext?: StaleProjectHintContext;
-}
-export declare function routeTurnProjectContext(params: {
-    config?: Record<string, unknown>;
-    sessionId?: string;
-    host: TurnProjectRoutingHost;
-    nowMs?: number;
-}): TurnProjectRoutingResult;

package/dist/cli/turn-project-router.js

@@ -1,141 +0,0 @@
-import * as path from "node:path";
-import * as projectStore from "../runtime/infra/project-store.js";
-import { getDefaultPathService } from "../runtime/infra/default-path-service.js";
-import { SessionLocator } from "../runtime/session/session-locator.js";
-import { getSessionMetadata } from "../runtime/session/session-persistence.js";
-const PROJECT_HINT_TTL_MS = 30 * 60 * 1000;
-const locator = new SessionLocator();
-export function routeTurnProjectContext(params) {
-    const { config, host, sessionId } = params;
-    if (config?.workdir && typeof config.workdir === "string") {
-        host.setActiveWorkdir(config.workdir);
-    }
-    if (!config?.workdir && sessionId && config?.projectId) {
-        const projectId = config.projectId;
-        try {
-            const workspaceDir = locator.getProjectWorkspaceDir(projectId);
-            if (host.getActiveProjectRoot() !== workspaceDir) {
-                host.log(`[turn] routing session ${sessionId} to project ${projectId} (${workspaceDir})`);
-                host.setActiveWorkdir(workspaceDir);
-            }
-        }
-        catch {
-            host.log(`[turn] project ${projectId} not found, using active project`);
-        }
-    }
-    if (config?.sessionType === "group" && typeof config?.groupKey === "string") {
-        routeGroupTurnProject(config, host);
-    }
-    const hintResult = routeProjectHint(config, host, params.nowMs ?? Date.now());
-    const sessionProjectRoot = resolveSessionProjectRoot(config, host);
-    return {
-        sessionProjectRoot,
-        sessionProjectId: resolveSessionProjectId(config, sessionProjectRoot, sessionId),
-        projectHintStale: hintResult.projectHintStale,
-        staleProjectHintContext: hintResult.staleProjectHintContext,
-    };
-}
-function routeGroupTurnProject(config, host) {
-    const groupKey = config.groupKey;
-    const parts = groupKey.split(":");
-    const compositeGroupId = parts.length >= 3 ? parts.slice(1).join(":") : groupKey;
-    const groupProject = projectStore.findByGroupId(compositeGroupId);
-    if (groupProject) {
-        host.setActiveWorkdir(groupProject.workspaceDir);
-        const active = projectStore.getActiveProject();
-        if (active?.id !== groupProject.id) {
-            projectStore.switchProject(groupProject.id);
-        }
-        return;
-    }
-    const groupName = config.groupName || compositeGroupId;
-    const safeGroupDir = compositeGroupId.replace(/[<>:"/\\|?*\x00-\x1f]/g, "_").trim() || "group";
-    const workspaceDir = path.join(getDefaultPathService().getUserAgentHome(), "workspaces", "groups", safeGroupDir);
-    const newProject = projectStore.createProject({
-        name: groupName,
-        workspaceDir,
-        type: "group",
-        groupId: compositeGroupId,
-    });
-    host.setActiveWorkdir(newProject.workspaceDir);
-    projectStore.switchProject(newProject.id);
-    host.sendNotification("project.created", {
-        id: newProject.id,
-        name: newProject.name,
-        type: "group",
-        groupId: compositeGroupId,
-        workspaceDir: newProject.workspaceDir,
-    });
-}
-function routeProjectHint(config, host, nowMs) {
-    const rawHint = config?.projectHint;
-    const hintObj = rawHint && typeof rawHint === "object" && "name" in rawHint
-        ? rawHint
-        : typeof rawHint === "string" ? { name: rawHint, updatedAt: nowMs } : null;
-    if (!hintObj || config?.sessionType === "group") {
-        return { projectHintStale: false };
-    }
-    const age = nowMs - hintObj.updatedAt;
-    if (age > PROJECT_HINT_TTL_MS) {
-        host.log(`[projectHint] stale (${Math.round(age / 60000)}min old), skipping auto-switch`);
-        const activeProject = projectStore.getActiveProject();
-        return {
-            projectHintStale: true,
-            staleProjectHintContext: {
-                activeProjectName: activeProject?.name,
-                projectNames: projectStore.listProjects()
-                    .filter(p => p.status === "active")
-                    .map(p => p.name)
-                    .slice(0, 10),
-            },
-        };
-    }
-    const hintName = hintObj.name;
-    const active = projectStore.getActiveProject();
-    if (!active || active.name.toLowerCase() !== hintName.toLowerCase()) {
-        const allProjects = projectStore.listProjects();
-        const hintLower = hintName.toLowerCase();
-        const target = allProjects.find(p => p.name.toLowerCase() === hintLower)
-            ?? allProjects.find(p => p.name.toLowerCase().includes(hintLower));
-        if (target && target.status === "active") {
-            projectStore.switchProject(target.id);
-            host.setActiveWorkdir(target.workspaceDir);
-        }
-    }
-    return { projectHintStale: false };
-}
-function resolveSessionProjectRoot(config, host) {
-    if (typeof config?.workdir === "string" && config.workdir) {
-        return config.workdir;
-    }
-    const projectId = config?.projectId;
-    if (projectId) {
-        try {
-            return locator.getProjectWorkspaceDir(projectId);
-        }
-        catch {
-            // Fall back to the active workdir below.
-        }
-    }
-    return host.getActiveProjectRoot();
-}
-function resolveSessionProjectId(config, sessionProjectRoot, sessionId) {
-    if (sessionId) {
-        const existingMetadata = getSessionMetadata(sessionId, sessionProjectRoot);
-        if (existingMetadata?.projectId)
-            return existingMetadata.projectId;
-    }
-    const explicitProjectId = config?.projectId;
-    if (explicitProjectId && projectStore.getProjectById(explicitProjectId)) {
-        return explicitProjectId;
-    }
-    const activeProject = projectStore.getActiveProject();
-    if (activeProject && samePath(activeProject.workspaceDir, sessionProjectRoot)) {
-        return activeProject.id;
-    }
-    const matchingProject = projectStore.listProjects().find(project => samePath(project.workspaceDir, sessionProjectRoot));
-    return matchingProject?.id;
-}
-function samePath(left, right) {
-    return path.resolve(left).toLowerCase() === path.resolve(right).toLowerCase();
-}

package/dist/cli/turn-project-router.test.d.ts

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

package/dist/cli/turn-project-router.test.js

@@ -1,79 +0,0 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { routeTurnProjectContext } from "./turn-project-router.js";
-import * as projectStore from "../runtime/infra/project-store.js";
-import { updateSessionMetadata } from "../runtime/session/session-persistence.js";
-const cleanupPaths = [];
-afterEach(() => {
-    vi.unstubAllEnvs();
-    for (const cleanupPath of cleanupPaths.splice(0)) {
-        rmSync(cleanupPath, { recursive: true, force: true });
-    }
-});
-function makeTempDir(prefix) {
-    const dir = mkdtempSync(join(tmpdir(), prefix));
-    cleanupPaths.push(dir);
-    return dir;
-}
-describe("routeTurnProjectContext", () => {
-    it("uses config.workdir as the session project root even when the active project is stale", () => {
-        const setActiveWorkdir = vi.fn();
-        const host = {
-            getActiveProjectRoot: () => "F:\\stale-active-project",
-            setActiveWorkdir,
-            log: vi.fn(),
-            sendNotification: vi.fn(),
-        };
-        const routed = routeTurnProjectContext({
-            config: { workdir: "F:\\requested-turn-project" },
-            sessionId: "session-workdir",
-            host,
-        });
-        expect(setActiveWorkdir).toHaveBeenCalledWith("F:\\requested-turn-project");
-        expect(routed.sessionProjectRoot).toBe("F:\\requested-turn-project");
-    });
-    it("returns the active project id when config.workdir belongs to the active project", () => {
-        const agentHome = makeTempDir("qlogicagent-router-home-");
-        const workspaceDir = makeTempDir("qlogicagent-router-workspace-");
-        vi.stubEnv("QLOGICAGENT_HOME", agentHome);
-        const project = projectStore.createProject({ name: "router-project", workspaceDir });
-        const setActiveWorkdir = vi.fn();
-        const host = {
-            getActiveProjectRoot: () => workspaceDir,
-            setActiveWorkdir,
-            log: vi.fn(),
-            sendNotification: vi.fn(),
-        };
-        const routed = routeTurnProjectContext({
-            config: { workdir: workspaceDir },
-            sessionId: "session-workdir",
-            host,
-        });
-        expect(routed.sessionProjectRoot).toBe(workspaceDir);
-        expect(routed.sessionProjectId).toBe(project.id);
-    });
-    it("preserves an existing session project id when another active project shares the workspace", async () => {
-        const agentHome = makeTempDir("qlogicagent-router-home-");
-        const workspaceDir = makeTempDir("qlogicagent-router-workspace-");
-        vi.stubEnv("QLOGICAGENT_HOME", agentHome);
-        const projectA = projectStore.createProject({ name: "router-project-a", workspaceDir });
-        const projectB = projectStore.createProject({ name: "router-project-b", workspaceDir });
-        const sessionId = "shared-workspace-session";
-        await updateSessionMetadata(sessionId, { projectId: projectA.id }, workspaceDir);
-        projectStore.switchProject(projectB.id);
-        const host = {
-            getActiveProjectRoot: () => workspaceDir,
-            setActiveWorkdir: vi.fn(),
-            log: vi.fn(),
-            sendNotification: vi.fn(),
-        };
-        const routed = routeTurnProjectContext({
-            config: { workdir: workspaceDir },
-            sessionId,
-            host,
-        });
-        expect(routed.sessionProjectId).toBe(projectA.id);
-    });
-});