qlogicagent 2.13.4 → 2.13.5

package/dist/cli/tool-bootstrap-media-registration.js

@@ -0,0 +1,348 @@
+import * as path from "node:path";
+import { createImageGenerateTool } from "../skills/tools/image-generate-tool.js";
+import { createTtsTool } from "../skills/tools/tts-tool.js";
+import { createVideoGenerateTool } from "../skills/tools/video-generate-tool.js";
+import { createMusicGenerateTool } from "../skills/tools/music-generate-tool.js";
+import { createVideoEditTool } from "../skills/tools/video-edit-tool.js";
+import { createVideoMergeTool } from "../skills/tools/video-merge-tool.js";
+import { createVideoUpscaleTool } from "../skills/tools/video-upscale-tool.js";
+import { createThreeDGenerateTool } from "../skills/tools/three-d-generate-tool.js";
+import { createSttTool } from "../skills/tools/stt-tool.js";
+import { createVoiceCloneTool } from "../skills/tools/voice-clone-tool.js";
+import { createMediaCancelTool } from "../skills/tools/media-cancel-tool.js";
+import { createPetdexCreateTool } from "../skills/tools/petdex-create-tool.js";
+import { createFileUploadTool, createFileQueryTool, createFileDeleteTool } from "../skills/tools/file-management-tool.js";
+import { cancelMediaTask, generateMedia, generateMusicLyrics, getMediaRuntimeContext, isMediaAvailable, isMediaOperationDeclaredAvailable, isMediaOperationAvailable, } from "./media-runtime-facade.js";
+import { createMediaFileToolService } from "./media-file-tool-service.js";
+import { defineToolRegistrationModule } from "../runtime/ports/index.js";
+import { enforceAbsoluteFloors, resolveToolPath } from "./tool-bootstrap-paths.js";
+export const localMediaToolRegistrationModule = defineToolRegistrationModule({
+    id: "local-media-tools",
+    kind: "media",
+    register: registerLocalMediaTools,
+});
+export function registerLocalMediaTools(context) {
+    const tools = context.tools;
+    tools.push({
+        ...createImageGenerateTool({
+            generateImage: async (params) => {
+                const result = await generateMedia({
+                    mediaType: "image",
+                    model: "",
+                    prompt: params.prompt,
+                    purpose: params.purpose,
+                    style: params.style,
+                    size: params.size,
+                    imageUrl: params.imageUrl,
+                    n: params.n,
+                    quality: params.quality,
+                    seed: params.seed,
+                });
+                return {
+                    mediaUrls: result.mediaUrls,
+                    model: result.model,
+                    size: result.size,
+                    durationMs: result.durationMs,
+                };
+            },
+        }),
+        isConcurrencySafe: true,
+        isEnabled: () => isMediaAvailable("image"),
+    });
+    tools.push({
+        ...createPetdexCreateTool({
+            resolveOutputDir: (outputDir) => {
+                const resolved = outputDir?.trim()
+                    ? resolvePath(context, outputDir)
+                    : path.join(context.activeProjectRoot(), ".qlogicagent", "petdex-assets");
+                const floorError = enforceAbsoluteFloors(resolved);
+                if (floorError)
+                    throw new Error(floorError);
+                return resolved;
+            },
+            generateImage: async (request) => {
+                const result = await generateMedia({
+                    mediaType: "image",
+                    model: "",
+                    prompt: request.prompt,
+                    purpose: request.purpose,
+                    style: request.style,
+                    size: request.size,
+                    imageUrl: request.imageUrl,
+                    referenceImages: request.referenceImages?.map((image) => image.imageUrl),
+                    n: request.n,
+                    quality: request.quality,
+                });
+                return {
+                    mediaUrls: result.mediaUrls,
+                    model: result.model,
+                    size: result.size,
+                    durationMs: result.durationMs,
+                };
+            },
+        }),
+        isEnabled: () => isMediaOperationDeclaredAvailable("image", "img2img"),
+    });
+    tools.push({
+        ...createTtsTool({
+            textToSpeech: async (params) => {
+                const result = await generateMedia({
+                    mediaType: "tts",
+                    model: "",
+                    prompt: "",
+                    text: params.text,
+                    channel: params.channel,
+                    voice: params.voice,
+                    speed: params.speed,
+                });
+                return {
+                    audioPath: "",
+                    provider: result.model,
+                    mediaUrls: result.mediaUrls,
+                };
+            },
+        }),
+        isConcurrencySafe: true,
+        isEnabled: () => isMediaAvailable("tts"),
+    });
+    tools.push({
+        ...createVideoGenerateTool({
+            generateVideo: async (params) => {
+                const result = await generateMedia({
+                    mediaType: "video",
+                    model: "",
+                    prompt: params.prompt,
+                    purpose: params.purpose,
+                    style: params.style,
+                    imageUrl: params.imageUrl,
+                    referenceVideos: params.referenceVideos,
+                    referenceAudios: params.referenceAudios,
+                    generateAudio: params.generateAudio,
+                    aspectRatio: params.aspectRatio,
+                    duration: params.duration,
+                    resolution: params.resolution,
+                    fps: params.fps,
+                    seed: params.seed,
+                    cameraFixed: params.cameraFixed,
+                    returnLastFrame: params.returnLastFrame,
+                    draft: params.draft,
+                    serviceTier: params.serviceTier,
+                    callbackUrl: params.callbackUrl,
+                    safetyIdentifier: params.safetyIdentifier,
+                    executionExpiresAfterSeconds: params.executionExpiresAfterSeconds,
+                    videoTools: params.videoTools,
+                });
+                return {
+                    mediaUrls: result.mediaUrls,
+                    model: result.model,
+                    durationMs: result.durationMs,
+                    lastFrameUrl: result.lastFrameUrl,
+                    taskId: result.taskId,
+                };
+            },
+        }),
+        isConcurrencySafe: true,
+        isEnabled: () => isMediaAvailable("video"),
+    });
+    tools.push({
+        ...createMusicGenerateTool({
+            generateMusic: async (params) => {
+                const result = await generateMedia({
+                    mediaType: "music",
+                    model: "",
+                    prompt: params.prompt,
+                    purpose: params.purpose,
+                    style: params.style,
+                    lyrics: params.lyrics,
+                    duration: params.duration,
+                    isInstrumental: params.isInstrumental,
+                    audioUrl: params.audioUrl,
+                    audioFormat: params.audioFormat,
+                });
+                return {
+                    mediaUrls: result.mediaUrls,
+                    model: result.model,
+                    durationMs: result.durationMs,
+                };
+            },
+            generateLyrics: generateMusicLyrics,
+        }),
+        isConcurrencySafe: true,
+        isEnabled: () => isMediaAvailable("music"),
+    });
+    tools.push({
+        ...createVideoEditTool({
+            editVideo: async (params) => {
+                const result = await generateMedia({
+                    mediaType: "video",
+                    model: "",
+                    prompt: params.prompt,
+                    operation: "edit",
+                    sourceVideos: params.sourceVideos,
+                    referenceImages: params.referenceImages,
+                    duration: params.duration,
+                    aspectRatio: params.aspectRatio,
+                    resolution: params.resolution,
+                });
+                return {
+                    mediaUrls: result.mediaUrls,
+                    model: result.model,
+                    durationMs: result.durationMs,
+                };
+            },
+        }),
+        shouldDefer: true,
+        isEnabled: () => isMediaOperationAvailable("video", "edit"),
+    });
+    tools.push({
+        ...createVideoMergeTool({
+            mergeVideos: async (params) => {
+                const promptParts = [`merge ${params.clips.length} clips`];
+                if (params.transition)
+                    promptParts.push(`transition: ${params.transition}${params.transitionDuration ? ` (${params.transitionDuration}s)` : ""}`);
+                if (params.subtitles)
+                    promptParts.push(`burn-in subtitles: ${params.subtitles}`);
+                if (params.bgm)
+                    promptParts.push(`background music: ${params.bgm}${params.bgmVolume !== undefined ? ` at volume ${params.bgmVolume}` : ""}`);
+                const result = await generateMedia({
+                    mediaType: "video",
+                    model: "",
+                    prompt: promptParts.join("; "),
+                    operation: "merge",
+                    sourceVideos: params.clips.map((c) => c.video),
+                    resolution: params.outputResolution,
+                    fps: params.outputFps,
+                });
+                return {
+                    localPath: "",
+                    servePath: result.mediaUrls[0] ?? "",
+                    durationSec: (result.durationMs ?? 0) / 1000,
+                    clipCount: params.clips.length,
+                    mediaUrls: result.mediaUrls,
+                };
+            },
+        }),
+        shouldDefer: true,
+        isEnabled: () => isMediaOperationAvailable("video", "merge"),
+    });
+    tools.push({
+        ...createVideoUpscaleTool({
+            upscaleVideo: async (params) => {
+                const promptParts = ["upscale"];
+                if (params.sharpness)
+                    promptParts.push(`sharpness: ${params.sharpness}`);
+                const result = await generateMedia({
+                    mediaType: "video",
+                    model: "",
+                    prompt: promptParts.join(", "),
+                    operation: "upscale",
+                    sourceVideos: [params.video],
+                    resolution: params.targetResolution ?? "1080p",
+                });
+                return {
+                    localPath: "",
+                    servePath: result.mediaUrls[0] ?? "",
+                    resolution: params.targetResolution ?? "1080p",
+                    durationSec: (result.durationMs ?? 0) / 1000,
+                    mediaUrls: result.mediaUrls,
+                };
+            },
+        }),
+        shouldDefer: true,
+        isEnabled: () => isMediaOperationAvailable("video", "upscale"),
+    });
+    tools.push({
+        ...createThreeDGenerateTool({
+            generate3D: async (params) => {
+                const result = await generateMedia({
+                    mediaType: "3d",
+                    model: "",
+                    prompt: params.prompt,
+                    imageUrl: params.imageUrl,
+                    outputFormat: params.outputFormat,
+                    seed: params.seed,
+                });
+                return {
+                    mediaUrls: result.mediaUrls,
+                    model: result.model,
+                    durationMs: result.durationMs,
+                    metadata: result.metadata,
+                };
+            },
+        }),
+        isConcurrencySafe: true,
+        shouldDefer: true,
+        isEnabled: () => isMediaAvailable("3d"),
+    });
+    tools.push({
+        ...createSttTool({
+            speechToText: async (params) => {
+                const result = await generateMedia({
+                    mediaType: "stt",
+                    model: "",
+                    prompt: "",
+                    audioUrl: params.audioUrl,
+                    metadata: params.language ? { language: params.language } : undefined,
+                });
+                return {
+                    transcription: result.metadata?.transcription ?? "",
+                    model: result.model,
+                    durationMs: result.durationMs,
+                };
+            },
+        }),
+        shouldDefer: true,
+        isEnabled: () => isMediaAvailable("stt"),
+    });
+    tools.push({
+        ...createVoiceCloneTool({
+            cloneVoice: async (params) => {
+                const result = await generateMedia({
+                    mediaType: "voice_clone",
+                    model: "",
+                    prompt: "",
+                    text: params.text,
+                    audioUrl: params.sampleAudioUrl,
+                    speed: params.speed,
+                });
+                return {
+                    mediaUrls: result.mediaUrls,
+                    model: result.model,
+                    voiceId: result.metadata?.voiceId,
+                    durationMs: result.durationMs,
+                };
+            },
+        }),
+        shouldDefer: true,
+        isEnabled: () => isMediaAvailable("voice_clone"),
+    });
+    tools.push({
+        ...createMediaCancelTool({
+            cancelTask: cancelMediaTask,
+        }),
+        shouldDefer: true,
+        isEnabled: () => isMediaAvailable("video") || isMediaAvailable("3d"),
+    });
+    const mediaFileToolService = createMediaFileToolService({
+        getContext: getMediaRuntimeContext,
+        resolvePath: (input) => resolvePath(context, input),
+    });
+    tools.push({
+        ...createFileUploadTool(mediaFileToolService),
+        shouldDefer: true,
+        isEnabled: () => mediaFileToolService.isAvailable(),
+    });
+    tools.push({
+        ...createFileQueryTool(mediaFileToolService),
+        shouldDefer: true,
+        isEnabled: () => mediaFileToolService.isAvailable(),
+    });
+    tools.push({
+        ...createFileDeleteTool(mediaFileToolService),
+        shouldDefer: true,
+        isEnabled: () => mediaFileToolService.isAvailable(),
+    });
+}
+function resolvePath(context, input) {
+    return resolveToolPath(input, context.getCwd());
+}

