dsh-opencode-go 0.1.24 → 0.2.0

package/lib/types/contracts.d.ts

@@ -0,0 +1,283 @@
+/** Browser-safe configuration, account metadata and RPC wire contracts. */
+import type { RemoteResult, TypertRemoteContribution } from '@deepseek-ai/dsh-typert-protocol';
+import type { AnalyticsFailureReason, AnalyticsQuery, AnalyticsReport } from './analytics.ts';
+/** Public DSH route and the private SDK transport have separate identities. */
+export declare const PROVIDER_ID = "dsh-opencode-go";
+export declare const DISPLAY_NAME = "DSH OpenCode Go";
+export declare const SDK_PROVIDER_ID = "opencode-go";
+/** Public Go discovery/usage base; inference uses the documented protocol-specific siblings. */
+export declare const DEFAULT_BASE_URL = "https://opencode.ai/inference/go/v1";
+/**
+ * Migrate the legacy official address before any request is constructed.
+ */
+export declare function migrateGatewayBaseURL(baseURL: string): string;
+/** Shared by Host validation and the browser form; never echo proxy credentials. */
+export declare function assertProxyURL(raw: string | undefined): string;
+/** Usage visibility shared by the Host schema and the browser settings. */
+export declare const USAGE_DISPLAY_MODES: readonly ["auto", "always", "off"];
+export type UsageDisplayMode = typeof USAGE_DISPLAY_MODES[number];
+export declare const DEFAULT_USAGE_DISPLAY: UsageDisplayMode;
+/** Client-safe account metadata. Secrets stay in the host credential service. */
+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;
+}
+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;
+}
+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;
+    /** Try other saved accounts on quota/credential rejection before any content is emitted. */
+    autoSwitch?: boolean;
+    /** Discovery/usage base; the official Go gateway selects inference endpoints by protocol. */
+    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>;
+/** 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;
+export interface GoModel {
+    id: string;
+    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. */
+    inputModalities?: readonly InputModality[];
+    /** 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.
+ */
+export declare const INPUT_MODALITIES: readonly ["text", "image", "audio", "video", "pdf"];
+export type InputModality = typeof INPUT_MODALITIES[number];
+/**
+ * Normalize one `modalities.input` array into display order.
+ * @param value - the raw declaration read from models.dev or from a Host response.
+ * @returns the declared modalities in {@link INPUT_MODALITIES} order, or
+ *   `undefined` when nothing recognizable was declared.
+ */
+export declare function normalizeInputModalities(value: unknown): readonly InputModality[] | undefined;
+/** Last successful check of one catalog source, plus any current refresh failure. */
+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 {
+    readonly models: readonly GoModel[];
+    readonly stale: boolean;
+    readonly error?: string;
+    /** Optional for clients reading an older Host response. Timestamps are Unix milliseconds. */
+    readonly sources?: {
+        readonly listing: GoCatalogSourceStatus;
+        readonly metadata: GoCatalogSourceStatus;
+    };
+}
+/** Missing configuration cannot be enabled; configured models follow explicit switches or lifecycle defaults. */
+export declare function isModelEnabled(model: Pick<GoModel, 'id' | 'deprecated' | 'configurationMissing'>, modelVisibility?: Readonly<Record<string, boolean>>): boolean;
+export declare function validReleaseDate(value: unknown): value is string;
+/** Calendar dates are supplied without a timezone; compare UTC dates consistently. */
+export declare function isNewModel(model: GoModel, now?: number): boolean;
+export declare function sortModels(models: readonly GoModel[], now?: number): GoModel[];
+export declare function parseGoModels(value: unknown): GoModel[];
+export declare function parseGoModelCatalog(value: unknown): GoModelCatalog;
+declare module '@deepseek-ai/dsh-typert-protocol' {
+    interface TypertRemoteNamespaceMap {
+        opencodeGoModels: {
+            read(): Promise<RemoteResult<GoModelCatalog>>;
+        };
+    }
+}
+export declare const modelsRemote: TypertRemoteContribution;
+export interface UsageWindow {
+    status: 'ok' | 'rate-limited';
+    percent: number;
+    resetsAt: string;
+}
+export interface GoUsage {
+    /** Opaque Host identity for this endpoint/account; never a credential or its hash. */
+    source?: string;
+    lastSwitch?: GoAccountSwitch;
+    rolling: UsageWindow;
+    weekly: UsageWindow;
+    monthly: UsageWindow;
+}
+export declare function parseAccountSwitch(value: unknown): GoAccountSwitch;
+/** Reject missing statistics rather than turning unavailable data into zero. */
+export declare function parseGoUsage(value: unknown): GoUsage;
+declare module '@deepseek-ai/dsh-typert-protocol' {
+    interface RemoteErrorDetailsMap {
+        'opencode-go/usage-unavailable': {
+            readonly retryable: boolean;
+            readonly retainPrevious: boolean;
+            readonly source?: string;
+            readonly lastSwitch?: GoAccountSwitch;
+        };
+    }
+    interface TypertRemoteNamespaceMap {
+        opencodeGoUsage: {
+            read(): Promise<RemoteResult<GoUsage>>;
+            readAccount(ref: string): Promise<RemoteResult<GoUsage>>;
+        };
+    }
+}
+export declare const usageRemote: TypertRemoteContribution;
+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;
+export type SettingsWriteResult = 'applied' | 'rejected' | 'unknown';
+export type { AnalyticsFailureReason, AnalyticsQuery, AnalyticsTotals, AnalyticsModelRow, AnalyticsDayRow, AnalyticsCoverage, AnalyticsPricing, AnalyticsReport } from './analytics.ts';
+/**
+ * Validate one query. Unknown fields are ignored so a newer client can add
+ * optional knobs without breaking an older Host.
+ * @param value - raw RPC argument.
+ * @returns the validated query.
+ */
+export declare function parseAnalyticsQuery(value: unknown): AnalyticsQuery;
+/** Check the response envelope; the host constructs typed aggregate rows. */
+export declare function parseAnalyticsReport(value: unknown): AnalyticsReport;
+declare module '@deepseek-ai/dsh-typert-protocol' {
+    interface RemoteErrorDetailsMap {
+        'opencode-go/analytics-unavailable': {
+            readonly reason: AnalyticsFailureReason;
+            readonly retryable: boolean;
+        };
+    }
+    interface TypertRemoteNamespaceMap {
+        opencodeGoAnalytics: {
+            read(query: AnalyticsQuery, signal?: AbortSignal): Promise<RemoteResult<AnalyticsReport>>;
+        };
+    }
+}
+/** The dashboard endpoint, mounted with the other plugin remotes. */
+export declare const analyticsRemote: TypertRemoteContribution;
+/** A registry owns one contribution per package; mount all plugin endpoints together. */
+export declare const goRemote: TypertRemoteContribution;
+/** Default image budgets, overridable through the adapter configuration. */
+export declare const DEFAULT_MAX_REQUEST_IMAGE_BYTES: number;
+export declare const DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET: number;
+export declare const DEFAULT_REQUEST_IMAGE_MAX_BYTES: number;

