dsh-opencode-go 0.1.21 → 0.1.23

package/lib/types/account-manager.d.ts

@@ -0,0 +1,25 @@
+import { type CredentialProvider } from '@deepseek-ai/dsh-credentials';
+import { type AccountSettingsWriter, type SettingsWriteResult } from './settings-bridge.ts';
+import { type AccountCommand } from './accounts-contract.ts';
+export declare const ACCOUNT_RECOVERY_TIMEOUT_MS = 30000;
+/** Serialize account commands and recover the same durable operations for one profile. */
+export declare class GoAccountManager {
+    private readonly logger;
+    private connection;
+    private pending;
+    private again;
+    private queue;
+    constructor(logger: {
+        warn(message: string): void;
+    });
+    connect(settings: AccountSettingsWriter, credentials: Pick<CredentialProvider, 'describe' | 'unset'> & Partial<Pick<CredentialProvider, 'set'>>): () => void;
+    trigger(): void;
+    recover(): Promise<void>;
+    private row;
+    private run;
+    /** Preserve an old selection by moving it first in the same revision-guarded write. */
+    private normalizeOrder;
+    private complete;
+    private enqueue;
+    execute(raw: AccountCommand): Promise<SettingsWriteResult>;
+}

package/lib/types/account-operations.d.ts

@@ -0,0 +1,31 @@
+/** Durable, client-safe intentions. Never put a credential value in this document. */
+import { type AccountSettings, type GoAccount } from './accounts.ts';
+export type GoAccountOperation = {
+    id: string;
+    kind: 'add';
+    account: GoAccount;
+    previousRef: string;
+    select: boolean;
+} | {
+    id: string;
+    kind: 'remove';
+    account: GoAccount;
+};
+export declare function ownsAccountCredential(account: GoAccount): boolean;
+export declare function assertAccountOperations(value: readonly GoAccountOperation[] | undefined): void;
+/** Pending additions remain visible so a lost key write can be repaired or removed. */
+export declare function visibleAccountsOf(settings: AccountSettings): readonly GoAccount[];
+/** The same transition completes a foreground operation or a recovered intention. */
+export declare function accountOperationPatch(settings: AccountSettings, operation: GoAccountOperation, dropLegacyRef?: string): ({
+    op: "set";
+    path: string[];
+    value: GoAccount[];
+} | {
+    op: "set";
+    path: string[];
+    value: string;
+} | {
+    op: "set";
+    path: string[];
+    value: GoAccountOperation[];
+})[];

package/lib/types/account-policy.d.ts

@@ -0,0 +1,16 @@
+import type { GoAccountSwitch } from './accounts.ts';
+export interface AttemptOutcome {
+    failure?: {
+        code: string;
+    };
+    emitted: boolean;
+    totalTokens: number;
+    aborted: boolean;
+    hasNext: boolean;
+}
+/** Switching accounts must never replay output or already charged work. */
+export declare function accountFallback(outcome: AttemptOutcome): GoAccountSwitch['reason'] | undefined;
+/** Missing local credentials and exhausted quota do not blacklist a gateway key. */
+export declare function isGatewayKeyRejection(failure: {
+    code: string;
+}): boolean;

package/lib/types/account-recovery.d.ts

@@ -0,0 +1,2 @@
+/** Backward-compatible name for the host's shared foreground/recovery executor. */
+export { GoAccountManager as GoAccountRecovery, ACCOUNT_RECOVERY_TIMEOUT_MS } from './account-manager.ts';

package/lib/types/account-selection.d.ts

@@ -0,0 +1,30 @@
+import type { GoAccountSettlement } from './adapter.ts';
+import { type GoAccountSwitch } from './accounts.ts';
+import type { OpencodeGoConfig } from './config.ts';
+import { type AccountSettingsWriter } from './settings-bridge.ts';
+export type { AccountSettingsWriter } from './settings-bridge.ts';
+/** Owns both the fallback notice and its optional persisted account selection. */
+export declare class GoAccountSelection {
+    private readonly config;
+    private readonly logger;
+    private settings;
+    private connection;
+    private credentials;
+    private version;
+    private signature;
+    private latestSeq;
+    private notice;
+    constructor(config: () => OpencodeGoConfig, logger: {
+        debug(message: string): void;
+        warn(message: string): void;
+    });
+    connect(settings: AccountSettingsWriter): () => void;
+    private row;
+    /** Reading the revision also catches A → C → A before async change watchers run. */
+    capture(): number;
+    credentialChanged(): void;
+    lastSwitch(): GoAccountSwitch | undefined;
+    /** One freshness decision governs both side effects of a request's outcome. */
+    settle(event: GoAccountSettlement): void;
+    private adopt;
+}