package/dist/cli/tool-bootstrap-paths.d.ts

@@ -0,0 +1,7 @@
+export declare function resolveToolPath(input: string, cwd: string): string;
+/**
+ * Enforce absolute, mode-independent floors. Workspace membership belongs to
+ * the permission pipeline; this helper only blocks device/system paths that no
+ * permission mode should allow through local file/media tooling.
+ */
+export declare function enforceAbsoluteFloors(resolved: string): string | null;

package/dist/cli/tool-bootstrap-paths.js

@@ -0,0 +1,17 @@
+import * as path from "node:path";
+export function resolveToolPath(input, cwd) {
+    if (path.isAbsolute(input))
+        return path.normalize(input);
+    return path.resolve(cwd, input);
+}
+/**
+ * Enforce absolute, mode-independent floors. Workspace membership belongs to
+ * the permission pipeline; this helper only blocks device/system paths that no
+ * permission mode should allow through local file/media tooling.
+ */
+export function enforceAbsoluteFloors(resolved) {
+    if (resolved.startsWith("/dev/") || resolved.startsWith("/proc/") || resolved.startsWith("/sys/")) {
+        return `Blocked: device/system path ${resolved}`;
+    }
+    return null;
+}

package/dist/cli/tool-bootstrap-providers.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeToolContract, ToolBootstrapProvider, ToolBootstrapProviderContext, ToolRegistrationModuleKind } from "../runtime/ports/index.js";
+export declare function runToolBootstrapProviders(providers: readonly ToolBootstrapProvider[], context: ToolBootstrapProviderContext): RuntimeToolContract[];
+export declare function createToolBootstrapProvider(id: string, register: ToolBootstrapProvider["register"], kind?: ToolRegistrationModuleKind): ToolBootstrapProvider;

