dsh-opencode-go 0.1.24 → 0.2.1

package/lib/types/accounts.d.ts

@@ -1,33 +1,98 @@
-/** 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[];
+/** Serialized account commands, primary selection and official quota reads. */
+import { type SettingsWriteResult, type GoAccountSwitch, type AccountCommand, type GoUsage } from './contracts.ts';
+import { type CredentialProvider } from '@deepseek-ai/dsh-credentials';
+import type { GoAccountSettlement } from './adapter.ts';
+import { type OpencodeGoConfig } from './config.ts';
+import type { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import { ProxyTransport } from './transport.ts';
+export interface AccountSettingsWriter {
+    describe(): readonly {
+        ns: string;
+        revision: number;
+        value: unknown;
+    }[];
+    mutate(ns: string, ops: readonly {
+        op: 'set';
+        path: string[];
+        value: unknown;
+    }[], expectedRevision?: number): Promise<unknown>;
 }
-export declare function accountRefOf(settings: AccountSettings): string;
-/** 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. */
-export interface GoAccountSwitch {
-    fromRef: string;
-    toRef: string;
-    reason: 'quota' | 'credential';
-    at: number;
+/** Locate the profile entry that owns this mount's account metadata. */
+export declare function accountSettingsRow(settings: AccountSettingsWriter): {
+    ns: string;
+    revision: number;
+    value: unknown;
+} | undefined;
+export interface AttemptOutcome {
+    failure?: {
+        code: string;
+    };
+    emitted: boolean;
+    totalTokens: number;
+    aborted: boolean;
+    hasNext: boolean;
 }
+/** Switching accounts must never replay output, charged work or model permission failures. */
+export declare function accountFallback(outcome: AttemptOutcome): GoAccountSwitch['reason'] | undefined;
+/** Only credential, rate and quota failures cool down a key; PERMISSION_DENIED is model-scoped. */
+export declare function isGatewayKeyRejection(failure: {
+    code: string;
+}): boolean;
+type AccountCredentials = Pick<CredentialProvider, 'describe' | 'resolve' | 'set' | 'unset'>;
+/** One mount serializes account edits, credential writes and fallback promotion in memory. */
+export declare class GoAccountManager {
+    private readonly config;
+    private readonly logger;
+    private connection;
+    private queue;
+    private generation;
+    private signature;
+    private credentialGeneration;
+    private latestSeq;
+    private notice;
+    constructor(config: () => OpencodeGoConfig, logger: {
+        warn(message: string): void;
+    });
+    connect(settings: AccountSettingsWriter, credentials: AccountCredentials): () => void;
+    private enqueue;
+    private read;
+    private write;
+    execute(raw: AccountCommand): Promise<SettingsWriteResult>;
+    private executeCommand;
+    /** A freshness fence prevents an old request from overriding a later user choice. */
+    capture(): number;
+    credentialChanged(): void;
+    lastSwitch(): GoAccountSwitch | undefined;
+    settle(event: GoAccountSettlement): void;
+}
+/** The browser sends commands; the host owns credentials and metadata writes. */
+export declare class GoAccountsService extends TypertRemoteService {
+    private readonly options;
+    constructor(ctx: Context, options: {
+        manager: GoAccountManager;
+    });
+    execute(command: AccountCommand): Promise<SettingsWriteResult>;
+}
+interface UsageOptions {
+    baseURL: () => string;
+    proxyURL?: () => string;
+    transport?: ProxyTransport;
+    resolveApiKey: (ref?: string) => Promise<string | undefined>;
+    activeRef?: () => string;
+    accountRefs?: () => readonly string[];
+    lastSwitch?: () => GoAccountSwitch | undefined;
+}
+/** Account statistics are fetched on the Host; credentials never enter the browser. */
+export declare class GoUsageService extends TypertRemoteService {
+    private readonly options;
+    private readonly identities;
+    private readonly pending;
+    private readonly transport;
+    constructor(ctx: Context, options: UsageOptions);
+    read(): Promise<GoUsage>;
+    readAccount(ref: string): Promise<GoUsage>;
+    private readRef;
+    private fetchUsage;
+}
+export {};

package/lib/types/adapter.d.ts

@@ -1,35 +1,22 @@
-/**
- * The OpenCode Go adapter: one route, one catalog, per-request routing header.
- *
- * Every request to the gateway carries two Harness-owned headers: the
- * attribution User-Agent (`deepseek-harness/<version>`), which pi-ai's client
- * lets request headers override, and `x-opencode-session`, which the gateway
- * requires and uses to route a conversation and share its prompt cache. The
- * header value is the request's session id, stable across continuation and
- * restore. Actual cache reads remain an upstream usage fact. A request with no
- * session id gets a fresh random value rather than a shared constant, because
- * a constant would merge unrelated traffic into one cache bucket.
- *
- * Multi-turn correctness rides on the shared pi-ai conversion machinery
- * (`toPiContext` reconstructs provider-native replay state from the session
- * log; `toStreamChunks` maps events to seam chunks), so assistant history,
- * tool calls, and usage land in the session log exactly as the generic pi-ai
- * adapter records them. Image content rides the same machinery: models whose
- * catalog entry declares the image modality convert attachments through the
- * durable attachment service, and every other model refuses image content
- * before any provider I/O.
- *
- * @module dsh-llm-opencode-go/adapter
- */
-import { LlmAdapter } from '@deepseek-ai/dsh-llm';
-import type { GenerateOptions, ImageAttachmentAccess, LlmModelInfo, LlmResolvedModelInfo, StreamChunk } from '@deepseek-ai/dsh-llm';
+/** Request snapshots, SDK dispatch, deadlines and seamless account fallback. */
+import { type OpencodeGoModelLimits, type GoAccountSwitch, type ModelSource } from './contracts.ts';
+import { type GenerateOptions, type ImageAttachmentAccess, type StreamChunk, LlmAdapter, type LlmModelInfo, type LlmResolvedModelInfo } from '@deepseek-ai/dsh-llm';
 import type { AttachmentStore, ImageAttachmentRef } from '@deepseek-ai/dsh-attachment';
+import type { Api, Model, Provider } from './sdk-types.ts';
+import { type OpencodeGoConfig } from './config.ts';
+import { ProxyTransport } from './transport.ts';
 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';
+import { FreeBunTransport } from './free-transport.ts';
+import { FreeChannelState } from './free-channel.ts';
+/**
+ * Cap large models at 64k unless the caller or settings specify an allowance.
+ * Per-model settings continue to cap explicit caller values.
+ */
+export declare function requestMaxTokens(model: {
+    id: string;
+    maxTokens: number;
+    source?: ModelSource;
+}, limits: OpencodeGoModelLimits, requested?: number): number | undefined;
 /**
  * The attachment-service bridges one image request reads. Construction-time
  * (context-dependent); the config-dependent policy numbers are merged per
@@ -41,6 +28,38 @@ export interface OpencodeGoImageAccess {
     /** Bridge one attachment reference into the current model-tool execution world. */
     resolveImageAccess: (attachments: AttachmentStore, ref: ImageAttachmentRef) => ImageAttachmentAccess | undefined;
 }
+/** Host dependencies used by a single attempt, independent of account selection. */
+export interface OpencodeGoRequestExecutorOptions {
+    /** Free-only passive backoff; never consulted by the Go executor. */
+    freeChannel?: FreeChannelState;
+    /** Resolve the credential reference captured with this call's endpoint; missing must fail loud. */
+    resolveApiKey: (config: OpencodeGoConfig, signal?: AbortSignal) => Promise<string | undefined>;
+    /**
+     * Image input machinery; absent refuses image content, which is the posture
+     * for direct construction without a durable attachment service behind it.
+     */
+    imageAccess?: OpencodeGoImageAccess;
+    /** Observe assistant history degrading to provider-neutral conversion. */
+    onReplayDegrade?: (reason: string) => void;
+}
+/** Inputs already resolved by the adapter, including one account and the wire session ID. */
+export interface OpencodeGoRequestSnapshot {
+    config: OpencodeGoConfig;
+    model: Model<Api>;
+    provider: Provider;
+    sessionId: string;
+    apiKey?: string;
+}
+/** Shares the adapter's transport without owning its lifetime or retrying accounts. */
+export declare class OpencodeGoRequestExecutor {
+    private readonly options;
+    private readonly transport;
+    private readonly freeTransport;
+    constructor(options: OpencodeGoRequestExecutorOptions, transport: ProxyTransport, freeTransport?: FreeBunTransport);
+    /** One account, one SDK attempt; host recovery still owns failures after output. */
+    stream(options: GenerateOptions, snapshot: OpencodeGoRequestSnapshot): AsyncIterable<StreamChunk>;
+    private attempt;
+}
 /** One request's serving account, with the identity captured before discovery. */
 export interface GoAccountSettlement {
     seq: number;
@@ -50,63 +69,58 @@ export interface GoAccountSettlement {
     notice?: GoAccountSwitch;
 }
 /** Constructor inputs for {@link OpencodeGoAdapter}. */
-export interface OpencodeGoAdapterOptions {
+export interface OpencodeGoAdapterOptions extends OpencodeGoRequestExecutorOptions {
+    source?: ModelSource;
     /** 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
      * two configuration generations.
      */
     config: () => OpencodeGoConfig;
-    /** Resolve the credential reference captured with this call's endpoint; missing must fail loud. */
-    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.
-     */
-    imageAccess?: OpencodeGoImageAccess;
-    /** Observe the catalog falling back to the curated table. */
+    /** Observe discovery retaining its last successful directory. */
     onFallback?: (detail: {
         url: string;
         error: unknown;
         kept: number;
     }) => void;
-    /** Observe live ids the curated table cannot route. */
+    /** Observe chat rows with invalid or unsupported declarations. */
     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 for actual requests, captured before asynchronous model discovery. */
     accountGeneration?: () => number;
+    /** Shared by both adapters so account settlement ordering spans both routes. */
+    nextCallSequence?: () => 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,
+ * One source's route adapter. The catalog snapshot freezes at each operation,
  * so a refresh between two requests never mixes model generations inside one
  * call.
  */
 export declare class OpencodeGoAdapter extends LlmAdapter {
     private readonly options;
+    private readonly source;
     private readonly resolveCatalog;
     private readonly transport;
+    private readonly requestExecutor;
+    private readonly freeTransport;
+    private readonly freeChannel;
     /** 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;
+    private nextCallSequence;
     constructor(options: OpencodeGoAdapterOptions);
     dispose(): Promise<void>;
     /**
@@ -132,15 +146,13 @@ export declare class OpencodeGoAdapter extends LlmAdapter {
     }>;
     /** Report the same default allowance used by dispatch so the host can budget compaction. */
     private modelInfo;
-    /** Validate an explicit effort against the model's own levels, without clamping. */
-    private resolveReasoningLevel;
     stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
     private streamWithSnapshot;
     private dispatch;
     private streamAccounts;
+    /** Resolve Free keys only when selecting an account or retrying a failed attempt. */
+    private accountCandidates;
     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/analytics.d.ts

@@ -0,0 +1,35 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import { type AnalyticsQuery, type AnalyticsReport, type AnalyticsExport } from './contracts.ts';
+import { ProxyTransport } from './transport.ts';
+export declare const ANALYTICS_MAX_BYTES: number;
+export interface AnalyticsOptions {
+    baseURL: () => string;
+    proxyURL?: () => string;
+    transport?: ProxyTransport;
+    resolveApiKey: (ref: string) => Promise<string | undefined>;
+    accountRefs: () => readonly string[];
+    now?: () => number;
+    fetch?: typeof globalThis.fetch;
+}
+/** The Host retains the official CSV; ordinary reads expose only aggregate numbers. */
+export declare class GoAnalyticsService extends TypertRemoteService {
+    private readonly options;
+    private readonly identities;
+    private readonly cache;
+    private readonly pending;
+    private readonly active;
+    private readonly transport;
+    constructor(ctx: Context, options: AnalyticsOptions);
+    read(raw: AnalyticsQuery, signal?: AbortSignal): Promise<AnalyticsReport>;
+    exportCsv(raw: AnalyticsQuery, signal?: AbortSignal): Promise<AnalyticsExport>;
+    private now;
+    private query;
+    private failure;
+    private forget;
+    private network;
+    private assertCurrentNetwork;
+    private identity;
+    private dataset;
+    private fetchDataset;
+}

package/lib/types/catalog.d.ts

@@ -1,71 +1,136 @@
-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 { DEFAULT_BASE_URL } from './gateway-url.ts';
+import { type LlmDiscoveredModel } from '@deepseek-ai/dsh-llm';
+import type { Api, Model, ModelThinkingLevel, ThinkingBudgets, ThinkingLevelMap, Provider } from './sdk-types.ts';
+import { type ThinkingBudgetRange, type GoModel, type OpencodeGoConfig, type ModelSource, type GoModelCatalog } from './contracts.ts';
+import { type ProxyTransport } from './transport.ts';
+import type { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+export declare const THINKING_LEVELS: readonly ModelThinkingLevel[];
+/** Protocol formats whose switch/budget is understood by pi-ai. */
+export declare const NATIVE_THINKING_FLAGS: ReadonlySet<string>;
+/** Expose budgets only when the SDK knows where to serialize a numeric limit. */
+export declare function supportsThinkingBudget(api: Api, compat: Model<Api>['compat']): boolean;
+export declare function reasoningBudgetRange(model: Model<Api>): ThinkingBudgetRange | undefined;
+export declare function unsupportedThinkingLevels(): ThinkingLevelMap;
+export declare function reasoningChoices(model: Model<Api>): readonly {
+    id: string;
+    name: string;
+}[];
+export type ReasoningIntent = {
+    kind: 'default';
+} | {
+    kind: 'off';
+} | {
+    kind: 'on';
+} | {
+    kind: 'effort';
+    level: Exclude<ModelThinkingLevel, 'off'>;
+} | {
+    kind: 'budget';
+    tokens: number;
+    min: number;
+};
+/** Called after validation against the model's choices. */
+export declare function reasoningIntent(model: Model<Api>, level: string | undefined): ReasoningIntent;
+/**
+ * The SDK serializes explicit choices. Default must leave all thinking controls
+ * to the service; a switch's On must not acquire an invented effort spelling.
+ */
+export declare function reasoningRequest(intent: ReasoningIntent): {
+    reasoning?: Exclude<ModelThinkingLevel, 'off'>;
+    thinkingBudgets?: ThinkingBudgets;
+    onPayload: (payload: unknown) => unknown;
+};
+export type ModelDetails = Pick<GoModel, 'deprecated' | 'releaseDate' | 'inputModalities'> & {
+    readonly costKnown?: false;
+};
+export interface ModelDirectory {
+    readonly models: ReadonlyMap<string, Model<Api>>;
+    readonly details: ReadonlyMap<string, ModelDetails>;
+    readonly errors: ReadonlyMap<string, string>;
+    readonly warning?: string;
+}
+/** Official listings own their protocol endpoints; custom gateways keep their prefix. */
+export declare function modelBaseURL(api: Api, baseURL: string, declared?: unknown, source?: ModelSource): string;
+export declare function readLiveModelIds(body: unknown, onInvalidRows?: (warning: string) => void): readonly string[];
+export declare function readModelDirectory(body: unknown, baseURL: string, source?: ModelSource): ModelDirectory;
+export declare const MODEL_LISTING_MAX_BYTES: number;
+export interface CachedDirectory {
+    readonly body: unknown;
+    readonly etag?: string;
+    readonly savedAtMs: number;
+}
+export declare function catalogCachePath(source?: ModelSource): string;
+export declare function catalogETag(value: unknown): string | undefined;
+export declare function readCatalogCache(path: string, sourceURL: string): Promise<CachedDirectory | undefined>;
+export declare function writeCatalogCache(path: string, sourceURL: string, value: CachedDirectory): Promise<boolean>;
+export { PROVIDER_ID, DISPLAY_NAME, FREE_PROVIDER_ID, FREE_DISPLAY_NAME, DEFAULT_BASE_URL, DEFAULT_FREE_BASE_URL } from './contracts.ts';
 export interface CatalogSnapshot {
-    readonly details: ModelMetadata['details'];
+    readonly source: ModelSource;
+    readonly details: ModelDirectory['details'];
     readonly models: ReadonlyMap<string, Model<Api>>;
-    /** Advertised ids with missing/unsupported metadata stay visible with a diagnostic. */
     readonly unavailable: ReadonlyMap<string, string>;
     readonly provider: Provider;
     readonly live: boolean;
-    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;
-    readonly metadataUpdatedAtMs?: number;
+    readonly failure?: unknown;
+    readonly warning?: string;
+    readonly updatedAtMs?: number;
     readonly fetchedAtMs: number;
 }
-/** A valid empty listing means the gateway serves nothing; malformed replies are failures. */
-export declare function readLiveModelIds(body: unknown, onInvalidRows?: (warning: string) => void): readonly string[];
-/** Runtime requests reuse a snapshot; discovery revalidates it. Concurrent reads coalesce. */
+/** One gateway owns its membership, disk cache, validator, refresh and failure backoff. */
 export declare class OpencodeGoCatalog {
     private readonly baseURL;
     private readonly refreshMs;
     private readonly onFallback;
-    /** Kept for API compatibility; now reports unconfigured ids rather than hiding them. */
     private readonly onOmitted;
     private readonly onRefresh;
     private readonly fetcher?;
     private readonly onWarning?;
+    readonly source: ModelSource;
     private served;
     private pending;
-    /** A cold runtime read can use disk metadata while the shared online refresh runs. */
-    private cachedPending;
     private initialized;
-    private readonly cachePath;
-    private metadata;
-    private metadataBody;
-    private metadataETag;
-    private metadataUpdatedAtMs;
-    private failures;
+    private cached;
+    private startupCache;
     private refreshAtMs;
-    constructor(baseURL: string, refreshMs: number, onFallback: (detail: {
+    private failures;
+    private readonly url;
+    private readonly cachePath;
+    constructor(baseURL: string, refreshMs: number, onFallback?: (detail: {
         url: string;
         error: unknown;
         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, onWarning?: ((warning: string) => void) | undefined);
+    }) => void, onOmitted?: (ids: readonly string[]) => void, onRefresh?: () => void, fetcher?: typeof globalThis.fetch | undefined, onWarning?: ((warning: string) => void) | undefined, source?: ModelSource);
     snapshot(force?: boolean, signal?: AbortSignal): Promise<CatalogSnapshot>;
-    private restoreMetadata;
-    private readSnapshot;
-    private currentSnapshot;
-    private startRefresh;
-    /** Conditional HTTP requests save bandwidth while still checking for updated metadata. */
-    private refreshMetadata;
-    private persistMetadata;
-    /** Gateway ids decide membership; online metadata decides how to call each model. */
+    private empty;
     private build;
-    /** New or previously unconfigured ids get a fresh lookup even during the runtime TTL. */
+    private restore;
+    private refresh;
     forModel(id: string, signal?: AbortSignal): Promise<CatalogSnapshot>;
 }
-/** Explicit discovery always revalidates both sources, including during the runtime TTL. */
 export declare function discoverCatalogModels(catalog: OpencodeGoCatalog): Promise<readonly LlmDiscoveredModel[]>;
-/** Settings expose the same retained catalog as requests, with a failed-refresh diagnostic. */
-export declare function discoverSettingsModels(catalog: OpencodeGoCatalog): Promise<GoModelCatalog>;
+export declare function discoverSettingsModels(catalog: OpencodeGoCatalog, freeCatalog?: OpencodeGoCatalog): Promise<GoModelCatalog>;
+export declare class GoCatalogManager {
+    private readonly options;
+    private readonly 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, source?: ModelSource): OpencodeGoCatalog;
+}
+export declare class GoModelsService extends TypertRemoteService {
+    private readonly options;
+    constructor(ctx: Context, options: {
+        catalog: () => OpencodeGoCatalog;
+        freeCatalog?: () => OpencodeGoCatalog;
+        onRefresh?: () => void;
+    });
+    read(): Promise<GoModelCatalog>;
+}

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

@@ -0,0 +1,18 @@
+import type { AnalyticsExport, AnalyticsQuery, AnalyticsReport, GoAccount, GoUsage } from '../contracts.ts';
+import { type en } from './presentation.ts';
+export declare function historyNumber(value: string, locale?: string, compact?: boolean): string;
+/** Keep micro-cents exact through rounding: one dollar is 100,000,000 units. */
+export declare function historyMoney(value: string, locale?: string): string;
+export interface AnalyticsDialogProps {
+    open: boolean;
+    onClose: () => void;
+    readAnalytics: (query: AnalyticsQuery, signal?: AbortSignal) => Promise<AnalyticsReport>;
+    exportAnalytics?: (query: AnalyticsQuery, signal?: AbortSignal) => Promise<AnalyticsExport>;
+    readQuota?: (ref: string) => Promise<GoUsage>;
+    accounts: readonly GoAccount[];
+    activeRef: string;
+    contextKey?: string | number;
+    t: (key: keyof typeof en) => string;
+    getLocale?: () => string;
+}
+export declare function AnalyticsDialog(props: AnalyticsDialogProps): import("react").JSX.Element;

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

@@ -1,12 +1,46 @@
+import { type en } from './presentation.ts';
+import type { GoAccountsActions, GoAccountsState, OpencodeGoModelLimit, OpencodeGoModelLimits, OpencodeGoModels, OpencodeGoSectionFace } from './controller.ts';
+import { type ModelSource } from '../contracts.ts';
+import type { InjectFace } from '@deepseek-ai/dsh-client-ui-slots';
+export declare function HintMark(props: {
+    hint: string;
+}): import("react").JSX.Element;
+export declare function HintText(props: {
+    id: string;
+    hint: string;
+}): import("react").JSX.Element;
+type AccountTranslate = (key: keyof typeof en, params?: Record<string, unknown>) => string;
 /**
- * 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.
+ * 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.
  */
-import type { InjectFace } from '@deepseek-ai/dsh-client-ui-slots';
-import type { OpencodeGoSectionFace } from './section-controller.ts';
-import type { en } from './locales.ts';
-export type { OpencodeGoSectionState } from './section-controller.ts';
+export declare function AccountsCard({ state, actions, writable, t, locale }: {
+    state: GoAccountsState;
+    actions: GoAccountsActions;
+    writable: boolean;
+    t: AccountTranslate;
+    locale?: string;
+}): import("react").JSX.Element;
+type ModelTranslate = (key: keyof typeof en, params?: Record<string, unknown>) => string;
+export declare function hasCapacityOverride(limit: OpencodeGoModelLimit | null | undefined): boolean;
+/** Per-model switches apply immediately; capacity edits stay in the staged form. */
+export declare function ModelEditor({ source, models, draft, modelVisibility, t, locale, disabled, visibilitySaving, onEdit, onModelEnabled }: {
+    source?: ModelSource;
+    models: OpencodeGoModels;
+    draft: OpencodeGoModelLimits;
+    modelVisibility: Readonly<Record<string, boolean>>;
+    t: ModelTranslate;
+    locale?: string;
+    disabled: boolean;
+    visibilitySaving: boolean;
+    onEdit: (next: OpencodeGoModelLimits) => void;
+    onModelEnabled: (id: string, enabled: boolean) => void;
+}): import("react").JSX.Element;
+export type { OpencodeGoSectionState } from './controller.ts';
 /** Section copy lookup, including the optional `{name}` template params. */
 type SectionTranslate = (key: keyof typeof en, params?: Record<string, unknown>) => string;
 /** Injected dependencies of {@link OpencodeGoSection} (slot `inject`). */

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

@@ -1,16 +1,25 @@
 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 { SettingsScope } from './settings.ts';
-import type { OpencodeGoSettings } from './section-controller.ts';
+import { type GoUsage, type AnalyticsQuery, type AnalyticsReport, type AnalyticsExport } from '../contracts.ts';
+import type { ConfigForm } from '@deepseek-ai/dsh-client-ui-settings/client';
+import type { OpencodeGoSettings } from './controller.ts';
 export interface UsagePillProps {
     directory: SnapshotStore<ModelDirectoryState>;
-    settings: SettingsScope<OpencodeGoSettings>;
+    settings: ConfigForm<OpencodeGoSettings>;
     readUsage: () => Promise<GoUsage>;
+    readAccountUsage?: (ref: string) => Promise<GoUsage>;
+    /** Optional so an embedded/test render can omit the dashboard. */
+    readAnalytics?: (query: AnalyticsQuery, signal?: AbortSignal) => Promise<AnalyticsReport>;
+    exportAnalytics?: (query: AnalyticsQuery, signal?: AbortSignal) => Promise<AnalyticsExport>;
     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, credentialChanges, ...props }: UsagePillProps): import("react").JSX.Element | null;
+/** A root sidebar entry receives its width mode from the host slot owner. */
+export type SidebarQuotaProps = Omit<UsagePillProps, 'directory'> & {
+    wide: boolean;
+};
+/** Only a visible, enabled input indicator mounts the usage poller. */
+export declare function UsagePill({ directory, ...props }: UsagePillProps): import("react").JSX.Element;
+export declare function SidebarQuota({ wide, ...props }: SidebarQuotaProps): import("react").JSX.Element;