qlogicagent 2.11.5 → 2.11.7

package/dist/types/runtime/infra/agent-install-runner.d.ts

@@ -0,0 +1,57 @@
+import type { AgentInstallSpec } from "../../protocol/wire/acp-agent-management.js";
+export type InstallEvent = {
+    type: "state";
+    state: "installing" | "verifying" | "installed" | "failed";
+} | {
+    type: "log";
+    stream: "stdout" | "stderr";
+    chunk: string;
+} | {
+    type: "done";
+    ok: boolean;
+    error?: string;
+};
+/** A child process shaped like node's, so tests can inject a fake. */
+export interface InstallProc {
+    stdout?: {
+        on(ev: "data", cb: (c: Buffer | string) => void): void;
+    } | null;
+    stderr?: {
+        on(ev: "data", cb: (c: Buffer | string) => void): void;
+    } | null;
+    on(ev: "close", cb: (code: number | null) => void): void;
+    on(ev: "error", cb: (err: Error) => void): void;
+}
+export type InstallSpawn = (command: string, shell: boolean) => InstallProc;
+/**
+ * Choose the best official install command for the current platform.
+ * Preference: brew (macOS only) → npm → pip → curl (POSIX shell only). Returns the raw
+ * command + whether it must run through a shell (curl pipelines / shell metachars).
+ */
+export declare function pickInstallCommand(install: AgentInstallSpec, platform: NodeJS.Platform): {
+    command: string;
+    shell: boolean;
+} | null;
+/**
+ * Inject a package-registry mirror into an install command, for users behind slow or blocked public
+ * registries (e.g. PyPI / npm from mainland China, where the default index frequently times out).
+ *
+ * Opt-in via `mirror`: "cn" applies curated China mirrors per package manager; off (undefined) by
+ * default so other users are unaffected. Only rewrites a command that hasn't already pinned a
+ * registry/index, and never touches brew/curl. Returns the command unchanged when not applicable.
+ */
+export declare function applyInstallMirror(command: string, mirror: string | undefined): string;
+/** Default spawner: split into argv (or run via shell for pipelines). */
+export declare const defaultInstallSpawn: InstallSpawn;
+/**
+ * Run an install spec end-to-end, streaming progress via onEvent. Emits state →
+ * log(s) → (verify) → done. Resolves with the final outcome.
+ */
+export declare function runAgentInstall(install: AgentInstallSpec, onEvent: (e: InstallEvent) => void, opts?: {
+    platform?: NodeJS.Platform;
+    spawnImpl?: InstallSpawn;
+    mirror?: string;
+}): Promise<{
+    ok: boolean;
+    error?: string;
+}>;

package/dist/types/runtime/infra/agent-process.d.ts