package/lib/types/account-service.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import type { AccountCommand } from './accounts-contract.ts';
+import type { GoAccountManager } from './account-manager.ts';
+/** The browser sends commands; the host owns credentials, revisions and recovery. */
+export declare class GoAccountsService extends TypertRemoteService {
+    private readonly options;
+    constructor(ctx: Context, options: {
+        manager: GoAccountManager;
+    });
+    execute(command: AccountCommand): Promise<import("./settings-bridge.ts").SettingsWriteResult>;
+}

package/lib/types/accounts-contract.d.ts

@@ -0,0 +1,38 @@
+import type { RemoteResult, TypertRemoteContribution } from '@deepseek-ai/dsh-typert-protocol';
+import type { SettingsWriteResult } from './settings-bridge.ts';
+export type AccountCommand = {
+    kind: 'add';
+    id: string;
+    name: string;
+    key: string;
+} | {
+    kind: 'remove';
+    ref: string;
+} | {
+    kind: 'select';
+    ref: string;
+} | {
+    kind: 'rename';
+    ref: string;
+    name: string;
+} | {
+    kind: 'replace-key';
+    ref: string;
+    key: string;
+} | {
+    kind: 'move';
+    ref: string;
+    toIndex: number;
+} | {
+    kind: 'auto-switch';
+    value: boolean;
+};
+export declare function parseAccountCommand(value: unknown): AccountCommand;
+declare module '@deepseek-ai/dsh-typert-protocol' {
+    interface TypertRemoteNamespaceMap {
+        opencodeGoAccounts: {
+            execute(command: AccountCommand): Promise<RemoteResult<SettingsWriteResult>>;
+        };
+    }
+}
+export declare const accountsRemote: TypertRemoteContribution;

package/lib/types/accounts.d.ts

@@ -1,4 +1,5 @@
 /** Client-safe account metadata. Secrets stay in the host credential service. */
