qlogicagent 1.1.0 → 1.2.0

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

@@ -10,6 +10,7 @@
  */
 import type { TokenUsage } from "../agent/types.js";
 import type { TodoItem } from "../contracts/todo.js";
+import type { AgentSource } from "../runtime/infra/acp-types.js";
 /** Embedded thread item for clients using the Thread protocol. */
 export interface NotificationThreadItem {
     id: string;
@@ -37,6 +38,7 @@ export interface TurnDeltaNotification {
     turnId: string;
     text: string;
     item?: NotificationThreadItem;
+    agentSource?: AgentSource;
 }
 /** Turn completed successfully. */
 export interface TurnEndNotification {
@@ -46,6 +48,7 @@ export interface TurnEndNotification {
     model?: string;
     provider?: string;
     item?: NotificationThreadItem;
+    agentSource?: AgentSource;
 }
 /** Turn failed. */
 export interface TurnErrorNotification {
@@ -68,6 +71,7 @@ export interface TurnToolCallNotification {
     /** Serialized arguments JSON. Enables UI to display "searching for X", "reading file Y". */
     arguments?: string;
     item?: NotificationThreadItem;
+    agentSource?: AgentSource;
 }
 /**
  * Tool execution completed.
@@ -141,6 +145,16 @@ export interface TurnSubagentEndedNotification {
     outputPreview?: string;
     error?: string;
 }
+/** URL citations / file citations returned by OpenAI built-in tools. */
+export interface TurnAnnotationsNotification {
+    turnId: string;
+    annotations: Array<{
+        type: string;
+        url?: string;
+        title?: string;
+        [key: string]: unknown;
+    }>;
+}
 export type MediaResultType = "image" | "tts" | "video";
 /** Structured media generation result — enables media preview cards. */
 export interface TurnMediaResultNotification {
@@ -162,6 +176,21 @@ export interface TurnMediaResultNotification {
     /** Billing info. */
     billingUnit?: string;
     billingQuantity?: number;
+    /** Backend task ID — for progress querying / cancellation. */
+    taskId?: string;
+}
+/** Async media generation progress — emitted during polling for video/music/3D tasks. */
+export interface TurnMediaProgressNotification {
+    turnId: string;
+    /** Backend task ID (provider-specific). */
+    taskId: string;
+    mediaType: MediaResultType;
+    /** Estimated progress (0-100). */
+    percent: number;
+    /** Provider status label (e.g. "queuing", "running", "processing"). */
+    status: string;
+    /** Provider id. */
+    provider?: string;
 }
 /** Full todo list updated — enables DeerFlow-style todo panel sync. */
 export interface TurnTodosUpdatedNotification {
@@ -188,6 +217,16 @@ export interface TurnExecProgressNotification {
     totalLines: number;
     totalBytes: number;
 }
+/** Generic progress heartbeat (e.g. builtin tool status). */
+export interface TurnHeartbeatNotification {
+    turnId: string;
+    message: string;
+}
+/** Human-readable summary of a tool use batch. */
+export interface TurnToolUseSummaryNotification {
+    turnId: string;
+    summary: string;
+}
 export type ArtifactType = "code" | "file" | "image" | "document" | "diagram" | "table";
 /** Structured artifact produced by the agent — enables Canvas-style rendering. */
 export interface TurnArtifactNotification {
@@ -218,6 +257,18 @@ export interface TurnSkillInstructionNotification {
     turnId: string;
     instruction: unknown;
 }
+/** Agent asks the user a clarifying question mid-turn. Host presents UI, then responds via thread.user_response. */
+export interface TurnAskUserNotification {
+    requestId: string;
+    questions: Array<{
+        header: string;
+        question: string;
+        options?: Array<{
+            label: string;
+            description?: string;
+        }>;
+    }>;
+}
 /** Memory content changed (local md or QMemory). */
 export interface MemoryUpdatedNotification {
     source: string;
@@ -251,8 +302,21 @@ export interface TeamUpdatedNotification {
     members?: Array<{
         agentName: string;
         role: string;
+        worktreePath?: string;
+        pid?: number;
     }>;
 }
+/** Forwarded notification from a team member child process. */
+export interface TeamMemberNotification {
+    memberId: string;
+    method: string;
+    params: unknown;
+}
+/** Team member child process state change. */
+export interface TeamMemberStateNotification {
+    memberId: string;
+    state: "starting" | "ready" | "running" | "completed" | "failed" | "killed";
+}
 export interface PongNotification {
 }
 /** Real-time token usage update (emitted after each LLM call within a turn). */
@@ -263,6 +327,86 @@ export interface TurnUsageUpdateNotification {
     /** Cumulative cost estimate for this session (USD). */
     sessionCostUSD?: number;
 }
+/** Agent status change notification. */
+export interface AgentsStatusNotification {
+    agentId: string;
+    status: "available" | "spawning" | "running" | "hang" | "failed" | "unavailable";
+    health?: {
+        missedBeats: number;
+        lastActiveAt: string;
+    };
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    error?: {
+        phase: string;
+        message: string;
+        retriesLeft: number;
+    };
+}
+/** Agent error notification. */
+export interface AgentsErrorNotification {
+    agentId: string;
+    phase: "detect" | "spawn" | "handshake" | "runtime" | "shutdown" | "heartbeat";
+    error: string;
+    retriesLeft: number;
+}
+/** Solo agent progress notification. */
+export interface SoloProgressNotification {
+    soloId: string;
+    agentId: string;
+    state: "pending" | "running" | "completed" | "failed";
+    progress?: string;
+}
+/** Solo evaluation completed notification. */
+export interface SoloEvaluationNotification {
+    soloId: string;
+    winnerId: string;
+    reasoning: string;
+}
+/** Solo agent streaming delta — text output from a competing agent. */
+export interface SoloAgentDeltaNotification {
+    soloId: string;
+    agentId: string;
+    text: string;
+}
+/** Product task started. */
+export interface ProductTaskStartedNotification {
+    productId: string;
+    taskId: string;
+    assignee: string;
+}
+/** Product task completed. */
+export interface ProductTaskCompletedNotification {
+    productId: string;
+    taskId: string;
+    result: string;
+}
+/** Product task failed. */
+export interface ProductTaskFailedNotification {
+    productId: string;
+    taskId: string;
+    error: string;
+}
+/** Product checkpoint saved. */
+export interface ProductCheckpointedNotification {
+    productId: string;
+    timestamp: string;
+}
+/** Product budget warning (>80%). */
+export interface ProductBudgetWarningNotification {
+    productId: string;
+    usedTokens: number;
+    maxTotalTokens: number;
+    percentage: number;
+}
+/** Product completed (all tasks done or terminal). */
+export interface ProductCompletedNotification {
+    productId: string;
+    summary: string;
+}
 export interface NotificationMethodMap {
     "turn.start": TurnStartNotification;
     "turn.delta": TurnDeltaNotification;
@@ -278,19 +422,37 @@ export interface NotificationMethodMap {
     "turn.subagent_started": TurnSubagentStartedNotification;
     "turn.subagent_delta": TurnSubagentDeltaNotification;
     "turn.subagent_ended": TurnSubagentEndedNotification;
+    "turn.annotations": TurnAnnotationsNotification;
     "turn.media_result": TurnMediaResultNotification;
+    "turn.media_progress": TurnMediaProgressNotification;
     "turn.todos_updated": TurnTodosUpdatedNotification;
     "task.updated": TaskUpdatedNotification;
     "turn.exec_progress": TurnExecProgressNotification;
+    "turn.heartbeat": TurnHeartbeatNotification;
+    "turn.tool_use_summary": TurnToolUseSummaryNotification;
     "turn.artifact": TurnArtifactNotification;
     "tool.approval.request": ToolApprovalRequestNotification;
     "turn.skill_instruction": TurnSkillInstructionNotification;
+    "turn.ask_user": TurnAskUserNotification;
     "memory.updated": MemoryUpdatedNotification;
     "session.info": SessionInfoNotification;
     "permission.rule_updated": PermissionRuleUpdatedNotification;
     "team.updated": TeamUpdatedNotification;
+    "team.member.notification": TeamMemberNotification;
+    "team.member.state": TeamMemberStateNotification;
     "turn.usage_update": TurnUsageUpdateNotification;
     "pong": PongNotification;
+    "agents.status": AgentsStatusNotification;
+    "agents.error": AgentsErrorNotification;
+    "solo.progress": SoloProgressNotification;
+    "solo.evaluation": SoloEvaluationNotification;
+    "solo.agentDelta": SoloAgentDeltaNotification;
+    "product.taskStarted": ProductTaskStartedNotification;
+    "product.taskCompleted": ProductTaskCompletedNotification;
+    "product.taskFailed": ProductTaskFailedNotification;
+    "product.checkpointed": ProductCheckpointedNotification;
+    "product.budgetWarning": ProductBudgetWarningNotification;
+    "product.completed": ProductCompletedNotification;
 }
 /** All known notification method names. */
 export type NotificationMethod = keyof NotificationMethodMap;

package/dist/types/runtime/infra/acp-detector.d.ts

@@ -0,0 +1,36 @@
+/**
+ * ACP Agent Detector — scans PATH for installed ACP-compatible CLI agents.
+ *
+ * Uses `which` (Unix) / `where` (Windows) to locate CLI binaries,
+ * then optionally probes version. Results are cached with TTL.
+ *
+ * Reference: AionUI AcpDetector + ACP_BACKENDS_ALL registry.
+ */
+import type { AcpBackendConfig, AgentDescriptor, AgentConfigStoreData } from "./acp-types.js";
+export declare const ACP_BACKENDS: Record<string, AcpBackendConfig>;
+export declare class AcpDetector {
+    private cache;
+    private configStore;
+    /**
+     * Provide the config store data so detector can populate `hasConfig` field
+     * and include user-registered custom agents.
+     */
+    setConfigStore(data: AgentConfigStoreData): void;
+    /**
+     * Scan for installed ACP agent CLIs.
+     * @param force - Clear cache and re-scan.
+     */
+    scan(force?: boolean): AgentDescriptor[];
+    /** Return cached results without IO. */
+    list(): AgentDescriptor[];
+    /** Clear the detection cache. */
+    clearCache(): void;
+    private detectBackend;
+    private detectCustomAgent;
+    private hasAgentConfig;
+    /**
+     * Build an ExternalAgentDescriptor suitable for AgentProcessManager.spawn().
+     * Returns null if the agent is not available.
+     */
+    buildExternalDescriptor(agentId: string): import("./acp-types.js").ExternalAgentDescriptor | null;
+}

package/dist/types/runtime/infra/acp-detector.test.d.ts

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

package/dist/types/runtime/infra/acp-protocol-adapter.d.ts

@@ -0,0 +1,73 @@
+/**
+ * ACP Protocol Adapter — translates between qlogicagent's internal JSON-RPC
+ * protocol and the ACP (Agent-Client Protocol) wire format.
+ *
+ * ACP = JSON-RPC 2.0 over stdio with different method names:
+ *   initialize → initialize (compatible)
+ *   session/new → create session with workspaceRoot + mcpServers
+ *   prompt → send task
+ *   session/close → abort
+ *   message notifications → turn.delta / turn.end
+ *
+ * Reference: AionUI AcpAgentManager, ACP protocol spec.
+ */
+import type { ChildProcess } from "node:child_process";
+import type { AcpInitializeResult, AcpSessionResult, AcpPromptResponse, McpServerConfig } from "./acp-types.js";
+/** Internal representation of an ACP notification translated to qlogicagent format. */
+export interface TranslatedNotification {
+    method: string;
+    params: Record<string, unknown>;
+}
+export declare class AcpProtocolAdapter {
+    private pendingRpcs;
+    private rl;
+    private onNotification;
+    /**
+     * Attach to a child process's stdio for ACP communication.
+     * Must be called before any RPC methods.
+     */
+    attach(child: ChildProcess, onNotification?: (method: string, params: unknown) => void): void;
+    /** Detach from the child process. */
+    detach(): void;
+    /** Send a raw JSON-RPC request and await response. */
+    sendRpc(child: ChildProcess, method: string, params?: unknown, timeoutMs?: number): Promise<unknown>;
+    /**
+     * Perform ACP initialize handshake.
+     * Permissive: fallback protocolVersion to 0 if missing.
+     * Extracts `supportsResume` from capabilities for D-1 session resume.
+     */
+    initialize(child: ChildProcess): Promise<AcpInitializeResult>;
+    /**
+     * Create an ACP session.
+     * Optionally injects MCP servers and system prompt.
+     */
+    createSession(child: ChildProcess, options: {
+        workspaceRoot: string;
+        mcpServers?: McpServerConfig[];
+        systemPrompt?: string;
+    }): Promise<AcpSessionResult>;
+    /**
+     * Send a prompt to a running ACP session.
+     * Returns the complete response.
+     */
+    sendPrompt(child: ChildProcess, sessionId: string, content: string, timeoutMs?: number): Promise<AcpPromptResponse>;
+    /**
+     * Resume an existing ACP session (D-1).
+     * Only call if the agent's capabilities.supportsResume is true.
+     * Falls back to createSession + summary injection if session/resume fails.
+     */
+    resumeSession(child: ChildProcess, sessionId: string, options?: {
+        workspaceRoot?: string;
+        mcpServers?: McpServerConfig[];
+        summary?: string;
+    }): Promise<AcpSessionResult>;
+    /**
+     * Close an ACP session.
+     */
+    closeSession(child: ChildProcess, sessionId: string): Promise<void>;
+    /**
+     * Translate an ACP notification into qlogicagent's internal format.
+     * Returns null if the notification is not translatable (handled separately).
+     */
+    static translateNotification(method: string, params: unknown): TranslatedNotification | null;
+}

package/dist/types/runtime/infra/acp-protocol-adapter.test.d.ts

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