@adecore/agents 0.31.12 → 0.32.0

package/dist/chat/chat-session.js

@@ -557,7 +557,7 @@ export class ChatSession {
     compact() {
         const compaction = this.options.provider.capabilities.compaction;
         if (compaction === 'none') {
-            throw new ChatError('chat-unsupported', `${this.options.provider.name} cannot fold its context`);
+            throw new ChatError('chat-unsupported', `${this.options.provider.name} cannot compact its context`);
         }
         if (compaction === 'prompt') {
             this.send('/compact');
@@ -711,7 +711,9 @@ export class ChatSession {
                     ...usage,
                     contextTokens: 0,
                     contextWindow: this.options.provider.catalog.contextWindowFor(this.thread.info.selection),
-                    breakdown: undefined
+                    breakdown: undefined,
+                    cacheTtlMs: undefined,
+                    cacheExpiresAt: undefined
                 }
             })
         ]);
@@ -1639,6 +1641,7 @@ export class ChatSession {
             resumeNote: this.options.resumeNote?.() ?? null,
             resumeInstructions: this.options.resumeInstructions?.() ?? null,
             ...(info.goal === undefined ? {} : { goal: info.goal }),
+            ...(info.usage.cacheTtlMs === undefined ? {} : { cacheTtlMs: info.usage.cacheTtlMs }),
             ...(folders.length > 0 ? { folders } : {}),
             ...(projectConfig ? {} : { projectConfig }),
             ...(this.options.spawn ? { spawn: this.options.spawn } : {})

package/dist/chat/claude-backend.js

@@ -32,7 +32,7 @@ export class ClaudeBackend {
         this.launch = launch;
         this.host = host;
         this.allowedTools = options.allowedTools ?? [];
-        this.protocol = new ClaudeProtocol(launch.goal ?? null, launch.now);
+        this.protocol = new ClaudeProtocol(launch.goal ?? null, launch.now, launch.cacheTtlMs ?? null);
     }
     get running() {
         return this.child !== null;
@@ -260,10 +260,10 @@ export class ClaudeBackend {
         this.failed(error);
     }
     failed(error) {
-        this.rejectSteers(`Claude transport failed: ${errorText(error)}`);
+        this.rejectSteers(`Lost the connection to Claude: ${errorText(error)}`);
         this.protocol.forgetPending();
         try {
-            this.host.onEvent({ type: 'failed', message: `Claude transport failed: ${errorText(error)}`, processAlive: this.running });
+            this.host.onEvent({ type: 'failed', message: `Lost the connection to Claude: ${errorText(error)}`, processAlive: this.running });
         }
         catch (reportError) {
             console.error('Reporting a Claude transport failure failed:', errorText(reportError));
@@ -311,7 +311,7 @@ export class ClaudeBackend {
             return;
         }
         this.child = null;
-        this.rejectSteers('Claude exited before acknowledging your message');
+        this.rejectSteers('Claude stopped before it got your message');
         this.protocol.forgetPending();
         this.host.onEvent({ type: 'exit', exitCode, ...(stderr === null ? {} : { stderr }) });
     }

package/dist/chat/claude-protocol.d.ts

@@ -15,6 +15,8 @@ export declare class ClaudeProtocol {
     private readonly foregroundShells;
     private readonly backgroundTasks;
     private readonly workflows;
+    private cacheMessageId;
+    private cacheTtlMs;
     private lastUuid;
     private readonly subagentModels;
     private apiError;
@@ -26,7 +28,7 @@ export declare class ClaudeProtocol {
     private goalAnswered;
     private interrupting;
     private readonly backgroundAgents;
-    constructor(goal?: ChatGoal | null, now?: () => number);
+    constructor(goal?: ChatGoal | null, now?: () => number, cacheTtlMs?: number | null);
     noteInterrupt(): void;
     private setGoal;
     beginSteer(promptId: string): void;
@@ -45,6 +47,7 @@ export declare class ClaudeProtocol {
     stopTaskRequest(taskId: string): unknown;
     private handleControlResponse;
     private handleStreamEvent;
+    private noteCache;
     private handleAssistant;
     private trackGoal;
     private settleGoal;

package/dist/chat/claude-protocol.js

@@ -27,6 +27,20 @@ function taskUsage(usage) {
 function contextTokens(usage) {
     return isRecord(usage) ? num(usage.input_tokens) + num(usage.cache_creation_input_tokens) + num(usage.cache_read_input_tokens) : 0;
 }
+// How long a prompt cache entry lives, by the field of `usage.cache_creation` that counts what a request wrote with it.
+const CACHE_TTL_MS = { ephemeral_5m_input_tokens: 5 * 60_000, ephemeral_1h_input_tokens: 60 * 60_000 };
+/*
+ * The lifetime of the cache a response wrote, or null when it wrote none or names no lifetime. A response that wrote
+ * with both answers the shorter, which is when the part of its context that goes cold first does.
+ */
+function cacheTtlWritten(usage) {
+    const creation = isRecord(usage) && isRecord(usage.cache_creation) ? usage.cache_creation : null;
+    if (creation === null) {
+        return null;
+    }
+    const written = Object.entries(CACHE_TTL_MS).filter(([field]) => num(creation[field]) > 0);
+    return written.length === 0 ? null : Math.min(...written.map(([, ttl]) => ttl));
+}
 // The kinds of task Claude Code keeps beside its turns that are a command or a monitor; a subagent has a row of its own.
 const BACKGROUND_TASK_TYPES = new Set(['local_bash', 'monitor_mcp', 'monitor_ws']);
 const ENDED_TASK_STATUSES = new Set(['completed', 'failed', 'killed', 'stopped']);
@@ -168,6 +182,9 @@ export class ClaudeProtocol {
     backgroundTasks = new Set();
     // Workflows still running, by task id, to the Workflow call that launched each.
     workflows = new Map();
+    // The main-chain response whose cache lifetime the thread has, and the lifetime of the cache last written.
+    cacheMessageId = null;
+    cacheTtlMs;
     // The uuid of the last main-chain assistant frame of the turn, which is the line of the transcript the turn ends on.
     lastUuid = null;
     // The model each subagent last answered with, so a frame only reports one it had not named yet.
@@ -187,9 +204,11 @@ export class ClaudeProtocol {
     interrupting = false;
     // Background subagents still at work; Claude Code holds a goal's check until they report.
     backgroundAgents = new Set();
-    constructor(goal = null, now = () => Date.now()) {
+    // `cacheTtlMs` is the lifetime the chat knew before this process, so a resumed CLI that only reads the cache still moves its expiry.
+    constructor(goal = null, now = () => Date.now(), cacheTtlMs = null) {
         this.goal = goal;
         this.now = now;
+        this.cacheTtlMs = cacheTtlMs;
     }
     /* A stop is on its way; the turn it ends leaves the goal set but nobody working on it. */
     noteInterrupt() {
@@ -524,6 +543,7 @@ export class ClaudeProtocol {
         }
         if (event.type === 'message_start') {
             const message = isRecord(event.message) ? event.message : {};
+            this.noteCache(str(message.id), message.usage, events);
             this.streamMessageId = str(message.id);
             this.streamTextCount = 0;
             this.streamThinkingCount = 0;
@@ -559,6 +579,27 @@ export class ClaudeProtocol {
             }
         }
     }
+    /*
+     * When the prompt cache goes cold, from the first frame of each main-chain response: its `message_start`, or its
+     * first `assistant` frame when the CLI streams no partial messages. The lifetime runs from the start of the request,
+     * and a response that only read the cache starts the lifetime it was written with again, as a cache hit does.
+     */
+    noteCache(messageId, usage, events) {
+        if (messageId === null || messageId === this.cacheMessageId || !isRecord(usage)) {
+            return;
+        }
+        this.cacheMessageId = messageId;
+        const written = cacheTtlWritten(usage);
+        if (written !== null) {
+            this.cacheTtlMs = written;
+        }
+        else if (num(usage.cache_read_input_tokens) === 0) {
+            return;
+        }
+        if (this.cacheTtlMs !== null) {
+            events.push({ type: 'usage', cacheTtlMs: this.cacheTtlMs, cacheExpiresAt: this.now() + this.cacheTtlMs });
+        }
+    }
     handleAssistant(frame, events) {
         const message = isRecord(frame.message) ? frame.message : {};
         const messageId = str(message.id) ?? 'message';
@@ -607,6 +648,9 @@ export class ClaudeProtocol {
         if (tokens > 0) {
             events.push({ type: 'usage', contextTokens: tokens });
         }
+        if (!parentRef) {
+            this.noteCache(str(message.id), message.usage, events);
+        }
         const error = str(frame.error);
         if (error) {
             events.push({ type: 'note', level: 'error', text: `The request failed: ${error.replaceAll('_', ' ')}` });
@@ -704,7 +748,7 @@ export class ClaudeProtocol {
                 events.push({ type: 'usage', costUsd: num(frame.total_cost_usd) });
             }
             if (frame.is_error === true) {
-                events.push({ type: 'note', level: 'warning', text: 'A background Claude turn failed; the submitted prompt is still pending.' });
+                events.push({ type: 'note', level: 'warning', text: 'Claude could not finish a turn in the background. Your message is still waiting.' });
             }
             return;
         }

package/dist/chat/codex-backend.js

@@ -243,7 +243,7 @@ export class CodexBackend {
     async runGoalCommand(command, input) {
         const transport = this.transport;
         if (!transport) {
-            this.emit({ type: 'failed', message: 'thread/goal failed: Codex is not running' });
+            this.emit({ type: 'failed', message: 'Codex is not running' });
             return;
         }
         const threadId = this.threadId;
@@ -308,7 +308,7 @@ export class CodexBackend {
     async goal(action) {
         const transport = this.transport;
         if (!transport) {
-            throw new Error('thread/goal failed: Codex is not running');
+            throw new Error('Codex is not running');
         }
         if (action === 'clear') {
             await transport.request('thread/goal/clear', { threadId: this.threadId, origin: 'user' });
@@ -417,7 +417,7 @@ export class CodexBackend {
     listThreadItems(params) {
         const transport = this.transport;
         if (!transport) {
-            return Promise.reject(new Error('thread/items/list failed: Codex is not running'));
+            return Promise.reject(new Error('Codex is not running'));
         }
         return transport.request('thread/items/list', params);
     }
@@ -502,7 +502,7 @@ export class CodexBackend {
     request(method, params, accepted) {
         const transport = this.transport;
         if (!transport) {
-            this.emit({ type: 'failed', message: `${method} failed: Codex is not running` });
+            this.emit({ type: 'failed', message: 'Codex is not running' });
             return;
         }
         void transport

package/dist/chat/fixtures/antigravity-1.4.1-question.json

@@ -0,0 +1,69 @@
+{
+  "version": "Antigravity ACP server 1.4.1, `agy_acp_server.par`",
+  "source": "Not recorded: a question needs the model to choose to ask one. Built from `ExternalOnInteractionHook` in the server's acp_server/hooks.py inside agy_acp_server.par 1.4.1: a `tool_call` with an `interaction_` id and an empty rawInput, then one `session/request_permission` per question with an `allow_once` option per choice, answered with the chosen optionId.",
+  "sessionId": "agy-session-1",
+  "initialize": {
+    "protocolVersion": 1,
+    "agentCapabilities": {
+      "loadSession": true,
+      "promptCapabilities": {
+        "image": false,
+        "embeddedContext": true
+      }
+    },
+    "authMethods": []
+  },
+  "sessionNew": {
+    "sessionId": "agy-session-1"
+  },
+  "commands": [],
+  "setConfigOption": {},
+  "promptUpdates": [
+    {
+      "sessionUpdate": "tool_call",
+      "toolCallId": "interaction_3f9a1c2e",
+      "title": "Which test runner should I set up?",
+      "rawInput": {},
+      "status": "pending"
+    },
+    {
+      "permission": {
+        "sessionId": "agy-session-1",
+        "toolCall": {
+          "toolCallId": "interaction_3f9a1c2e",
+          "title": "Which test runner should I set up?",
+          "rawInput": {},
+          "status": "pending"
+        },
+        "options": [
+          {
+            "optionId": "opt_builtin",
+            "name": "The built-in runner",
+            "kind": "allow_once"
+          },
+          {
+            "optionId": "opt_separate",
+            "name": "A separate runner",
+            "kind": "allow_once"
+          }
+        ]
+      }
+    },
+    {
+      "sessionUpdate": "tool_call_update",
+      "toolCallId": "interaction_3f9a1c2e",
+      "status": "completed",
+      "rawOutput": "Response received"
+    },
+    {
+      "sessionUpdate": "agent_message_chunk",
+      "content": {
+        "type": "text",
+        "text": "Setting it up."
+      }
+    }
+  ],
+  "promptResponse": {
+    "stopReason": "end_turn"
+  }
+}

package/dist/chat/fixtures/antigravity-1.4.1-quota.json

@@ -0,0 +1,35 @@
+{
+  "version": "Antigravity ACP server 1.4.1, `agy_acp_server.par`",
+  "source": "Not recorded: no account here runs out of quota on demand. Built from the server's own Python modules inside agy_acp_server.par 1.4.1 (acp_server/server.py and ccpa_connection/quota_errors.py): on QUOTA_EXHAUSTED it writes this message as an agent_message_chunk and answers the prompt with `end_turn`; the reset is the delay in its two largest units, or the time when only that is known.",
+  "sessionId": "agy-session-1",
+  "initialize": {
+    "protocolVersion": 1,
+    "agentCapabilities": {
+      "loadSession": true,
+      "promptCapabilities": {
+        "image": false,
+        "embeddedContext": true
+      }
+    },
+    "authMethods": []
+  },
+  "sessionNew": {
+    "sessionId": "agy-session-1"
+  },
+  "commands": [],
+  "setConfigOption": {},
+  "promptUpdates": [
+    {
+      "sessionUpdate": "agent_message_chunk",
+      "content": {
+        "type": "text",
+        "text": "Usage Limit Reached\n\nYou have reached your current quota for this period. Your limit will reset in 4 days, 23 hours."
+      }
+    }
+  ],
+  "promptResponse": {
+    "stopReason": "end_turn"
+  },
+  "resetOn": "Usage Limit Reached\n\nYou have reached your current quota for this period. Your limit will reset on Oct 23, 2026 14:05 UTC.",
+  "noReset": "Usage Limit Reached\n\nYou have reached your current quota for this period."
+}

package/dist/chat/fixtures/grok-1.0.62-limits.json

@@ -0,0 +1,66 @@
+{
+  "version": "Grok 1.0.62, `grok --no-auto-update agent stdio`",
+  "source": "Not recorded: no account here runs into these limits on demand. Built from the source of xai-org/grok-build at 2bdd1d6a, the closest to 1.0.62 it publishes: `handle_sampling_failure` in acp_session_impl/sampler_turn.rs fails `session/prompt` with -32003 after a 429 and with -32603 for an overloaded model once its retries ran out, and sampling/error.rs builds the `data` (a string, or `message` with `http_status`). The bodies after the status line are examples.",
+  "sessionId": "grok-session-1",
+  "initialize": {
+    "protocolVersion": 1,
+    "agentCapabilities": {
+      "loadSession": true,
+      "promptCapabilities": {
+        "image": false,
+        "embeddedContext": true
+      }
+    },
+    "authMethods": []
+  },
+  "sessionNew": {
+    "sessionId": "grok-session-1"
+  },
+  "commands": [],
+  "setConfigOption": {},
+  "promptUpdates": [
+    {
+      "sessionUpdate": "agent_thought_chunk",
+      "content": {
+        "type": "text",
+        "text": "Reading the request."
+      }
+    }
+  ],
+  "promptResponse": {
+    "stopReason": "end_turn"
+  },
+  "errors": {
+    "freeUsage": {
+      "code": -32003,
+      "message": "Rate limited",
+      "data": "API error (status 429 Too Many Requests): {\"code\":\"subscription:free-usage-exhausted\",\"error\":\"You have used the free usage of this period.\"}"
+    },
+    "rateLimited": {
+      "code": -32003,
+      "message": "Rate limited",
+      "data": "API error (status 429 Too Many Requests): {\"code\":\"rate_limit_exceeded\",\"error\":\"Too many requests.\"}"
+    },
+    "overloaded": {
+      "code": -32603,
+      "message": "Internal error",
+      "data": {
+        "message": "API error (status 529): Overloaded",
+        "http_status": 529
+      }
+    },
+    "overloadedStream": {
+      "code": -32603,
+      "message": "Internal error",
+      "data": "stream error (overloaded_error): Overloaded"
+    },
+    "badRequest": {
+      "code": -32603,
+      "message": "Internal error",
+      "data": {
+        "message": "API error (status 400 Bad Request): The prompt is too long.",
+        "http_status": 400
+      }
+    }
+  }
+}

package/dist/chat/fixtures/grok-1.0.62-question.json

@@ -0,0 +1,99 @@
+{
+  "version": "Grok 1.0.62, `grok --no-auto-update agent stdio`",
+  "source": "Not recorded: a question needs the model to choose to ask one. Built from the source of xai-org/grok-build at 2bdd1d6a, the closest to 1.0.62 it publishes: the ext request `_x.ai/ask_user_question` (acp_session_impl/spawn.rs) with the params of ask_user_question/types.rs; its answer is `{ outcome: \"accepted\", answers, annotations? }`, keyed by the question's text.",
+  "sessionId": "grok-session-1",
+  "initialize": {
+    "protocolVersion": 1,
+    "agentCapabilities": {
+      "loadSession": true,
+      "promptCapabilities": {
+        "image": false,
+        "embeddedContext": true
+      }
+    },
+    "authMethods": []
+  },
+  "sessionNew": {
+    "sessionId": "grok-session-1"
+  },
+  "commands": [],
+  "setConfigOption": {},
+  "promptUpdates": [
+    {
+      "sessionUpdate": "tool_call",
+      "toolCallId": "call-ask-1",
+      "title": "Ask the user",
+      "kind": "other",
+      "status": "pending"
+    },
+    {
+      "request": {
+        "method": "_x.ai/ask_user_question",
+        "params": {
+          "sessionId": "grok-session-1",
+          "toolCallId": "call-ask-1",
+          "mode": "default",
+          "questions": [
+            {
+              "question": "Which database should the service use?",
+              "options": [
+                {
+                  "label": "Postgres",
+                  "description": "The one the other services run on"
+                },
+                {
+                  "label": "SQLite",
+                  "description": "A file beside the service"
+                }
+              ],
+              "multiSelect": false
+            },
+            {
+              "question": "Which checks should run before a release?",
+              "options": [
+                {
+                  "label": "Tests",
+                  "description": "The unit tests"
+                },
+                {
+                  "label": "Lint, strict",
+                  "description": "Every warning fails"
+                },
+                {
+                  "label": "Types",
+                  "description": "The type check"
+                }
+              ],
+              "multiSelect": true
+            },
+            {
+              "question": "Anything else to keep in mind?",
+              "options": [
+                {
+                  "label": "No",
+                  "description": "Nothing"
+                }
+              ],
+              "multiSelect": null
+            }
+          ]
+        }
+      }
+    },
+    {
+      "sessionUpdate": "tool_call_update",
+      "toolCallId": "call-ask-1",
+      "status": "completed"
+    },
+    {
+      "sessionUpdate": "agent_message_chunk",
+      "content": {
+        "type": "text",
+        "text": "Noted."
+      }
+    }
+  ],
+  "promptResponse": {
+    "stopReason": "end_turn"
+  }
+}

package/dist/chat/json-rpc-transport.js

@@ -48,7 +48,7 @@ export class JsonRpcTransport {
         const timeoutMs = options.timeoutMs === undefined ? this.options.requestTimeoutMs : options.timeoutMs;
         return new Promise((resolve, reject) => {
             if (this.closed) {
-                reject(new Error(`${method} failed: ${label} is not running`));
+                reject(new Error(`${label} is not running`));
                 return;
             }
             const id = this.nextId++;
@@ -122,7 +122,7 @@ export class JsonRpcTransport {
         this.failed(error);
     }
     failed(error) {
-        const failure = new Error(`${this.options.label} transport failed: ${errorText(error)}`);
+        const failure = new Error(`Lost the connection to ${this.options.label}: ${errorText(error)}`);
         this.rejectPending(() => failure);
         try {
             this.options.onError?.(failure);

package/dist/chat/projector.js

@@ -308,16 +308,28 @@ export class ThreadProjector {
                 break;
             }
             case 'usage': {
-                const contextTokens = event.contextTokens ?? info.usage.contextTokens;
-                events.push(this.thread.patchInfo({
-                    usage: {
-                        ...info.usage,
-                        contextTokens,
-                        contextWindow: event.contextWindow ?? info.usage.contextWindow,
-                        costUsd: Math.max(info.usage.costUsd, event.costUsd ?? 0),
-                        breakdown: contextTokens > 0 ? estimateContextBreakdown(this.thread.list(), contextTokens) : undefined
-                    }
-                }));
+                const usage = info.usage;
+                const contextTokens = event.contextTokens ?? usage.contextTokens;
+                const next = {
+                    ...usage,
+                    contextTokens,
+                    contextWindow: event.contextWindow ?? usage.contextWindow,
+                    costUsd: Math.max(usage.costUsd, event.costUsd ?? 0),
+                    // The estimate reads the whole thread, so only a new count of tokens is worth it.
+                    ...(contextTokens === usage.contextTokens
+                        ? {}
+                        : { breakdown: contextTokens > 0 ? estimateContextBreakdown(this.thread.list(), contextTokens) : undefined }),
+                    ...(event.cacheTtlMs === undefined || event.cacheExpiresAt === undefined
+                        ? {}
+                        : { cacheTtlMs: event.cacheTtlMs, cacheExpiresAt: event.cacheExpiresAt })
+                };
+                if (next.contextTokens !== usage.contextTokens ||
+                    next.contextWindow !== usage.contextWindow ||
+                    next.costUsd !== usage.costUsd ||
+                    next.cacheTtlMs !== usage.cacheTtlMs ||
+                    next.cacheExpiresAt !== usage.cacheExpiresAt) {
+                    events.push(this.thread.patchInfo({ usage: next }));
+                }
                 break;
             }
             case 'compaction':

package/dist/providers/accounts/service.js

@@ -153,6 +153,10 @@ export class ProviderAccountsService {
         };
         if (isDefaultAccountOf(kind, id)) {
             const account = this.accounts[kind] ?? { kind };
+            // Only a start that names it: every turn of a chat on the default account asks with none.
+            if (id !== undefined && account.enabled === false) {
+                throw refuse('it is turned off');
+            }
             return accountEnv(kind, account, provider, baseEnv, variables(account));
         }
         const account = this.accounts[key];

package/dist/providers/claude-provider.js

@@ -31,7 +31,8 @@ export function createClaudeProvider(options = {}) {
                 { kind: 'env', variable: 'ANTHROPIC_API_KEY' }
             ]
         },
-        detect: detectCli,
+        // The version probe must never be the start that updates the CLI.
+        detect: (command, env) => detectCli(command, { ...env, DISABLE_AUTOUPDATER: '1' }),
         oneShotArgs: (prompt) => ['-p', prompt, '--output-format', 'text'],
         // `-p` without a prompt argument reads the prompt from stdin.
         oneShotStdinArgs: ['-p', '--output-format', 'text'],

package/dist/providers/detect.d.ts

@@ -3,4 +3,4 @@ export interface CliDetection {
     installed: boolean;
     version: string | null;
 }
-export declare function detectCli(command: string, env?: Record<string, string | undefined>, spawn?: SpawnChatProcess): Promise<CliDetection>;
+export declare function detectCli(command: string, env?: Record<string, string | undefined>, spawn?: SpawnChatProcess, flags?: readonly string[]): Promise<CliDetection>;

package/dist/providers/detect.js

@@ -1,13 +1,16 @@
 import { spawnChatProcess } from '../chat/chat-process.js';
 import { definedEnv } from './accounts/launch.js';
-/* Asks a CLI for its version; a missing binary is a plain "not installed", never an error. */
-export async function detectCli(command, env = process.env, spawn = spawnChatProcess) {
+/*
+ * Asks a CLI for its version; a missing binary is a plain "not installed", never an error. `flags` go before
+ * `--version`, for a CLI that would otherwise look for an update of itself on any start.
+ */
+export async function detectCli(command, env = process.env, spawn = spawnChatProcess, flags = []) {
     try {
         let exited = () => undefined;
         const code = new Promise((resolve) => {
             exited = resolve;
         });
-        const proc = spawn({ command: [command, '--version'], cwd: process.cwd(), env: definedEnv(env), onExit: (exitCode) => exited(exitCode) });
+        const proc = spawn({ command: [command, ...flags, '--version'], cwd: process.cwd(), env: definedEnv(env), onExit: (exitCode) => exited(exitCode) });
         proc.stdin.end();
         const output = await new Response(proc.stdout).text();
         if ((await code) !== 0) {

package/dist/providers/registry.d.ts

@@ -16,7 +16,11 @@ export declare class ProviderRegistry {
     private readonly detect;
     private readonly env;
     private readonly cache;
+    private readonly listeners;
+    private readonly stops;
     constructor(options?: ProviderRegistryOptions);
+    add(provider: ChatProvider): void;
+    remove(kind: AgentKind): void;
     list(): Promise<ProviderInfo[]>;
     kinds(): AgentKind[];
     get(kind: AgentKind): ChatProvider;
@@ -26,5 +30,8 @@ export declare class ProviderRegistry {
     onChange(listener: (kind: AgentKind) => void): () => void;
     invalidate(kind: AgentKind): void;
     protected fallback(kind: AgentKind): ChatProvider;
+    private follow;
+    private unfollow;
+    private changed;
     private detection;
 }