package/dist/cli/tool-bootstrap-providers.js

@@ -0,0 +1,10 @@
+export function runToolBootstrapProviders(providers, context) {
+    const tools = [];
+    for (const provider of providers) {
+        provider.register(tools, context);
+    }
+    return tools;
+}
+export function createToolBootstrapProvider(id, register, kind = "local") {
+    return { id, kind, register };
+}

package/dist/cli/tool-bootstrap-web-registration.d.ts

@@ -0,0 +1,13 @@
+import type { PortableTool } from "../skills/portable-tool.js";
+import type { ModelPurpose } from "../runtime/infra/model-registry.js";
+import type { LLMTransport } from "./provider-core-facade.js";
+export interface LocalWebToolRegistrationContext {
+    tools: PortableTool<any>[];
+    resolveClientForPurpose?(purpose: ModelPurpose): {
+        transport: LLMTransport;
+        apiKey: string;
+        model: string;
+    } | null;
+}
+export declare const localWebToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<LocalWebToolRegistrationContext>;
+export declare function registerLocalWebTools(context: LocalWebToolRegistrationContext): void;

package/dist/cli/tool-bootstrap-web-registration.js

@@ -0,0 +1,144 @@
+import { createWebFetchTool } from "../skills/tools/web-fetch-tool.js";
+import { createWebSearchTool } from "../skills/tools/web-search-tool.js";
+import { createWebAnswerTool } from "../skills/tools/web-answer-tool.js";
+import { createWebResearchTool } from "../skills/tools/web-research-tool.js";
+import { defineToolRegistrationModule } from "../runtime/ports/index.js";
+import { buildWebSearchSources } from "../skills/web-search/source-factory.js";
+import { createMultiSourceBackend } from "../skills/web-search/multi-source-backend.js";
+import { InMemorySourceCache, InMemoryCircuitBreaker } from "../skills/web-search/stability.js";
+import { createCrawl4aiExtractor } from "../skills/web-search/crawl4ai-extractor.js";
+import { createEmbeddingReranker } from "../skills/web-search/embedding-rerank.js";
+import { cascadeWebSearch } from "../orchestration/tool-cascade.js";
+import { getProviderToolAPI } from "./media-runtime-facade.js";
+export const localWebToolRegistrationModule = defineToolRegistrationModule({
+    id: "local-web-tools",
+    kind: "web",
+    register: registerLocalWebTools,
+});
+export function registerLocalWebTools(context) {
+    const tools = context.tools;
+    tools.push(createWebFetchTool(createWebFetchDeps()));
+    tools.push(createWebSearchTool(createWebSearchDeps()));
+    const resolveLlmForWeb = context.resolveClientForPurpose;
+    if (!resolveLlmForWeb)
+        return;
+    const webFetchDepsForWeb = createWebFetchDeps();
+    const searchBackendForWeb = createWebSearchDeps();
+    const webLlmDeps = {
+        search: searchBackendForWeb.search,
+        fetchUrl: webFetchDepsForWeb.fetchUrl,
+        generate: async (purpose, prompt, signal) => {
+            const client = resolveLlmForWeb(purpose) ?? resolveLlmForWeb("textGeneration");
+            if (!client)
+                return null;
+            let out = "";
+            for await (const chunk of client.transport.stream({ model: client.model, messages: [{ role: "user", content: prompt }], temperature: 0.2, maxTokens: 1500, tools: [] }, client.apiKey, signal)) {
+                if (chunk.type === "delta")
+                    out += chunk.text;
+            }
+            return out;
+        },
+    };
+    tools.push(createWebAnswerTool(webLlmDeps));
+    let memoryStateForWeb = null;
+    tools.push(createWebResearchTool({
+        ...webLlmDeps,
+        saveMemory: async (text, meta) => {
+            const { ensureLocalMemoryProvider } = await import("./memory-coordinator.js");
+            const { resolveActiveOwnerUserId } = await import("../runtime/infra/agent-paths.js");
+            memoryStateForWeb ??= ensureLocalMemoryProvider(resolveActiveOwnerUserId());
+            const provider = memoryStateForWeb.toolProvider;
+            if (typeof provider?.addText !== "function")
+                return false;
+            await provider.addText(text, memoryStateForWeb.userId, {
+                source: meta.source,
+                category: meta.category,
+                importance: 0.6,
+            });
+            return true;
+        },
+    }));
+}
+function createWebFetchDeps() {
+    const crawl4ai = createCrawl4aiExtractor();
+    return {
+        async fetchUrl(params) {
+            if (params.extractMode !== "json") {
+                const extracted = await crawl4ai.extract(params.url, { maxChars: params.maxChars, signal: params.signal });
+                if (extracted)
+                    return extracted;
+            }
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 30_000);
+            const onCallerAbort = () => controller.abort();
+            params.signal?.addEventListener("abort", onCallerAbort, { once: true });
+            try {
+                const res = await fetch(params.url, {
+                    signal: controller.signal,
+                    headers: {
+                        "User-Agent": "Mozilla/5.0 (compatible; QLogicAgent/1.0)",
+                        Accept: "text/html,application/xhtml+xml,text/plain,*/*",
+                    },
+                    redirect: "follow",
+                });
+                if (!res.ok) {
+                    return { content: `HTTP ${res.status} ${res.statusText}` };
+                }
+                const contentType = res.headers.get("content-type") ?? "";
+                let body = await res.text();
+                if (params.maxChars && body.length > params.maxChars) {
+                    body = body.slice(0, params.maxChars);
+                }
+                if (contentType.includes("html") && params.extractMode !== "json") {
+                    body = stripHtmlTags(body);
+                }
+                return { content: body, title: extractTitle(body) };
+            }
+            finally {
+                clearTimeout(timeout);
+                params.signal?.removeEventListener("abort", onCallerAbort);
+            }
+        },
+    };
+}
+function stripHtmlTags(html) {
+    return html
+        .replace(/<script[\s\S]*?<\/script>/gi, "")
+        .replace(/<style[\s\S]*?<\/style>/gi, "")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&nbsp;/gi, " ")
+        .replace(/&amp;/gi, "&")
+        .replace(/&lt;/gi, "<")
+        .replace(/&gt;/gi, ">")
+        .replace(/&quot;/gi, '"')
+        .replace(/&#39;/gi, "'")
+        .replace(/\s{2,}/g, " ")
+        .trim();
+}
+function extractTitle(text) {
+    const m = text.match(/<title[^>]*>([^<]+)<\/title>/i);
+    return m?.[1]?.trim();
+}
+function createWebSearchDeps() {
+    const multiSource = createMultiSourceBackend({
+        sources: buildWebSearchSources(),
+        cache: new InMemorySourceCache(),
+        breaker: new InMemoryCircuitBreaker(),
+        perSourceTimeoutMs: 5_000,
+        dedupe: true,
+        maxResults: 10,
+        rerank: createEmbeddingReranker({
+            getProvider: async () => {
+                const { resolveMemoryConfigFromEnv } = await import("../skills/memory/memory-provider-factory.js");
+                const { createEmbeddingProvider } = await import("../skills/memory/local-embedding.js");
+                return createEmbeddingProvider(resolveMemoryConfigFromEnv().embedding);
+            },
+        }),
+    });
+    return {
+        search: (query, options) => {
+            const cascaded = cascadeWebSearch(getProviderToolAPI(), multiSource.search);
+            return cascaded(query, options);
+        },
+    };
+}

