@adecore/agents 0.31.2 → 0.31.4

package/dist/chat/acp-backend.d.ts

@@ -1,5 +1,5 @@
 import { type ModelSelection } from '@adecore/agent-contracts';
-import { type AcpModeMap, type AcpSessionInfo } from './acp-protocol.ts';
+import { type AcpModeMap, type AcpPermissionRequest, type AcpSessionInfo, type AcpTurnUsage } from './acp-protocol.ts';
 import type { ApprovalDecision, BackendHost, BackendLaunch, ChatBackend, TurnInput } from './backend.ts';
 export interface AcpClientInfo {
     name: string;
@@ -16,6 +16,13 @@ export interface AcpAgentSpec {
     client?: AcpClientInfo;
     model?(selection: ModelSelection): string | null;
     onSession?(info: AcpSessionInfo): void;
+    onUsage?(usage: AcpUsageReport): void;
+    autoAllow?(request: AcpPermissionRequest): boolean;
+}
+export interface AcpUsageReport extends AcpTurnUsage {
+    sessionId: string;
+    cwd: string;
+    model: string;
 }
 export declare class AcpBackend implements ChatBackend {
     private readonly launch;
@@ -29,6 +36,7 @@ export declare class AcpBackend implements ChatBackend {
     private replaying;
     private contextPending;
     private prompt;
+    private model;
     constructor(launch: BackendLaunch, host: BackendHost, spec: AcpAgentSpec);
     get running(): boolean;
     get pid(): number | null;
@@ -52,7 +60,9 @@ export declare class AcpBackend implements ChatBackend {
     private respond;
     private fail;
     private handleFrame;
+    private hostAllows;
     private handleExit;
+    private report;
     private emitAll;
     private emit;
 }

package/dist/chat/acp-backend.js

@@ -2,7 +2,7 @@ import { readFileSync } from 'node:fs';
 import { attachmentImageMime } from '@adecore/agent-contracts';
 import { errorText } from '../error-text.js';
 import { MODE_ORDER } from '../modes.js';
-import { ACP_AUTH_REQUIRED, ACP_PROTOCOL_VERSION, AcpProtocol, acpStopWords, autoAllows, parseInitialize, parseSessionInfo, resolveAcpMode, runtimeModeOf, sessionIdOf } from './acp-protocol.js';
+import { ACP_AUTH_REQUIRED, ACP_PROTOCOL_VERSION, AcpProtocol, acpStopWords, autoAllows, parseInitialize, parseSessionInfo, promptUsageOf, resolveAcpMode, runtimeModeOf, sessionIdOf, thoughtLevelOf } from './acp-protocol.js';
 import { attachmentNote } from './input.js';
 import { JsonRpcError, JsonRpcTransport } from './json-rpc-transport.js';
 export const DEFAULT_ACP_CLIENT = { name: 'agents', title: 'Agents', version: '0.1.0' };
@@ -30,6 +30,7 @@ export class AcpBackend {
     replaying = false;
     contextPending = null;
     prompt = null;
+    model = null;
     constructor(launch, host, spec) {
         this.launch = launch;
         this.host = host;
@@ -85,8 +86,9 @@ export class AcpBackend {
         this.capabilities = capabilities;
         const info = await this.openSession(transport, capabilities);
         const modeId = await this.applyMode(transport, info);
-        const model = await this.applyModel(transport, info);
-        await this.applyThoughtLevel(transport, info);
+        const { model, thoughtLevel } = await this.applyModel(transport, info);
+        this.model = model;
+        await this.applyThoughtLevel(transport, thoughtLevel);
         this.spec.onSession?.(info);
         this.emit({
             type: 'session',
@@ -189,25 +191,29 @@ export class AcpBackend {
         }
         return resolved.modeId;
     }
-    /* Switches to the selected model where the agent offers it; answers the model the session runs. */
+    /*
+     * Switches to the selected model where the agent offers it; answers the model the session runs and the
+     * reasoning effort it offers there, which may change with the model.
+     */
     async applyModel(transport, info) {
         const models = info.models;
+        const thoughtLevel = info.thoughtLevel;
         const wanted = this.spec.model ? this.spec.model(this.launch.selection) : this.launch.selection.model;
         if (models === null || wanted === null || wanted === models.current) {
-            return models?.current ?? wanted;
+            return { model: models?.current ?? wanted, thoughtLevel };
         }
         if (!models.models.some((model) => model.id === wanted)) {
             this.emit({ type: 'note', level: 'warning', text: `${this.spec.name} does not offer ${this.launch.modelName}. It runs ${models.current}.` });
-            return models.current;
+            return { model: models.current, thoughtLevel };
         }
         try {
             if (models.configId === null) {
                 await transport.request('session/set_model', { sessionId: this.sessionId, modelId: wanted });
+                return { model: wanted, thoughtLevel };
             }
-            else {
-                await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: models.configId, value: wanted });
-            }
-            return wanted;
+            const result = await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: models.configId, value: wanted });
+            const after = thoughtLevelOf(result);
+            return { model: wanted, thoughtLevel: after === undefined ? thoughtLevel : after };
         }
         catch (error) {
             if (!(error instanceof JsonRpcError)) {
@@ -218,20 +224,26 @@ export class AcpBackend {
                 level: 'warning',
                 text: `${this.spec.name} did not switch to ${this.launch.modelName} (${errorText(error)}). It runs ${models.current}.`
             });
-            return models.current;
+            return { model: models.current, thoughtLevel };
         }
     }
-    async applyThoughtLevel(transport, info) {
-        const level = info.thoughtLevel;
+    /* Sets the selected effort where the session offers it; a model without one runs as it is. */
+    async applyThoughtLevel(transport, level) {
         const effort = this.launch.selection.options.effort;
-        if (level === null || typeof effort !== 'string' || effort === level.current || !level.values.includes(effort)) {
+        const choice = level?.choices.find((entry) => entry.id === effort);
+        if (level === null || choice === undefined || effort === level.current) {
             return;
         }
-        await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: level.configId, value: effort }).catch((error) => {
+        try {
+            await transport.request('session/set_config_option', { sessionId: this.sessionId, configId: level.configId, value: choice.id });
+        }
+        catch (error) {
             if (!(error instanceof JsonRpcError)) {
                 throw error;
             }
-        });
+            const current = level.choices.find((entry) => entry.id === level.current)?.name ?? level.current;
+            this.emit({ type: 'note', level: 'warning', text: `${this.spec.name} kept its reasoning at ${current} instead of ${choice.name}.` });
+        }
     }
     promptBlocks(input) {
         const sendsImages = this.capabilities?.images === true;
@@ -265,6 +277,7 @@ export class AcpBackend {
             .then((result) => {
             if (this.transport === transport && this.prompt === turn) {
                 this.prompt = null;
+                this.report(result);
                 this.emitAll(this.protocol.finish(turn.cancelled ? { stopReason: 'cancelled' } : result, turn.promptId));
             }
         })
@@ -373,7 +386,7 @@ export class AcpBackend {
             }
             return;
         }
-        if (autoAllows(this.launch.runtimeMode, permission.kind)) {
+        if (autoAllows(this.launch.runtimeMode, permission.kind) || this.hostAllows(permission.request)) {
             this.emitAll(permission.events.filter((event) => event.type !== 'approval.requested'));
             const answer = this.protocol.answer(permission.requestId, 'allow');
             if (answer) {
@@ -383,6 +396,14 @@ export class AcpBackend {
         }
         this.emitAll(permission.events);
     }
+    hostAllows(request) {
+        try {
+            return this.spec.autoAllow?.(request) === true;
+        }
+        catch {
+            return false;
+        }
+    }
     handleExit(transport, exitCode, stderr) {
         if (this.transport !== transport) {
             return;
@@ -392,12 +413,23 @@ export class AcpBackend {
         this.protocol.cancelPermissions();
         this.emit({ type: 'exit', exitCode, ...(stderr === null ? {} : { stderr }) });
     }
+    /* A cancelled turn still spent what it reports. */
+    report(result) {
+        const usage = this.spec.onUsage === undefined ? null : promptUsageOf(result);
+        if (usage === null) {
+            return;
+        }
+        this.spec.onUsage?.({ ...usage, sessionId: this.sessionId, cwd: this.launch.cwd, model: this.model ?? this.launch.selection.model });
+    }
     emitAll(events) {
         for (const event of events) {
             this.emit(event);
         }
     }
     emit(event) {
+        if (event.type === 'model') {
+            this.model = event.model;
+        }
         this.host.onEvent(event);
     }
 }

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

@@ -9,6 +9,14 @@ declare const DiffSchema: z.ZodObject<{
     oldText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     newText: z.ZodString;
 }, z.core.$loose>;
+export interface AcpTurnUsage {
+    input: number;
+    cacheRead: number;
+    cacheWrite: number;
+    output: number;
+    reasoning: number;
+}
+export declare function promptUsageOf(result: unknown): AcpTurnUsage | null;
 export interface AcpAgentInfo {
     name: string;
     title: string | null;
@@ -44,17 +52,24 @@ export interface AcpModeState {
     modes: AcpMode[];
     configId: string | null;
 }
+export interface AcpChoice {
+    id: string;
+    name: string;
+    description: string | null;
+}
+export interface AcpThoughtLevel {
+    configId: string;
+    current: string;
+    choices: AcpChoice[];
+}
 export interface AcpSessionInfo {
     sessionId: string;
     agent: AcpAgentInfo | null;
     models: AcpModelState | null;
     modes: AcpModeState | null;
-    thoughtLevel: {
-        configId: string;
-        current: string;
-        values: string[];
-    } | null;
+    thoughtLevel: AcpThoughtLevel | null;
 }
+export declare function thoughtLevelOf(result: unknown): AcpThoughtLevel | null | undefined;
 export declare function parseSessionInfo(result: unknown, sessionId: string, agent: AcpAgentInfo | null): AcpSessionInfo;
 export declare function sessionIdOf(result: unknown): string | null;
 export type AcpModeMap = Partial<Record<RuntimeMode, readonly string[]>>;
@@ -84,10 +99,16 @@ export declare function toolRow(tool: Pick<ToolState, 'title' | 'name' | 'kind'
     input: Record<string, unknown>;
     changes?: ChatFileChange[];
 };
+export interface AcpPermissionRequest {
+    kind: string | null;
+    title: string | null;
+    commands: string[];
+}
 export interface AcpPermission {
     requestId: string;
     rpcId: number | string;
     kind: string | null;
+    request: AcpPermissionRequest;
     events: BackendEvent[];
 }
 export interface AcpStopWords {

package/dist/chat/acp-protocol.js

@@ -40,12 +40,42 @@ const PermissionRequestSchema = z.looseObject({
 });
 const SessionNotificationSchema = z.looseObject({ sessionId: z.string(), update: z.looseObject({ sessionUpdate: z.string() }) });
 const PromptResponseSchema = z.looseObject({ stopReason: z.string() });
+const tokenCount = z.number().int().nonnegative();
+// Unstable in the protocol (`PromptResponse.usage`); only the three totals are required.
+const PromptUsageSchema = z.looseObject({
+    totalTokens: tokenCount,
+    inputTokens: tokenCount,
+    outputTokens: tokenCount,
+    thoughtTokens: tokenCount.nullish(),
+    cachedReadTokens: tokenCount.nullish(),
+    cachedWriteTokens: tokenCount.nullish()
+});
+/*
+ * The `usage` a `session/prompt` response carries, or null where the agent reports none. The protocol
+ * leaves open whether the input holds the cached part, so the total decides: when the kinds add up
+ * to more than it, the input counted the cache too and loses it here.
+ */
+export function promptUsageOf(result) {
+    const response = z.looseObject({ usage: PromptUsageSchema }).safeParse(result);
+    if (!response.success) {
+        return null;
+    }
+    const usage = response.data.usage;
+    const cacheRead = usage.cachedReadTokens ?? 0;
+    const cacheWrite = usage.cachedWriteTokens ?? 0;
+    const apart = usage.inputTokens + usage.outputTokens + cacheRead + cacheWrite <= usage.totalTokens;
+    const input = apart ? usage.inputTokens : Math.max(0, usage.inputTokens - cacheRead - cacheWrite);
+    if (input + cacheRead + cacheWrite + usage.outputTokens === 0) {
+        return null;
+    }
+    return { input, cacheRead, cacheWrite, output: usage.outputTokens, reasoning: usage.thoughtTokens ?? 0 };
+}
 const ModeStateSchema = z.looseObject({
     currentModeId: z.string(),
     availableModes: z.array(z.unknown())
 });
 const ModeSchema = z.looseObject({ id: z.string(), name: z.string() });
-const SelectValueSchema = z.looseObject({ value: z.string(), name: z.string() });
+const SelectValueSchema = z.looseObject({ value: z.string(), name: z.string(), description: z.string().nullish() });
 const ConfigOptionSchema = z.looseObject({
     id: z.string(),
     name: z.string(),
@@ -114,6 +144,18 @@ function selectValues(option) {
 function selectOption(options, category) {
     return options.find((option) => option.type === 'select' && option.category === category && typeof option.currentValue === 'string') ?? null;
 }
+function thoughtOption(options) {
+    return (selectOption(options, 'thought_level') ??
+        options.find((option) => option.type === 'select' && option.id === 'reasoning_effort' && typeof option.currentValue === 'string') ??
+        null);
+}
+/* The reasoning effort in a response that carries the session's config options; undefined when it carries none. */
+export function thoughtLevelOf(result) {
+    if (!isRecord(result) || !Array.isArray(result.configOptions)) {
+        return undefined;
+    }
+    return sessionState(validItems(ConfigOptionSchema, result.configOptions), null, null).thoughtLevel;
+}
 export function parseSessionInfo(result, sessionId, agent) {
     const record = isRecord(result) ? result : {};
     const options = validItems(ConfigOptionSchema, Array.isArray(record.configOptions) ? record.configOptions : []);
@@ -122,7 +164,7 @@ export function parseSessionInfo(result, sessionId, agent) {
 function sessionState(options, modes, models) {
     const modelOption = selectOption(options, 'model');
     const modeOption = selectOption(options, 'mode');
-    const thoughtOption = selectOption(options, 'thought_level');
+    const thought = thoughtOption(options);
     const modeState = ModeStateSchema.safeParse(modes);
     const modelState = ModelStateSchema.safeParse(models);
     return {
@@ -156,8 +198,12 @@ function sessionState(options, modes, models) {
                     configId: null
                 }
                 : null,
-        thoughtLevel: thoughtOption
-            ? { configId: thoughtOption.id, current: thoughtOption.currentValue, values: selectValues(thoughtOption).map((value) => value.value) }
+        thoughtLevel: thought
+            ? {
+                configId: thought.id,
+                current: thought.currentValue,
+                choices: selectValues(thought).map((value) => ({ id: value.value, name: value.name, description: value.description ?? null }))
+            }
             : null
     };
 }
@@ -416,7 +462,9 @@ export class AcpProtocol {
             description: tool.title === '' ? null : tool.title,
             canAllowAlways: options.some((option) => option.kind === 'allow_always')
         });
-        return { requestId, rpcId, kind: tool.kind, events };
+        const command = rawField(tool.rawInput, 'command', 'cmd');
+        const asked = { kind: tool.kind, title: tool.title === '' ? null : tool.title, commands: [...(command === null ? [] : [command]), ...tool.text] };
+        return { requestId, rpcId, kind: tool.kind, request: asked, events };
     }
     /*
      * The answer to a permission request: allow once, reject, or allow always only when the agent offered it.

package/dist/chat/index.d.ts

@@ -1,5 +1,5 @@
-export { type AcpAgentSpec, type AcpClientInfo, createAcpBackend } from './acp-backend.ts';
-export type { AcpAgentInfo, AcpModel, AcpModelState, AcpMode, AcpModeState, AcpSessionInfo, AcpModeMap } from './acp-protocol.ts';
+export { type AcpAgentSpec, type AcpClientInfo, type AcpUsageReport, createAcpBackend } from './acp-backend.ts';
+export type { AcpAgentInfo, AcpModel, AcpModelState, AcpMode, AcpModeState, AcpPermissionRequest, AcpSessionInfo, AcpModeMap, AcpChoice, AcpThoughtLevel, AcpTurnUsage } from './acp-protocol.ts';
 export { AttachmentStore } from './attachment-store.ts';
 export type { BackendLaunch, TurnInput, ApprovalDecision, BackendEvent, BackendHost, ChatBackend } from './backend.ts';
 export { runningInBackground, type BackgroundWork } from './background-work.ts';

package/dist/providers/acp-provider.d.ts

@@ -21,5 +21,6 @@ export interface AcpProviderSpec extends AcpAgentSpec {
     enabled?(): boolean;
     accountProbe?: boolean;
     adoptModels?: boolean;
+    usageLog?: string;
 }
 export declare function createAcpProvider(spec: AcpProviderSpec): ChatProvider;

package/dist/providers/acp-provider.js

@@ -1,5 +1,6 @@
 import { createAcpBackend } from '../chat/acp-backend.js';
 import { askAcpAccount } from './accounts/acp-account.js';
+import { writeAcpUsage } from './acp-usage-log.js';
 import { detectCli } from './detect.js';
 /*
  * What every ACP agent can do through this backend. A file change comes as the text before and after;
@@ -22,18 +23,47 @@ export const ACP_CAPABILITIES = {
     reportsThinking: true,
     slashCommands: true
 };
+/* Agents whose own usage files the scanner reads; a log of their turns would count every one twice. */
+const OWN_USAGE_FILES = new Set(['grok']);
 /* An agent's model id may reach a command line, so one that reads as a flag is left out. */
 function adoptableModels(info) {
     return (info.models?.models ?? []).filter((model) => model.id !== '' && !model.id.startsWith('-')).map((model) => ({ slug: model.id, name: model.name }));
 }
+/* The reasoning effort a session offers, as the `effort` option the composer draws for every provider. */
+function effortOption(info) {
+    const level = info.thoughtLevel;
+    if (level === null || !level.choices.some((choice) => choice.id === level.current)) {
+        return [];
+    }
+    return [
+        {
+            id: 'effort',
+            label: 'Reasoning',
+            type: 'select',
+            defaultChoice: level.current,
+            choices: level.choices.map((choice) => ({
+                id: choice.id,
+                label: choice.name,
+                ...(choice.description === null ? {} : { description: choice.description })
+            }))
+        }
+    ];
+}
 export function createAcpProvider(spec) {
     const capabilities = { ...ACP_CAPABILITIES, ...spec.capabilities };
     const onSession = (info) => {
         if (spec.adoptModels !== false && info.models !== null) {
-            spec.catalog.adopt(adoptableModels(info), info.models.current);
+            spec.catalog.adopt(adoptableModels(info), info.models.current, effortOption(info));
         }
         spec.onSession?.(info);
     };
+    const usageLog = spec.usageLog === undefined || OWN_USAGE_FILES.has(spec.kind) ? null : spec.usageLog;
+    const onUsage = usageLog === null
+        ? spec.onUsage
+        : (report) => {
+            writeAcpUsage(usageLog, report, Date.now());
+            spec.onUsage?.(report);
+        };
     return {
         kind: spec.kind,
         name: spec.name,
@@ -63,6 +93,6 @@ export function createAcpProvider(spec) {
                     onSession
                 })
             }),
-        createBackend: createAcpBackend({ ...spec, onSession })
+        createBackend: createAcpBackend({ ...spec, onSession, ...(onUsage === undefined ? {} : { onUsage }) })
     };
 }

package/dist/providers/acp-usage-log.d.ts

@@ -0,0 +1,2 @@
+import type { AcpUsageReport } from '../chat/acp-backend.ts';
+export declare function writeAcpUsage(folder: string, report: AcpUsageReport, at: number): void;

package/dist/providers/acp-usage-log.js

@@ -0,0 +1,21 @@
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { errorText } from '../error-text.js';
+import { hostUsageLine } from '../usage/readers/host-log.js';
+/*
+ * Appends one turn to the session's own file in the folder, so a scan that hashes what it already read
+ * of a file never rereads the log of every other session. Written at once, since it is one line per turn.
+ */
+export function writeAcpUsage(folder, report, at) {
+    const { sessionId, cwd, model, ...tokens } = report;
+    try {
+        mkdirSync(folder, { recursive: true, mode: 0o700 });
+        appendFileSync(join(folder, `${encodeURIComponent(sessionId === '' ? 'session' : sessionId)}.jsonl`), hostUsageLine({ at, model, session: sessionId, cwd, ...tokens }), {
+            mode: 0o600
+        });
+    }
+    catch (e) {
+        // A turn whose line could not be written is missing from the usage page; the chat itself goes on.
+        console.warn('Could not write the usage of an ACP turn:', errorText(e));
+    }
+}

package/dist/providers/catalog.d.ts

@@ -1,4 +1,4 @@
-import type { ModelCatalogData, ModelInfo, ModelSelection } from '@adecore/agent-contracts';
+import type { ModelCatalogData, ModelInfo, ModelOptionDescriptor, ModelSelection } from '@adecore/agent-contracts';
 export type ModelCatalogInput = Omit<ModelCatalogData, 'updatedAt'> & {
     updatedAt?: string;
 };
@@ -11,7 +11,7 @@ export declare class ModelCatalog {
     adopt(models: ReadonlyArray<{
         slug: string;
         name: string;
-    }>, defaultModel: string): boolean;
+    }>, defaultModel: string, options?: readonly ModelOptionDescriptor[]): boolean;
     list(): ModelInfo[];
     nameOf(slug: string): string;
     resolveModel(name: string): string | null;

package/dist/providers/catalog.js

@@ -30,13 +30,16 @@ export class ModelCatalog {
     /*
      * Takes the models an agent reported for itself in place of the list, the agent's current model as the
      * default and its order kept; answers whether the models changed. Every model gets the profile the
-     * default has now, as an agent names its models but not what each can be asked for.
+     * default has now, as an agent names its models but not what each can be asked for, with `options`
+     * in place of the profile's options of the same id.
      */
-    adopt(models, defaultModel) {
+    adopt(models, defaultModel, options = []) {
         if (models.length === 0 || !models.some((model) => model.slug === defaultModel)) {
             return false;
         }
-        const profile = this.profileOf(this.data.defaultModel) ?? { options: [], contextWindowTokens: {} };
+        const base = this.profileOf(this.data.defaultModel) ?? { options: [], contextWindowTokens: {} };
+        const replaced = new Set(options.map((option) => option.id));
+        const profile = { ...base, options: [...base.options.filter((option) => !replaced.has(option.id)), ...options] };
         const data = {
             ...(this.data.updatedAt === undefined ? {} : { updatedAt: this.data.updatedAt }),
             defaultModel,

package/dist/providers/index.d.ts

@@ -12,5 +12,6 @@ export { type CodexRules, codexRulesText, codexRulesPathIn, defaultCodexHome, in
 export { codexThreadOptions, codexServiceTier } from './codex.ts';
 export { type CliDetection, detectCli } from './detect.ts';
 export type { ChatProvider, ProviderHome } from './provider.ts';
+export { isOnlyCommands } from './shell-commands.ts';
 export { ProviderRegistry, type ProviderRegistryOptions } from './registry.ts';
 export { MODE_ORDER, narrowerMode, ceilingForOpening, modeFlag } from '../modes.ts';

package/dist/providers/index.js

@@ -10,5 +10,6 @@ export { createCodexProvider } from './codex-provider.js';
 export { codexRulesText, codexRulesPathIn, defaultCodexHome, installCodexRules } from './codex-rules.js';
 export { codexThreadOptions, codexServiceTier } from './codex.js';
 export { detectCli } from './detect.js';
+export { isOnlyCommands } from './shell-commands.js';
 export { ProviderRegistry } from './registry.js';
 export { MODE_ORDER, narrowerMode, ceilingForOpening, modeFlag } from '../modes.js';

package/dist/providers/shell-commands.d.ts

@@ -0,0 +1 @@
+export declare function isOnlyCommands(command: string, allowed: readonly string[]): boolean;

package/dist/providers/shell-commands.js

@@ -0,0 +1,119 @@
+// Unquoted, each of these makes the shell do more than run a word list: a pipe, a redirect, an expansion,
+// a subshell or group, a glob, a comment or a history or negation mark.
+const REFUSED = new Set(['|', '>', '<', '$', '`', '(', ')', '{', '}', '*', '?', '[', '~', '#', '!']);
+/*
+ * Whether a shell command line is only simple commands, joined by `&&`, `||`, `;` or newlines, each of
+ * which starts with one of `allowed`. Anything the tokenizer cannot prove simple answers false, so a
+ * true is safe to act on without a person: a pipe, a redirect, an expansion, a subshell, a background
+ * `&`, an unquoted glob or an unbalanced quote all refuse the whole line.
+ */
+export function isOnlyCommands(command, allowed) {
+    let word = '';
+    let inWord = false;
+    let words = [];
+    let commands = 0;
+    // A separator that still needs a command after it; a trailing `;` or newline needs none.
+    let dangling = false;
+    const endWord = () => {
+        if (inWord) {
+            words.push(word);
+        }
+        word = '';
+        inWord = false;
+    };
+    const endCommand = (separator) => {
+        endWord();
+        if (words.length === 0) {
+            // Blank lines are fine, and so is a newline after `&&` or `||`; an empty command before any other separator is not.
+            return separator === '\n';
+        }
+        if (!allowed.includes(words[0])) {
+            return false;
+        }
+        commands++;
+        words = [];
+        dangling = separator === '&&' || separator === '||';
+        return true;
+    };
+    for (let i = 0; i < command.length; i++) {
+        const char = command[i];
+        const next = command[i + 1];
+        if (char === ' ' || char === '\t') {
+            endWord();
+            continue;
+        }
+        if (char === '\n' || char === ';') {
+            if (!endCommand(char)) {
+                return false;
+            }
+            continue;
+        }
+        if ((char === '&' || char === '|') && next === char) {
+            if (!endCommand(char + next)) {
+                return false;
+            }
+            i++;
+            continue;
+        }
+        if (char === '&' || REFUSED.has(char)) {
+            return false;
+        }
+        if (char === '\\') {
+            if (next === undefined) {
+                return false;
+            }
+            i++;
+            if (next !== '\n') {
+                word += next;
+                inWord = true;
+            }
+            continue;
+        }
+        if (char === "'") {
+            const close = command.indexOf("'", i + 1);
+            if (close === -1) {
+                return false;
+            }
+            word += command.slice(i + 1, close);
+            inWord = true;
+            i = close;
+            continue;
+        }
+        if (char === '"') {
+            inWord = true;
+            let closed = false;
+            for (i++; i < command.length; i++) {
+                const quoted = command[i];
+                if (quoted === '"') {
+                    closed = true;
+                    break;
+                }
+                if (quoted === '$' || quoted === '`') {
+                    return false;
+                }
+                if (quoted === '\\') {
+                    const escaped = command[i + 1];
+                    if (escaped === undefined) {
+                        return false;
+                    }
+                    i++;
+                    if (escaped === '"' || escaped === '\\' || escaped === '$' || escaped === '`') {
+                        word += escaped;
+                    }
+                    else if (escaped !== '\n') {
+                        word += quoted + escaped;
+                    }
+                    continue;
+                }
+                word += quoted;
+            }
+            if (!closed) {
+                return false;
+            }
+            continue;
+        }
+        word += char;
+        inWord = true;
+    }
+    return endCommand('\n') && commands > 0 && !dangling;
+}

package/dist/testing/fake-acp.d.ts

@@ -6,6 +6,8 @@ export interface FakeAcpOptions {
     modes?: readonly string[];
     legacyModels?: boolean;
     closeSession?: boolean;
+    turnUsage?: Record<string, number>;
+    reasoningEffort?: 'accept' | 'reject';
 }
 export declare function fakeAcpWith(options: FakeAcpOptions): FakeCli;
 export declare const fakeAcp: FakeCli;