qlogicagent 2.10.22 → 2.10.24

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

@@ -0,0 +1,73 @@
+import { type MediaCapability, type VolcengineFileTransport } from "./provider-core-facade.js";
+export interface MediaFileApiProvider {
+    id: string;
+    type: "volcengine" | "gemini";
+}
+export interface MediaFileServiceContext {
+    mediaClient: {
+        getTransport(providerId: string): unknown;
+    } | undefined;
+    mediaProviders: Partial<Record<MediaCapability, {
+        provider: string;
+        model: string;
+    }>>;
+    mediaApiKeys: Record<string, string>;
+}
+export interface MediaFileUploadInput {
+    buffer: Buffer;
+    filename: string;
+    mimeType: string;
+    bytes: number;
+    purpose?: string;
+}
+export interface MediaFileUploadResult {
+    fileId: string;
+    url?: string;
+    filename: string;
+    bytes: number;
+    provider: string;
+}
+export interface MediaFileInfo {
+    id: string;
+    filename: string;
+    bytes: number;
+    status: string;
+    createdAt?: string;
+    url?: string;
+}
+interface GeminiFileInfo {
+    name: string;
+    uri?: string;
+    state?: string;
+    displayName?: string;
+    sizeBytes?: string | number;
+    createTime?: string;
+}
+interface GeminiFileApiClient {
+    uploadFile(buffer: Buffer, apiKey: string, options: {
+        mimeType: string;
+        displayName: string;
+    }): Promise<GeminiFileInfo>;
+    waitForProcessing(fileName: string, apiKey: string): Promise<GeminiFileInfo>;
+    getFile(fileId: string, apiKey: string): Promise<GeminiFileInfo>;
+    listFiles(apiKey: string, options: {
+        pageSize: number;
+    }): Promise<{
+        files: GeminiFileInfo[];
+    }>;
+    deleteFile(fileId: string, apiKey: string): Promise<void>;
+}
+export interface MediaFileApiServiceDeps {
+    createGeminiFileApi?: () => GeminiFileApiClient;
+    isVolcengineFileTransport?: (transport: unknown) => transport is VolcengineFileTransport;
+}
+export interface MediaFileApiService {
+    resolveProvider(context: MediaFileServiceContext): MediaFileApiProvider | undefined;
+    uploadFile(context: MediaFileServiceContext, input: MediaFileUploadInput): Promise<MediaFileUploadResult>;
+    queryFile(context: MediaFileServiceContext, fileId: string): Promise<MediaFileInfo>;
+    listFiles(context: MediaFileServiceContext, limit: number): Promise<MediaFileInfo[]>;
+    deleteFile(context: MediaFileServiceContext, fileId: string): Promise<void>;
+}
+export declare function createMediaFileApiService(deps?: MediaFileApiServiceDeps): MediaFileApiService;
+export declare const defaultMediaFileApiService: MediaFileApiService;
+export {};

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

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

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

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

package/dist/types/cli/memory-coordinator.d.ts

