qlogicagent 2.3.0 → 2.5.0

package/dist/types/llm/transports/openai-responses.d.ts

@@ -1,5 +1,5 @@
 /**
- * OpenAI Responses API Transport — SSE streaming implementation.
+ * OpenAI Responses API Transport 鈥?SSE streaming implementation.
  *
  * Implements the OpenAI Responses API (`POST /v1/responses`),
  * the officially recommended path for GPT-5.x text generation.
@@ -49,14 +49,14 @@ export declare class OpenAIResponsesTransport implements LLMTransport {
      *
      * Event format: "event: <type>\ndata: <json>\n\n"
      * Key events:
-     *   - response.output_text.delta           → text content delta
-     *   - response.reasoning_summary_text.delta → reasoning summary text
-     *   - response.function_call_arguments.delta → tool call arguments streaming
-     *   - response.output_item.added           → new output item started
-     *   - response.output_item.done            → output item completed
-     *   - response.content_part.done           → content part completed (annotations)
-     *   - response.completed                   → full response complete with usage
-     *   - response.failed                      → error
+     *   - response.output_text.delta           鈫?text content delta
+     *   - response.reasoning_summary_text.delta 鈫?reasoning summary text
+     *   - response.function_call_arguments.delta 鈫?tool call arguments streaming
+     *   - response.output_item.added           鈫?new output item started
+     *   - response.output_item.done            鈫?output item completed
+     *   - response.content_part.done           鈫?content part completed (annotations)
+     *   - response.completed                   鈫?full response complete with usage
+     *   - response.failed                      鈫?error
      */
     private parseSSEStream;
     private processEvent;

package/dist/types/llm/transports/volcengine-responses.d.ts

@@ -1,5 +1,5 @@
 /**
- * Volcengine Responses API Transport — SSE streaming implementation.
+ * Volcengine Responses API Transport 鈥?SSE streaming implementation.
  *
  * Implements the fire mountain ark Responses API (`/api/v3/responses`),
  * which is the officially recommended primary path for Doubao LLM text generation
@@ -37,9 +37,9 @@ export declare class VolcengineResponsesTransport implements LLMTransport {
     stream(request: LLMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<LLMChunk>;
     /**
      * Resolve known Volcengine Responses API incompatibilities:
-     *   - instructions + caching → drop caching (§20.7)
-     *   - caching + json_schema → downgrade to json_object (§20.10)
-     *   - caching + builtin_web_search/image_process → drop those builtin tools
+     *   - instructions + caching 鈫?drop caching (搂20.7)
+     *   - caching + json_schema 鈫?downgrade to json_object (搂20.10)
+     *   - caching + builtin_web_search/image_process 鈫?drop those builtin tools
      * Returns a shallow copy with fields adjusted; never mutates the original.
      */
     private resolveConstraints;
