qlogicagent 2.15.7 → 2.15.9

package/dist/types/cli/handlers/agents-handler.d.ts

@@ -46,6 +46,13 @@ export declare function handleAgentsConfig(this: AgentsHandlerHost, msg: AgentRp
 export declare function handleAgentsSetConfig(this: AgentsHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleAgentsGetConfig(this: AgentsHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleAgentsRemoveConfig(this: AgentsHandlerHost, msg: AgentRpcRequest): Promise<void>;
+/**
+ * Log out / switch account for an `account`-mode agent: clear the CLI's own native credential store
+ * (where we know it — e.g. codex's ~/.codex/auth.json) and invalidate the resident pool so the next
+ * turn re-evaluates auth (and re-prompts login). For agents whose store we don't manage, returns a
+ * hint to run the CLI's own `logout`. "Switch account" = logout, then log in again.
+ */
+export declare function handleAgentsLogout(this: AgentsHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleAgentsSetGateway(this: AgentsHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleAgentsGetGateway(this: AgentsHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleAgentsListConfigured(this: AgentsHandlerHost, msg: AgentRpcRequest): Promise<void>;

package/dist/types/protocol/wire/acp-agent-management.d.ts

@@ -5,7 +5,7 @@
  * external ACP-compatible agent CLIs alongside qlogicagent's internal agents.
  */
 import type { AgentCapabilities, CustomAgentDef, AgentConfig, ProductTaskStatus, ProductInstanceDef, ProductTaskDef } from "./agent-methods.js";
-export type { AgentCategory, AgentProtocol, AgentStatus, AgentCapabilities, AgentDescriptor, CustomAgentDef, AgentConfig, SoloState, SoloAgentState, SoloAgentResult, SoloStatus, ProductPhase, ProductTaskStatus, ProductInstanceDef, ProductTaskDef, ProductStatus, ProductSummary, } from "./agent-methods.js";
+export type { AgentCategory, AgentProtocol, AgentStatus, AgentCapabilities, AgentDescriptor, CustomAgentDef, AgentConfig, AuthPreference, SoloState, SoloAgentState, SoloAgentResult, SoloStatus, ProductPhase, ProductTaskStatus, ProductInstanceDef, ProductTaskDef, ProductStatus, ProductSummary, } from "./agent-methods.js";
 /** Pre-defined configuration for a known ACP backend. */
 export interface AcpBackendConfig {
     /** Backend ID, e.g. "claude" | "codex" | "goose". */
@@ -71,6 +71,13 @@ export interface ExternalAgentDescriptor {
     acpArgs: string[];
     /** Extra environment variables for spawn. */
     env?: Record<string, string>;
+    /**
+     * Env var names the spawn layer must DELETE from the merged child env (after Object.assign of `env`),
+     * so a forwarded/stale shell key cannot override the CLI's own native login. Set in `account` mode
+     * (the load-bearing fix for the env-injection-override bug — buildBackendEnv alone cannot unset a
+     * whitelisted forwarded key). See acp-detector.resolveSuppressEnvKeys.
+     */
+    suppressEnvKeys?: string[];
     /** Communication protocol. */
     protocol: "acp";
 }

package/dist/types/protocol/wire/agent-methods.d.ts

@@ -46,6 +46,15 @@ export interface CustomAgentDef {
     skillsDirs?: string[];
     supportsBaseUrlOverride?: boolean;
 }
+/**
+ * Per-agent credential source preference (BYO-account/key axis).
+ *  - "auto"    : ladder — detected native account → user's own key → managed gateway (default; reproduces legacy behavior).
+ *  - "managed" : force the platform gateway (sk-qllm); guarantees a first conversation, ignores any user key.
+ *  - "account" : use the CLI's own native account/subscription login; inject NO key (the spawn layer also deletes any
+ *                forwarded key) so the CLI's own credential store wins. Not available for claude (Anthropic bans 3rd-party OAuth).
+ *  - "userKey" : use the user's own provider API key against the official endpoint (no gateway baseUrl override).
+ */
+export type AuthPreference = "auto" | "managed" | "account" | "userKey";
 /** Persisted per-agent configuration. */
 export interface AgentConfig {
     apiKey?: string;
@@ -55,6 +64,8 @@ export interface AgentConfig {
     customArgs?: string[];
     customCliPath?: string;
     modelIdMap?: Record<string, string>;
+    /** Credential-source preference (undefined ⇒ "auto"; see AuthPreference). No migration needed. */
+    authPreference?: AuthPreference;
 }
 export type SoloState = "running" | "evaluating" | "completed" | "cancelled" | "failed";
 export type SoloAgentState = "pending" | "running" | "completed" | "failed" | "idle";

package/dist/types/protocol/wire/gateway-rpc.d.ts

@@ -643,6 +643,16 @@ export interface AgentCallOptions {
     idempotencyKey?: string;
     traceId?: string;
 }
-export type AgentCall = <M extends keyof GatewayRpcMethodMap>(method: M, params: GatewayRpcMethodMap[M]["params"], options?: AgentCallOptions) => Promise<GatewayRpcMethodMap[M]["result"]>;
+/**
+ * Gateway → agent RPC. The gateway is a GENERIC proxy: alongside the strongly-typed methods in
+ * GatewayRpcMethodMap (first call signature — params/result inferred), it must forward arbitrary
+ * methods by name — dynamic dispatch, and methods not (yet) in the map — via the second signature
+ * (opaque params/result). The typed signature is listed first so known method literals resolve to
+ * it; a plain `string` method falls through to the proxy signature.
+ */
+export type AgentCall = {
+    <M extends keyof GatewayRpcMethodMap>(method: M, params: GatewayRpcMethodMap[M]["params"], options?: AgentCallOptions): Promise<GatewayRpcMethodMap[M]["result"]>;
+    (method: string, params?: Record<string, unknown>, options?: AgentCallOptions): Promise<unknown>;
+};
 /** All gateway-facing RPC method names (runtime array). */
 export declare const GATEWAY_RPC_METHODS: (keyof GatewayRpcMethodMap)[];

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

@@ -6,7 +6,7 @@
  *
  * Reference: AionUI AcpDetector + ACP_BACKENDS_ALL registry.
  */
-import type { AcpBackendConfig, AgentDescriptor, AgentConfigStoreData } from "../../protocol/wire/acp-agent-management.js";
+import type { AcpBackendConfig, AgentDescriptor, AgentConfigStoreData, AuthPreference } from "../../protocol/wire/acp-agent-management.js";
 export declare const ACP_BACKENDS: Record<string, AcpBackendConfig>;
 export declare const AGENT_CATALOG_IDS: readonly ["claude", "codex", "gemini", "copilot", "cursor", "qwen", "kimi", "glm", "opencode", "kiro", "qoder", "openclaw", "hermes"];
 /** Merged catalog entry (base ACP config + grid/install metadata) for one id. */
@@ -85,16 +85,40 @@ export interface CatalogKeySources {
         baseUrl?: string;
         model?: string;
     };
+    /** Probe: does this agent have a usable native account/subscription login (e.g. ~/.codex/auth.json,
+     *  present + not expired)? Drives `account`-mode readiness and `auto`'s account-first preference.
+     *  Tri-state: true = detected login, false = probeable but not logged in (blocks readiness), undefined
+     *  = no probe for this agent (treated as ready-if-installed; auto does NOT pick account). Wired in Cut 4. */
+    hasSubscription?: (agentId: string) => boolean | undefined;
 }
+/** Resolve the effective mode, coercing unsupported combinations (claude.account → auto). */
+export declare function effectiveAuthPreference(entry: AcpBackendConfig, mode: AuthPreference): AuthPreference;
 /**
- * Resolve the login-free key env for a catalog agent from the unified key sources.
- * "set key once in our system → all agents" — the user never logs into each CLI.
- *   - authMode "oauth" / keySource "none" → {} (no bypass; account required)
- *   - keySource "llmrouter" → gateway sk-qllm + gateway baseUrl (agent calls our gateway)
- *   - keySource "direct"    → the user's provider key (agent calls the provider directly)
- * Only emits env vars the backend actually declares (apiKeyEnvVar / baseUrlEnvVar).
+ * The credential-source modes the UI should offer for an agent (derived from catalog metadata, the
+ * single source of truth — spec §4.2/§8.2/§15). Never includes a permanently-dead option:
+ *   - oauth / keyless (copilot/cursor/kimi/…): ["account"] only (no gateway endpoint to repoint)
+ *   - claude (Anthropic bans subscription): ["managed","userKey"] — no account
+ *   - codex (llmrouter + account-capable): ["account","userKey","managed"]
+ *   - other llmrouter agents: ["userKey","managed"]
+ *   - direct agents (qwen/glm/…): ["userKey"] (managed wiring for qwen/opencode is Cut 7)
  */
-export declare function resolveCatalogKeyEnv(entry: AcpBackendConfig | undefined, sources: CatalogKeySources): Record<string, string>;
+export declare function getAvailableAuthModes(entry: AcpBackendConfig): AuthPreference[];
+/**
+ * Resolve the login-free key env for a catalog agent, honoring the per-agent `authPreference`.
+ *   - "account" → {} (inject nothing; the spawn layer also deletes the forwarded key, see resolveSuppressEnvKeys)
+ *   - "userKey" → the user's own provider key against the official endpoint (no gateway baseUrl/model)
+ *   - "managed" → force the gateway sk-qllm + baseUrl (ignores any user key) — guarantees a first conversation
+ *   - "auto"    → ladder: user's own key (if present) → managed gateway → host-model passthrough
+ * oauth / keyless agents never get a key injected. Only emits env vars the backend declares.
+ */
+export declare function resolveCatalogKeyEnv(entry: AcpBackendConfig | undefined, sources: CatalogKeySources, mode?: AuthPreference): Record<string, string>;
+/**
+ * Env var names the spawn layer must DELETE from the merged child env (account mode), so a
+ * forwarded/stale shell key cannot override the CLI's own native login. This is the load-bearing
+ * half of the §1.3 override-bug fix: buildBackendEnv alone cannot unset a whitelist-forwarded key.
+ * Returns [] when not in account mode (or the agent has no account path — claude is coerced to auto).
+ */
+export declare function resolveSuppressEnvKeys(entry: AcpBackendConfig | undefined, mode: AuthPreference, sources?: CatalogKeySources): string[];
 export declare class AcpDetector {
     private cache;
     private configStore;

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

@@ -62,7 +62,30 @@ export interface AcpAuthMethod {
     id?: string;
     name?: string;
     description?: string;
+    /**
+     * ACP auth-method discriminator (when the agent follows the discriminated schema):
+     *  - "agent"    : the agent self-drives login (opens its own browser / prints a device code)
+     *  - "env_var"  : the user supplies a key — surface a key dialog (≈ userKey)
+     *  - "terminal" : run an interactive login command (the agent's own `login` subcommand)
+     * Drives how the host routes the login affordance (see classifyAuthMethod). Absent on agents that
+     * don't tag their methods — those fall back to guide-only.
+     */
+    type?: "agent" | "env_var" | "terminal" | string;
+    /** For a terminal-type method: the command + args the host runs to start the interactive login. */
+    args?: string[];
+    /** For a terminal-type method: extra env for the login command. */
+    env?: Record<string, string>;
 }
+/** How the host should surface a login for an advertised auth method (spec §7). */
+export type AuthMethodRouting = "agent" | "key" | "terminal" | "guide";
+/**
+ * Route an advertised auth method to the right login affordance:
+ *  agent → drive the ACP `authenticate` request; env_var → open a key dialog (userKey); terminal →
+ *  run the agent's interactive login command; otherwise guide-only (show the command, user runs it).
+ * Gating login on a concrete classified method (never a heuristic) prevents firing an uncompletable
+ * login (e.g. claude's key-only method) — spec §7 risk.
+ */
+export declare function classifyAuthMethod(method: AcpAuthMethod | undefined): AuthMethodRouting;
 /**
  * Thrown when an agent rejects session setup because the user must authenticate first — e.g. kimi
  * returns -32000 "Authentication required" with a `kimi login` authMethod. Carries the agent's

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

@@ -141,6 +141,17 @@ export interface AgentProcessCallbacks {
     sessionDir?: string;
 }
 export declare function ensureLoopbackNoProxy(env: Record<string, string>): Record<string, string>;
+/**
+ * Merge an external descriptor's env onto the forwarded base env, then DELETE any `suppressEnvKeys`
+ * (account mode). This is the load-bearing half of the env-injection-override fix: `Object.assign` can
+ * only add/overwrite, so a whitelist-forwarded `ANTHROPIC_API_KEY`/`OPENAI_API_KEY` (from the gateway's
+ * own shell) would otherwise survive into the child and override the CLI's native subscription login.
+ * Deleting after the merge guarantees `account` mode hands credential control to the CLI's own store.
+ */
+export declare function applyExternalDescriptorEnv(env: Record<string, string>, ext: {
+    env?: Record<string, string>;
+    suppressEnvKeys?: string[];
+}): Record<string, string>;
 /**
  * Build LLM-related environment variables for an external ACP teammate.
  *

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

@@ -30,6 +30,13 @@ export interface PooledAgentEntry {
         current: PooledTurnCtx | null;
     };
     lastUsed: number;
+    /**
+     * Set when a credential-mode change (authPreference / key / login) arrived while this process was
+     * mid-turn. The env is baked at spawn, so the switch can only take effect by respawning — but we must
+     * not abort the in-flight turn (D2: "下条消息生效"). The turn-runner evicts the entry once the turn
+     * settles (settlePooledTurn), so the NEXT turn respawns with the new credentials.
+     */
+    pendingRecredential?: boolean;
 }
 /** Pool key: same agent + workspace + session ⇒ same resident process (and shared memory). */
 export declare function poolKey(agentId: string, cwd: string, sessionId?: string): string;
@@ -47,6 +54,22 @@ export declare function adoptWarmedAgent(warmKey: string, sessionKey: string): P
 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;
+/**
+ * Invalidate every resident process for an agent after a credential-mode change (authPreference / key /
+ * login). The spawn env is baked at spawn time and reused across turns, so a switch only takes effect by
+ * respawning. Idle/warm entries are evicted immediately; a busy entry (turn in flight) is flagged
+ * `pendingRecredential` and evicted by settlePooledTurn when its turn settles (D2: never abort the
+ * in-flight turn — the switch lands on the next message). Returns counts for UI messaging.
+ */
+export declare function evictPooledAgentsByAgentId(agentId: string): {
+    evicted: number;
+    deferred: number;
+};
+/**
+ * Call when a pooled turn settles (success or error). If a credential change arrived mid-turn
+ * (pendingRecredential), evict now so the next turn respawns with the new credentials.
+ */
+export declare function settlePooledTurn(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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qlogicagent",
-  "version": "2.15.7",
+  "version": "2.15.9",
   "description": "XiaozhiClaw Agent CLI — subprocess architecture (JSON-RPC over stdio)",
   "type": "module",
   "main": "dist/index.js",