dsh-opencode-go 0.1.24 → 0.2.0

package/lib/types/catalog.d.ts

@@ -1,9 +1,89 @@
-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 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;
+/** Exact model/protocol controls verified against OpenCode Go. */
+export declare function withGatewayReasoning(model: Model<Api>): Model<Api>;
+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 declare const MODEL_METADATA_URL = "https://models.dev/api.json";
+/** Lifecycle and capability data the online catalog adds to a gateway listing. */
+export type ModelDetails = Pick<GoModel, 'deprecated' | 'releaseDate' | 'inputModalities'> & {
+    /**
+     * Present only when the upstream cost block is missing or carries a malformed
+     * component: its zeros are then indistinguishable from a genuinely free model,
+     * so analytics must treat the model as unpriced instead of pricing it at 0.
+     * A published block with legal components stays unmarked even when all zero.
+     */
+    readonly costKnown?: false;
+};
+export interface ModelMetadata {
+    readonly models: ReadonlyMap<string, Model<Api>>;
+    readonly details: ReadonlyMap<string, ModelDetails>;
+    readonly errors: ReadonlyMap<string, string>;
+}
+/** Select documented official protocol endpoints while preserving custom gateway prefixes. */
+export declare function modelBaseURL(api: Api, baseURL: string): string;
+/** Shared Responses defaults for declared models and explicit protocol overrides. */
+export declare function responsesCompatibility(): NonNullable<Model<'openai-responses'>['compat']>;
+/**
+ * Only read the opencode-go record. Online endpoints, headers and credentials
+ * are deliberately ignored: protocol endpoints are selected on the configured gateway.
+ * A bad entry is isolated instead of discarding every other model.
+ */
+export declare function readModelMetadata(body: unknown, baseURL: string, builtin: ReadonlyMap<string, Model<Api>>): ModelMetadata;
+export declare const MODEL_METADATA_MAX_BYTES: number;
+export interface CachedMetadata {
+    readonly body: unknown;
+    readonly etag?: string;
+    /** Last successful download or HTTP 304 verification. */
+    readonly savedAtMs: number;
+}
+export declare function metadataCachePath(): string;
+/** Only persist validators that can safely become an HTTP request header. */
+export declare function metadataETag(value: unknown): string | undefined;
+export declare function readMetadataCache(path: string): Promise<CachedMetadata | undefined>;
+export declare function writeMetadataCache(path: string, value: CachedMetadata): Promise<boolean>;
+/** Resolve a request's wire model without mutating the shared metadata catalog. */
+export declare function withProtocolOverride(model: Model<Api>, config: OpencodeGoConfig): Model<Api>;
+export { PROVIDER_ID, DISPLAY_NAME } from './contracts.ts';
+export { DEFAULT_BASE_URL } from './contracts.ts';
 export interface CatalogSnapshot {
     readonly details: ModelMetadata['details'];
     readonly models: ReadonlyMap<string, Model<Api>>;
@@ -69,3 +149,29 @@ export declare class OpencodeGoCatalog {
 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>;
+/** 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;
+}
+/** Uses the same gateway snapshot as the adapter, including models hidden from pickers. */
+export declare class GoModelsService extends TypertRemoteService {
+    private readonly options;
+    constructor(ctx: Context, options: {
+        catalog: () => OpencodeGoCatalog;
+        onRefresh?: () => void;
+    });
+    read(): Promise<GoModelCatalog>;
+}

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

@@ -0,0 +1,25 @@
+import type { AnalyticsQuery, AnalyticsReport, GoUsage } from '../contracts.ts';
+import { type en } from './presentation.ts';
+type AnalyticsKey = keyof typeof en;
+export interface AnalyticsDialogProps {
+    open: boolean;
+    onClose: () => void;
+    /** The signal reaches the Host's cancellation parameter (review M4). */
+    readAnalytics: (query: AnalyticsQuery, signal?: AbortSignal) => Promise<AnalyticsReport>;
+    readQuota?: () => Promise<GoUsage>;
+    t: (key: AnalyticsKey) => string;
+    getLocale?: () => string;
+}
+/**
+ * Shared usage dashboard, opened from the composer pill and the settings card.
+ * It scans only when opened or when the range asks for it; closing the modal
+ * aborts the request. The window end is frozen once per open, so repeated
+ * requests inside one open share the Host's dedup key (review P5/S5), a range
+ * already seen in this open renders instantly and revalidates in the
+ * background (review P17), and while a scan runs the previous results stay
+ * visible under the newly selected range with an explicit annotation
+ * (review P19). Every number shown here comes from the same Host report as
+ * before; only the presentation and the palette are new.
+ */
+export declare function AnalyticsDialog({ open, onClose, readAnalytics, readQuota, t, getLocale }: AnalyticsDialogProps): import("react").JSX.Element;
+export {};

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

@@ -1,12 +1,56 @@
+import { type en } from './presentation.ts';
+import { type ReactNode } from 'react';
+import type { GoAccountsActions, GoAccountsState, OpencodeGoModelLimit, OpencodeGoModelLimits, OpencodeGoModels, OpencodeGoSectionFace } from './controller.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;
 /**
- * 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 one place a style is chosen: four previews, each a miniature of the
+ * surface it selects, on the Settings page. The picker lives here rather than in
+ * the pill or the dashboard so a working session never changes its own look.
+ * @param props.t - copy lookup.
  */
-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 ThemePicker({ t }: {
+    t: (key: keyof typeof en) => string;
+}): import("react").JSX.Element;
+type AccountTranslate = (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: 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({ models, draft, modelVisibility, t, locale, disabled, visibilitySaving, filterAction, onEdit, onModelEnabled }: {
+    models: OpencodeGoModels;
+    draft: OpencodeGoModelLimits;
+    modelVisibility: Readonly<Record<string, boolean>>;
+    t: ModelTranslate;
+    locale?: string;
+    disabled: boolean;
+    visibilitySaving: boolean;
+    /** Optional control pinned to the right of the filter row, such as a refresh. */
+    filterAction?: ReactNode;
+    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,12 +1,14 @@
 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 } 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>;
+    /** Optional so an embedded/test render can omit the dashboard. */
+    readAnalytics?: (query: AnalyticsQuery, signal?: AbortSignal) => Promise<AnalyticsReport>;
     t: (key: string) => string;
     getLocale?: () => string;
     credentialChanges?: SnapshotStore<number>;

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

@@ -0,0 +1,176 @@
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
+import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
+import { type SnapshotStore } from '@deepseek-ai/dsh-client-store';
+import type { ConfigForm } from '@deepseek-ai/dsh-client-ui-settings/client';
+import { type OpencodeGoSettings, type OpencodeGoModelLimits, type GoAccount, type GoModel, type GoModelCatalog, type GoUsage, type AnalyticsQuery, type AnalyticsReport, type AccountCommand, type SettingsWriteResult } from '../contracts.ts';
+export type { OpencodeGoSettings, OpencodeGoModelLimit, OpencodeGoModelLimits } from '../contracts.ts';
+export declare const OPENCODE_GO_NS = "llm-opencode-go";
+export declare const TEXT_FIELDS: readonly ["usageDisplay", "protocolOverrides", "baseURL", "proxyURL", "refreshMinutes", "streamIdleTimeoutMs", "maxImages", "maxRequestImageBytes", "requestImagePixelBudget", "requestImageMaxBytes"];
+export type TextField = typeof TEXT_FIELDS[number];
+export type EditableField = TextField | 'modelLimits';
+export interface FieldState {
+    text: string;
+    overridden: boolean;
+    invalid: boolean;
+}
+export interface FormActions {
+    edit(field: TextField, text: string): void;
+    editModelLimits(value: OpencodeGoModelLimits): void;
+    resetField(field: EditableField): void;
+    save(): void;
+    discard(): void;
+}
+interface FormShell {
+    available: boolean;
+    writable: boolean;
+    dirty: boolean;
+    invalid: boolean;
+    saving: boolean;
+    failed: boolean;
+}
+/** The gateway's model listing as the page reports it. */
+export type OpencodeGoModels = 
+/** Not asked for yet; the page asks once it mounts. */
+{
+    readonly status: 'idle';
+}
+/** A listing request is outstanding. */
+ | {
+    readonly status: 'loading';
+}
+/**
+ * The gateway answered: a count/preview for the compact summary plus every
+ * discovered entry used by the capacity editor.
+ */
+ | {
+    readonly status: 'ready';
+    readonly count: number;
+    readonly preview: readonly string[];
+    readonly entries: readonly GoModel[];
+    readonly stale?: boolean;
+    readonly message?: string;
+    readonly refreshing?: boolean;
+    readonly sources?: GoModelCatalog['sources'];
+}
+/** The listing could not be read; `message` is the Host's own diagnostic. */
+ | {
+    readonly status: 'failed';
+    readonly message?: string;
+    readonly sources?: GoModelCatalog['sources'];
+};
+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>;
+    /** 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>;
+    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>;
+}
+export interface OpencodeGoSectionState extends FormShell {
+    accounts: GoAccountsState;
+    enabled: boolean;
+    usageDisplay: FieldState;
+    protocolOverrides: FieldState;
+    modelVisibility: Readonly<Record<string, boolean>>;
+    pickerSaving: boolean;
+    pickerFailed: boolean;
+    baseURL: FieldState;
+    proxyURL: FieldState;
+    refreshMinutes: FieldState;
+    streamIdleTimeoutMs: FieldState;
+    maxImages: FieldState;
+    maxRequestImageBytes: FieldState;
+    requestImagePixelBudget: FieldState;
+    requestImageMaxBytes: FieldState;
+    models: OpencodeGoModels;
+    modelLimits: Omit<FieldState, 'text'>;
+    modelLimitDraft: OpencodeGoModelLimits;
+}
+export interface OpencodeGoSectionFace extends FormActions, GoAccountsActions {
+    hooks: {
+        opencodeGo: SnapshotStore<OpencodeGoSectionState>;
+    };
+    loadModels(): void;
+    readAnalytics(query: AnalyticsQuery, signal?: AbortSignal): Promise<AnalyticsReport>;
+    readQuota(ref: string): Promise<GoUsage>;
+    setEnabled(next: boolean): void;
+    setModelEnabled(id: string, next: boolean): void;
+}
+/** One controller owns the page's typed drafts and immediate account operations. */
+export declare class OpencodeGoSectionController {
+    private readonly scope;
+    private readonly ctx;
+    private readonly readModels;
+    private readonly readUsage;
+    private readonly executeAccountCommand;
+    private readonly readAnalytics;
+    private readonly drafts;
+    private readonly store;
+    private readonly unsubscribe;
+    private saving;
+    private failed;
+    private pickerSaving;
+    private pickerFailed;
+    private models;
+    private modelsRequest;
+    private face;
+    private accountRows;
+    private accountBusy;
+    private accountRefreshing;
+    private accountFailure;
+    private accountEpoch;
+    private accountsIdentity;
+    private accountsLoaded;
+    private disposed;
+    private addition;
+    constructor(scope: ConfigForm<OpencodeGoSettings>, ctx: ClientContext, readModels?: () => Promise<RemoteResult<GoModelCatalog>>, readUsage?: (ref: string) => Promise<GoUsage>, executeAccountCommand?: ExecuteAccountCommand, readAnalytics?: (query: AnalyticsQuery, signal?: AbortSignal) => Promise<AnalyticsReport>);
+    dispose(): void;
+    private publish;
+    private blocked;
+    private stored;
+    private value;
+    private field;
+    private plan;
+    private projection;
+    private edit;
+    save(): Promise<void>;
+    setEnabled(next: boolean): Promise<void>;
+    setModelEnabled(id: string, next: boolean): Promise<void>;
+    private writePickerSetting;
+    inject(): OpencodeGoSectionFace;
+    loadModels(): void;
+    accountState(): GoAccountsState;
+    syncAccounts(): void;
+    refreshCredential(ref: string): void;
+    refreshAccounts(): Promise<void>;
+    /** Mark every account row as unreadable with the Host's own diagnostic. */
+    private markUnreadable;
+    accountActions(): GoAccountsActions;
+    private runAccountAction;
+}

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

@@ -1,12 +1,7 @@
-/**
- * OpenCode Go settings plugin, browser half. Registers the "OpenCode Go"
- * settings page over the `llm-opencode-go` namespace: the API key (stored
- * write-only through the credentials domain), the gateway's current model
- * listing, and the adapter knobs behind the page's advanced disclosure. The
- * Host settings and credential contracts stay behind their existing wire APIs.
- */
-import type { Context as ClientContext } from '@deepseek-ai/cordis';
-import { en } from './locales.ts';
+import type { Context as ClientContext, Context } from '@deepseek-ai/cordis';
+import type { ConfigForm } from '@deepseek-ai/dsh-client-ui-settings/client';
+import { type OpencodeGoSettings, type ExecuteAccountCommand } from './controller.ts';
+import { en } from './presentation.ts';
 declare module '@deepseek-ai/dsh-client-ui-slots' {
     interface LocaleNamespaceMap {
         /** The OpenCode Go settings page copy. */
@@ -14,9 +9,9 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
     }
 }
 export type { OpencodeGoSectionProps } from './Section.tsx';
-export type { OpencodeGoSectionState, OpencodeGoSettings } from './section-controller.ts';
-export { OPENCODE_GO_NS } from './section-controller.ts';
-export type { OpencodeGoKey } from './locales.ts';
+export type { OpencodeGoSectionState, OpencodeGoSettings } from './controller.ts';
+export { OPENCODE_GO_NS } from './controller.ts';
+export type { OpencodeGoKey } from './presentation.ts';
 /**
  * Required services (cordis fiber inject). The target slot is declared by
  * ui-settings' apply, whose activation order relative to this one is NOT
@@ -32,3 +27,5 @@ export declare const inject: string[];
  * @param ctx - client root context.
  */
 export declare function apply(ctx: ClientContext): void;
+export declare function accountCommands(ctx: Context): ExecuteAccountCommand;
+export declare function registerUsagePill(ctx: Context, settings: ConfigForm<OpencodeGoSettings>, selectAccount?: (ref: string) => Promise<boolean>): void;

package/lib/types/client/{locales.d.ts → presentation.d.ts}

@@ -1,3 +1,5 @@
+/** English and Chinese copy, palette tokens and local theme preferences. */
+import { type CSSProperties } from 'react';
 /** Copy dictionaries for the OpenCode Go settings page. English is the key-set source of truth. */
 export declare const en: {
     accountsTitle: string;
@@ -59,6 +61,77 @@ export declare const en: {
     usageLastUpdated: string;
     usageRetry: string;
     usageRefreshing: string;
+    analyticsOpen: string;
+    analyticsTitle: string;
+    analyticsSubtitle: string;
+    analyticsClose: string;
+    analyticsRange: string;
+    analyticsRangeToday: string;
+    analyticsRange7d: string;
+    analyticsRange30d: string;
+    analyticsRange90d: string;
+    analyticsRefresh: string;
+    analyticsRetry: string;
+    analyticsLoading: string;
+    analyticsEmpty: string;
+    analyticsUnsupported: string;
+    analyticsFailed: string;
+    analyticsRequests: string;
+    analyticsTokens: string;
+    analyticsSpend: string;
+    analyticsCoverage: string;
+    analyticsSessions: string;
+    analyticsSeconds: string;
+    analyticsSummaries: string;
+    analyticsUnsettled: string;
+    analyticsByModel: string;
+    analyticsByDay: string;
+    analyticsInput: string;
+    analyticsOutput: string;
+    analyticsCacheRead: string;
+    analyticsPriced: string;
+    analyticsUnpriced: string;
+    analyticsMissing: string;
+    analyticsFailedSessions: string;
+    analyticsUnattributed: string;
+    analyticsUnread: string;
+    analyticsScanSegments: string;
+    analyticsStaleResults: string;
+    analyticsTruncated: string;
+    analyticsScanMore: string;
+    analyticsPriceSource: string;
+    analyticsNotInvoice: string;
+    analyticsPricingUnavailable: string;
+    analyticsLegacy: string;
+    analyticsCardTitle: string;
+    analyticsCardHint: string;
+    analyticsBoardLabel: string;
+    analyticsOpenBoard: string;
+    analyticsQuota: string;
+    analyticsQuotaHint: string;
+    analyticsQuotaFailed: string;
+    analyticsChartSpend: string;
+    analyticsChartTokens: string;
+    analyticsKicker: string;
+    analyticsLead: string;
+    analyticsLeadTop: string;
+    analyticsComposition: string;
+    analyticsCompositionHint: string;
+    analyticsCompositionOther: string;
+    analyticsCompositionFree: string;
+    analyticsModel: string;
+    analyticsCost: string;
+    analyticsShare: string;
+    analyticsCacheHit: string;
+    analyticsDailyAverage: string;
+    analyticsPeak: string;
+    analyticsTotal: string;
+    themeLabel: string;
+    themeSilentBlack: string;
+    themeGraphite: string;
+    themeSeaSalt: string;
+    themeWarmSand: string;
+    themeHint: string;
     nav: string;
     title: string;
     titleLabel: string;
@@ -183,3 +256,54 @@ export declare const en: {
 export declare const zh: typeof en;
 /** Every copy key this page's dictionaries must supply. */
 export type OpencodeGoKey = keyof typeof en;
+/** One palette's six theme colors plus the neutral surface steps. */
+export interface GoThemeTokens {
+    readonly bg: string;
+    readonly surface: string;
+    readonly surface2: string;
+    readonly border: string;
+    readonly text: string;
+    readonly muted: string;
+    readonly accent: string;
+    readonly accent2: string;
+    readonly success: string;
+    readonly warning: string;
+    readonly danger: string;
+}
+/** The four selectable styles. */
+export declare const GO_THEMES: readonly ["silent-black", "graphite", "sea-salt", "warm-sand"];
+export type GoThemeId = typeof GO_THEMES[number];
+/** Graphite is the default: it is the quietest match for the Host chrome. */
+export declare const DEFAULT_GO_THEME: GoThemeId;
+/** Locale key carrying each theme's display name. */
+export declare const GO_THEME_LABELS: Record<GoThemeId, keyof typeof en>;
+/** Each style in both Host color schemes. */
+export declare const GO_THEME_TOKENS: Record<GoThemeId, {
+    dark: GoThemeTokens;
+    light: GoThemeTokens;
+}>;
+/** The selected style, stable until the next write. */
+export declare function getGoTheme(): GoThemeId;
+/**
+ * Select a style and persist it for this browser.
+ * @param id - one of {@link GO_THEMES}; unknown ids are ignored.
+ */
+export declare function setGoTheme(id: GoThemeId): void;
+/** Subscribe to style changes (for useSyncExternalStore). */
+export declare function subscribeGoTheme(listener: () => void): () => void;
+/** Read the selected style in a component. */
+export declare function useGoTheme(): GoThemeId;
+/**
+ * Follow the Host's light/dark scheme. The layout presenter marks a dark body
+ * with `data-ds-dark-theme`; the attribute is observed so switching the Host
+ * theme updates the surfaces without a reload.
+ */
+export declare function useHostScheme(): 'dark' | 'light';
+/** The active style's tokens for the Host's current scheme. */
+export declare function useGoThemeTokens(): GoThemeTokens;
+/**
+ * Inline custom properties consumed by the pill and dialog styles.
+ * @param tokens - the active palette.
+ * @returns a style object carrying every `--go-*` variable.
+ */
+export declare function themeStyle(tokens: GoThemeTokens): CSSProperties;

package/lib/types/config.d.ts

@@ -1,16 +1,8 @@
-/**
- * Configuration schema for the OpenCode Go adapter plugin. The section is
- * installed under the `llm-opencode-go` settings namespace on DSH 0.1.5/0.1.6.
- * DSH 0.1.7 edits the `opencode-go` profile entry through live references.
- * Both paths update field by field without a restart. Self-contained constraints
- * (URL shape, numeric bounds) fail at load for the composition layer and
- * refuse the write for the settings layer.
- *
- * @module dsh-llm-opencode-go/config
- */
+/** Live profile configuration, validation and settings presentation. */
 import z from '@deepseek-ai/schemastery';
-import type { OpencodeGoConfig } from './config-contract.ts';
-export type { OpencodeGoConfig, OpencodeGoModelLimit, OpencodeGoModelLimits } from './config-contract.ts';
+import { type OpencodeGoConfig } from './contracts.ts';
+import type { Context } from '@deepseek-ai/cordis';
+export type { OpencodeGoConfig, OpencodeGoModelLimit, OpencodeGoModelLimits } from './contracts.ts';
 /** Environment variable resolving the OpenCode API key. */
 export declare const DEFAULT_API_KEY_ENV = "OPENCODE_API_KEY";
 /** Successful refresh lifetime; failed refreshes retry sooner and explicit discovery revalidates immediately. */
@@ -19,9 +11,9 @@ export declare const DEFAULT_REFRESH_MINUTES = 60;
 export declare const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 300000;
 export declare const DEFAULT_REQUEST_PREPARATION_TIMEOUT_MS = 60000;
 export declare const DEFAULT_REQUEST_TIMEOUT_MS: number;
-/** Plain values used by the adapter and by pre-0.1.7 settings documents. */
+/** Plain configuration values used by validation and direct adapter consumers. */
 export declare const PlainConfig: z<OpencodeGoConfig>;
-/** 0.1.7's Loader retains these references when profile fields change. */
+/** The Loader retains these references when profile fields change. */
 export type LiveConfig = {
     [K in keyof OpencodeGoConfig]-?: {
         get(): OpencodeGoConfig[K];
@@ -46,3 +38,6 @@ export declare function assertBaseURL(raw: string): string;
  * @param raw - the configured credential reference.
  */
 export declare function assertApiKeyEnv(raw: string): void;
+export declare function validateGoConfig(value: OpencodeGoConfig): void;
+/** DSH profile forms edit the plugin's live Config fields directly. */
+export declare function installHostSettings(ctx: Context): void;