package/lib/types/conversion.d.ts

@@ -0,0 +1,147 @@
+/** Request history, durable images, provider replay and stream conversion. */
+import { type Message as HistoryMessage, type ReplayEnvelope, type RequestMessage as Message, type GenerateOptions, type ImageAttachmentAccessResolver, type FinishReason, type StreamChunk, type TokenUsage } from '@deepseek-ai/dsh-llm';
+import type { Api, AssistantMessage, Usage as PiUsage, Context as PiContext, AssistantMessageEvent } from './sdk-types.ts';
+import { type ImageAttachmentRef, type AttachmentStore } from '@deepseek-ai/dsh-attachment';
+/** Per-block half of the pi-ai replay envelope, one entry per content block. */
+export type PiAiReplayBlock = {
+    type: 'text';
+    textSignature?: string;
+} | {
+    type: 'reasoning';
+    thinkingSignature?: string;
+    redacted?: boolean;
+} | {
+    type: 'tool-call';
+    thoughtSignature?: string;
+};
+/** Versioned response-level half of the pi-ai replay envelope. */
+export interface PiAiReplayResponse {
+    kind: 'pi-ai';
+    version: 2;
+    api: Api;
+    /** Requested DSH provider identity, matching the durable assistant source. */
+    provider: string;
+    /** Native SDK provider when it differs from the DSH route. */
+    sdkProvider?: string;
+    /** Requested model identity, matching the durable assistant source. */
+    model: string;
+    /** Provider-reported model; informational only, so requested identity still matches replay signatures. */
+    responseModel?: string;
+    responseId?: string;
+    /** Provider-native effort for historical replay; absence is preserved. */
+    providerThinkingLevel?: string;
+    stopReason: AssistantMessage['stopReason'];
+}
+/**
+ * Project a successful pi-ai response into the minimal durable replay state.
+ * The per-block half is index-aligned with the streamed blocks (pi-ai content
+ * order), so `BlockAssembler` prunes an entry with its block whenever assembly
+ * removes one.
+ * @param message - completed native pi-ai assistant response.
+ * @param requestedModel - request identity stored in the assistant source; defaults to the native model.
+ * @param requestedProvider - DSH route stored in the assistant source; defaults to the native provider.
+ * @returns the versioned lossless-JSON replay projection.
+ */
+export declare function toPiReplayState(message: AssistantMessage, requestedModel?: string, requestedProvider?: string): ReplayEnvelope;
+/**
+ * Convert one durable Harness assistant message into pi-ai history.
+ *
+ * Durable content is the authoritative record; replay metadata only restores
+ * native fidelity (ids, signatures). A replay state this build cannot use —
+ * another adapter's kind, another version, a malformed value, or metadata that
+ * no longer matches the content — therefore degrades the one message to
+ * provider-neutral history instead of failing the request.
+ * @param message - assistant content with required source and optional adapter-owned replay metadata.
+ * @param onDegrade - called with the diagnostic reason when an unusable replay
+ *   state falls back to provider-neutral conversion.
+ * @returns a native pi-ai assistant message reconstructed from durable content.
+ */
+export declare function toPiAssistant(message: HistoryMessage, onDegrade?: (reason: string) => void): AssistantMessage;
+interface ImageProjectionPolicy {
+    maxImages?: number;
+    maxBytes?: number;
+    byteLength: (ref: ImageAttachmentRef) => number;
+    placeholder: (ref: ImageAttachmentRef) => string;
+    exact: boolean;
+}
+export declare function projectRequestImages(messages: readonly Message[], policy: ImageProjectionPolicy): readonly Message[];
+/** 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. */
+    attachments: AttachmentStore;
+    /** Resolve current tool access separately from deterministic request-image versions. */
+    resolveImageAccess: ImageAttachmentAccessResolver;
+    /** Maximum retained image occurrences across request history; omission leaves the count unlimited. */
+    maxImages?: number;
+    /** Request-level bound on the base64-encoded payload of retained images; omission leaves the bound unchecked. */
+    maxRequestImageBytes?: number;
+    /** Route pixel and raw encoded-byte budgets. */
+    requestImagePolicy?: PiImageRequestBudget;
+}
+/** Per-route budgets from which each request image's target is derived. */
+export interface PiImageRequestBudget {
+    /** Total-pixel budget; larger sources are downscaled proportionally. */
+    maxPixels: number;
+    /** Encoded-byte target for one request image. */
+    maxBytes: number;
+}
+/**
+ * Convert text-only harness history to a synchronous pi-ai Context. Tool
+ * result names are recovered from preceding assistant tool calls.
+ * @param options - the harness request; `options.system`, else a leading `system` message, maps to pi-ai's single `systemPrompt` slot.
+ * @param images - absent; selects the synchronous conversion.
+ * @param onReplayDegrade - forwarded to {@link toPiAssistant} for each assistant message.
+ * @returns the pi-ai context; `tools` is omitted when the request declares none.
+ * @throws {LlmError} `UNSUPPORTED_CONTENT` for a `developer` history message, a tool-change block, a deferred tool, or an image in any history role, including a leading system message.
+ */
+export declare function toPiContext(options: GenerateOptions, images?: undefined, onReplayDegrade?: (reason: string) => void): PiContext;
+/**
+ * Convert harness history to a pi-ai Context while resolving durable images.
+ * Tool result names are recovered from preceding assistant tool calls.
+ * Occurrences the surface marks offloaded become placeholders; when the
+ * retained occurrences exceed `maxImages` or their exact base64 payload exceeds
+ * `maxRequestImageBytes`, the call fails with `IMAGE_OFFLOAD_REQUIRED` naming
+ * how many more oldest occurrences must be offloaded.
+ * @param options - the harness request; `options.system`, else a leading `system` message, maps to pi-ai's single `systemPrompt` slot.
+ * @param images - attachment provider, current path resolver, and request limits.
+ * @param onReplayDegrade - forwarded to {@link toPiAssistant} for each assistant message.
+ * @returns the asynchronously resolved pi-ai context.
+ */
+export declare function toPiContext(options: GenerateOptions, images: PiImageRequestContext, onReplayDegrade?: (reason: string) => void): Promise<PiContext>;
+/**
+ * Map pi-ai usage (reasoning folded into output by pi-ai).
+ * @param usage - cumulative usage from the terminal pi-ai event.
+ * @returns harness counts with pi-ai's exact total; cache fields appear only
+ *   when non-zero (pi-ai reports zeros, not absence).
+ */
+export declare function mapUsage(usage: PiUsage): TokenUsage;
+/**
+ * Map a terminal pi-ai event to the harness finish reason.
+ * @param message - the assistant message carried by the `done` or `error` event.
+ * @param contextWindow - resolved catalog capacity for usage-based overflow detection.
+ * @param reservedMaxTokens - requested output allowance before SDK context clamping.
+ * @returns the mapped harness reason. Recognized error text, `stop` usage above
+ *   `contextWindow`, and zero-output `length` usage that fills the window map
+ *   to `CONTEXT_WINDOW_EXCEEDED`; a `stop` with no content blocks maps to an
+ *   `EMPTY_RESPONSE` error. Other empty `length` responses map to `INVALID_REQUEST`
+ *   with output-limit or compaction guidance. Terminal `pending` and `deferred`
+ *   states map to non-retryable `PI_AI_ERROR` failures.
+ */
+export declare function mapStopReason(message: AssistantMessage, contextWindow?: number, reservedMaxTokens?: number): FinishReason;
+/**
+ * Translate the pi-ai event stream into StreamChunks. pi-ai never throws
+ * mid-stream — failures arrive as `error` events, which become error/aborted
+ * `finish` chunks (the harness protocol's other error-delivery style).
+ * @param events - one assistant turn's pi-ai event stream.
+ * @param contextWindow - resolved catalog capacity for usage-based overflow detection.
+ * @param callerSignal - caller cancellation state; an aborted caller makes any
+ *   in-band terminal error an aborted finish.
+ * @param requestedModel - request model identity recorded for durable replay.
+ * @param requestedProvider - DSH provider identity recorded for durable replay.
+ * @param reservedMaxTokens - requested output allowance before SDK context clamping.
+ * @returns the harness chunks, ending with measured `usage` then `finish`;
+ *   failures with no measured tokens omit usage to preserve context pressure. Throws
+ *   `LlmError` (`STREAM_CLOSED`) if the source ends without a terminal event.
+ */
+export declare function toStreamChunks(events: AsyncIterable<AssistantMessageEvent>, contextWindow?: number, callerSignal?: AbortSignal, requestedModel?: string, requestedProvider?: string, reservedMaxTokens?: number): AsyncGenerator<StreamChunk>;
+export { DEFAULT_MAX_REQUEST_IMAGE_BYTES, DEFAULT_REQUEST_IMAGE_MAX_BYTES, DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET, } from './contracts.ts';

