dsh-opencode-go 0.1.20 → 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

@@ -0,0 +1,31 @@
+/** 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;
+    apiKeyEnv: string;
+};
+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. */
+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. */
+export interface GoAccountSwitch {
+    fromRef: string;
+    toRef: string;
+    reason: 'quota' | 'credential';
+    at: number;
+}

package/lib/types/adapter.d.ts

@@ -25,7 +25,11 @@ import { LlmAdapter } from '@deepseek-ai/dsh-llm';
 import type { GenerateOptions, ImageAttachmentAccess, LlmModelInfo, LlmResolvedModelInfo, StreamChunk } from '@deepseek-ai/dsh-llm';
 import type { AttachmentStore, ImageAttachmentRef } from '@deepseek-ai/dsh-attachment';
 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
@@ -37,8 +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
@@ -46,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.
@@ -60,10 +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;
+    /** 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,
@@ -72,14 +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;
+    /** Monotonic sequence of the latest request this adapter started. */
+    private callSeq;
     constructor(options: OpencodeGoAdapterOptions);
+    dispose(): Promise<void>;
     /**
      * The catalog resolver for one configuration, rebuilding on the facts it
      * owns. Public for the plugin's discovery registration, which resolves the
@@ -94,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<{
@@ -107,4 +134,11 @@ 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;
+    /** One account, one SDK attempt; host recovery still owns failures after output. */
+    private streamAttempt;
 }

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;
@@ -30,6 +31,8 @@ export declare class OpencodeGoCatalog {
     /** Kept for API compatibility; now reports unconfigured ids rather than hiding them. */
     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. */
@@ -48,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);
+    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/AccountsCard.d.ts

@@ -0,0 +1,19 @@
+import type { GoAccountsActions, GoAccountsState } from './accounts-controller.ts';
+import type { en } from './locales.ts';
+type Translate = (key: keyof typeof en, params?: Record<string, unknown>) => string;
+/**
+ * The account card: a folded header that summarizes the set, and one row per
+ * account inside. Rows keep the identity, key state, rolling quota and its reset
+ * countdown; everything else opens under the row. The handle is the drag source —
+ * dragging it, or the arrow keys on it, reorders the list, and the first row is
+ * the preferred account. Every row is read in the same pass, so the one refresh
+ * stamp belongs to the card and sits in its header.
+ */
+export declare function AccountsCard({ state, actions, writable, t, locale }: {
+    state: GoAccountsState;
+    actions: GoAccountsActions;
+    writable: boolean;
+    t: Translate;
+    locale?: string;
+}): import("react").JSX.Element;
+export {};

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

@@ -1,10 +1,7 @@
 /**
- * The OpenCode Go settings page. Three cards carry the page's whole order — the
- * connection (the switch that routes the provider plus the API key it
- * authenticates with), the models the gateway currently serves and their
- * capacities, and the adapter tuning fields behind a collapsed disclosure at the
- * foot. The credential reference, the endpoint, and the tuning knobs all live in
- * the `llm-opencode-go` namespace, so every card writes the same document.
+ * The OpenCode Go settings page: provider activation, accounts and credentials,
+ * available models and capacities, then advanced tuning. Account operations
+ * apply immediately; tuning fields use the page's save/discard actions.
  */
 import type { InjectFace } from '@deepseek-ai/dsh-client-ui-slots';
 import type { OpencodeGoSectionFace } from './section-controller.ts';

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

@@ -1,6 +1,6 @@
 import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
 import type { ModelDirectoryState } from '@deepseek-ai/dsh-client-ui-model-selection/client';