package/dist/cli/tool-bootstrap-workflow-registration.d.ts

@@ -0,0 +1,7 @@
+import type { PortableTool } from "../skills/portable-tool.js";
+export interface LocalWorkflowToolRegistrationContext {
+    tools: PortableTool<any>[];
+    activeProjectRoot(): string;
+}
+export declare const localWorkflowToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<LocalWorkflowToolRegistrationContext>;
+export declare function registerLocalWorkflowTools(context: LocalWorkflowToolRegistrationContext): void;

package/dist/cli/tool-bootstrap-workflow-registration.js

@@ -0,0 +1,65 @@
+import { createWorkflowTool } from "../skills/tools/workflow-tool.js";
+import { defineToolRegistrationModule } from "../runtime/ports/index.js";
+import { WorkflowController } from "../orchestration/workflow/workflow-controller.js";
+import { WorkflowStore } from "../orchestration/workflow/workflow-store.js";
+import { getWorkflowController } from "../orchestration/workflow/workflow-service.js";
+export const localWorkflowToolRegistrationModule = defineToolRegistrationModule({
+    id: "local-workflow-tools",
+    kind: "workflow",
+    register: registerLocalWorkflowTools,
+});
+export function registerLocalWorkflowTools(context) {
+    context.tools.push(createWorkflowTool({ getService: () => createWorkflowToolService(context.activeProjectRoot()) }));
+}
+const workflowAuthoringOnlyFactory = () => {
+    throw new Error("workflow tool: this controller is authoring-only; `run` requires the initialized engine");
+};
+function createWorkflowToolService(cwd) {
+    function resolve() {
+        const store = new WorkflowStore(cwd);
+        const live = getWorkflowController();
+        const controller = live ?? new WorkflowController(store, workflowAuthoringOnlyFactory);
+        return { controller, live, store };
+    }
+    return {
+        async list() {
+            return resolve().store.list();
+        },
+        async get(id) {
+            return resolve().store.require(id);
+        },
+        async describe(id) {
+            return resolve().controller.describe(id);
+        },
+        async create(input) {
+            return resolve().controller.create({
+                id: input.id,
+                name: input.name,
+                def: input.def,
+                active: input.active,
+            });
+        },
+        async patch(id, envelope) {
+            return resolve().controller.patch(id, {
+                patch: envelope.patch,
+                baseRev: envelope.baseRev,
+                scope: envelope.scope,
+            });
+        },
+        async setActive(id, active) {
+            return resolve().controller.setActive(id, active);
+        },
+        async run(id) {
+            const { live } = resolve();
+            if (!live) {
+                throw new Error("workflow engine is not initialized in this context. Activate the workflow " +
+                    "(setActive) so a trigger runs it, or run it from the app.");
+            }
+            const trigger = { type: "manual" };
+            return live.run(id, trigger);
+        },
+        async delete(id) {
+            await resolve().store.delete(id);
+        },
+    };
+}

package/dist/cli/tool-bootstrap.background-exec.test.d.ts

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