dsh-opencode-go 0.1.24 → 0.2.1

package/lib/types/contracts.d.ts

@@ -0,0 +1,338 @@
+/** Browser-safe configuration, account metadata and RPC wire contracts. */
+import type { RemoteResult, TypertRemoteContribution } from '@deepseek-ai/dsh-typert-protocol';
+/** 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 FREE_PROVIDER_ID = "dsh-opencode-free";
+export declare const FREE_DISPLAY_NAME = "DSH OpenCode Free";
+export type ModelSource = 'go' | 'free';
+/** Go keeps its legacy keys; Free owns a separate settings namespace. */
+export declare function modelSettingsKey(model: {
+    id: string;
+    source?: ModelSource;
+}): string;
+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";
+export declare const DEFAULT_FREE_BASE_URL = "https://opencode.ai/inference/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;
+export declare const USAGE_PILL_STYLES: readonly ["badge", "plain"];
+export type UsagePillStyle = typeof USAGE_PILL_STYLES[number];
+export declare const DEFAULT_USAGE_PILL_STYLE: UsagePillStyle;
+/** 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 plugin serves Go and Free. False withdraws both routes and
+     * their models without unloading the settings page. Go additionally requires
+     * a usable configured key; Free supports public access.
+     */
+    enabled: boolean;
+    /** Usage pill visibility; auto follows only the selected Go route. */
+    usageDisplay: UsageDisplayMode;
+    /** Show quota in the sidebar independently of the selected conversation model. */
+    showSidebarQuota: boolean;
+    /** Appearance of the conversation input's quota trigger. */
+    usagePillStyle: UsagePillStyle;
+    /** Per-model picker switches; absent entries default to enabled unless deprecated. */
+    modelVisibility?: Record<string, boolean>;
+    /** 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;
+    /** Platform discovery base; only explicitly free chat models are served. */
+    freeBaseURL: 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>;
+export interface GoModel {
+    id: string;
+    source?: ModelSource;
+    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 the gateway 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; MIME types are normalized to these tokens.
+ */
+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 gateway declaration or 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 go: GoCatalogSourceStatus;
+        readonly free: GoCatalogSourceStatus;
+    };
+}
+/** Missing configuration cannot be enabled; configured models follow explicit switches or lifecycle defaults. */
+export declare function isModelEnabled(model: Pick<GoModel, 'id' | 'source' | '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 AnalyticsRange = 'today' | '7d' | '30d' | '90d';
+export interface AnalyticsQuery {
+    accountRef: string;
+    range: AnalyticsRange;
+    refresh?: boolean;
+}
+/** Exact nonnegative integers on the wire; one USD is 100,000,000 micro cents. */
+export interface AnalyticsTotals {
+    requests: string;
+    inputTokens: string;
+    outputTokens: string;
+    cacheReadTokens: string;
+    cacheWrite5mTokens: string;
+    cacheWrite1hTokens: string;
+    cacheWriteTokens: string;
+    tokens: string;
+    costMicroCents: string;
+}
+export interface AnalyticsModelRow extends AnalyticsTotals {
+    provider: string;
+    model: string;
+}
+export interface AnalyticsDayRow extends AnalyticsTotals {
+    day: string;
+}
+export interface AnalyticsReport {
+    accountRef: string;
+    /** Opaque account, credential and network identity; contains no credential material. */
+    source: string;
+    generatedAt: number;
+    period: AnalyticsRange;
+    range: {
+        from: number;
+        to: number;
+    };
+    timeZone: 'UTC';
+    totals: AnalyticsTotals;
+    byModel: AnalyticsModelRow[];
+    byDay: AnalyticsDayRow[];
+}
+export interface AnalyticsExport {
+    filename: string;
+    csv: string;
+}
+export type AnalyticsFailureReason = 'invalid-query' | 'unknown-account' | 'missing-credential' | 'credential-unavailable' | 'unsupported-gateway' | 'invalid-proxy' | 'permission-denied' | 'upstream' | 'network' | 'timeout' | 'invalid-response';
+/**
+ * Validate one account-scoped official history query.
+ * @param value - raw RPC argument.
+ * @returns the validated query.
+ */
+export declare function parseAnalyticsQuery(value: unknown): AnalyticsQuery;
+/** Keep the browser wire response limited to validated aggregate fields. */
+export declare function parseAnalyticsReport(value: unknown): AnalyticsReport;
+export declare function parseAnalyticsExport(value: unknown): AnalyticsExport;
+declare module '@deepseek-ai/dsh-typert-protocol' {
+    interface RemoteErrorDetailsMap {
+        'opencode-go/analytics-unavailable': {
+            readonly reason: AnalyticsFailureReason;
+            readonly retryable: boolean;
+            readonly retainPrevious?: boolean;
+            readonly source?: string;
+        };
+    }
+    interface TypertRemoteNamespaceMap {
+        opencodeGoAnalytics: {
+            read(query: AnalyticsQuery, signal?: AbortSignal): Promise<RemoteResult<AnalyticsReport>>;
+            exportCsv(query: AnalyticsQuery, signal?: AbortSignal): Promise<RemoteResult<AnalyticsExport>>;
+        };
+    }
+}
+/** 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,155 @@
+/** 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'];
+    /** Measured context footprint for the next turn's SDK output-token clamp. */
+    usage?: Pick<PiUsage, 'input' | 'output' | 'cacheRead' | 'cacheWrite' | 'totalTokens'>;
+    /** Fingerprint of the request prefix and this reply that the usage measured. */
+    usageContext?: string;
+}
+/** Capture one converted request before the SDK can mutate it while streaming. */
+export declare function piContextUsageKey(context: PiContext, provider: string, model: string): string;
+/**
+ * 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.
+ * @param usageContext - fingerprint of the request that produced this response.
+ * @returns the versioned lossless-JSON replay projection.
+ */
+export declare function toPiReplayState(message: AssistantMessage, requestedModel?: string, requestedProvider?: string, usageContext?: 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.
+ * @param usageContext - fingerprint of the request whose usage may budget a later turn.
+ * @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, usageContext?: string): AsyncGenerator<StreamChunk>;
+export { DEFAULT_MAX_REQUEST_IMAGE_BYTES, DEFAULT_REQUEST_IMAGE_MAX_BYTES, DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET, } from './contracts.ts';

