@adecore/agents 0.31.11 → 0.32.0

package/src/chat/claude-protocol.ts

@@ -46,6 +46,22 @@ function contextTokens(usage: unknown): number {
     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: Record<string, number> = { 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: unknown): number | null {
+    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']);
@@ -202,6 +218,9 @@ export class ClaudeProtocol {
     private readonly backgroundTasks = new Set<string>();
     // Workflows still running, by task id, to the Workflow call that launched each.
     private readonly workflows = new Map<string, string>();
+    // The main-chain response whose cache lifetime the thread has, and the lifetime of the cache last written.
+    private cacheMessageId: string | null = null;
+    private cacheTtlMs: number | null;
     // The uuid of the last main-chain assistant frame of the turn, which is the line of the transcript the turn ends on.
     private lastUuid: string | null = null;
     // The model each subagent last answered with, so a frame only reports one it had not named yet.
@@ -224,9 +243,11 @@ export class ClaudeProtocol {
     // Background subagents still at work; Claude Code holds a goal's check until they report.
     private readonly backgroundAgents = new Set<string>();
 
-    constructor(goal: ChatGoal | null = null, now: () => number = () => 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: ChatGoal | null = null, now: () => number = () => Date.now(), cacheTtlMs: number | null = 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. */
@@ -572,6 +593,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;
@@ -607,6 +629,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.
+     */
+    private noteCache(messageId: string | null, usage: unknown, events: BackendEvent[]): void {
+        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 });
+        }
+    }
+
     private handleAssistant(frame: Frame, events: BackendEvent[]): void {
         const message = isRecord(frame.message) ? frame.message : {};
         const messageId = str(message.id) ?? 'message';
@@ -653,6 +696,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('_', ' ')}` });
@@ -756,7 +802,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/src/chat/codex-backend.ts

@@ -262,7 +262,7 @@ export class CodexBackend implements ChatBackend {
     private async runGoalCommand(command: GoalCommand, input: TurnInput): Promise<void> {
         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;
@@ -328,7 +328,7 @@ export class CodexBackend implements ChatBackend {
     async goal(action: ChatGoalAction): Promise<void> {
         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' });
@@ -443,7 +443,7 @@ export class CodexBackend implements ChatBackend {
     listThreadItems(params: { threadId: string; cursor?: string; limit: number; sortDirection: 'asc' | 'desc' }): Promise<unknown> {
         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);
     }
@@ -537,7 +537,7 @@ export class CodexBackend implements ChatBackend {
     private request(method: string, params: unknown, accepted?: () => void): void {
         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/src/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/src/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/src/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/src/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/src/chat/json-rpc-transport.ts

@@ -84,7 +84,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++;
@@ -165,7 +165,7 @@ export class JsonRpcTransport {
     }
 
     private failed(error: unknown): void {
-        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/src/chat/projector.ts

@@ -351,18 +351,30 @@ 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/src/providers/accounts/service.ts

@@ -225,6 +225,10 @@ export class ProviderAccountsService implements AccountLaunches {
         };
         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/src/providers/claude-provider.ts

@@ -33,7 +33,8 @@ export function createClaudeProvider(options: ClaudeBackendOptions = {}): ChatPr
                 { 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/src/providers/detect.ts

@@ -6,18 +6,22 @@ export interface CliDetection {
     version: string | null;
 }
 
-/* Asks a CLI for its version; a missing binary is a plain "not installed", never an error. */
+/*
+ * 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: string,
     env: Record<string, string | undefined> = process.env,
-    spawn: SpawnChatProcess = spawnChatProcess
+    spawn: SpawnChatProcess = spawnChatProcess,
+    flags: readonly string[] = []
 ): Promise<CliDetection> {
     try {
         let exited: (code: number | null) => void = () => undefined;
         const code = new Promise<number | null>((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/src/providers/registry.ts

@@ -72,14 +72,48 @@ export class ProviderRegistry {
     private readonly detect: ((command: string) => Promise<CliDetection>) | null;
     private readonly env: Record<string, string | undefined>;
     private readonly cache = new Map<AgentKind, { at: number; detection: CliDetection }>();
+    private readonly listeners = new Set<(kind: AgentKind) => void>();
+    // What the registry listens to on each provider, so one taken away is let go.
+    private readonly stops = new Map<ChatProvider, () => void>();
 
     constructor(options: ProviderRegistryOptions = {}) {
-        this.providers = options.providers ?? [...BUILT_IN_PROVIDERS];
+        this.providers = [...(options.providers ?? BUILT_IN_PROVIDERS)];
         this.commands = options.commands ?? {};
         this.detect = options.detect ?? null;
         this.env = options.env ?? process.env;
     }
 
+    /*
+     * Offers one more provider after the host started, such as a CLI a person installed since, or puts it in the
+     * place of the one of its kind. The `onChange` listeners hear its kind, so a host hands its clients the new list.
+     */
+    add(provider: ChatProvider): void {
+        const index = this.providers.findIndex((entry) => entry.kind === provider.kind);
+        if (index === -1) {
+            this.providers.push(provider);
+        } else {
+            this.unfollow(this.providers[index]!);
+            this.providers[index] = provider;
+        }
+        this.cache.delete(provider.kind);
+        if (this.listeners.size > 0) {
+            this.follow(provider);
+        }
+        this.changed(provider.kind);
+    }
+
+    /* Stops offering a kind; a record that names it gets the stand-in `get` answers for a kind the host does not offer. */
+    remove(kind: AgentKind): void {
+        const index = this.providers.findIndex((entry) => entry.kind === kind);
+        if (index === -1) {
+            return;
+        }
+        this.unfollow(this.providers[index]!);
+        this.providers.splice(index, 1);
+        this.cache.delete(kind);
+        this.changed(kind);
+    }
+
     async list(): Promise<ProviderInfo[]> {
         return await Promise.all(
             this.providers.map(async (provider) => ({
@@ -128,12 +162,24 @@ export class ProviderRegistry {
         return this.get(kind).enabled?.() !== false;
     }
 
-    /* Calls the listener with the kind of every provider whose models or capabilities changed, so a host can list them again; answers how to stop. */
+    /*
+     * Calls the listener with the kind of every provider whose models or capabilities changed, and of every one
+     * added or removed, so a host can list them again; answers how to stop.
+     */
     onChange(listener: (kind: AgentKind) => void): () => void {
-        const stops = this.providers.flatMap((provider) => (provider.onChange ? [provider.onChange(() => listener(provider.kind))] : []));
+        if (this.listeners.size === 0) {
+            for (const provider of this.providers) {
+                this.follow(provider);
+            }
+        }
+        this.listeners.add(listener);
         return () => {
-            for (const stop of stops) {
-                stop();
+            this.listeners.delete(listener);
+            if (this.listeners.size === 0) {
+                for (const stop of this.stops.values()) {
+                    stop();
+                }
+                this.stops.clear();
             }
         };
     }
@@ -146,6 +192,26 @@ export class ProviderRegistry {
         return unofferedProvider(kind);
     }
 
+    private follow(provider: ChatProvider): void {
+        if (provider.onChange && !this.stops.has(provider)) {
+            this.stops.set(
+                provider,
+                provider.onChange(() => this.changed(provider.kind))
+            );
+        }
+    }
+
+    private unfollow(provider: ChatProvider): void {
+        this.stops.get(provider)?.();
+        this.stops.delete(provider);
+    }
+
+    private changed(kind: AgentKind): void {
+        for (const listener of [...this.listeners]) {
+            listener(kind);
+        }
+    }
+
     private async detection(provider: ChatProvider): Promise<CliDetection> {
         if (provider.enabled?.() === false) {
             return DISABLED;