@@ -101,6 +101,14 @@ export interface AgentProcessCallbacks {
     onExit?: (memberId: string, code: number | null, signal: string | null) => void;
     /** Called when MCP bridge server proxies a tool call from an external agent. */
     onMcpToolCall?: (memberId: string, tool: string, args: Record<string, unknown>) => Promise<unknown>;
+    /**
+     * Called when an external agent requests permission (ACP session/request_permission). When set,
+     * it drives interactive approval (forward to user, await decision) instead of the auto-allow
+     * host-trust baseline; resolve with the chosen optionId.
+     */
+    onPermissionRequest?: (memberId: string, params: Record<string, unknown>) => Promise<{
+        optionId: string;
+    }>;
     /** Logger. */
     log?: {
         info(msg: string): void;
@@ -243,6 +251,8 @@ export declare class AgentProcessManager {
     getHandle(memberId: string): AgentProcessHandle | undefined;
     /** Get all handles. */
     getAllHandles(): AgentProcessHandle[];
+    /** Whether a member's process is still spawned and usable (for pool reuse across turns). */
+    isAlive(memberId: string): boolean;
     /** Get usage tracker for an ACP agent (returns null for internal agents). */
     getUsageTracker(memberId: string): AcpUsageTracker | null;
     /**

package/dist/types/runtime/infra/external-agent-approvals.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Pending interactive-approval registry for EXTERNAL agents.
+ *
+ * When a spawned external agent (Codex/Claude/…) asks for permission (ACP session/request_permission),
+ * the host handler forwards the request to the frontend and parks the ACP response here until the user
+ * decides. The gateway delivers the decision via the agents.approvalResponse RPC, which resolves the
+ * matching pending promise so the host handler can return the chosen optionId to the external agent.
+ *
+ * This is the qlogicagent-side mirror of the gateway adapter's pendingPermissionRequests map.
+ */
+/**
+ * Park an approval until the user decides. Resolves with the chosen optionId, or null on timeout
+ * (the caller then applies a safe default). Idempotent per approvalId — a duplicate replaces the old.
+ */
+export declare function awaitApprovalDecision(approvalId: string, timeoutMs: number): Promise<string | null>;
+/** Deliver the user's decision. Returns false if no approval was pending for this id (no-op). */
+export declare function resolveApprovalDecision(approvalId: string, optionId: string): boolean;
+/** Cancel all pending approvals (e.g. on shutdown) — resolves them as null so awaiters unblock. */
+export declare function cancelAllApprovals(): void;
+export declare function pendingApprovalCount(): number;
+export interface ApprovalForwardDeps {
+    agentId: string;
+    /** Current streaming turn identity (read fresh each call, since members are reused across turns). */
+    turnContext: () => {
+        sessionId?: string;
+        turnId?: string;
+        requestId?: string;
+    } | null;
+    /** Emit the forward notification to the gateway (→ turn.approval_request → UI card). */
+    sendNotification?: (method: string, params: Record<string, unknown>) => void;
+    timeoutMs?: number;
+}
+/**
+ * Drive one interactive approval for an external agent: forward the ACP session/request_permission
+ * to the user (agents.prompt.approval), await the decision, and return the chosen optionId. Falls
+ * back to a reject option if there's no streaming turn context or the user doesn't decide in time.
+ * Pure + injectable so the bidirectional loop is unit-testable without a live agent.
+ */
+export declare function forwardExternalApproval(params: Record<string, unknown>, deps: ApprovalForwardDeps): Promise<{
+    optionId: string;
+}>;

package/dist/types/runtime/infra/external-agent-pool.d.ts

@@ -0,0 +1,54 @@
+/**
+ * External-agent process pool (A).
+ *
+ * Keeps spawned external ACP agents (Codex/Claude/etc.) alive and reuses them across chat turns,
+ * instead of the spawn → one turn → kill cycle that paid a full ACP cold-start (several seconds)
+ * on every message. Reuse also gives external agents real multi-turn memory (same ACP session).
+ *
+ * Design (mirrors how VSCode keeps language-server-style agent CLIs resident):
+ *  - One AgentProcessManager + one spawned member per pool key (agentId + cwd + sessionId).
+ *  - The first turn spawns + registers; subsequent turns reuse the live member (sendTask only).
+ *  - A mutable `holder.current` carries the *current* turn's identity so the manager's
+ *    construction-time onNotification can tag live deltas with the right turn (see agents-handler).
+ *  - Idle entries are reaped after IDLE_TTL_MS; the pool is bounded to MAX_POOL by LRU eviction.
+ *  - Busy entries (a turn in flight) are never evicted.
+ */
+import type { AgentProcessManager } from "./agent-process.js";
+/** Mutable per-turn context read by the pooled manager's onNotification callback. */
+export interface PooledTurnCtx {
+    sessionId?: string;
+    turnId?: string;
+    requestId?: string;
+    deltas: string[];
+    streamedAny: boolean;
+}
+export interface PooledAgentEntry {
+    manager: AgentProcessManager;
+    memberId: string;
+    /** Boxed so the manager's onNotification (built before registration) can read the live turn. */
+    holder: {
+        current: PooledTurnCtx | null;
+    };
+    lastUsed: number;
+}
+/** Pool key: same agent + workspace + session ⇒ same resident process (and shared memory). */
+export declare function poolKey(agentId: string, cwd: string, sessionId?: string): string;
+/** Return a live pooled entry for the key, or undefined (evicting a dead one if found). */
+export declare function getAlivePooledAgent(key: string): PooledAgentEntry | undefined;
+/** Register a freshly-spawned entry, evicting any stale same-key entry and enforcing MAX_POOL. */
+export declare function registerPooledAgent(key: string, entry: PooledAgentEntry): void;
+/**
+ * Re-key a pre-warmed entry (spawned before a session existed, under WARM_SESSION) onto the real
+ * session key, so the first turn adopts the warmed process and skips the cold start. Does not
+ * dispose — the same live process is moved. Returns undefined if no live warmed entry exists.
+ */
+export declare function adoptWarmedAgent(warmKey: string, sessionKey: string): PooledAgentEntry | undefined;
+/** Reserved session token for a process pre-warmed before its real session id is known. */
+export declare const WARM_SESSION = "__warm__";
+/** Drop + dispose a single entry (e.g. after a turn errors and the process is suspect). */
+export declare function evictPooledAgent(key: string): void;
+/** Kill + dispose every pooled agent and stop the reaper. Call on agent shutdown. */
+export declare function disposeAllPooledAgents(): void;
+export declare function pooledAgentCount(): number;
+/** Reap idle (non-busy) entries past the TTL. Exposed for deterministic testing. */
+export declare function reapIdlePooledAgents(now: number): void;

package/dist/types/runtime/infra/model-registry.d.ts

@@ -90,6 +90,12 @@ export declare class ModelRegistry {
     addModel(entry: Omit<ModelEntry, "id"> & {
         id?: string;
     }): string;
+    /**
+     * Backfill the reasoning control class for entries that arrived without it
+     * (e.g. from the llmrouter cloud catalog), using provider-core as the single
+     * source of truth. Entries that already carry reasoningMode are left as-is.
+     */
+    private withReasoningMode;
     replaceCatalogModels(entries: ModelEntry[]): void;
     replaceProviderModels(providerId: string, entries: ModelEntry[]): void;
     migrateModelIds(aliasToNative: Map<string, string>): void;

package/dist/types/runtime/infra/provider-catalog-adapter.d.ts

@@ -58,5 +58,12 @@ export declare class ProviderCatalogAdapter {
     getProvider(providerId: string): RuntimeProviderCatalogProvider | undefined;
     listProviders(): RuntimeProviderCatalogProvider[];
     listModels(providerId: string): RuntimeProviderCatalogModel[];
+    /**
+     * Classify a model's reasoning control from provider-core (the single source of
+     * truth), for entries sourced outside the builtin catalog (e.g. the llmrouter
+     * cloud catalog). Returns undefined when the model isn't a known provider-core
+     * model — callers should fall back to the granular default.
+     */
+    classifyReasoningMode(providerId: string, modelId: string): ReasoningMode | undefined;
     resolveBest(input: RuntimeProviderVariantResolutionInput): RuntimeProviderVariantResolution | undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qlogicagent",
-  "version": "2.11.5",
+  "version": "2.11.7",
   "description": "XiaozhiClaw Agent CLI — subprocess architecture (JSON-RPC over stdio)",
   "type": "module",
   "main": "dist/index.js",
@@ -86,6 +86,7 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
+    "@agentclientprotocol/sdk": "^0.25.0",
     "@napi-rs/canvas": "0.1.100",
     "@xiaozhiclaw/pet-core": "0.1.0",
     "@xiaozhiclaw/provider-core": "0.1.4",
@@ -98,7 +99,6 @@
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.15.0",
-    "@zed-industries/agent-client-protocol": "0.4.5",
     "esbuild": "^0.28.0",
     "oxlint": "1.67.0",
     "tsx": "^4.19.0",

package/dist/types/skills/tools/notify-tool.d.ts

@@ -1,53 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const NOTIFY_TOOL_NAME: "notify";
-export interface NotifyToolParams {
-    /** Notification message */
-    message: string;
-    /** Optional title/subject */
-    title?: string;
-    /** Priority level */
-    priority?: "low" | "normal" | "high";
-    /** Target channel override (default: user's primary channel) */
-    channel?: string;
-}
-export declare const NOTIFY_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly message: {
-            readonly type: "string";
-            readonly description: "Notification content to send to the user.";
-        };
-        readonly title: {
-            readonly type: "string";
-            readonly description: "Optional notification title/subject line.";
-        };
-        readonly priority: {
-            readonly type: "string";
-            readonly enum: readonly ["low", "normal", "high"];
-            readonly description: "Notification priority (default: normal). High may trigger sound/vibration.";
-        };
-        readonly channel: {
-            readonly type: "string";
-            readonly description: "Target delivery channel (e.g. 'wechat', 'feishu', 'discord'). Default: user's primary.";
-        };
-    };
-    readonly required: readonly ["message"];
-};
-export interface NotifyResult {
-    delivered: boolean;
-    channel: string;
-    error?: string;
-}
-/**
- * Host-provided notification delivery backend.
- */
-export interface NotifyToolDeps {
-    /** Send notification to user. Host routes to correct platform. */
-    sendNotification(params: {
-        message: string;
-        title?: string;
-        priority?: string;
-        channel?: string;
-    }): Promise<NotifyResult>;
-}
-export declare function createNotifyTool(deps: NotifyToolDeps): PortableTool<NotifyToolParams>;