qlogicagent 2.13.3 → 2.13.5

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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