dsh-opencode-go 0.1.21 → 0.1.23

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,11 +59,10 @@ export interface OpencodeGoSectionState extends FormShell {
      */
     enabled: boolean;
     usageDisplay: FieldState;
+    protocolOverrides: FieldState;
     modelVisibility: Readonly<Record<string, boolean>>;
     pickerSaving: boolean;
     pickerFailed: boolean;
-    /** Credential reference naming the environment key. */
-    apiKeyEnv: FieldState;
     /** The gateway endpoint. */
     baseURL: FieldState;
     proxyURL: FieldState;
@@ -149,6 +111,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 +129,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 +194,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;

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

@@ -0,0 +1,70 @@
+/** Browser-safe configuration vocabulary shared by both plugin faces. */
+import type { GoAccount } from './accounts.ts';
+import type { GoAccountOperation } from './account-operations.ts';
+import type { UsageDisplayMode } from './usage-display.ts';
+import type { GoProtocolOverrides } from './protocol-contract.ts';
+export declare const SETTINGS_NAMESPACE = "llm-opencode-go";
+export declare const PROFILE_ENTRY_ID = "opencode-go";
+/**
+ * One model's configured capacities. Every field is optional so a deployment
+ * can override only the value it needs. Null explicitly selects the catalog
+ * value even when a lower profile/settings layer supplies an override.
+ */
+export interface OpencodeGoModelLimit {
+    /** Context window in tokens, overriding what the catalog advertised. */
+    contextWindow?: number | null;
+    /** Output cap per request, overriding what the catalog advertised. */
+    maxTokens?: number | null;
+    /** Additional selectable thinking budgets, in tokens; null keeps the standard presets. */
+    thinkingBudgets?: number[] | null;
+}
+/** Per-model capacities; a null entry selects both original catalog values. */
+export type OpencodeGoModelLimits = Record<string, OpencodeGoModelLimit | null>;
+/** Runtime configuration for one plugin mount. */
+export interface OpencodeGoConfig {
+    /**
+     * Whether this adapter serves its route at all. False withdraws the
+     * `dsh-opencode-go` route and its models from every picker without unloading the
+     * plugin, so the settings page that owns this switch stays reachable to turn
+     * it back on. Independent of the credential: a key present while this is
+     * false registers nothing.
+     */
+    enabled: boolean;
+    /** Usage pill visibility; auto follows this plugin's selected provider. */
+    usageDisplay: UsageDisplayMode;
+    /** Per-model picker switches; absent entries default to enabled unless deprecated. */
+    modelVisibility?: Record<string, boolean>;
+    /** Experimental opt-in routing; omitted/null entries follow the catalog. */
+    protocolOverrides?: GoProtocolOverrides;
+    /** Legacy credential reference, kept in sync with the first/current account. */
+    apiKeyEnv: string;
+    /** The first account is current; subsequent accounts are tried in order. */
+    accounts?: GoAccount[] | null;
+    accountOperations?: GoAccountOperation[];
+    /** Try other saved accounts on quota/credential rejection before any content is emitted. */
+    autoSwitch?: boolean;
+    /** Shared gateway base for model discovery, inference and usage requests. */
+    baseURL: string;
+    /** Optional HTTP(S) or SOCKS5 proxy; blank uses the default network transport. */
+    proxyURL: string;
+    /** Request/picker cache lifetime in minutes; explicit discovery bypasses it. */
+    refreshMinutes: number;
+    /** Largest idle gap between stream events before the request fails. */
+    streamIdleTimeoutMs: number;
+    /** Bound discovery and each attempt's credential/image preparation. */
+    requestPreparationTimeoutMs?: number;
+    /** Whole dispatch deadline, including discovery and account fallback. */
+    requestTimeoutMs?: number;
+    /** Optional retained image occurrence cap per request; omission or null leaves the count unlimited. */
+    maxImages?: number | null;
+    /** Request-level bound on base64-encoded image payload, in bytes. */
+    maxRequestImageBytes: number;
+    /** Total-pixel budget for one request image. */
+    requestImagePixelBudget: number;
+    /** Raw encoded-byte target for one request image before base64 expansion. */
+    requestImageMaxBytes: number;
+    /** Per-model capacity overrides; an absent field inherits the catalog value. */
+    modelLimits: OpencodeGoModelLimits;
+}
+/** Settings snapshots may omit fields inherited from their base layer. */
+export type OpencodeGoSettings = Partial<OpencodeGoConfig>;

package/lib/types/config.d.ts

@@ -9,65 +9,16 @@
  * @module dsh-llm-opencode-go/config
  */
 import z from '@deepseek-ai/schemastery';
-import { type UsageDisplayMode } from './usage-display.ts';
-import { type GoAccount } from './accounts.ts';
+import type { OpencodeGoConfig } from './config-contract.ts';
+export type { OpencodeGoConfig, OpencodeGoModelLimit, OpencodeGoModelLimits } from './config-contract.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. */
 export declare const DEFAULT_REFRESH_MINUTES = 60;
 /** Default maximum idle interval while a stream read is outstanding. */
 export declare const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 300000;
-/**
- * One model's configured capacities. Every field is optional so a deployment
- * can override only the value it needs. Null explicitly selects the catalog
- * value even when a lower profile/settings layer supplies an override.
- */
-export interface OpencodeGoModelLimit {
-    /** Context window in tokens, overriding what the catalog advertised. */
-    contextWindow?: number | null;
-    /** Output cap per request, overriding what the catalog advertised. */
-    maxTokens?: number | null;
-}
-/** Per-model capacities; a null entry selects both original catalog values. */
-export type OpencodeGoModelLimits = Record<string, OpencodeGoModelLimit | null>;
-/** Runtime configuration for one plugin mount. */
-export interface OpencodeGoConfig {
-    /**
-     * Whether this adapter serves its route at all. False withdraws the
-     * `dsh-opencode-go` route and its models from every picker without unloading the
-     * plugin, so the settings page that owns this switch stays reachable to turn
-     * it back on. Independent of the credential: a key present while this is
-     * false registers nothing.
-     */
-    enabled: boolean;
-    /** Usage pill visibility; auto follows this plugin's selected provider. */
-    usageDisplay: UsageDisplayMode;
-    /** Per-model picker switches; absent entries default to enabled unless deprecated. */
-    modelVisibility?: Record<string, boolean>;
-    /** Credential reference: the environment variable the key resolves from. */
-    apiKeyEnv: string;
-    accounts?: GoAccount[] | null;
-    /** Try other saved accounts on quota/credential rejection before any content is emitted. */
-    autoSwitch?: boolean;
-    /** The gateway endpoint; also the base of the live model listing. */
-    baseURL: string;
-    /** Optional HTTP(S) or SOCKS5 proxy; blank uses the default network transport. */
-    proxyURL: string;
-    /** Request/picker cache lifetime in minutes; explicit discovery bypasses it. */
-    refreshMinutes: number;
-    /** Largest idle gap between stream events before the request fails. */
-    streamIdleTimeoutMs: number;
-    /** Optional retained image occurrence cap per request; omission or null leaves the count unlimited. */
-    maxImages?: number | null;
-    /** Request-level bound on base64-encoded image payload, in bytes. */
-    maxRequestImageBytes: number;
-    /** Total-pixel budget for one request image. */
-    requestImagePixelBudget: number;
-    /** Raw encoded-byte target for one request image before base64 expansion. */
-    requestImageMaxBytes: number;
-    /** Per-model capacity overrides; an absent field inherits the catalog value. */
-    modelLimits: OpencodeGoModelLimits;
-}
+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. */
 export declare const PlainConfig: z<OpencodeGoConfig>;
 /** 0.1.7's Loader retains these references when profile fields change. */
@@ -84,6 +35,14 @@ export declare function readConfig(config: LiveConfig): OpencodeGoConfig;
  * the composition layer and as the settings section's write validator, so a
  * bad URL fails where it is written, never at first request.
  * @param raw - the configured base URL.
- * @returns the normalized base URL without trailing slashes.
+ * @returns the current gateway base URL without trailing slashes.
  */
 export declare function assertBaseURL(raw: string): string;
+/**
+ * Reject a selected credential reference that is not a bare environment
+ * variable name. The schema pattern above fails the composition layer and the
+ * settings write; this assert gives the load and validate paths a message that
+ * names the field, instead of schemastery's generic regexp complaint.
+ * @param raw - the configured credential reference.
+ */
+export declare function assertApiKeyEnv(raw: string): void;

package/lib/types/conversion/context.d.ts

@@ -5,7 +5,8 @@
  */
 import type { GenerateOptions, ImageAttachmentAccessResolver } from '@deepseek-ai/dsh-llm';
 import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
-import type { Context as PiContext } from 'opencode-go-pi-ai';
+import type { Context as PiContext } from '../sdk-types.ts';
+import { ImagePayloadLease, type ImagePoolObserver } from './image-pool.ts';
 /** Inputs that bind deterministic request images to one current tool execution world. */
 export interface PiImageRequestContext {
     /** Durable provider that resolves request-image bytes and provider-owned host objects. */
@@ -18,6 +19,9 @@ export interface PiImageRequestContext {
     maxRequestImageBytes?: number;
     /** Route pixel and raw encoded-byte budgets. */
     requestImagePolicy?: PiImageRequestBudget;
+    /** Adapter-owned lease retains its charge through provider streaming. */
+    payloadLease?: ImagePayloadLease;
+    onImagePool?: ImagePoolObserver;
 }
 /** Per-route budgets from which each request image's target is derived. */
 export interface PiImageRequestBudget {

package/lib/types/conversion/image-pool.d.ts

@@ -0,0 +1,24 @@
+/** Shared across requests so concurrent conversations cannot multiply image work. */
+export declare const IMAGE_PREPARATION_CONCURRENCY = 4;
+export declare const IMAGE_PREPARATION_QUEUE_LIMIT = 32;
+/** Raw prepared bytes plus base64 payloads, not a bound on native decoder RSS. */
+export declare const IMAGE_PAYLOAD_BUDGET_BYTES: number;
+export interface ImagePoolObservation {
+    queueWaitMs: number;
+    active: number;
+    queued: number;
+    retainedBytes: number;
+    rejected?: boolean;
+}
+export type ImagePoolObserver = (observation: ImagePoolObservation) => void;
+/** Held by the adapter until an attempt ends, including streaming and fallback. */
+export declare class ImagePayloadLease {
+    private readonly observer?;
+    private bytes;
+    private closed;
+    constructor(observer?: ImagePoolObserver | undefined);
+    reserve(bytes: number): void;
+    [Symbol.dispose](): void;
+}
+/** Keep the permit until real work settles, even if its caller stops waiting. */
+export declare function withImagePermit<T>(work: () => Promise<T>, signal?: AbortSignal, observer?: ImagePoolObserver): Promise<T>;

package/lib/types/conversion/replay.d.ts

@@ -8,7 +8,7 @@
  * @module dsh-opencode-go/conversion/replay
  */
 import type { Message, ReplayEnvelope } from '@deepseek-ai/dsh-llm';
-import type { Api, AssistantMessage } from 'opencode-go-pi-ai';
+import type { Api, AssistantMessage } from '../sdk-types.ts';
 /** Per-block half of the pi-ai replay envelope, one entry per content block. */
 export type PiAiReplayBlock = {
     type: 'text';

package/lib/types/conversion/stream.d.ts

@@ -8,7 +8,7 @@
  * @module dsh-opencode-go/conversion/stream
  */
 import type { FinishReason, StreamChunk, TokenUsage } from '@deepseek-ai/dsh-llm';
-import type { AssistantMessage, AssistantMessageEvent, Usage as PiUsage } from 'opencode-go-pi-ai';
+import type { AssistantMessage, AssistantMessageEvent, Usage as PiUsage } from '../sdk-types.ts';
 /**
  * Map pi-ai usage (reasoning folded into output by pi-ai).
  * @param usage - cumulative usage from the terminal pi-ai event.

package/lib/types/gateway-diagnostics.d.ts

@@ -0,0 +1,22 @@
+/** One SDK attempt owns its capture; simultaneous requests cannot share evidence. */
+export declare class GatewayDiagnostics {
+    private readonly options;
+    private evidence;
+    private code;
+    private readonly secrets;
+    constructor(options: {
+        provider: string;
+        model: string;
+        apiKey: string;
+        proxyURL?: string;
+        fetch?: typeof globalThis.fetch;
+        directory?: string;
+        callId?: string;
+        attempt?: number;
+        onResponse?: (status: number, requestId?: string) => void;
+    });
+    private redact;
+    readonly fetch: typeof globalThis.fetch;
+    failureCode(fallback: string): Promise<string>;
+    failureMessage(original: string): Promise<string>;
+}

package/lib/types/gateway-error.d.ts

@@ -0,0 +1,2 @@
+/** Gateway status codes cover several domains; a 401 alone cannot reject a key. */
+export declare function classifyGatewayError(status: number, body: string, fallback: string): string;

package/lib/types/gateway-url.d.ts

@@ -0,0 +1,7 @@
+/** Public Go gateway shared by discovery, inference and usage. */
+export declare const DEFAULT_BASE_URL = "https://opencode.ai/inference/go/v1";
+/**
+ * Migrate the legacy official address before any request is constructed.
+ * Keep this callback self-contained: settings schemas serialize its source.
+ */
+export declare function migrateGatewayBaseURL(baseURL: string): string;

package/lib/types/google-fetch.d.ts

@@ -0,0 +1,6 @@
+export declare function withGoogleFetch<T>(options: {
+    fetch?: typeof globalThis.fetch;
+    headers?: Record<string, string | null>;
+} | undefined, request: () => T): T;
+/** The pinned Google SDK's HTTP call uses this binding in builds and tests. */
+export declare const googleFetch: typeof globalThis.fetch;

package/lib/types/google-generative-ai.d.ts

@@ -0,0 +1,3 @@
+import type { SimpleStreamOptions, StreamFunction } from './sdk-types.ts';
+export declare const stream: StreamFunction<'google-generative-ai'>;
+export declare const streamSimple: StreamFunction<'google-generative-ai', SimpleStreamOptions>;

package/lib/types/host-settings.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { OpencodeGoConfig } from './config-contract.ts';
+import type { AccountSettingsWriter } from './settings-bridge.ts';
+export declare function validateGoConfig(value: OpencodeGoConfig): void;
+/** Version-specific settings attachment and validation stay at the host boundary. */
+export declare function installHostSettings(ctx: Context, entry: OpencodeGoConfig, options: {
+    connect: (settings: AccountSettingsWriter) => () => void;
+    setSource: (source: () => OpencodeGoConfig) => void;
+    onChange: () => void;
+    recover: () => void;
+}): void;

package/lib/types/index.d.ts

@@ -17,7 +17,7 @@
  *   config:
  *     enabled: true                     # false withdraws the route; the plugin stays mounted
  *     apiKeyEnv: OPENCODE_API_KEY       # default
- *     baseURL: https://opencode.ai/zen/go/v1   # default
+ *     baseURL: https://opencode.ai/inference/go/v1   # default
  *     refreshMinutes: 60                # live catalog re-resolution interval
  * ```
  *
@@ -38,7 +38,7 @@ declare module '@deepseek-ai/cordis' {
     }
 }
 export { OpencodeGoAdapter } from './adapter.ts';
-export type { OpencodeGoAdapterOptions, OpencodeGoImageAccess } from './adapter.ts';
+export type { OpencodeGoAdapterOptions, OpencodeGoImageAccess, GoAccountSettlement, GoCallTrace } from './adapter.ts';
 export { DEFAULT_BASE_URL, DISPLAY_NAME, PROVIDER_ID, OpencodeGoCatalog, discoverCatalogModels, readLiveModelIds, } from './catalog.ts';
 export { Config, PlainConfig, assertBaseURL } from './config.ts';
 export { assertProxyURL } from './proxy-url.ts';

package/lib/types/model-metadata.d.ts

@@ -1,5 +1,5 @@
-/** Convert OpenCode's online models.dev metadata into the SDK's three wire protocols. */
-import type { Api, Model } from 'opencode-go-pi-ai';
+/** Convert OpenCode's online models.dev metadata into the supported SDK wire protocols. */
+import type { Api, Model } from './sdk-types.ts';
 import { type GoModel } from './models-contract.ts';
 export declare const MODEL_METADATA_URL = "https://models.dev/api.json";
 /** Lifecycle and capability data the online catalog adds to a gateway listing. */
@@ -9,8 +9,10 @@ export interface ModelMetadata {
     readonly details: ReadonlyMap<string, ModelDetails>;
     readonly errors: ReadonlyMap<string, string>;
 }
-/** Anthropic's SDK appends /v1/messages; the OpenAI SDKs append paths below /v1. */
+/** Use the current gateway for every protocol, then normalize SDK paths. */
 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: model traffic always stays on the configured gateway.

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

@@ -5,6 +5,8 @@ export interface GoModel {
     name?: string;
     contextWindow?: number;
     maxTokens?: number;
+    /** Token budget controls available to this model, including their catalog bounds. */
+    reasoningBudget?: ThinkingBudgetRange;
     deprecated?: boolean;
     releaseDate?: string;
     /** Input modalities models.dev declares, in {@link INPUT_MODALITIES} order. */
@@ -12,6 +14,10 @@ export interface GoModel {
     /** Advertised by the gateway but lacking a usable protocol and capability configuration. */
     configurationMissing?: boolean;
 }
+export interface ThinkingBudgetRange {
+    min: number;
+    max: number;
+}
 /**
  * Input modalities this page can name. models.dev uses these same five tokens, so
  * an unknown token is dropped rather than rendered as an untranslatable chip.
@@ -29,6 +35,7 @@ export declare function normalizeInputModalities(value: unknown): readonly Input
 export interface GoCatalogSourceStatus {
     readonly updatedAt?: number;
     readonly error?: string;
+    readonly warning?: string;
 }
 /** A failed refresh retains the Host's usable data with an explicit diagnostic. */
 export interface GoModelCatalog {

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

@@ -0,0 +1,5 @@
+/** The supported experimental override surface, shared with the settings UI. */
+export declare const RESPONSES_OVERRIDE_MODEL = "deepseek-v4.1-flash";
+export type GoProtocolOverrides = Partial<Record<typeof RESPONSES_OVERRIDE_MODEL, 'openai-responses' | null>>;
+/** Null selects catalog routing even when a lower settings layer overrides it. */
+export declare function assertProtocolOverrides(value: unknown): asserts value is GoProtocolOverrides | undefined;

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

@@ -0,0 +1,4 @@
+import type { Api, Model } from './sdk-types.ts';
+import type { OpencodeGoConfig } from './config-contract.ts';
+/** Resolve a request's wire model without mutating the shared metadata catalog. */
+export declare function withProtocolOverride(model: Model<Api>, config: OpencodeGoConfig): Model<Api>;

package/lib/types/reasoning.d.ts

@@ -1,10 +1,40 @@
-/** Gateway reasoning controls shared by live metadata, fallbacks and requests. */
-import type { Api, Model, ModelThinkingLevel, ThinkingLevelMap } from 'opencode-go-pi-ai';
+import type { Api, Model, ModelThinkingLevel, ThinkingBudgets, ThinkingLevelMap } from './sdk-types.ts';
+import type { ThinkingBudgetRange } from './models-contract.ts';
 export declare const THINKING_LEVELS: readonly ModelThinkingLevel[];
-/** Formats that explicitly disable thinking when no SDK effort is supplied. */
+/** 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 rules verified against OpenCode Go, never inherited by a family. */
+/** Exact model/protocol controls verified against OpenCode Go. */
 export declare function withGatewayReasoning(model: Model<Api>): Model<Api>;
-/** An unset OpenAI effort preserves the provider default; explicit Off retains its wire value. */
-export declare function withRequestReasoning(model: Model<Api>, level: ModelThinkingLevel | undefined): 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;
+};

package/lib/types/request-control.d.ts

@@ -0,0 +1,2 @@
+/** Cancel a wait even when an external service does not observe its signal. */
+export declare function waitWithSignal<T>(work: () => PromiseLike<T>, signal?: AbortSignal): Promise<T>;