package/lib/types/index.d.ts

@@ -1,56 +1,24 @@
-/**
- * Dedicated OpenCode Go adapter plugin. Registers one `dsh-opencode-go` route
- * whose catalog follows the gateway's live model listing and models.dev
- * metadata, and installs the `llm-opencode-go` settings section: the Web UI
- * renders it as its own settings page where the API key and every knob are
- * edited, and a change reaches the next request without a restart. The plugin
- * exists because the gateway has wire requirements a generic pi-ai route
- * cannot express: a mandatory per-conversation `x-opencode-session` routing
- * header and a model list that rotates faster than any shipped catalog.
- *
- * DSH 0.1.5/0.1.6 layer the settings document over the composition entry;
- * 0.1.7 edits live configuration fields on the profile entry directly.
- *
- * ```yaml
- * - id: llm-opencode-go
- *   name: 'dsh-opencode-go'
- *   config:
- *     enabled: true                     # false withdraws the route; the plugin stays mounted
- *     apiKeyEnv: OPENCODE_API_KEY       # default
- *     baseURL: https://opencode.ai/inference/go/v1   # default
- *     refreshMinutes: 60                # live catalog re-resolution interval
- * ```
- *
- * The credential resolves per request through the credentials seam, falling
- * back to the process environment — the same reference semantics the generic
- * pi-ai adapter uses. The route registers atomically: if another adapter
- * mount already owns `dsh-opencode-go`,
- * the refusal is logged with the reason and everything else this plugin does
- * still works.
- *
- * @module dsh-opencode-go
- */
 import type { Context } from '@deepseek-ai/cordis';
