@dan-ai-studio/dshopencodego 0.1.5

package/lib/types/conversion/replay.js

@@ -0,0 +1,242 @@
+/**
+ * Durable pi-ai replay metadata and assistant-history reconstruction.
+ *
+ * Harness content is the durable source of truth for text and tool calls; this
+ * module stores only the provider-native metadata needed to rebuild a pi-ai
+ * assistant message on a later request (signatures, response ids, native
+ * thinking level). When that metadata is unusable — another adapter wrote it, a
+ * future version wrote it, or it no longer matches the content — the message
+ * degrades to provider-neutral history instead of failing the request.
+ *
+ * @module @dan-ai-studio/dshopencodego/conversion/replay
+ */
+import { LlmError } from '@deepseek-ai/dsh-llm';
+/** Tool arguments arrive as raw JSON strings; a malformed one becomes `{}`. */
+function parseArguments(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // Malformed arguments are the model's fault, not a reason to fail replay.
+    }
+    return {};
+}
+/** Historical pi-ai messages require a usage value; none of it is replayed. */
+function emptyPiUsage() {
+    return {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
+}
+/**
+ * Project a successful pi-ai response into the minimal durable replay state.
+ * @param message - the completed native response.
+ * @param requestedModel - request identity stored on the assistant source.
+ * @returns the versioned lossless-JSON envelope; `blocks` is index-aligned with
+ *   the streamed blocks, so assembly prunes an entry with its block.
+ */
+export function toPiReplayState(message, requestedModel = message.model) {
+    const responseModel = message.api === 'anthropic-messages' && message.model !== requestedModel
+        ? message.model
+        : message.responseModel;
+    const response = {
+        kind: 'pi-ai',
+        version: 2,
+        api: message.api,
+        provider: message.provider,
+        model: requestedModel,
+        ...responseModel === undefined ? {} : { responseModel },
+        ...message.responseId === undefined ? {} : { responseId: message.responseId },
+        ...message.providerThinkingLevel === undefined ? {} : { providerThinkingLevel: message.providerThinkingLevel },
+        stopReason: message.stopReason,
+    };
+    return {
+        response,
+        blocks: message.content.map((block) => {
+            switch (block.type) {
+                case 'text': return {
+                    type: 'text',
+                    ...block.textSignature === undefined ? {} : { textSignature: block.textSignature },
+                };
+                case 'thinking': return {
+                    type: 'reasoning',
+                    ...block.thinkingSignature === undefined ? {} : { thinkingSignature: block.thinkingSignature },
+                    ...block.redacted === undefined ? {} : { redacted: block.redacted },
+                };
+                case 'toolCall': return {
+                    type: 'tool-call',
+                    ...block.thoughtSignature === undefined ? {} : { thoughtSignature: block.thoughtSignature },
+                };
+            }
+        }),
+    };
+}
+function invalidReplay(message) {
+    throw new LlmError(`invalid pi-ai replay state: ${message}`, 'INVALID_REPLAY_STATE');
+}
+/** Validate a durable envelope before any of it reaches pi-ai. */
+function readReplayState(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return invalidReplay('expected a replay envelope');
+    const envelope = value;
+    const rawResponse = envelope['response'];
+    if (typeof rawResponse !== 'object' || rawResponse === null || Array.isArray(rawResponse)) {
+        return invalidReplay('expected a response object');
+    }
+    const response = rawResponse;
+    if (response['kind'] !== 'pi-ai')
+        return invalidReplay('unknown state kind');
+    if (response['version'] !== 2)
+        return invalidReplay(`unsupported version ${String(response['version'])}`);
+    for (const key of ['api', 'provider', 'model']) {
+        if (typeof response[key] !== 'string' || response[key].length === 0)
+            return invalidReplay(`${key} must be a non-empty string`);
+    }
+    if (!['stop', 'length', 'toolUse', 'error', 'aborted'].includes(String(response['stopReason']))) {
+        return invalidReplay('unknown stopReason');
+    }
+    for (const key of ['responseModel', 'responseId', 'providerThinkingLevel']) {
+        if (response[key] !== undefined && typeof response[key] !== 'string')
+            return invalidReplay(`${key} must be a string`);
+    }
+    const blocks = envelope['blocks'];
+    if (!Array.isArray(blocks))
+        return invalidReplay('blocks must be an array');
+    for (const [index, value] of blocks.entries()) {
+        if (typeof value !== 'object' || value === null || Array.isArray(value))
+            return invalidReplay(`block ${index} must be an object`);
+        const block = value;
+        if (!['text', 'reasoning', 'tool-call'].includes(String(block['type']))) {
+            return invalidReplay(`block ${index} has an unknown type`);
+        }
+        for (const signature of ['textSignature', 'thinkingSignature', 'thoughtSignature']) {
+            if (block[signature] !== undefined && typeof block[signature] !== 'string') {
+                return invalidReplay(`block ${index} ${signature} must be a string`);
+            }
+        }
+        if (block['redacted'] !== undefined && typeof block['redacted'] !== 'boolean') {
+            return invalidReplay(`block ${index} redacted must be boolean`);
+        }
+    }
+    return { response: response, blocks: blocks };
+}
+/** Convert provider-neutral blocks without claiming same-model fidelity. */
+function foreignAssistant(message) {
+    const source = message.source.kind === 'model' ? message.source : undefined;
+    const content = [];
+    for (const block of message.content) {
+        switch (block.type) {
+            case 'text':
+                content.push({ type: 'text', text: block.text });
+                break;
+            case 'reasoning':
+                content.push({ type: 'thinking', thinking: block.text });
+                break;
+            case 'tool-call':
+                content.push({
+                    type: 'toolCall', id: block.id, name: block.name, arguments: parseArguments(block.arguments),
+                });
+                break;
+            case 'image':
+                throw new LlmError('pi-ai chat history cannot represent structured assistant image output', 'UNSUPPORTED_CONTENT');
+            default:
+                // Plugin-added block types have no pi-ai representation.
+                break;
+        }
+    }
+    return {
+        role: 'assistant',
+        content,
+        // Deliberately never equals a catalog API: absent replay state is foreign
+        // even when the source names this same provider and model.
+        api: 'dsh-foreign',
+        provider: source?.provider ?? 'dsh-foreign',
+        model: source?.model ?? 'dsh-foreign',
+        usage: emptyPiUsage(),
+        stopReason: content.some(piece => piece.type === 'toolCall') ? 'toolUse' : 'stop',
+        timestamp: 0,
+    };
+}
+/** Recombine durable content with validated replay metadata. */
+function replayedAssistant(message, source, rawState) {
+    const state = readReplayState(rawState);
+    if (state.response.provider !== source.provider)
+        return invalidReplay('provider does not match assistant source');
+    if (state.response.model !== source.model)
+        return invalidReplay('model does not match assistant source');
+    if (state.blocks.length !== message.content.length)
+        return invalidReplay('block count does not match assistant content');
+    const content = message.content.map((block, index) => {
+        const replay = state.blocks[index];
+        if (replay === undefined || replay.type !== block.type)
+            return invalidReplay(`block ${index} does not match assistant content`);
+        switch (block.type) {
+            case 'text': return {
+                type: 'text',
+                text: block.text,
+                ...replay.type === 'text' && replay.textSignature !== undefined ? { textSignature: replay.textSignature } : {},
+            };
+            case 'reasoning': return {
+                type: 'thinking',
+                thinking: block.text,
+                ...replay.type === 'reasoning' && replay.thinkingSignature !== undefined
+                    ? { thinkingSignature: replay.thinkingSignature } : {},
+                ...replay.type === 'reasoning' && replay.redacted !== undefined ? { redacted: replay.redacted } : {},
+            };
+            case 'tool-call': return {
+                type: 'toolCall',
+                id: block.id,
+                name: block.name,
+                arguments: parseArguments(block.arguments),
+                ...replay.type === 'tool-call' && replay.thoughtSignature !== undefined
+                    ? { thoughtSignature: replay.thoughtSignature } : {},
+            };
+            default: return invalidReplay(`block ${index} has an unsupported Harness type`);
+        }
+    });
+    return {
+        role: 'assistant',
+        content,
+        api: state.response.api,
+        provider: state.response.provider,
+        // Anthropic reports aliases and fallbacks as `model`, unlike Completions'
+        // informational `responseModel`.
+        model: state.response.api === 'anthropic-messages'
+            ? state.response.responseModel ?? state.response.model
+            : state.response.model,
+        ...state.response.responseModel === undefined ? {} : { responseModel: state.response.responseModel },
+        ...state.response.responseId === undefined ? {} : { responseId: state.response.responseId },
+        ...state.response.providerThinkingLevel === undefined
+            ? {} : { providerThinkingLevel: state.response.providerThinkingLevel },
+        usage: emptyPiUsage(),
+        stopReason: state.response.stopReason,
+        timestamp: 0,
+    };
+}
+/**
+ * Convert one durable assistant message into pi-ai history.
+ * @param message - assistant content with its model source and optional replay metadata.
+ * @param onDegrade - called with the reason when unusable metadata falls back.
+ * @returns the native assistant message, or a provider-neutral reconstruction.
+ */
+export function toPiAssistant(message, onDegrade) {
+    const source = message.source;
+    if (source.kind !== 'model' || source.replayState === undefined)
+        return foreignAssistant(message);
+    try {
+        return replayedAssistant(message, source, source.replayState);
+    }
+    catch (error) {
+        if (!(error instanceof LlmError) || error.code !== 'INVALID_REPLAY_STATE')
+            throw error;
+        onDegrade?.(error.message);
+        return foreignAssistant(message);
+    }
+}

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

@@ -0,0 +1,46 @@
+/**
+ * pi-ai assistant events translated into the Harness streaming protocol.
+ *
+ * pi-ai hands back parsed tool-call arguments while the Harness keeps their raw
+ * JSON representation, and it reports failures as terminal stream events rather
+ * than throws. Both are normalized here, together with usage and stop reasons.
+ *
+ * @module @dan-ai-studio/dshopencodego/conversion/stream
+ */
+import type { FinishReason, StreamChunk, TokenUsage } from '@deepseek-ai/dsh-llm';
+import type { AssistantMessage, AssistantMessageEvent, Usage as PiUsage } from '@earendil-works/pi-ai';
+/**
+ * Map pi-ai usage (reasoning already folded into output).
+ * @param usage - the terminal event's cumulative usage.
+ * @returns Harness counts; cache fields appear only when non-zero, because
+ *   pi-ai reports zeros rather than absence.
+ */
+export declare function mapUsage(usage: PiUsage): TokenUsage;
+/**
+ * Classify a provider error string into a Harness error code.
+ *
+ * pi-ai flattens a caught transport error to its `message` before this point,
+ * so the actionable detail is only available as text. The patterns are ordered
+ * from most specific to least, and anything unrecognized stays `PI_AI_ERROR`
+ * rather than being guessed into a retryable class.
+ */
+export declare function classifyPiAiError(message: string): string;
+/**
+ * Map a terminal pi-ai message to the Harness finish reason.
+ * @param message - the assistant message carried by `done` or `error`.
+ * @param contextWindow - catalog capacity, for usage-based overflow detection.
+ * @returns the finish reason; a recognized overflow, a zero-content `stop`, and
+ *   the non-terminal `pending`/`deferred` states all become errors.
+ */
+export declare function mapStopReason(message: AssistantMessage, contextWindow?: number): FinishReason;
+/**
+ * Translate one assistant turn's pi-ai events into Harness chunks.
+ * @param events - the pi-ai event stream for this turn.
+ * @param contextWindow - catalog capacity, for usage-based overflow detection.
+ * @param callerSignal - caller cancellation; an aborted caller turns an in-band
+ *   terminal error into an aborted finish.
+ * @param requestedModel - request identity recorded in the replay envelope.
+ * @returns chunks ending in `usage` then `finish`.
+ * @throws {LlmError} `STREAM_CLOSED` when the source ends with no terminal event.
+ */
+export declare function toStreamChunks(events: AsyncIterable<AssistantMessageEvent>, contextWindow?: number, callerSignal?: AbortSignal, requestedModel?: string): AsyncGenerator<StreamChunk>;

package/lib/types/conversion/stream.js

@@ -0,0 +1,203 @@
+/**
+ * pi-ai assistant events translated into the Harness streaming protocol.
+ *
+ * pi-ai hands back parsed tool-call arguments while the Harness keeps their raw
+ * JSON representation, and it reports failures as terminal stream events rather
+ * than throws. Both are normalized here, together with usage and stop reasons.
+ *
+ * @module @dan-ai-studio/dshopencodego/conversion/stream
+ */
+import { brandString } from '@deepseek-ai/dsh-brand';
+import { CONTEXT_WINDOW_EXCEEDED_CODE, EMPTY_RESPONSE_CODE, isContextWindowExceededError, isQuotaExceededError, LlmError, QUOTA_EXCEEDED_CODE, } from '@deepseek-ai/dsh-llm';
+import { isContextOverflow } from '@earendil-works/pi-ai';
+import { toPiReplayState } from "./replay.js";
+/**
+ * Map pi-ai usage (reasoning already folded into output).
+ * @param usage - the terminal event's cumulative usage.
+ * @returns Harness counts; cache fields appear only when non-zero, because
+ *   pi-ai reports zeros rather than absence.
+ */
+export function mapUsage(usage) {
+    return {
+        inputTokens: usage.input,
+        outputTokens: usage.output,
+        totalTokens: usage.totalTokens,
+        ...usage.cacheRead > 0 ? { cacheReadTokens: usage.cacheRead } : {},
+        ...usage.cacheWrite > 0 ? { cacheWriteTokens: usage.cacheWrite } : {},
+    };
+}
+/**
+ * Classify a provider error string into a Harness error code.
+ *
+ * pi-ai flattens a caught transport error to its `message` before this point,
+ * so the actionable detail is only available as text. The patterns are ordered
+ * from most specific to least, and anything unrecognized stays `PI_AI_ERROR`
+ * rather than being guessed into a retryable class.
+ */
+export function classifyPiAiError(message) {
+    if (/\b(?:401|403)\b/.test(message))
+        return 'AUTH';
+    if (isQuotaExceededError(message))
+        return QUOTA_EXCEEDED_CODE;
+    if (/\b429\b|rate.?limit/i.test(message))
+        return 'RATE_LIMIT';
+    if (/\b413\b|payload too large|request body too large|length limit exceeded/i.test(message))
+        return 'INVALID_REQUEST';
+    if (/\b400\b|invalid.?request/i.test(message))
+        return 'INVALID_REQUEST';
+    if (/\b5\d\d\b/.test(message))
+        return 'SERVER';
+    if (/\btime(?:d)?\s*out\b|timeout/i.test(message))
+        return 'TIMEOUT';
+    if (/stream ended (?:before|without)\b/i.test(message))
+        return 'TRANSPORT';
+    if (/\b(?:network|connection|socket|fetch)\b|\bECONN[A-Z]+\b/i.test(message)
+        || /\b(?:other side closed|HTTP2 request did not get a response|WebSocket closed unexpectedly)\b/i.test(message)
+        || /\bterminated\b|premature close/i.test(message)) {
+        return 'TRANSPORT';
+    }
+    return 'PI_AI_ERROR';
+}
+/**
+ * Map a terminal pi-ai message to the Harness finish reason.
+ * @param message - the assistant message carried by `done` or `error`.
+ * @param contextWindow - catalog capacity, for usage-based overflow detection.
+ * @returns the finish reason; a recognized overflow, a zero-content `stop`, and
+ *   the non-terminal `pending`/`deferred` states all become errors.
+ */
+export function mapStopReason(message, contextWindow) {
+    const overflow = isContextOverflow(message, contextWindow)
+        || (message.stopReason === 'error'
+            && message.errorMessage !== undefined
+            && isContextWindowExceededError(message.errorMessage));
+    if (overflow) {
+        return {
+            kind: 'error',
+            failure: {
+                message: message.errorMessage ?? `pi-ai detected context overflow for model "${message.model}"`,
+                code: CONTEXT_WINDOW_EXCEEDED_CODE,
+            },
+        };
+    }
+    switch (message.stopReason) {
+        case 'stop':
+            if (message.content.length === 0) {
+                return {
+                    kind: 'error',
+                    failure: {
+                        message: `model "${message.model}" returned a completed response with no content`,
+                        code: EMPTY_RESPONSE_CODE,
+                    },
+                };
+            }
+            return { kind: 'stop' };
+        case 'length': return { kind: 'max-tokens' };
+        case 'toolUse': return { kind: 'tool-calls' };
+        case 'pending': return {
+            kind: 'error',
+            failure: { message: `pi-ai stream for model "${message.model}" ended pending`, code: 'PI_AI_ERROR' },
+        };
+        case 'deferred': return {
+            kind: 'error',
+            failure: { message: `pi-ai deferred response for model "${message.model}" is not supported`, code: 'PI_AI_ERROR' },
+        };
+        case 'aborted': return {
+            kind: 'aborted',
+            failure: { message: message.errorMessage ?? 'pi-ai stream aborted', code: 'ABORTED' },
+        };
+        case 'error': {
+            const text = message.errorMessage ?? 'pi-ai stream error';
+            return { kind: 'error', failure: { message: text, code: classifyPiAiError(text) } };
+        }
+    }
+}
+/**
+ * Translate one assistant turn's pi-ai events into Harness chunks.
+ * @param events - the pi-ai event stream for this turn.
+ * @param contextWindow - catalog capacity, for usage-based overflow detection.
+ * @param callerSignal - caller cancellation; an aborted caller turns an in-band
+ *   terminal error into an aborted finish.
+ * @param requestedModel - request identity recorded in the replay envelope.
+ * @returns chunks ending in `usage` then `finish`.
+ * @throws {LlmError} `STREAM_CLOSED` when the source ends with no terminal event.
+ */
+export async function* toStreamChunks(events, contextWindow, callerSignal, requestedModel) {
+    const toolCalls = new Map();
+    for await (const event of events) {
+        switch (event.type) {
+            case 'start':
+                break;
+            case 'text_start':
+                yield { type: 'block-start', index: event.contentIndex, blockType: 'text' };
+                break;
+            case 'text_delta':
+                yield { type: 'text-delta', index: event.contentIndex, text: event.delta };
+                break;
+            case 'text_end':
+                yield { type: 'block-end', index: event.contentIndex, block: { type: 'text', text: event.content } };
+                break;
+            case 'thinking_start':
+                yield { type: 'block-start', index: event.contentIndex, blockType: 'reasoning' };
+                break;
+            case 'thinking_delta':
+                yield { type: 'reasoning-delta', index: event.contentIndex, text: event.delta };
+                break;
+            case 'thinking_end':
+                yield { type: 'block-end', index: event.contentIndex, block: { type: 'reasoning', text: event.content } };
+                break;
+            case 'toolcall_start': {
+                // The id and name live on the partial message at this index.
+                const partial = event.partial.content[event.contentIndex];
+                toolCalls.set(event.contentIndex, {
+                    id: partial?.type === 'toolCall' ? partial.id : '',
+                    name: partial?.type === 'toolCall' ? partial.name : '',
+                });
+                yield { type: 'block-start', index: event.contentIndex, blockType: 'tool-call' };
+                break;
+            }
+            case 'toolcall_delta': {
+                const known = toolCalls.get(event.contentIndex);
+                yield {
+                    type: 'tool-call-delta',
+                    index: event.contentIndex,
+                    id: brandString(known?.id ?? ''),
+                    ...known !== undefined && known.name.length > 0 ? { name: known.name } : {},
+                    argumentsDelta: event.delta,
+                };
+                break;
+            }
+            case 'toolcall_end':
+                yield {
+                    type: 'block-end',
+                    index: event.contentIndex,
+                    block: {
+                        type: 'tool-call',
+                        id: brandString(event.toolCall.id),
+                        name: event.toolCall.name,
+                        // pi-ai parses the arguments; the Harness vocabulary keeps the raw
+                        // JSON string it stores and replays.
+                        arguments: JSON.stringify(event.toolCall.arguments),
+                    },
+                };
+                break;
+            case 'done':
+                yield { type: 'usage', usage: mapUsage(event.message.usage) };
+                yield {
+                    type: 'finish',
+                    reason: mapStopReason(event.message, contextWindow),
+                    replayState: toPiReplayState(event.message, requestedModel),
+                };
+                return;
+            case 'error':
+                // pi-ai delivers failures in-band; the Harness protocol's other
+                // sanctioned error path is an error/aborted finish chunk.
+                yield { type: 'usage', usage: mapUsage(event.error.usage) };
+                yield {
+                    type: 'finish',
+                    reason: mapStopReason(callerSignal?.aborted ? { ...event.error, stopReason: 'aborted' } : event.error, contextWindow),
+                };
+                return;
+        }
+    }
+    throw new LlmError('pi-ai event stream ended without a terminal event', 'STREAM_CLOSED');
+}

package/lib/types/go-limits.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Go's published per-model quota.
+ *
+ * No API exposes this — the gateway's `/v1/models` answers only ids, and
+ * `/usage` answers three account-wide percentages — so the numbers are
+ * transcribed from the provider's own documentation.
+ *
+ * Source: https://opencode.ai/docs/zh-cn/go — the 「使用限制」 and
+ * 「预估请求数」 tables. Transcribed 2026-09-25.
+ *
+ * Two caveats are part of the data's meaning, not noise:
+ * - `monthlyUsd` is the hard monthly allowance; the request counts are the
+ *   provider's own estimate for a typical request mix, not a hard ceiling.
+ * - DeepSeek V4.1 Flash carries a limited-time 4x allowance (until 2026-09-27)
+ *   already reflected here; the archived numbers follow the provider page.
+ *
+ * @module @dan-ai-studio/dshopencodego/go-limits
+ */
+/** One model's published Go allowance. */
+export interface GoQuota {
+    /** Monthly usage allowance in USD, or `unlimited` where none is published. */
+    readonly monthlyUsd: number | 'unlimited';
+    /** Provider's estimated requests per month for a typical mix, when listed. */
+    readonly monthlyRequests?: number | 'unlimited';
+}
+/** The transcribed table, keyed by model id. */
+export declare const GO_QUOTAS: Readonly<Record<string, GoQuota>>;
+/**
+ * The published quota for one model id.
+ * @param id - the gateway's model id.
+ * @returns the transcribed allowance, or undefined when the page lists none.
+ */
+export declare function goQuotaFor(id: string): GoQuota | undefined;
+/**
+ * Rank a quota for "most usable first" ordering: unlimited beats any finite
+ * request estimate, a larger estimate beats a smaller one, and a model the
+ * page does not quantify sorts last.
+ * @param quota - the allowance under comparison, when one exists.
+ * @returns a sortable rank.
+ */
+export declare function monthlyRequestsRank(quota: GoQuota | undefined): number;

package/lib/types/go-limits.js

@@ -0,0 +1,79 @@
+/**
+ * Go's published per-model quota.
+ *
+ * No API exposes this — the gateway's `/v1/models` answers only ids, and
+ * `/usage` answers three account-wide percentages — so the numbers are
+ * transcribed from the provider's own documentation.
+ *
+ * Source: https://opencode.ai/docs/zh-cn/go — the 「使用限制」 and
+ * 「预估请求数」 tables. Transcribed 2026-09-25.
+ *
+ * Two caveats are part of the data's meaning, not noise:
+ * - `monthlyUsd` is the hard monthly allowance; the request counts are the
+ *   provider's own estimate for a typical request mix, not a hard ceiling.
+ * - DeepSeek V4.1 Flash carries a limited-time 4x allowance (until 2026-09-27)
+ *   already reflected here; the archived numbers follow the provider page.
+ *
+ * @module @dan-ai-studio/dshopencodego/go-limits
+ */
+/** The transcribed table, keyed by model id. */
+export const GO_QUOTAS = {
+    'glm-5.3-flash': { monthlyUsd: 60, monthlyRequests: 31_580 },
+    'glm-5.3': { monthlyUsd: 15, monthlyRequests: 1_080 },
+    'glm-5.2': { monthlyUsd: 60, monthlyRequests: 4_300 },
+    'glm-5.1': { monthlyUsd: 60, monthlyRequests: 4_300 },
+    'kimi-k3': { monthlyUsd: 15, monthlyRequests: 490 },
+    'kimi-k2.7-code': { monthlyUsd: 60, monthlyRequests: 6_750 },
+    'kimi-k2.6': { monthlyUsd: 60, monthlyRequests: 5_750 },
+    'longcat-2.0': { monthlyUsd: 60, monthlyRequests: 57_200 },
+    'mimo-v2.6-flash': { monthlyUsd: 60, monthlyRequests: 150_400 },
+    'mimo-v2.6-pro': { monthlyUsd: 15, monthlyRequests: 16_300 },
+    'mimo-v2.5': { monthlyUsd: 60, monthlyRequests: 150_400 },
+    'mimo-v2.5-pro': { monthlyUsd: 15, monthlyRequests: 16_300 },
+    'minimax-m3': { monthlyUsd: 60, monthlyRequests: 16_000 },
+    'minimax-m2.7': { monthlyUsd: 60, monthlyRequests: 17_000 },
+    'minimax-m2.5': { monthlyUsd: 60 },
+    'muse-spark-1.3-contributor': { monthlyUsd: 60, monthlyRequests: 226_600 },
+    'muse-spark-1.2-contributor': { monthlyUsd: 60, monthlyRequests: 226_600 },
+    'qwen3.8-max': { monthlyUsd: 15, monthlyRequests: 810 },
+    'qwen3.8-flash': { monthlyUsd: 30, monthlyRequests: 27_000 },
+    'qwen3.7-max': { monthlyUsd: 30, monthlyRequests: 840 },
+    'qwen3.7-plus': { monthlyUsd: 60, monthlyRequests: 21_600 },
+    'qwen3.6-plus': { monthlyUsd: 60, monthlyRequests: 16_300 },
+    'deepseek-v4.1-flash': { monthlyUsd: 60, monthlyRequests: 130_000 },
+    'deepseek-v4-pro': { monthlyUsd: 15, monthlyRequests: 5_200 },
+    'deepseek-v4-flash': { monthlyUsd: 30, monthlyRequests: 65_000 },
+    'deepseek-v4-flash-vision-exp': { monthlyUsd: 15, monthlyRequests: 32_500 },
+    'hy4-preview': { monthlyUsd: 30, monthlyRequests: 6_770 },
+    'hy3': { monthlyUsd: 60, monthlyRequests: 21_500 },
+    'space-bunny-free': { monthlyUsd: 'unlimited', monthlyRequests: 'unlimited' },
+    'grok-4.7': { monthlyUsd: 15, monthlyRequests: 845 },
+    'grok-4.6': { monthlyUsd: 15, monthlyRequests: 845 },
+    'gpt-6-luna': { monthlyUsd: 15, monthlyRequests: 21_130 },
+    'gpt-5.6-luna': { monthlyUsd: 15, monthlyRequests: 10_250 },
+};
+/**
+ * The published quota for one model id.
+ * @param id - the gateway's model id.
+ * @returns the transcribed allowance, or undefined when the page lists none.
+ */
+export function goQuotaFor(id) {
+    return Object.hasOwn(GO_QUOTAS, id) ? GO_QUOTAS[id] : undefined;
+}
+/**
+ * Rank a quota for "most usable first" ordering: unlimited beats any finite
+ * request estimate, a larger estimate beats a smaller one, and a model the
+ * page does not quantify sorts last.
+ * @param quota - the allowance under comparison, when one exists.
+ * @returns a sortable rank.
+ */
+export function monthlyRequestsRank(quota) {
+    if (quota === undefined)
+        return -1;
+    const requests = quota.monthlyRequests;
+    if (requests === 'unlimited')
+        return Number.MAX_SAFE_INTEGER;
+    if (requests === undefined)
+        return quota.monthlyUsd === 'unlimited' ? Number.MAX_SAFE_INTEGER : -1;
+    return requests;
+}

package/lib/types/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The `dshopencodego` plugin: one `opencode-go` route with a live catalog and
+ * the gateway's mandatory session header.
+ *
+ * The plugin exists because a generic pi-ai route cannot express two things the
+ * OpenCode Go gateway needs: a model list that rotates faster than any shipped
+ * catalog, and a per-conversation `x-opencode-session` routing header on every
+ * inference request.
+ *
+ * Route registration is gated on both configuration and credential: a route
+ * whose key is missing would otherwise sit in every model picker and read as a
+ * usable provider to first-run onboarding. The gate re-evaluates on every
+ * credential write and every loader update, and a route another adapter already
+ * owns is reported rather than crashing the mount.
+ *
+ * ```yaml
+ * - id: dshopencodego
+ *   name: '@dan-ai-studio/dshopencodego'
+ *   config:
+ *     enabled: true                             # false withdraws the route only
+ *     apiKeyEnv: OPENCODE_GO_API_KEY             # default
+ *     baseURL: https://opencode.ai/zen/go/v1     # default
+ *     refreshMinutes: 60                         # live catalog TTL
+ *     modelProtocols:                            # last-resort protocol override
+ *       some-model: openai-responses
+ * ```
+ *
+ * @module @dan-ai-studio/dshopencodego
+ */
+import type { Context } from '@deepseek-ai/cordis';
+declare module '@deepseek-ai/cordis' {
+    interface Events {
+        'loader/volatile-update'(paths: readonly (readonly string[])[]): void;
+    }
+}
+export { OpencodeGoAdapter } from './adapter.ts';
+export type { OpencodeGoAdapterOptions, OpencodeGoImageAccess } from './adapter.ts';
+export { DEFAULT_BASE_URL, DISPLAY_NAME, PROVIDER_ID, OpencodeGoCatalog, discoverCatalogModels } from './catalog/index.ts';
+export { Config, PlainConfig, assertBaseURL, DEFAULT_API_KEY_ENV } from './config.ts';
+export type { OpencodeGoConfig } from './config.ts';
+export { SESSION_HEADER, opencodeSessionValue, providerHeaders } from './session-header.ts';
+export { isModelEnabled, sortModels } from './models.ts';
+export type { ModelSummary } from './models.ts';
+export declare const name = "dshopencodego";
+export declare const inject: string[];
+/**
+ * Register the route, its discovery, and their teardown for one mount.
+ *
+ * Configuration is read through a live source so a profile edit reaches the
+ * next request without a restart; the adapter re-reads it at every operation.
+ * @param ctx - the plugin's Cordis context.
+ * @param raw - the loader's live config, or a plain object in tests.
+ */
+export declare function apply(ctx: Context, raw?: unknown): void;