package/lib/types/free-channel.d.ts

@@ -0,0 +1,21 @@
+import type { OpencodeGoConfig } from './contracts.ts';
+type Network = Pick<OpencodeGoConfig, 'freeBaseURL' | 'proxyURL'>;
+export interface FreeAttemptTicket {
+    key: string;
+    sequence: number;
+}
+export interface FreeAttemptResult {
+    outcome: 'success' | 'error' | 'aborted';
+    code?: string;
+    retryAt?: number;
+}
+export declare class FreeChannelState {
+    private readonly entries;
+    private sequence;
+    private key;
+    cooldownUntil(config: Network): number | undefined;
+    assertReady(config: Network): void;
+    begin(config: Network): FreeAttemptTicket;
+    finish(ticket: FreeAttemptTicket, result: FreeAttemptResult): void;
+}
+export {};

package/lib/types/free-http-worker.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+/** Free-specific error semantics; Go account classification remains unchanged. */
+export declare function classifyFreeGatewayError(status: number, body: string): string | undefined;
+/** Parse delta-seconds or HTTP-date, accounting for a server clock when supplied. */
+export declare function retryAfterDeadline(value: string | null, now?: number, serverDate?: string | null): number | undefined;

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

@@ -0,0 +1,16 @@
+/** Private stdin/stdout protocol; request credentials never enter argv or files. */
+export interface FreeHttpRequest {
+    url: string;
+    method: string;
+    headers: [string, string][];
+    body?: string;
+    redirect: RequestRedirect;
+    proxy?: string;
+}
+export interface FreeHttpResponse {
+    status: number;
+    statusText: string;
+    headers: [string, string][];
+    url: string;
+    redirected: boolean;
+}

package/lib/types/free-runtime.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveFreeRuntime(): string;
+export declare function freeWorkerPath(): string;

package/lib/types/free-socks-tunnel.d.ts

@@ -0,0 +1,4 @@
+export declare function openSocksTunnel(raw: string, signal: AbortSignal): Promise<{
+    url: string;
+    close(): Promise<void>;
+}>;

package/lib/types/free-transport.d.ts

@@ -0,0 +1,19 @@
+export declare const OPENCODE_FREE_USER_AGENT = "opencode/latest/2.2.5/cli";
+export declare class FreeBunTransport {
+    private readonly options;
+    private readonly shutdown;
+    private readonly workers;
+    private readonly requests;
+    private readonly waiters;
+    private active;
+    constructor(options?: {
+        executable?: () => string;
+        workerPath?: () => string;
+        maxConcurrent?: number;
+    });
+    forProxy(raw?: string): typeof globalThis.fetch;
+    private acquire;
+    private fetchRequest;
+    private response;
+    dispose(): Promise<void>;
+}

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 { DEFAULT_BASE_URL, DISPLAY_NAME, PROVIDER_ID, OpencodeGoCatalog, discoverCatalogModels, readLiveModelIds, } from './catalog.ts';
+export type { OpencodeGoAdapterOptions, OpencodeGoImageAccess, GoAccountSettlement } from './adapter.ts';
+export { DEFAULT_BASE_URL, DEFAULT_FREE_BASE_URL, DISPLAY_NAME, PROVIDER_ID, FREE_DISPLAY_NAME, FREE_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/pricing.d.ts

@@ -0,0 +1,29 @@
+/** Strict gateway tariff validation for model discovery and Free eligibility. */
+import type { ModelCost } from './sdk-types.ts';
+type Comparison<T> = {
+    in?: T[];
+    eq?: T;
+    gt?: T;
+    gte?: T;
+    lt?: T;
+    lte?: T;
+};
+export interface PricingCondition {
+    all?: PricingCondition[];
+    any?: PricingCondition[];
+    utc_days?: Comparison<string>;
+    utc_hours?: Comparison<string>;
+    date?: Comparison<string>;
+}
+export interface PriceMultiplier {
+    when: PricingCondition;
+    factor: number;
+}
+export interface ParsedCost {
+    cost: ModelCost;
+    multipliers?: PriceMultiplier[];
+    free: boolean;
+}
+/** Missing base prices or malformed optional components invalidate the entire tariff. */
+export declare function readModelCost(value: unknown): ParsedCost | undefined;
+export {};