-import type { LiveConfig, OpencodeGoConfig } from './config.ts';
+import { type LiveConfig, type OpencodeGoConfig } from './config.ts';
 declare module '@deepseek-ai/cordis' {
     interface Events {
         'loader/volatile-update'(paths: readonly (readonly string[])[]): void;
     }
 }
 export { OpencodeGoAdapter } from './adapter.ts';
-export type { OpencodeGoAdapterOptions, OpencodeGoImageAccess, GoAccountSettlement, GoCallTrace } from './adapter.ts';
+export type { OpencodeGoAdapterOptions, OpencodeGoImageAccess, GoAccountSettlement } 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';
+export { assertProxyURL } from './contracts.ts';
 export type { OpencodeGoConfig } from './config.ts';
 export declare const name = "llm-opencode-go";
 export declare const inject: string[];
 /** Settings namespace this plugin installs and the Web page edits. */
 export declare const NS = "llm-opencode-go";
 /**
- * Register the route, its discovery, the settings section, and their
- * teardown for one mount. Configuration starts as the cordis.yml entry and is
- * replaced by the settings section's resolved value once the settings
- * provider attaches; the adapter re-reads it at every operation.
+ * Register the route, model discovery and settings presentation for one mount.
+ * The adapter re-reads live profile fields at every operation.
  */
 export declare function apply(ctx: Context, raw?: OpencodeGoConfig | LiveConfig): void;