@@ -0,0 +1,36 @@
+import { type MemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
+import type { HookRegistry } from "../contracts/hooks.js";
+import type { RuntimeLogger } from "../runtime/hooks/hook-registry.js";
+import type { MemoryDreamRuntimeProvider, MemoryHandlerProvider, MemoryLearningSink, MemoryProvider, MemoryRuntimeHookProvider, MemoryToolProvider, ProjectMemoryStore } from "../runtime/ports/index.js";
+import type { LLMTransport } from "./provider-core-facade.js";
+export interface MemoryProviderState {
+    recallProvider: MemoryProvider | null;
+    runtimeHookProvider: MemoryRuntimeHookProvider | null;
+    learningSink: MemoryLearningSink | null;
+    toolProvider: MemoryToolProvider | null;
+    handlerProvider: MemoryHandlerProvider | null;
+    dreamProvider: MemoryDreamRuntimeProvider | null;
+    userId: string;
+}
+export declare function ensureLocalMemoryProvider(projectRoot: string, currentUserId: string): MemoryProviderState;
+export interface RegisterMemoryRuntimeHooksDeps {
+    hooks: HookRegistry;
+    projectRoot: string;
+    currentUserId: string;
+    log: RuntimeLogger;
+    prefetchState: MemoryPrefetchState;
+    getLastUserMessage: () => string | undefined;
+    getLastAssistantMessage: () => string | undefined;
+    resolveSmallModelClient: () => {
+        transport: LLMTransport;
+        apiKey: string;
+        model: string;
+    } | null;
+}
+export declare function registerMemoryRuntimeHooks(deps: RegisterMemoryRuntimeHooksDeps): MemoryProviderState;
+export interface RegisterMemoryToolDeps {
+    memdir: ProjectMemoryStore;
+    memoryProvider: MemoryToolProvider | null;
+    memoryUserId: string;
+}
+export declare function registerMemoryTool(deps: RegisterMemoryToolDeps): void;

package/dist/types/cli/model-client-resolver.d.ts

@@ -0,0 +1,22 @@
+import type { ModelPurpose } from "../runtime/infra/model-registry.js";
+import type { TurnConfig } from "../agent/types.js";
+import { type LLMTransport, type ProviderRegistry } from "./provider-core-facade.js";
+export interface ResolvedModelClient {
+    transport: LLMTransport;
+    apiKey: string;
+    model: string;
+}
+export interface ResolvedTextGenerationConfig {
+    provider: string;
+    model: string;
+    apiKey: string;
+    baseUrl?: string;
+    configKey: string;
+}
+export declare function resolveTextGenerationConfig(config: TurnConfig, log?: (message: string) => void): ResolvedTextGenerationConfig | null;
+export declare function resolveModelClientForPurpose(deps: {
+    purpose: ModelPurpose;
+    providerRegistry: ProviderRegistry;
+    currentProvider: string;
+    currentTransport: LLMTransport | null;
+}): ResolvedModelClient | null;

package/dist/types/cli/multi-agent-handler-host.d.ts

@@ -0,0 +1,27 @@
+import type { AgentRpcError } from "../protocol/wire/index.js";
+import type { AgentConfigRuntime, AgentConfigRuntimeDeps } from "./agent-config-runtime.js";
+import type { AgentsHandlerHost } from "./handlers/agents-handler.js";
+import type { ProductHandlerHost } from "./handlers/product-handler.js";
+import type { SoloHandlerHost } from "./handlers/solo-handler.js";
+type AgentStatusExtra = {
+    missedBeats?: number;
+    lastActivityAt?: number;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+};
+export type MultiAgentHandlerHost = AgentsHandlerHost & SoloHandlerHost & ProductHandlerHost;
+export interface MultiAgentHandlerHostDeps {
+    acpDetector?: AgentsHandlerHost["acpDetector"];
+    createAgentConfigRuntime?: (deps: AgentConfigRuntimeDeps) => AgentConfigRuntime;
+    getActiveProjectRoot(): string;
+    emitAgentStatus(agentId: string, state: string, extra?: AgentStatusExtra): void;
+    handleMcpToolCall(memberId: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
+    log(message: string): void;
+    sendNotification(method: string, params: Record<string, unknown>): void;
+    sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
+}
+export declare function createMultiAgentHandlerHost(deps: MultiAgentHandlerHostDeps): MultiAgentHandlerHost;
+export {};

package/dist/types/cli/multi-agent-handler-host.test.d.ts

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

package/dist/types/cli/multi-agent-state-coordinator.d.ts

@@ -0,0 +1,11 @@
+import type { ProductOrchestrator } from "../orchestration/agent-instance.js";
+import type { ProductPlanner } from "../orchestration/product-planner.js";
+import type { SoloEvaluator } from "../orchestration/solo-evaluator.js";
+import type { AgentProcessManager } from "../runtime/infra/agent-process.js";
+export declare class MultiAgentStateCoordinator {
+    soloEvaluator: SoloEvaluator | null;
+    productOrchestrator: ProductOrchestrator | null;
+    productPlanner: ProductPlanner | null;
+    soloProcessManager: AgentProcessManager | null;
+    productProcessManager: AgentProcessManager | null;
+}

package/dist/types/cli/permission-bootstrap.d.ts

@@ -0,0 +1,33 @@
+import type { HookRegistry } from "../contracts/hooks.js";
+import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
+import type { AcpPermissionRequestParams } from "../protocol/wire/index.js";
+import type { ApprovalRequest, ApprovalResponse } from "../runtime/ports/index.js";
+import { PermissionChecker } from "../skills/permissions/hook-runner.js";
+import { PermissionRuleEngine } from "../skills/permissions/rule-engine.js";
+export interface PermissionBootstrapDeps {
+    config: Record<string, unknown>;
+    hooks: HookRegistry;
+    log: {
+        info(message: string): void;
+        warn(message: string): void;
+    };
+    sessionId: string;
+    getTurnId(): string;
+    getActiveProjectRoot(): string;
+    getAcpPermissionSession(): {
+        sessionId: string;
+        requestPermission(params: AcpPermissionRequestParams): Promise<{
+            optionId?: string;
+        }>;
+    } | undefined;
+    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
+    isPetActive(): boolean;
+    currentUnregister?: (() => void) | null;
+}
+export interface PermissionBootstrapResult {
+    permissionChecker: PermissionChecker;
+    permissionUnregister: () => void;
+    ruleEngine: PermissionRuleEngine;
+}
+export declare function configurePermissionBootstrap(deps: PermissionBootstrapDeps): PermissionBootstrapResult;
+export declare function createApprovalResponseFromAcpOption(request: ApprovalRequest, optionId: string | undefined): ApprovalResponse;

package/dist/types/cli/permission-bootstrap.test.d.ts

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

package/dist/types/cli/permission-settings-store.d.ts

@@ -0,0 +1,2 @@
+import type { PermissionUpdate } from "../runtime/ports/index.js";
+export declare function persistPermissionUpdateToSettings(update: PermissionUpdate, settingsPath?: string): void;

package/dist/types/cli/permission-settings-store.test.d.ts

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

package/dist/types/cli/pet-confirm-coordinator.d.ts

@@ -0,0 +1,20 @@
+import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
+import type { ApprovalResponse } from "../runtime/ports/index.js";
+export interface PetConfirmPermissionResolver {
+    resolveApproval(response: ApprovalResponse): void;
+}
+export interface PetConfirmCoordinatorDeps {
+    getPermissionResolver(): PetConfirmPermissionResolver | null | undefined;
+    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
+}
+export interface PetConfirmResponse {
+    confirmId: string;
+    approved: boolean;
+}
+export declare class PetConfirmCoordinator {
+    private readonly deps;
+    private readonly pendingConfirms;
+    constructor(deps: PetConfirmCoordinatorDeps);
+    requestConfirm(toolName: string, description: string, risk: "low" | "medium" | "high", timeoutMs?: number): Promise<boolean>;
+    handleResponse({ confirmId, approved }: PetConfirmResponse): void;
+}

package/dist/types/cli/pet-confirm-coordinator.test.d.ts

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

package/dist/types/cli/pet-runtime.d.ts

@@ -0,0 +1,34 @@
+import type { ChatMessage } from "../agent/types.js";
+import type { ModelPurpose } from "../runtime/infra/model-registry.js";
+import { type PetStats } from "../runtime/pet/index.js";
+import type { LLMTransport } from "./provider-core-facade.js";
+export type PetSoulGenerator = (rarity: string, stats: PetStats) => Promise<{
+    name: string;
+    personality: string;
+    catchphrase: string;
+}>;
+export type SmallLlmCall = (prompt: string, maxTokens: number) => Promise<string | null>;
+export interface PetLlmClient {
+    transport: LLMTransport;
+    apiKey: string;
+    model: string;
+}
+export interface PetRuntime {
+    createPetSoulGenerator(): PetSoulGenerator | undefined;
+    createSmallLLMCall(): SmallLlmCall | undefined;
+    forgeAnalyzeImage(imageBase64: string, hint?: string): Promise<string>;
+    forgeGenerateSkeleton(characterDesc: string): Promise<string>;
+    forgeScoreConsistency(referenceSvg: string, candidateSvg: string, state: string, characterDesc: string): Promise<{
+        score: number;
+        feedback: string;
+    }>;
+    awardXp(event: string): Promise<void>;
+    reactAfterTurn(messages: ChatMessage[]): Promise<void>;
+    isActive(): boolean;
+}
+export interface PetRuntimeDeps {
+    getActiveProjectRoot(): string;
+    resolveClientForPurpose(purpose: ModelPurpose): PetLlmClient | null;
+    sendNotification(method: string, params: Record<string, unknown>): void;
+}
+export declare function createPetRuntime(deps: PetRuntimeDeps): PetRuntime;

package/dist/types/cli/pet-runtime.test.d.ts

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

package/dist/types/cli/project-context.d.ts

@@ -0,0 +1 @@
+export declare function isActiveProjectGroup(): boolean;

package/dist/types/cli/project-memory-store-factory.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectMemoryStoreFactory } from "../runtime/ports/index.js";
+export declare function createCliProjectMemoryStoreFactory(): ProjectMemoryStoreFactory;

package/dist/types/cli/project-template-seeder.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Copy global template files (~/.qlogicagent/INSTRUCTIONS.md + rules/) into a new project's
+ * .qlogicagent/ directory. Only copies if the target does NOT already exist.
+ */
+export declare function seedProjectFromGlobalTemplates(workspaceDir: string): void;

package/dist/types/cli/provider-core-facade.d.ts

@@ -0,0 +1,27 @@
+import { MediaClient, ProviderRegistry, createLLMClient, isAsyncMediaTransport, type ImageCapabilities, type LLMTransport, type MediaCapability, type MediaRequest, type MediaResult, type MusicCapabilities, type ProviderToolAPI, type TtsCapabilities, type VideoCapabilities } from "@xiaozhiclaw/provider-core";
+import { GeminiFileAPI } from "@xiaozhiclaw/provider-core/transports/gemini-file-api";
+export { MediaClient, ProviderRegistry, createLLMClient, isAsyncMediaTransport, type ImageCapabilities, type LLMTransport, type MediaCapability, type MediaRequest, type MediaResult, type MusicCapabilities, type ProviderToolAPI, type TtsCapabilities, type VideoCapabilities, };
+export declare function normalizeMediaProviderId(providerId: string): string;
+export declare function resolveMediaApiKey(apiKeys: Record<string, string>, providerId: string): string | undefined;
+export declare function createProviderToolAPIForSession(providerId: string | undefined, apiKey: string | undefined): ProviderToolAPI | undefined;
+export declare function wrapDebugTransportIfEnabled(transport: LLMTransport, sessionId: string): LLMTransport;
+export declare function isMiniMaxLyricsTransport(transport: unknown): transport is {
+    generateLyrics(prompt: string, apiKey: string): Promise<string>;
+};
+export interface VolcengineFileTransport {
+    uploadFile(blob: Blob, apiKey: string, options: {
+        purpose: string;
+        filename: string;
+    }): Promise<{
+        id: string;
+    }>;
+    getFile(fileId: string, apiKey: string): Promise<Record<string, unknown>>;
+    listFiles(apiKey: string, options: {
+        limit: number;
+    }): Promise<{
+        data?: Array<Record<string, unknown>>;
+    }>;
+    deleteFile(fileId: string, apiKey: string): Promise<void>;
+}
+export declare function isVolcengineFileTransport(transport: unknown): transport is VolcengineFileTransport;
+export declare function createGeminiFileApi(): GeminiFileAPI;

package/dist/types/cli/rpc-registry.community.test.d.ts

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

package/dist/types/cli/rpc-registry.d.ts

@@ -0,0 +1,8 @@
+import type { AgentRpcRequest } from "../protocol/wire/index.js";
+import type { MultiAgentHandlerHost } from "./multi-agent-handler-host.js";
+export type RpcMethodHandler = (msg: AgentRpcRequest) => void;
+type RpcRegistryHost = Record<string, unknown> & {
+    multiAgentHandlerHost?: MultiAgentHandlerHost;
+};
+export declare function createRpcMethodRegistry(host: RpcRegistryHost): ReadonlyMap<string, RpcMethodHandler>;
+export {};

package/dist/types/cli/runtime-hook-bootstrap.d.ts

@@ -0,0 +1,34 @@
+import type { AgentLogger } from "../agent/types.js";
+import type { HookRegistry } from "../contracts/hooks.js";
+import { type MemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
+import type { TaskStore } from "../runtime/infra/task-runtime.js";
+import type { MemoryDreamRuntimeProvider, MemoryHandlerProvider, MemoryLearningSink, ProjectMemoryStore } from "../runtime/ports/index.js";
+import type { LLMTransport } from "./provider-core-facade.js";
+export interface RuntimeHookBootstrapDeps {
+    log: AgentLogger;
+    taskStore: TaskStore;
+    sessionId: string;
+    projectRoot: string;
+    memdir: ProjectMemoryStore;
+    currentUserId: string;
+    prefetchState: MemoryPrefetchState;
+    getLastUserMessage(): string | undefined;
+    getLastAssistantMessage(): string | undefined;
+    resolveSmallModelClient(): {
+        transport: LLMTransport;
+        apiKey: string;
+        model: string;
+    } | null;
+    compressionClient: {
+        transport: LLMTransport;
+        apiKey: string;
+    };
+}
+export interface RuntimeHookBootstrapResult {
+    hooks: HookRegistry;
+    memoryHandlerProvider: MemoryHandlerProvider | null;
+    memoryDreamProvider: MemoryDreamRuntimeProvider | null;
+    memoryLearningSink: MemoryLearningSink | null;
+    memoryUserId: string;
+}
+export declare function configureRuntimeHookBootstrap(deps: RuntimeHookBootstrapDeps): RuntimeHookBootstrapResult;

package/dist/types/cli/runtime-watcher-bootstrap.d.ts

@@ -0,0 +1,15 @@
+import type { AgentLogger } from "../agent/types.js";
+import type { HookRegistry } from "../contracts/hooks.js";
+import { type FileWatcher } from "../runtime/infra/file-watcher.js";
+import type { PermissionRuleEngine } from "../skills/permissions/rule-engine.js";
+export type { FileWatcher };
+export interface RuntimeWatcherBootstrapDeps {
+    config: Record<string, unknown>;
+    hooks: HookRegistry;
+    ruleEngine: PermissionRuleEngine;
+    sessionId: string;
+    currentFileWatcher: FileWatcher | null;
+    log: AgentLogger;
+    setFileWatcher(watcher: FileWatcher | null): void;
+}
+export declare function configureRuntimeWatchers(deps: RuntimeWatcherBootstrapDeps): void;

package/dist/types/cli/session-coordinator.d.ts

@@ -0,0 +1,10 @@
+import type { PathService } from "../runtime/ports/index.js";
+import type { MediaPersistence } from "../runtime/infra/media-persistence.js";
+export declare class CliPathService implements PathService {
+    private readonly mediaPersistence;
+    private activeWorkdir;
+    constructor(mediaPersistence: MediaPersistence);
+    getActiveProjectRoot(): string;
+    setActiveWorkdir(dir: string): void;
+    resolveProjectDir(projectId?: string): string | undefined;
+}

package/dist/types/cli/session-coordinator.test.d.ts

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

package/dist/types/cli/session-history-coordinator.d.ts

@@ -0,0 +1,11 @@
+import type { ChatMessage } from "../agent/types.js";
+export declare class SessionHistoryCoordinator {
+    private readonly acpSessionHistories;
+    private readonly resumedSessionHistories;
+    appendAcpUserMessage(sessionId: string, content: string): ChatMessage[];
+    appendAcpAssistantMessage(sessionId: string, content: string): void;
+    clearAcpSession(sessionId: string): void;
+    saveResumedSession(sessionId: string, messages: readonly unknown[]): void;
+    withResumedHistory(sessionId: string, messages: ChatMessage[]): ChatMessage[];
+    private getOrCreateAcpHistory;
+}

package/dist/types/cli/session-history-coordinator.test.d.ts

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

package/dist/types/cli/skill-meta-tool-bootstrap.d.ts

@@ -0,0 +1,25 @@
+import type { TurnEvent, TurnRequest } from "../agent/types.js";
+import type { HookRegistry } from "../contracts/hooks.js";
+import type { NotificationMethod, NotificationMethodMap } from "../protocol/notifications.js";
+import type { MemoryLearningSink } from "../runtime/ports/index.js";
+import type { WorkspaceSkill } from "../skills/skill-system/skill-types.js";
+import type { SkillLifecycleRecord } from "../skills/skill-system/skill-lifecycle.js";
+export interface SkillMetaToolBootstrapDeps {
+    config: Record<string, unknown>;
+}
+export interface SkillSubturnAgent {
+    run(request: TurnRequest, signal?: AbortSignal): AsyncGenerator<TurnEvent>;
+}
+export type SkillLearningMemorySink = MemoryLearningSink;
+export interface SkillMetaToolHost {
+    getActiveProjectRoot(): string;
+    getPluginSkills(): WorkspaceSkill[];
+    getAgent(): SkillSubturnAgent | null;
+    getCurrentSessionId(): string;
+    getCurrentHooks(): HookRegistry | null;
+    sendNotification<M extends NotificationMethod>(method: M, params: NotificationMethodMap[M]): void;
+    getMemoryLearningSink(): SkillLearningMemorySink | null;
+    getMemoryUserId(): string;
+}
+export declare function configureSkillMetaToolBootstrap(host: SkillMetaToolHost, deps: SkillMetaToolBootstrapDeps): void;
+export declare function resolveSkillSubagentTypeForLifecycle(skillName: string, record: SkillLifecycleRecord | undefined): string;

package/dist/types/cli/skill-meta-tool-bootstrap.test.d.ts

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