@@ -51,13 +51,13 @@ export declare class VolcengineResponsesTransport implements LLMTransport {
      *
      * Event format: "event: <type>\ndata: <json>\n\n"
      * Key events:
-     *   - response.output_text.delta           → text content delta
-     *   - response.reasoning_summary_text.delta → thinking/reasoning text
-     *   - response.function_call_arguments.delta → tool call arguments streaming
-     *   - response.output_item.added           → new output item started
-     *   - response.output_item.done            → output item completed
-     *   - response.completed                   → full response complete with usage
-     *   - response.failed                      → error
+     *   - response.output_text.delta           鈫?text content delta
+     *   - response.reasoning_summary_text.delta 鈫?thinking/reasoning text
+     *   - response.function_call_arguments.delta 鈫?tool call arguments streaming
+     *   - response.output_item.added           鈫?new output item started
+     *   - response.output_item.done            鈫?output item completed
+     *   - response.completed                   鈫?full response complete with usage
+     *   - response.failed                      鈫?error
      */
     private parseSSEStream;
     private processEvent;

package/dist/types/orchestration/agent-instance.d.ts

@@ -26,6 +26,19 @@ export interface ProductCallbacks {
     onCheckpointed?: (productId: string, timestamp: string) => void;
     onBudgetWarning?: (productId: string, usedTokens: number, maxTotalTokens: number, percentage: number) => void;
     onCompleted?: (productId: string, summary: string) => void;
+    /** DAG topology resolved and sent to client for visualization. */
+    onDagTopology?: (productId: string, nodes: {
+        id: string;
+        label: string;
+        deps: string[];
+    }[], edges: {
+        from: string;
+        to: string;
+    }[]) => void;
+    /** Real-time budget consumption update. */
+    onBudgetUpdate?: (productId: string, inputTokens: number, outputTokens: number, elapsed: number, maxTotalTokens?: number) => void;
+    /** Streaming text output from a running task. */
+    onTaskOutputDelta?: (productId: string, taskId: string, text: string) => void;
 }
 export declare class ProductOrchestrator {
     private processManager;
@@ -46,6 +59,8 @@ export declare class ProductOrchestrator {
     checkpoint(productId: string): Promise<void>;
     /** Delete a product session, pausing first if active. */
     delete(productId: string): Promise<void>;
+    /** Rollback a product to a checkpoint: delete running session then resume from disk. */
+    rollback(productId: string, _checkpoint: string): Promise<void>;
     /** Get product status. */
     getStatus(productId: string): ProductStatus | null;
     /** List all products (in-memory + on-disk). */

package/dist/types/orchestration/solo-evaluator.d.ts

@@ -24,6 +24,13 @@ export interface SoloCallbacks {
     onEvaluation?: (soloId: string, evaluation: SoloEvaluation) => void;
     /** Streaming text delta from a competing agent (forwarded from child process). */
     onAgentDelta?: (soloId: string, agentId: string, text: string) => void;
+    /** File diff produced by a completed agent. */
+    onAgentDiff?: (soloId: string, agentId: string, files: {
+        path: string;
+        hunks: string;
+    }[]) => void;
+    /** Token usage report after agent completes. */
+    onAgentUsage?: (soloId: string, agentId: string, inputTokens: number, outputTokens: number) => void;
 }
 export declare class SoloEvaluator {
     private processManager;
@@ -32,6 +39,12 @@ export declare class SoloEvaluator {
     private callbacks;
     private sessions;
     constructor(processManager: AgentProcessManager, acpDetector: AcpDetector, configStore: AgentConfigStore | null, callbacks?: SoloCallbacks);
+    /** Persist current session data to disk (fire-and-forget). */
+    private persistSession;
+    /** Restore sessions from disk (call once at startup). */
+    restoreFromDisk(cwd?: string): Promise<number>;
+    /** Delete a solo session from memory and disk. */
+    deleteSolo(soloId: string): Promise<boolean>;
     /**
      * Start a Solo Mode PK session.
      * Creates worktrees, spawns agents in parallel, waits for completion, then evaluates.

package/dist/types/orchestration/solo-persistence.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Solo Persistence — read/write Solo Mode state to disk.
+ *
+ * State is stored at `<project>/.qlogicagent/solos/<soloId>/solo-state.json`.
+ * Mirrors the product-persistence.ts pattern.
+ */
+import type { SoloState, SoloAgentState, SoloEvaluation } from "../runtime/infra/acp-types.js";
+export interface PersistedSoloState {
+    soloId: string;
+    state: SoloState;
+    task: string;
+    cwd: string;
+    gitRoot: string;
+    agents: Array<{
+        agentId: string;
+        memberId: string;
+        worktreePath: string;
+        worktreeBranch: string;
+        state: SoloAgentState;
+        resultText?: string;
+        diff?: string;
+        usage?: {
+            inputTokens: number;
+            outputTokens: number;
+        };
+        error?: string;
+    }>;
+    evaluation?: SoloEvaluation;
+    createdAt: number;
+}
+/** Save solo state to disk. */
+export declare function saveSoloState(state: PersistedSoloState, cwd?: string): Promise<void>;
+/** Load solo state from disk. Returns undefined if not found. */
+export declare function loadSoloState(soloId: string, cwd?: string): Promise<PersistedSoloState | undefined>;
+/** List all solo session IDs with their persisted state. */
+export declare function listSoloSessions(cwd?: string): Promise<PersistedSoloState[]>;
+/** Delete solo state from disk. */
+export declare function deleteSoloState(soloId: string, cwd?: string): Promise<boolean>;

package/dist/types/orchestration/tool-loop/tool-choice-policy.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimeToolEligibilityContract } from "qlogicagent-runtime-contracts";
+import type { RuntimeToolEligibilityContract } from "../../protocol/wire/index.js";
 export type ToolChoiceLike = "auto" | "none" | "required" | {
     type: "function";
     function?: {

package/dist/types/protocol/methods.d.ts

@@ -1,5 +1,5 @@
 /**
- * Centralized RPC Method Protocol — all JSON-RPC request methods
+ * Centralized RPC Method Protocol 鈥?all JSON-RPC request methods
  * that qlogicagent exposes to external apps.
  *
  * This is the SINGLE SOURCE OF TRUTH for the agent's inbound API contract.
@@ -8,7 +8,8 @@
  */
 import type { ChatMessage, ToolDefinition } from "../agent/types.js";
 import type { TodoItem } from "../contracts/todo.js";
-import type { AgentDescriptor, AgentConfig, AgentsScanParams, AgentsConfigParams, AgentsSetConfigParams, AgentsGetConfigParams, AgentsRemoveConfigParams, AgentsSetGatewayParams, SoloStatus, SoloStartParams, SoloIdParams, SoloSelectParams, ProductCreateParams, ProductIdParams, ProductStatus, ProductSummary } from "../runtime/infra/acp-types.js";
+import type { AgentDescriptor, AgentConfig, GatewayRpcMethodMap, RpcProjectInfo, RpcProjectType, RpcProjectStatus, SoloStatus, ProductStatus, ProductSummary } from "./wire/index.js";
+import type { AgentsScanParams, AgentsConfigParams, AgentsSetConfigParams, AgentsGetConfigParams, AgentsRemoveConfigParams, AgentsSetGatewayParams, SoloStartParams, SoloIdParams, SoloSelectParams, SoloDeleteParams, ProductCreateParams, ProductIdParams, ProductDeleteParams } from "../runtime/infra/acp-types.js";
 export interface InitializeParams {
     protocolVersion: string;
     host?: {
@@ -125,6 +126,8 @@ export interface SessionGetInfoResult {
         totalCost?: number;
     };
 }
+export type SessionGetMessagesParams = GatewayRpcMethodMap["session.getMessages"]["params"];
+export type SessionGetMessagesResult = GatewayRpcMethodMap["session.getMessages"]["result"];
 export interface MemoryListParams {
     /** Filter by source: "local" (md files), "store" (in-memory), "qmemory" (remote). */
     source?: "local" | "store" | "qmemory" | "all";
@@ -177,7 +180,7 @@ export interface MemoryDreamResult {
 export interface ToolsListParams {
     /** Filter by category. */
     category?: "builtin" | "mcp" | "plugin" | "all";
-    /** Include full parameter schemas (default false — names only). */
+    /** Include full parameter schemas (default false 鈥?names only). */
     includeSchema?: boolean;
 }
 export interface ToolsListResult {
@@ -302,56 +305,59 @@ export interface TasksCancelResult {
     ok: boolean;
     message: string;
 }
-export type ProjectType = "default" | "personal" | "group";
-export type ProjectStatus = "active" | "archived";
-export interface ProjectInfo {
-    id: string;
-    name: string;
-    workspaceDir: string;
-    type: ProjectType;
-    status: ProjectStatus;
-    groupId?: string;
-    createdAt: string;
-    updatedAt: string;
-}
-export interface ProjectCreateParams {
-    name: string;
-    workspaceDir: string;
-    type?: ProjectType;
-    groupId?: string;
-}
-export interface ProjectCreateResult {
-    ok: boolean;
-    project: ProjectInfo;
-}
-export interface ProjectListParams {
-}
-export interface ProjectListResult {
-    projects: ProjectInfo[];
-}
-export interface ProjectDeleteParams {
-    projectId: string;
-}
-export interface ProjectDeleteResult {
-    ok: boolean;
-    switchedTo?: ProjectInfo;
-}
-export interface SessionSwitchProjectParams {
-    projectId?: string;
-    projectName?: string;
-    workspaceDir?: string;
-}
-export interface SessionSwitchProjectResult {
-    ok: boolean;
-    project: ProjectInfo;
-}
-export interface SessionGetStateParams {
-}
-export interface SessionGetStateResult {
-    sessionId: string;
-    activeProject: ProjectInfo | null;
-    projects: ProjectInfo[];
-}
+export type ProjectType = RpcProjectType;
+export type ProjectStatus = RpcProjectStatus;
+export type ProjectInfo = RpcProjectInfo;
+export type ProjectCreateParams = GatewayRpcMethodMap["project.create"]["params"];
+export type ProjectCreateResult = GatewayRpcMethodMap["project.create"]["result"];
+export type ProjectListParams = GatewayRpcMethodMap["project.list"]["params"];
+export type ProjectListResult = GatewayRpcMethodMap["project.list"]["result"];
+export type ProjectDeleteParams = GatewayRpcMethodMap["project.delete"]["params"];
+export type ProjectDeleteResult = GatewayRpcMethodMap["project.delete"]["result"];
+export type ProjectRenameParams = GatewayRpcMethodMap["project.rename"]["params"];
+export type ProjectRenameResult = GatewayRpcMethodMap["project.rename"]["result"];
+export type ProjectArchiveParams = GatewayRpcMethodMap["project.archive"]["params"];
+export type ProjectArchiveResult = GatewayRpcMethodMap["project.archive"]["result"];
+export type ProjectUnarchiveParams = GatewayRpcMethodMap["project.unarchive"]["params"];
+export type ProjectUnarchiveResult = GatewayRpcMethodMap["project.unarchive"]["result"];
+export type ProjectArchiveByGroupParams = GatewayRpcMethodMap["project.archiveByGroup"]["params"];
+export type ProjectArchiveByGroupResult = GatewayRpcMethodMap["project.archiveByGroup"]["result"];
+export type SessionCreateParams = GatewayRpcMethodMap["session.create"]["params"];
+export type SessionCreateResult = GatewayRpcMethodMap["session.create"]["result"];
+export type SessionListParams = GatewayRpcMethodMap["session.list"]["params"];
+export type SessionListResult = GatewayRpcMethodMap["session.list"]["result"];
+export type SessionGetParams = GatewayRpcMethodMap["session.get"]["params"];
+export type SessionGetResult = GatewayRpcMethodMap["session.get"]["result"];
+export type SessionUpdateParams = GatewayRpcMethodMap["session.update"]["params"];
+export type SessionUpdateResult = GatewayRpcMethodMap["session.update"]["result"];
+export type SessionDeleteParams = GatewayRpcMethodMap["session.delete"]["params"];
+export type SessionDeleteResult = GatewayRpcMethodMap["session.delete"]["result"];
+export type SessionArchiveParams = GatewayRpcMethodMap["session.archive"]["params"];
+export type SessionArchiveResult = GatewayRpcMethodMap["session.archive"]["result"];
+export type InstructionsListParams = GatewayRpcMethodMap["instructions.list"]["params"];
+export type InstructionsListResult = GatewayRpcMethodMap["instructions.list"]["result"];
+export type InstructionsReadParams = GatewayRpcMethodMap["instructions.read"]["params"];
+export type InstructionsReadResult = GatewayRpcMethodMap["instructions.read"]["result"];
+export type InstructionsWriteParams = GatewayRpcMethodMap["instructions.write"]["params"];
+export type InstructionsWriteResult = GatewayRpcMethodMap["instructions.write"]["result"];
+export type InstructionsDeleteParams = GatewayRpcMethodMap["instructions.delete"]["params"];
+export type InstructionsDeleteResult = GatewayRpcMethodMap["instructions.delete"]["result"];
+export type FilesListParams = GatewayRpcMethodMap["files.list"]["params"];
+export type FilesListResult = GatewayRpcMethodMap["files.list"]["result"];
+export type FilesReadParams = GatewayRpcMethodMap["files.read"]["params"];
+export type FilesReadResult = GatewayRpcMethodMap["files.read"]["result"];
+export type FilesCreateParams = GatewayRpcMethodMap["files.create"]["params"];
+export type FilesCreateResult = GatewayRpcMethodMap["files.create"]["result"];
+export type FilesRenameParams = GatewayRpcMethodMap["files.rename"]["params"];
+export type FilesRenameResult = GatewayRpcMethodMap["files.rename"]["result"];
+export type FilesDeleteParams = GatewayRpcMethodMap["files.delete"]["params"];
+export type FilesDeleteResult = GatewayRpcMethodMap["files.delete"]["result"];
+export type FilesGitStatusParams = GatewayRpcMethodMap["files.gitStatus"]["params"];
+export type FilesGitStatusResult = GatewayRpcMethodMap["files.gitStatus"]["result"];
+export type SessionSwitchProjectParams = GatewayRpcMethodMap["session.switchProject"]["params"];
+export type SessionSwitchProjectResult = GatewayRpcMethodMap["session.switchProject"]["result"];
+export type SessionGetStateParams = GatewayRpcMethodMap["session.getState"]["params"];
+export type SessionGetStateResult = GatewayRpcMethodMap["session.getState"]["result"];
 export interface RpcMethodMap {
     "initialize": {
         params: InitializeParams;
@@ -377,6 +383,10 @@ export interface RpcMethodMap {
         params: SessionGetInfoParams;
         result: SessionGetInfoResult;
     };
+    "session.getMessages": {
+        params: SessionGetMessagesParams;
+        result: SessionGetMessagesResult;
+    };
     "memory.list": {
         params: MemoryListParams;
         result: MemoryListResult;
@@ -502,6 +512,16 @@ export interface RpcMethodMap {
             mergedBranch: string;
         };
     };
+    "solo.list": {
+        params: undefined;
+        result: SoloStatus[];
+    };
+    "solo.delete": {
+        params: SoloDeleteParams;
+        result: {
+            ok: true;
+        };
+    };
     "product.create": {
         params: ProductCreateParams;
         result: {
@@ -534,6 +554,26 @@ export interface RpcMethodMap {
         params: undefined;
         result: ProductSummary[];
     };
+    "product.delete": {
+        params: ProductDeleteParams;
+        result: {
+            ok: true;
+        };
+    };
+    "product.cancel": {
+        params: ProductIdParams;
+        result: {
+            ok: true;
+        };
+    };
+    "product.rollback": {
+        params: ProductIdParams & {
+            checkpoint?: string;
+        };
+        result: {
+            ok: true;
+        };
+    };
     "project.create": {
         params: ProjectCreateParams;
         result: ProjectCreateResult;
@@ -546,6 +586,22 @@ export interface RpcMethodMap {
         params: ProjectDeleteParams;
         result: ProjectDeleteResult;
     };
+    "project.rename": {
+        params: ProjectRenameParams;
+        result: ProjectRenameResult;
+    };
+    "project.archive": {
+        params: ProjectArchiveParams;
+        result: ProjectArchiveResult;
+    };
+    "project.unarchive": {
+        params: ProjectUnarchiveParams;
+        result: ProjectUnarchiveResult;
+    };
+    "project.archiveByGroup": {
+        params: ProjectArchiveByGroupParams;
+        result: ProjectArchiveByGroupResult;
+    };
     "session.switchProject": {
         params: SessionSwitchProjectParams;
         result: SessionSwitchProjectResult;
@@ -554,6 +610,70 @@ export interface RpcMethodMap {
         params: SessionGetStateParams;
         result: SessionGetStateResult;
     };
+    "session.create": {
+        params: SessionCreateParams;
+        result: SessionCreateResult;
+    };
+    "session.list": {
+        params: SessionListParams;
+        result: SessionListResult;
+    };
+    "session.get": {
+        params: SessionGetParams;
+        result: SessionGetResult;
+    };
+    "session.update": {
+        params: SessionUpdateParams;
+        result: SessionUpdateResult;
+    };
+    "session.delete": {
+        params: SessionDeleteParams;
+        result: SessionDeleteResult;
+    };
+    "session.archive": {
+        params: SessionArchiveParams;
+        result: SessionArchiveResult;
+    };
+    "instructions.list": {
+        params: InstructionsListParams;
+        result: InstructionsListResult;
+    };
+    "instructions.read": {
+        params: InstructionsReadParams;
+        result: InstructionsReadResult;
+    };
+    "instructions.write": {
+        params: InstructionsWriteParams;
+        result: InstructionsWriteResult;
+    };
+    "instructions.delete": {
+        params: InstructionsDeleteParams;
+        result: InstructionsDeleteResult;
+    };
+    "files.list": {
+        params: FilesListParams;
+        result: FilesListResult;
+    };
+    "files.read": {
+        params: FilesReadParams;
+        result: FilesReadResult;
+    };
+    "files.create": {
+        params: FilesCreateParams;
+        result: FilesCreateResult;
+    };
+    "files.rename": {
+        params: FilesRenameParams;
+        result: FilesRenameResult;
+    };
+    "files.delete": {
+        params: FilesDeleteParams;
+        result: FilesDeleteResult;
+    };
+    "files.gitStatus": {
+        params: FilesGitStatusParams;
+        result: FilesGitStatusResult;
+    };
 }
 /** All known RPC method names. */
 export type RpcMethod = keyof RpcMethodMap;