+/** Register once per plugin mount, after either registry activation order. */
+export declare function registerGoRemotes(ctx: Context): void;

package/lib/types/sdk-types.d.ts

@@ -1,7 +1,6 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { ResponseCreateParamsStreaming } from 'openai/resources/responses/responses.js';
 import OpenAI from 'openai';
-import { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
 
 interface TSchema {
 }
@@ -3093,63 +3092,15 @@ interface Provider<TApi extends Api = Api> {
     classify?(model: ClassifierModel<ClassifierApi>, context: ClassifierContext, options?: ClassifierOptions): Promise<ClassifierResult>;
 }
 
-/** Settings discovery includes lifecycle data that the host's generic model DTO omits. */
-
-interface GoModel {
-    id: string;
-    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. */
-    inputModalities?: readonly InputModality[];
-    /** Advertised by the gateway but lacking a usable protocol and capability configuration. */
-    configurationMissing?: boolean;
-}
-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.
- */
-declare const INPUT_MODALITIES: readonly ["text", "image", "audio", "video", "pdf"];
-type InputModality = typeof INPUT_MODALITIES[number];
-/** Last successful check of one catalog source, plus any current refresh failure. */
-interface GoCatalogSourceStatus {
-    readonly updatedAt?: number;
-    readonly error?: string;
-    readonly warning?: string;
-}
-/** A failed refresh retains the Host's usable data with an explicit diagnostic. */
-interface GoModelCatalog {
-    readonly models: readonly GoModel[];
-    readonly stale: boolean;
-    readonly error?: string;
-    /** Optional for clients reading an older Host response. Timestamps are Unix milliseconds. */
-    readonly sources?: {
-        readonly listing: GoCatalogSourceStatus;
-        readonly metadata: GoCatalogSourceStatus;
-    };
-}
-declare module '@deepseek-ai/dsh-typert-protocol' {
-    interface TypertRemoteNamespaceMap {
-        opencodeGoModels: {
-            read(): Promise<RemoteResult<GoModelCatalog>>;
-        };
-    }
-}
-
-/** Public SDK types are bundled at build time, alongside the private implementation. */
+/** Public SDK types bundled independently of the private runtime implementation. */
 
 /** User controls are independent of the SDK's internal level used to enable a switch. */
 type Model<TApi extends Api> = Model$1<TApi> & {
     reasoningControl?: 'toggle' | 'effort' | 'budget';
-    reasoningBudget?: ThinkingBudgetRange;
+    reasoningBudget?: {
+        min: number;
+        max: number;
+    };
     reasoningBudgetPresets?: readonly number[];
 };
 

package/lib/types/transport.d.ts

@@ -0,0 +1,63 @@
+/** 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>;
+/** Per-mount transport. Fetch closures retain their address across settings changes. */
+export declare class ProxyTransport {
+    private current;
+    private readonly retired;
+    private disposed;
+    forProxy(raw?: string): typeof globalThis.fetch | undefined;
+    /** Close replaced pools after their in-flight response bodies have finished. */
+    private retire;
+    /** Unloading the mount cancels remaining requests and releases every pool. */
+    dispose(): Promise<void>;
+}
+/** Describe transport failures without echoing credentials or upstream response text. */
+export declare function transportFailure(error: unknown): string;
+/** Keep the endpoint useful in diagnostics without user information or query secrets. */
+export declare function diagnosticURL(raw: string): string;
+/** The caller's signal covers both attempts, the retry delay, and all response reads. */
+export declare function fetchJsonResponse(url: string, init: RequestInit, maxBytes: number, encoding?: 'identity' | 'gzip', fetcher?: typeof globalThis.fetch, readError?: (response: Response) => Promise<unknown>): Promise<{
+    response: Response;
+    body: unknown;
+}>;
+/** Fetch normally decodes HTTP; only negotiated gzip may recover a raw gzip body (#7). */
+export declare function readJsonResponse(response: Response, maxBytes: number, options?: {
+    gzip?: boolean;
+    signal?: AbortSignal | null;
+}): Promise<unknown>;
+/** Gateway status codes cover several domains; a 401 alone cannot reject a key. */
+export declare function classifyGatewayError(status: number, body: string, fallback: string): string;
+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;
+        contextWindow?: number;
+        maxTokens?: number;
+    });
+    private redact;
+    readonly fetch: typeof globalThis.fetch;
+    failureCode(fallback: string): Promise<string>;
+    failureMessage(original: string): Promise<string>;
+}
+interface UsageErrorOptions {
+    apiKey: string;
+    baseURL: string;
+    proxyURL: string;
+    signal: AbortSignal;
+}
+/** Read only diagnostic text; a slow/broken error body cannot hide its HTTP status. */
+export declare function readUsageError(response: Response, options: UsageErrorOptions): Promise<string | undefined>;
+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;
+export {};