+import type { GoAccountOperation } from './account-operations.ts';
 export type GoAccount = {
     id: string;
     name: string;
@@ -7,14 +8,20 @@ export type GoAccount = {
 export declare const MAX_ACCOUNTS = 20;
 export declare const ACCOUNT_REF_PREFIX = "DSH_OPENCODE_GO_ACCOUNT_";
 export declare const DEFAULT_ACCOUNT_REF = "OPENCODE_API_KEY";
+/** A credential reference is a bare environment variable name, never empty or decorated. */
+export declare const ACCOUNT_REF_PATTERN: RegExp;
 export interface AccountSettings {
     apiKeyEnv?: string;
     /** Omission/null preserves legacy credentials; an explicit empty list removes all accounts. */
     accounts?: readonly GoAccount[] | null;
     autoSwitch?: boolean;
+    /** Recovery intentions owned by this exact settings/profile document. */
+    accountOperations?: readonly GoAccountOperation[];
 }
 export declare function accountRefOf(settings: AccountSettings): string;
-/** Include an externally selected reference without rewriting existing configuration. */
+/** Promote one account while preserving every other account's relative order. */
+export declare function moveAccountFirst(accounts: readonly GoAccount[], ref: string): readonly GoAccount[];
+/** Read legacy selections as the first account until the host persists their order. */
 export declare function accountsOf(settings: AccountSettings): readonly GoAccount[];
 export declare function assertAccounts(accounts: readonly GoAccount[] | null | undefined, selectedRef?: string): void;
 /** Safe UI notice for a successful request using a fallback account. */

package/lib/types/adapter.d.ts

@@ -28,6 +28,8 @@ import { OpencodeGoCatalog } from './catalog.ts';
 import { ProxyTransport } from './proxy.ts';
 import type { OpencodeGoConfig } from './config.ts';
 import { type GoAccountSwitch } from './accounts.ts';
+import { type GoCallTrace } from './call-trace.ts';
+export type { GoCallTrace } from './call-trace.ts';
 /**
  * The attachment-service bridges one image request reads. Construction-time
  * (context-dependent); the config-dependent policy numbers are merged per
@@ -39,10 +41,22 @@ export interface OpencodeGoImageAccess {
     /** Bridge one attachment reference into the current model-tool execution world. */
     resolveImageAccess: (attachments: AttachmentStore, ref: ImageAttachmentRef) => ImageAttachmentAccess | undefined;
 }
+/** One request's serving account, with the identity captured before discovery. */
+export interface GoAccountSettlement {
+    seq: number;
+    generation: number;
+    config: OpencodeGoConfig;
+    ref: string;
+    notice?: GoAccountSwitch;
+}
 /** Constructor inputs for {@link OpencodeGoAdapter}. */
 export interface OpencodeGoAdapterOptions {
     /** Shared with Host usage reads for this plugin mount. */
     transport?: ProxyTransport;
+    /** Mount-owned discovery; direct construction supplies its own manager. */
+    catalog?: (config: OpencodeGoConfig) => OpencodeGoCatalog;
+    /** Optional directory for bounded HTTP error evidence; request contents are omitted. */
+    debugDirectory?: () => string | undefined;
     /**
      * The current configuration, re-read at every operation: a settings write
      * reaches the next request without a restart, and one operation never mixes
@@ -50,7 +64,9 @@ export interface OpencodeGoAdapterOptions {
      */
     config: () => OpencodeGoConfig;
     /** Resolve the credential reference captured with this call's endpoint; missing must fail loud. */
-    resolveApiKey: (config: OpencodeGoConfig) => Promise<string | undefined>;
+    resolveApiKey: (config: OpencodeGoConfig, signal?: AbortSignal) => Promise<string | undefined>;
+    /** Observe one bounded, content-free summary for every dispatched call. */
+    onCallTrace?: (trace: GoCallTrace) => void;
     /**
      * Image input machinery; absent refuses image content, which is the posture
      * for direct construction without a durable attachment service behind it.
@@ -64,11 +80,17 @@ export interface OpencodeGoAdapterOptions {
     }) => void;
     /** Observe live ids the curated table cannot route. */
     onOmitted?: (ids: readonly string[]) => void;
+    onCatalogWarning?: (warning: string) => void;
     /** Observe assistant history degrading to provider-neutral conversion. */
     onReplayDegrade?: (reason: string) => void;
     /** Re-read picker models after a background catalog refresh commits. */
     onCatalogRefresh?: () => void;
-    onAccountSwitch?: (notice: GoAccountSwitch | undefined, config: OpencodeGoConfig) => void;
+    /** Host account-state version for actual requests, captured before asynchronous model discovery. */
+    accountGeneration?: () => number;
+    /** One outcome for both the displayed notice and the persisted selection. */
+    onAccountSettled?: (event: GoAccountSettlement) => void;
+    /** Legacy notice observer. Hosts that persist selection should use onAccountSettled. */
+    onAccountSwitch?: (notice: GoAccountSwitch | undefined, config: OpencodeGoConfig, seq: number) => void;
 }
 /**
  * The single route's adapter. The catalog snapshot freezes at each operation,
@@ -77,16 +99,14 @@ export interface OpencodeGoAdapterOptions {
  */
 export declare class OpencodeGoAdapter extends LlmAdapter {
     private readonly options;
-    /**
-     * One catalog instance per endpoint/refresh pair. A settings write that
-     * changes either gets a fresh resolver (and a fresh live-listing fetch) on
-     * the next operation; an unchanged configuration keeps its cached snapshot
-     * for the whole refresh interval.
-     */
-    private catalogCache;
+    private readonly resolveCatalog;
     private readonly transport;
     /** Per-reference rejection deadlines, isolated by the gateway that rejected it. */
     private readonly rejectedKeys;
+    /** Reference updates invalidate rejections from attempts using an older key. */
+    private readonly credentialVersions;
+    /** Monotonic sequence of the latest request this adapter started. */
+    private callSeq;
     constructor(options: OpencodeGoAdapterOptions);
     dispose(): Promise<void>;
     /**
@@ -103,8 +123,8 @@ export declare class OpencodeGoAdapter extends LlmAdapter {
     };
     listModels(_provider: string): Promise<readonly LlmModelInfo[]>;
     resolveModel(_provider: string, model: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
-    /** Copy nested limits before discovery can yield to a settings update. */
-    private callSnapshot;
+    /** Capture limits and protocol before discovery can yield to a settings update. */
+    private modelSnapshot;
     /** Keep capability resolution and eventual dispatch on the same configuration. */
     prepareCall(_provider: string, model: string, signal?: AbortSignal): Promise<{
         model: LlmResolvedModelInfo;
@@ -116,6 +136,8 @@ export declare class OpencodeGoAdapter extends LlmAdapter {
     private resolveReasoningLevel;
     stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
     private streamWithSnapshot;
+    private dispatch;
+    private streamAccounts;
     private rememberRejectedKey;
     /** A stored change to a reference outranks the gateway's last rejection of it. */
     forgetRejectedKey(ref: string): void;

package/lib/types/call-trace.d.ts

@@ -0,0 +1,54 @@
+import type { ImagePoolObservation } from './conversion/image-pool.ts';
+type Outcome = 'completed' | 'failed' | 'aborted' | 'consumer-stopped';
+type Stages = Partial<Record<'discovery' | 'credential' | 'images' | 'stream', number>>;
+export interface GoAttemptTrace {
+    attempt: number;
+    elapsedMs: number;
+    stages: Stages;
+    outcome: Outcome;
+    code?: string;
+    httpStatus?: number;
+    requestId?: string;
+    /** First text, reasoning or tool argument delta, measured from attempt start. */
+    firstOutputMs?: number;
+    imagePool?: {
+        queueWaitMs: number;
+        maxActive: number;
+        maxQueued: number;
+        maxRetainedBytes: number;
+        rejected: boolean;
+    };
+}
+/** Safe per-call diagnostics: no transcript, credential, URL or raw session id. */
+export interface GoCallTrace {
+    callId: string;
+    model: string;
+    elapsedMs: number;
+    stages: Stages;
+    attempts: number;
+    attemptDetails: readonly GoAttemptTrace[];
+    outcome: Outcome;
+    code?: string;
+}
+export declare class CallTrace {
+    private readonly model;
+    private readonly observer?;
+    private readonly started;
+    readonly callId: `${string}-${string}-${string}-${string}-${string}`;
+    readonly stages: GoCallTrace['stages'];
+    attempts: number;
+    outcome: GoCallTrace['outcome'];
+    code: string | undefined;
+    private readonly details;
+    private current;
+    private finished;
+    constructor(model: string, observer?: ((trace: GoCallTrace) => void) | undefined);
+    startAttempt(): void;
+    response(status: number, requestId?: string): void;
+    firstOutput(): void;
+    imagePool: (value: ImagePoolObservation) => void;
+    endAttempt(outcome?: Outcome, code?: string): void;
+    measure<T>(stage: keyof GoCallTrace['stages'], work: () => Promise<T>): Promise<T>;
+    finish(): void;
+}
+export {};

package/lib/types/catalog-manager.d.ts

@@ -0,0 +1,20 @@
+import { OpencodeGoCatalog } from './catalog.ts';
+import type { OpencodeGoConfig } from './config-contract.ts';
+import type { ProxyTransport } from './proxy.ts';
+/** One mount owns discovery; inference, settings and pickers share its snapshots. */
+export declare class GoCatalogManager {
+    private readonly options;
+    private current;
+    constructor(options: {
+        transport: ProxyTransport;
+        onFallback?: (detail: {
+            url: string;
+            error: unknown;
+            kept: number;
+        }) => void;
+        onOmitted?: (ids: readonly string[]) => void;
+        onRefresh?: () => void;
+        onWarning?: (warning: string) => void;
+    });
+    forConfig(config: OpencodeGoConfig): OpencodeGoCatalog;
+}

package/lib/types/catalog.d.ts

@@ -1,9 +1,9 @@
-import type { Api, Model, Provider } from 'opencode-go-pi-ai';
+import type { Api, Model, Provider } from './sdk-types.ts';
 import type { LlmDiscoveredModel } from '@deepseek-ai/dsh-llm';
 import { type GoModelCatalog } from './models-contract.ts';
 import type { ModelMetadata } from './model-metadata.ts';
 export { PROVIDER_ID, DISPLAY_NAME } from './provider-identity.ts';
-export declare const DEFAULT_BASE_URL = "https://opencode.ai/zen/go/v1";
+export { DEFAULT_BASE_URL } from './gateway-url.ts';
 export interface CatalogSnapshot {
     readonly details: ModelMetadata['details'];
     readonly models: ReadonlyMap<string, Model<Api>>;
@@ -14,6 +14,7 @@ export interface CatalogSnapshot {
     readonly metadataLive: boolean;
     /** Retained for explicit discovery; runtime callers may still use the last catalog. */
     readonly listingFailure?: unknown;
+    readonly listingWarning?: string;
     readonly metadataFailure?: unknown;
     /** Last successful fetch or revalidation, not the time of a failed attempt. */
     readonly listingUpdatedAtMs?: number;
@@ -21,7 +22,7 @@ export interface CatalogSnapshot {
     readonly fetchedAtMs: number;
 }
 /** A valid empty listing means the gateway serves nothing; malformed replies are failures. */
-export declare function readLiveModelIds(body: unknown): readonly string[];
+export declare function readLiveModelIds(body: unknown, onInvalidRows?: (warning: string) => void): readonly string[];
 /** Runtime requests reuse a snapshot; discovery revalidates it. Concurrent reads coalesce. */
 export declare class OpencodeGoCatalog {
     private readonly baseURL;
@@ -31,6 +32,7 @@ export declare class OpencodeGoCatalog {
     private readonly onOmitted;
     private readonly onRefresh;
     private readonly fetcher?;
+    private readonly onWarning?;
     private served;
     private pending;
     /** A cold runtime read can use disk metadata while the shared online refresh runs. */
@@ -49,7 +51,7 @@ export declare class OpencodeGoCatalog {
         kept: number;
     }) => void, 
     /** Kept for API compatibility; now reports unconfigured ids rather than hiding them. */
-    onOmitted: (ids: readonly string[]) => void, onRefresh?: () => void, fetcher?: typeof globalThis.fetch | undefined);
+    onOmitted: (ids: readonly string[]) => void, onRefresh?: () => void, fetcher?: typeof globalThis.fetch | undefined, onWarning?: ((warning: string) => void) | undefined);
     snapshot(force?: boolean, signal?: AbortSignal): Promise<CatalogSnapshot>;
     private restoreMetadata;
     private readSnapshot;

package/lib/types/client/accounts-controller.d.ts

@@ -2,6 +2,9 @@ import type { Context } from '@deepseek-ai/cordis';
 import { type AccountSettings, type GoAccount } from '../accounts.ts';
 import type { GoUsage } from '../usage-contract.ts';
 import type { SettingsScope } from './settings.ts';
+import type { AccountCommand } from '../accounts-contract.ts';
+import type { SettingsWriteResult } from '../settings-bridge.ts';
+export type ExecuteAccountCommand = (command: AccountCommand) => Promise<SettingsWriteResult>;
 export interface GoAccountView extends GoAccount {
     configured?: boolean;
     writable?: boolean;
@@ -25,6 +28,8 @@ export interface GoAccountsState {
 export interface GoAccountsActions {
     loadAccounts: () => void;
     addAccount: (name: string, key: string) => Promise<boolean>;
+    /** A newly opened addition form owns a fresh ID; retries keep its existing ID. */
+    resetAddition?: () => void;
     renameAccount: (ref: string, name: string) => Promise<boolean>;
     removeAccount: (ref: string) => Promise<boolean>;
     selectAccount: (ref: string) => Promise<boolean>;
@@ -40,6 +45,7 @@ export declare class GoAccountsController {
     private readonly readUsage;
     private readonly publish;
     private readonly blocked;
+    private readonly execute;
     private rows;
     private busy;
     private refreshing;
@@ -48,10 +54,11 @@ export declare class GoAccountsController {
     private identity;
     private loaded;
     private disposed;
+    private addition;
     constructor(scope: SettingsScope<AccountSettings & {
         baseURL?: string;
         proxyURL?: string;
-    }>, ctx: Context, readUsage: (ref: string) => Promise<GoUsage>, publish: () => void, blocked: () => boolean);
+    }>, ctx: Context, readUsage: (ref: string) => Promise<GoUsage>, publish: () => void, blocked: () => boolean, execute?: ExecuteAccountCommand);
     snapshot(): GoAccountsState;
     sync(): void;
     dispose(): void;
@@ -60,21 +67,5 @@ export declare class GoAccountsController {
     /** Mark every account row as unreadable with the Host's own diagnostic. */
     private markUnreadable;
     actions(): GoAccountsActions;
-    /**
-     * Reorder the visible accounts and keep the preferred reference on the first row.
-     * The adapter tries the preferred reference first and the rest in array order, so
-     * one write is what makes top-to-bottom the real call order. A placeholder row the
-     * settings never stored is materialized here, which its `legacy:` id admits.
-     */
-    private move;
-    private account;
-    private mutate;
-    private add;
-    /** Loaded rows answer from cache; anything they do not know is described on
-     * the spot, so a placeholder decision never races the page's first describe. */
-    private configuredOf;
-    private rename;
-    private select;
-    private remove;
     private run;
 }

package/lib/types/client/hint-mark.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The hint mark a label carries and the sentence behind it.
+ *
+ * The Host's own Tooltip opens the sentence on hover and on keyboard focus, while
+ * the same sentence stays in the document so assistive technology reads it without
+ * opening anything. A Host that ships no question glyph still gets a mark, and a
+ * Host with no Tooltip keeps the sentence visible instead of hiding it.
+ */
+/** A focusable help trigger; fields also retain their {@link HintText} description. */
+export declare function HintMark(props: {
+    hint: string;
+}): import("react").JSX.Element;
+/** The hint sentence, at the id a control points its `aria-describedby` at. */
+export declare function HintText(props: {
+    id: string;
+    hint: string;
+}): import("react").JSX.Element;

package/lib/types/client/host-compat.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type OpencodeGoSettings } from '../config-contract.ts';
+import type { SettingsScope } from './settings.ts';
+import type { ExecuteAccountCommand } from './accounts-controller.ts';
+/** Only the boundary knows whether the host exposes profile forms or legacy scopes. */
+export declare function mountSettingsScopes(ctx: Context, mount: (ctx: Context, scope: SettingsScope<OpencodeGoSettings>) => void): void;
+export declare function accountCommands(ctx: Context): ExecuteAccountCommand;

package/lib/types/client/host-primitives.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Host UI atoms this page reaches for across DSH generations.
+ *
+ * Icon names moved from pixel size (`IconQuestionOutline14`, DSH 0.1.6 and older) to
+ * stroke weight (`IconQuestionOutlineRegular`, 0.1.7 and later), and the old alias is
+ * gone in 0.2. A missing atom is not a cosmetic loss here: React throws on an
+ * undefined element type, which takes the whole settings surface down with it, so
+ * every lookup resolves the current name first and keeps the older one behind it.
+ */
+/** The atom's component, or undefined when this Host ships neither name. */
+export declare function hostAtom<T>(host: Record<string, unknown>, current: string, previous: string): T | undefined;

package/lib/types/client/locales.d.ts

@@ -96,6 +96,11 @@ export declare const en: {
     limitsModel: string;
     limitsContext: string;
     limitsOutput: string;
+    thinkingBudgets: string;
+    thinkingBudgetsHint: string;
+    thinkingBudgetAddLabel: string;
+    thinkingBudgetAdd: string;
+    thinkingBudgetRemove: string;
     capacityDefault: string;
     capacityMissing: string;
     modalityLabel: string;
@@ -131,16 +136,22 @@ export declare const en: {
     limitsEmpty: string;
     limitsContextLabel: string;
     limitsOutputLabel: string;
-    advancedSummary: string;
+    advancedResetAll: string;
     advancedLabel: string;
+    groupUsageProtocol: string;
+    groupConnection: string;
+    groupCacheTimeouts: string;
+    groupImages: string;
     advancedHint: string;
     usageDisplayLabel: string;
     usageDisplayHint: string;
     usageDisplay_auto: string;
     usageDisplay_always: string;
     usageDisplay_off: string;
-    apiKeyEnvLabel: string;
-    apiKeyEnvHint: string;
+    protocolOverridesLabel: string;
+    protocolOverridesHint: string;
+    protocolOverridesAuto: string;
+    protocolOverridesResponses: string;
     baseURLLabel: string;
     baseURLHint: string;
     proxyURLLabel: string;