dsh-opencode-go 0.1.21 → 0.1.22

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

@@ -0,0 +1,23 @@
+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;
+    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,11 +8,15 @@ 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. */

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, 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,12 @@ 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;
+    /** Monotonic sequence of the latest request this adapter started. */
+    private callSeq;
     constructor(options: OpencodeGoAdapterOptions);
     dispose(): Promise<void>;
     /**
@@ -103,7 +121,7 @@ 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. */
+    /** Capture limits and protocol before discovery can yield to a settings update. */
     private callSnapshot;
     /** Keep capability resolution and eventual dispatch on the same configuration. */
     prepareCall(_provider: string, model: string, signal?: AbortSignal): Promise<{
@@ -116,6 +134,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,4 +1,4 @@
-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';
@@ -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;
@@ -40,6 +43,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 +52,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 +65,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/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/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;
@@ -139,6 +144,10 @@ export declare const en: {
     usageDisplay_auto: string;
     usageDisplay_always: string;
     usageDisplay_off: string;
+    protocolOverridesLabel: string;
+    protocolOverridesHint: string;
+    protocolOverridesAuto: string;
+    protocolOverridesResponses: string;
     apiKeyEnvLabel: string;
     apiKeyEnvHint: string;
     baseURLLabel: string;

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

@@ -4,58 +4,21 @@
  *
  * The key is the one control that does not live in the section: its literal
  * never rides a response, so the page learns only whether one is configured
- * and writes it through the credentials domain, addressed by the reference the
- * section names. It is still staged with the rest of the form, so one save
+ * and writes it through the host account service, pinned to the account where
+ * the draft began. It is still staged with the rest of the form, so one save
  * covers everything the page shows.
  */
 import type { Context as ClientContext } from '@deepseek-ai/cordis';
 import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
 import type { GoModel, GoModelCatalog } from '../models-contract.ts';
-import { type UsageDisplayMode } from '../usage-display.ts';
 import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
 import type { SettingsScope } from './settings.ts';
-import type { GoAccount } from '../accounts.ts';
-import { type GoAccountsState, type GoAccountsActions } from './accounts-controller.ts';
+import type { OpencodeGoSettings, OpencodeGoModelLimits } from '../config-contract.ts';
+export type { OpencodeGoSettings, OpencodeGoModelLimit, OpencodeGoModelLimits } from '../config-contract.ts';
+import { type GoAccountsState, type GoAccountsActions, type ExecuteAccountCommand } from './accounts-controller.ts';
 import { type FieldState, type FormActions, type FormShell } from './staged-form.ts';
-/** Namespace of the OpenCode Go adapter. Spelled here rather than imported: a client package must not depend on a Host package. */
+/** Namespace shared with the host through the browser-safe configuration contract. */
 export declare const OPENCODE_GO_NS = "llm-opencode-go";
-/** The adapter fields this page edits. */
-export interface OpencodeGoSettings {
-    /** Whether the adapter serves its route; false withdraws it from every picker. */
-    enabled?: boolean;
-    /** Usage pill visibility, independent of the selected model in always mode. */
-    usageDisplay?: UsageDisplayMode;
-    /** Per-model switches; normal models default on, deprecated models default off. */
-    modelVisibility?: Record<string, boolean>;
-    /** Credential reference naming the environment key. */
-    apiKeyEnv?: string;
-    accounts?: GoAccount[] | null;
-    autoSwitch?: boolean;
-    /** The gateway endpoint; also the live listing base. */
-    baseURL?: string;
-    /** Optional network proxy used by the Host. */
-    proxyURL?: string;
-    /** Live catalog re-resolution interval, in minutes. */
-    refreshMinutes?: number;
-    /** Largest idle gap between stream events, in milliseconds. */
-    streamIdleTimeoutMs?: number;
-    /** Optional retained image occurrence cap per request. */
-    maxImages?: number | null;
-    /** Accumulated base64 image payload bound for one request. */
-    maxRequestImageBytes?: number;
-    /** Total-pixel budget for one request image. */
-    requestImagePixelBudget?: number;
-    /** Raw encoded-byte target for one request image. */
-    requestImageMaxBytes?: number;
-    /** Per-model capacity overrides, keyed by the gateway model id. */
-    modelLimits?: OpencodeGoModelLimits;
-}
-/** The two capacity values the settings table can override. */
-export interface OpencodeGoModelLimit {
-    contextWindow?: number | null;
-    maxTokens?: number | null;
-}
-export type OpencodeGoModelLimits = Record<string, OpencodeGoModelLimit | null>;
 /** The gateway's model listing as the page reports it. */
 export type OpencodeGoModels = 
 /** Not asked for yet; the page asks once it mounts. */
@@ -96,6 +59,7 @@ export interface OpencodeGoSectionState extends FormShell {
      */
     enabled: boolean;
     usageDisplay: FieldState;
+    protocolOverrides: FieldState;
     modelVisibility: Readonly<Record<string, boolean>>;
     pickerSaving: boolean;
     pickerFailed: boolean;
@@ -149,6 +113,7 @@ export declare class OpencodeGoSectionController {
     private readonly scope;
     private readonly ctx;
     private readonly readModels;
+    private readonly executeAccountCommand;
     private readonly form;
     private readonly store;
     private credential;
@@ -166,7 +131,7 @@ export declare class OpencodeGoSectionController {
      * @param ctx - the page plugin's context, whose `remote.credentials` namespace
      *   answers for the credential the section references.
      */
-    constructor(scope: SettingsScope<OpencodeGoSettings>, ctx: ClientContext, readModels?: () => Promise<RemoteResult<GoModelCatalog>>, readUsage?: (ref: string) => Promise<import('../usage-contract.ts').GoUsage>);
+    constructor(scope: SettingsScope<OpencodeGoSettings>, ctx: ClientContext, readModels?: () => Promise<RemoteResult<GoModelCatalog>>, readUsage?: (ref: string) => Promise<import('../usage-contract.ts').GoUsage>, executeAccountCommand?: ExecuteAccountCommand);
     /** Release subscriptions without disposing the host's shared form. */
     dispose(): void;
     private projection;
@@ -231,9 +196,9 @@ export declare class OpencodeGoSectionController {
      */
     inject(): OpencodeGoSectionFace;
     /**
-     * Write the staged key, then re-read whether the Host now holds one.
+     * Ask the account service to write the staged key, then refresh its display.
      * @param value - the staged credential literal.
-     * @returns whether the Host reports a configured credential afterwards.
+     * @returns whether the Host confirmed the write.
      */
     private writeKey;
 }

package/lib/types/client/staged-form.d.ts

@@ -2,7 +2,7 @@
  * The staged form behind the OpenCode Go settings page.
  *
  * The page stages what the user types and writes it only when they save. Each
- * settings write is a durable, revision-fenced document mutation, so a control
+ * settings batch is a durable, revision-fenced document mutation, so a control
  * that committed as it settled turned one edit into a write the user never
  * asked for and could not preview; staged text makes what is on screen exactly
  * what a save would store.
@@ -182,8 +182,6 @@ export declare class StagedForm {
      * @returns the planned writes, in the order the fields were staged.
      */
     private plan;
-    private clear;
-    private store;
     private stage;
     private spec;
     private snapshotOf;

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

@@ -1,4 +1,4 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { SettingsScope } from './settings.ts';
 import type { OpencodeGoSettings } from './section-controller.ts';
-export declare function registerUsagePill(ctx: Context, settings: SettingsScope<OpencodeGoSettings>): void;
+export declare function registerUsagePill(ctx: Context, settings: SettingsScope<OpencodeGoSettings>, selectAccount?: (ref: string) => Promise<boolean>): void;