-import type { GoUsage } from '../usage-contract.ts';
+import { type GoUsage } from '../usage-contract.ts';
 import type { SettingsScope } from './settings.ts';
 import type { OpencodeGoSettings } from './section-controller.ts';
 export interface UsagePillProps {
@@ -9,6 +9,8 @@ export interface UsagePillProps {
     readUsage: () => Promise<GoUsage>;
     t: (key: string) => string;
     getLocale?: () => string;
+    credentialChanges?: SnapshotStore<number>;
+    selectAccount?: (ref: string) => Promise<boolean>;
 }
 /** Only a visible, enabled pill mounts the usage poller. */
-export declare function UsagePill({ directory, settings, ...props }: UsagePillProps): import("react").JSX.Element | null;
+export declare function UsagePill({ directory, settings, credentialChanges, ...props }: UsagePillProps): import("react").JSX.Element | null;

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

@@ -0,0 +1,69 @@
+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;
+    usage?: GoUsage;
+    updatedAt?: number;
+    stale?: boolean;
+    loading?: boolean;
+    failed?: boolean;
+    /** Why the last quota read failed, safe to show: it carries no credential value. */
+    problem?: string;
+}
+export interface GoAccountsState {
+    entries: readonly GoAccountView[];
+    activeRef: string;
+    autoSwitch: boolean;
+    busy: boolean;
+    blocked: boolean;
+    refreshing: boolean;
+    failure?: 'write' | 'cleanup' | 'remove' | 'read';
+}
+export interface GoAccountsActions {
+    loadAccounts: () => void;
+    addAccount: (name: string, key: string) => Promise<boolean>;
+    renameAccount: (ref: string, name: string) => Promise<boolean>;
+    removeAccount: (ref: string) => Promise<boolean>;
+    selectAccount: (ref: string) => Promise<boolean>;
+    setAutoSwitch: (next: boolean) => Promise<boolean>;
+    replaceAccountKey: (ref: string, key: string) => Promise<boolean>;
+    /** Move one account to a new position; the first row becomes the preferred account. */
+    moveAccount: (ref: string, toIndex: number) => Promise<boolean>;
+}
+/** Immediate account operations, separate from the page's staged tuning form. */
+export declare class GoAccountsController {
+    private readonly scope;
+    private readonly ctx;
+    private readonly readUsage;
+    private readonly publish;
+    private readonly blocked;
+    private readonly execute;
+    private rows;
+    private busy;
+    private refreshing;
+    private failure;
+    private epoch;
+    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, execute?: ExecuteAccountCommand);
+    snapshot(): GoAccountsState;
+    sync(): void;
+    dispose(): void;
+    invalidate(ref: string): void;
+    refresh(): Promise<void>;
+    /** Mark every account row as unreadable with the Host's own diagnostic. */
+    private markUnreadable;
+    actions(): GoAccountsActions;
+    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

@@ -1,8 +1,49 @@
 /** Copy dictionaries for the OpenCode Go settings page. English is the key-set source of truth. */
 export declare const en: {
+    accountsTitle: string;
+    accountsRefresh: string;
+    accountsBlocked: string;
+    accountsEmpty: string;
+    accountsWriteFailed: string;
+    accountsReadFailed: string;
+    accountsCleanupFailed: string;
+    accountsRemoveKeyFailed: string;
+    accountsStatusUnknown: string;
+    accountDefault: string;
+    accountAdd: string;
+    accountRename: string;
+    accountReplaceKey: string;
+    accountRemove: string;
+    accountRemoveHint: string;
+    accountName: string;
+    accountKeyHint: string;
+    accountConfirm: string;
+    accountCancel: string;
+    accountAutoSwitch: string;
+    accountAutoSwitchHint: string;
+    accountPreferredTag: string;
+    accountSwitchAction: string;
+    accountSwitchTitle: string;
+    accountSwitchBack: string;
+    accountSwitchHint: string;
+    accountSwitchFailed: string;
+    accountFallbackQuota: string;
+    accountFallbackCredential: string;
+    accountsSummary: string;
+    accountsSummaryEmpty: string;
+    accountsAvailability: string;
+    accountsAvailabilityFailed: string;
+    accountsDetails: string;
+    accountsDetailsHide: string;
+    accountDragHandle: string;
+    accountConfigureHint: string;
+    usageResetMinutes: string;
+    usageResetHours: string;
+    usageResetDays: string;
+    usageResetDue: string;
+    usageResetUnknown: string;
     usageTitle: string;
     usageRollingShort: string;
-    usageHint: string;
     usageWeekShort: string;
     usage_rolling: string;
     usage_weekly: string;
@@ -12,6 +53,7 @@ export declare const en: {
     usageLoading: string;
     usageUnavailable: string;
     usageStaleShort: string;
+    usageFallbackShort: string;
     usageStaleHint: string;
     usageRefreshFailed: string;
     usageLastUpdated: string;
@@ -54,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;
@@ -97,10 +144,17 @@ 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;
     baseURLHint: string;
+    proxyURLLabel: string;
+    proxyURLHint: string;
+    proxyURLInvalid: string;
     refreshMinutesLabel: string;
     refreshMinutesHint: string;
     streamIdleTimeoutMsLabel: string;