@dan-ai-studio/dshopencodego 0.1.43 → 0.1.45

package/lib/types/catalog/go-doc.js

@@ -1,192 +0,0 @@
-/**
- * The provider's own Go documentation as a data source.
- *
- * No API exposes the per-model allowances: the gateway's `/models` answers ids,
- * and `/usage` answers account-wide percentages. The numbers live on a docs page
- * whose source is a markdown file in the provider's repository, so this module
- * fetches that file and parses its tables — allowances (with the provider's own
- * request estimates) and the endpoint table that names each model's protocol.
- *
- * The document is the primary source. The transcribed table in `go-limits.ts`
- * stays behind it as a startup seed and a permanent fallback for the day the
- * URL moves, and its age is surfaced wherever it is used.
- *
- * @module @dan-ai-studio/dshopencodego/catalog/go-doc
- */
-import { attributionHeaders, LlmError } from '@deepseek-ai/dsh-llm';
-import { METADATA_FETCH_TIMEOUT_MS } from './constants.js';
-import { readBoundedText } from './json-response.js';
-/**
- * Documentation sources, tried in order.
- *
- * The repository file is the source of truth; the jsDelivr entry caches the
- * same path and is tried when GitHub itself is unreachable.
- */
-export const GO_DOC_URLS = [
-    'https://raw.githubusercontent.com/anomalyco/opencode/dev/packages/web/src/content/docs/go.mdx',
-    'https://cdn.jsdelivr.net/gh/anomalyco/opencode@dev/packages/web/src/content/docs/go.mdx',
-];
-/** The document is about 30 KB; the cap leaves room without inviting a flood. */
-const GO_DOC_MAX_BYTES = 1024 * 1024;
-/** The protocol each documented endpoint path names. */
-const ENDPOINT_PROTOCOLS = {
-    '/chat/completions': 'openai-completions',
-    '/messages': 'anthropic-messages',
-    '/responses': 'openai-responses',
-};
-/** Strip markdown decoration (`**bold**`, `` `code` ``) from one cell. */
-function cell(value) {
-    return (value ?? '').replace(/[*`]/g, '').trim();
-}
-/**
- * A display name without its tier suffix, so the three tables join.
- * `Qwen3.7 Plus (≤ 256K tokens)` and `DeepSeek V4 Pro (Peak)` both reduce to the
- * name the endpoint table carries.
- */
-function baseName(name) {
-    return name.replace(/\s*\(.*\)\s*$/, '').trim();
-}
-/** `$60` → 60; `Unlimited 限时` → `unlimited`; anything else → undefined. */
-function parseAllowance(value) {
-    if (/^unlimited\b/i.test(value) || value.startsWith('无限制'))
-        return 'unlimited';
-    const match = value.match(/\$([\d,]+(?:\.\d+)?)/);
-    if (match?.[1] === undefined)
-        return undefined;
-    const amount = Number(match[1].replace(/,/g, ''));
-    return Number.isFinite(amount) ? amount : undefined;
-}
-/** `6,320` → 6320; `Unlimited` → `unlimited`; anything else → undefined. */
-function parseCount(value) {
-    if (/^unlimited\b/i.test(value) || value.startsWith('无限制'))
-        return 'unlimited';
-    const amount = Number(value.replace(/,/g, ''));
-    return value.length > 0 && Number.isFinite(amount) ? amount : undefined;
-}
-/**
- * The protocol a documented endpoint names.
- *
- * Matched by path suffix: the table spells full URLs, and every supported API
- * lives at a distinct tail (`/chat/completions`, `/messages`, `/responses`).
- */
-function protocolOfEndpoint(endpoint) {
-    for (const [suffix, protocol] of Object.entries(ENDPOINT_PROTOCOLS)) {
-        if (endpoint.endsWith(suffix))
-            return protocol;
-    }
-    return undefined;
-}
-/**
- * The data rows of the table whose header carries `required`.
- *
- * Data starts after the header and its separator, and ends at the first line
- * that is not a table row, so three tables in one document stay apart.
- * @param lines - the document, split into lines.
- * @param required - a header cell that table alone carries.
- * @returns one array of trimmed cells per data row.
- */
-function tableRows(lines, required) {
-    const start = lines.findIndex(line => line.startsWith('|') && line.includes(required));
-    if (start < 0)
-        return [];
-    const rows = [];
-    for (let index = start + 2; index < lines.length; index++) {
-        const line = lines[index] ?? '';
-        if (!line.startsWith('|'))
-            break;
-        rows.push(line.split('|').slice(1, -1).map(entry => entry.trim()));
-    }
-    return rows;
-}
-/**
- * Parse the Go documentation into the two data sets this plugin consumes.
- *
- * Titles are the join key: the allowance tables name models the way the page
- * presents them while the endpoint table carries the ids, so ids come from the
- * endpoint table and the other two attach by normalised display name. A row
- * that names no known model, or states no usable number, is skipped rather than
- * guessed; a tiered model whose rows disagree is dropped entirely.
- * @param markdown - the raw document text.
- * @returns the parsed allowances and protocols; both may be empty when the
- *   document does not carry the expected tables.
- */
-export function parseGoDocument(markdown) {
-    const lines = markdown.split('\n');
-    const ids = new Map();
-    const protocols = new Map();
-    for (const row of tableRows(lines, 'Model ID')) {
-        const name = cell(row[0]);
-        const id = cell(row[1]);
-        if (name.length === 0 || id.length === 0)
-            continue;
-        ids.set(name, id);
-        const protocol = protocolOfEndpoint(cell(row[2]));
-        if (protocol !== undefined)
-            protocols.set(id, protocol);
-    }
-    const quotas = new Map();
-    for (const row of tableRows(lines, 'Monthly limit')) {
-        const id = ids.get(baseName(cell(row[0])));
-        if (id === undefined)
-            continue;
-        const monthlyUsd = parseAllowance(cell(row[5]));
-        if (monthlyUsd === undefined)
-            continue;
-        const previous = quotas.get(id);
-        // Tiered rows (token bands, peak/off-peak) repeat one allowance; the first
-        // row wins, and a disagreement drops the model instead of picking a band.
-        if (previous === undefined)
-            quotas.set(id, { monthlyUsd });
-        else if (previous.monthlyUsd !== monthlyUsd)
-            quotas.delete(id);
-    }
-    for (const row of tableRows(lines, 'requests per month')) {
-        const id = ids.get(baseName(cell(row[0])));
-        if (id === undefined)
-            continue;
-        const monthlyRequests = parseCount(cell(row[3]));
-        const quota = quotas.get(id);
-        if (monthlyRequests === undefined || quota === undefined)
-            continue;
-        quotas.set(id, { ...quota, monthlyRequests });
-    }
-    return { quotas, protocols };
-}
-/**
- * Fetch and parse the documentation, trying each source in turn.
- *
- * A source that answers without a usable allowance table counts as a failure,
- * not as an empty document: that is what a moved or restructured page looks
- * like, and the caller must keep its previous data rather than blank the page.
- * @param signal - caller cancellation, if any.
- * @returns the parsed document from the first source that carried one.
- * @throws {LlmError} `DOCUMENT_UNAVAILABLE` when every source failed.
- */
-export async function fetchGoDocument(signal) {
-    const failures = [];
-    for (const url of GO_DOC_URLS) {
-        try {
-            const timeout = AbortSignal.timeout(METADATA_FETCH_TIMEOUT_MS);
-            const response = await fetch(url, {
-                redirect: 'error',
-                headers: { ...attributionHeaders(), accept: 'text/plain', 'cache-control': 'no-cache' },
-                signal: signal === undefined ? timeout : AbortSignal.any([signal, timeout]),
-            });
-            if (!response.ok) {
-                await response.body?.cancel().catch(() => { });
-                failures.push(`${url} answered HTTP ${response.status}`);
-                continue;
-            }
-            const document = parseGoDocument(await readBoundedText(response, GO_DOC_MAX_BYTES));
-            if (document.quotas.size === 0) {
-                failures.push(`${url} carried no allowance table`);
-                continue;
-            }
-            return document;
-        }
-        catch (error) {
-            failures.push(`${url}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    throw new LlmError(`could not read the Go documentation (${failures.join('; ')})`, 'DOCUMENT_UNAVAILABLE');
-}

package/lib/types/catalog/index.js

@@ -1,377 +0,0 @@
-/**
- * The live catalog: which models exist, and how to call each one.
- *
- * Membership comes from the gateway listing, capability from models.dev, and
- * exact protocol/wire quirks from the installed pi-ai catalog, merged through
- * the ladder in `./protocol.ts`. Per-model allowances, and a protocol for the
- * models nothing else covers, come from the provider's own documentation (see
- * `./go-doc.ts`). The snapshot is cached for the configured refresh interval,
- * and an unknown model id forces one revalidation even inside that interval —
- * that is what makes a model the gateway added this morning callable this
- * afternoon without a plugin release.
- *
- * Failures degrade rather than empty: a listing outage keeps the last known
- * models and marks the snapshot not-live, a metadata outage keeps the last
- * document, a documentation outage keeps the last parsed allowances (or leaves
- * the page on its frozen seed), and a single unparseable model is reported by
- * id while every other model keeps serving.
- *
- * @module @dan-ai-studio/dshopencodego/catalog
- */
-// Subpath imports on purpose. The package root re-exports `./api/lazy.js` (every
-// provider's wire implementation) and `providers/all.js` loads every provider's
-// model data — 991 KB under `providers/data` alone. This plugin mounts three
-// APIs for one provider, so each symbol is taken from the narrowest public entry
-// that exports it. Types still come from the root: they vanish at build time.
-import { createProvider } from '@earendil-works/pi-ai/models';
-import { OPENCODE_GO_MODELS } from '@earendil-works/pi-ai/providers/opencode-go.models';
-import { anthropicMessagesApi } from '@earendil-works/pi-ai/api/anthropic-messages.lazy';
-import { openAICompletionsApi } from '@earendil-works/pi-ai/api/openai-completions.lazy';
-import { openAIResponsesApi } from '@earendil-works/pi-ai/api/openai-responses.lazy';
-import { attributionHeaders, LlmError } from '@deepseek-ai/dsh-llm';
-import { DISPLAY_NAME, MODEL_METADATA_MAX_BYTES, MODEL_METADATA_URL, PROVIDER_ID, METADATA_FETCH_TIMEOUT_MS, } from './constants.js';
-import { fetchModelIds } from './gateway.js';
-import { fetchGoDocument, GO_DOC_URLS } from './go-doc.js';
-import { readBoundedJson } from './json-response.js';
-import { readOnlineMetadata, toPiModel } from './metadata.js';
-import { asWireProtocol } from './protocol.js';
-export { PROVIDER_ID, DISPLAY_NAME, DEFAULT_BASE_URL, CONSOLE_BASE_URL } from './constants.js';
-export { readModelIds, fetchModelIds } from './gateway.js';
-export { readOnlineMetadata, toPiModel, modelBaseURL } from './metadata.js';
-export { decideProtocol, inferProtocol, protocolOfNpm } from './protocol.js';
-/**
- * The installed catalog, re-pointed at the configured gateway.
- *
- * These entries are the first rung of the ladder and the outage fallback: their
- * `compat` is what keeps DeepSeek-family reasoning replay correct.
- */
-function builtinModels(baseURL) {
-    // `OPENCODE_GO_MODELS` is the same table `getBuiltinModels('opencode-go')`
-    // reads — verified entry for entry — reached without loading the aggregate
-    // `models.generated.js` that carries every provider.
-    return new Map(Object.values(OPENCODE_GO_MODELS).map(model => [model.id, {
-            ...model,
-            provider: PROVIDER_ID,
-            baseUrl: modelBaseURLFor(model.api, baseURL),
-        }]));
-}
-function modelBaseURLFor(api, baseURL) {
-    const base = baseURL.replace(/\/+$/, '');
-    return api === 'anthropic-messages' ? base.replace(/\/v1$/, '') : base;
-}
-/** The adapter resolves and passes the credential for every request. */
-function harnessApiKeyAuth() {
-    return {
-        apiKey: {
-            name: 'OpenCode Go API key',
-            resolve: () => Promise.resolve({ auth: {}, source: 'OpenCode Go API key' }),
-        },
-    };
-}
-/**
- * The installed catalog's protocol, when this plugin cannot serve it.
- *
- * `Model<Api>['api']` is pi-ai's wider union; this plugin mounts exactly the
- * three in `WIRE_PROTOCOLS`. The check exists because the catalog is wider
- * than the plugin and grows on its own release cadence.
- * @param api - the raw `api` string the installed catalog states.
- * @returns the unusable protocol, or undefined when there is nothing to refuse.
- */
-function unsupportedBuiltinApi(api) {
-    return api === undefined || asWireProtocol(api) !== undefined ? undefined : api;
-}
-function buildProvider(baseURL, models) {
-    return createProvider({
-        id: PROVIDER_ID,
-        name: DISPLAY_NAME,
-        baseUrl: baseURL,
-        auth: harnessApiKeyAuth(),
-        models: [...models],
-        api: {
-            'anthropic-messages': anthropicMessagesApi(),
-            'openai-completions': openAICompletionsApi(),
-            'openai-responses': openAIResponsesApi(),
-        },
-    });
-}
-/**
- * One gateway's catalog. Requests reuse a cached snapshot; explicit discovery
- * and unknown ids revalidate it.
- */
-export class OpencodeGoCatalog {
-    options;
-    served;
-    pending;
-    metadataDocument;
-    metadataETag;
-    lastMetadata;
-    /** The last parsed documentation; retained across failed fetches. */
-    document;
-    constructor(options) {
-        this.options = options;
-    }
-    /** The cached snapshot, refreshed when it is older than the configured TTL. */
-    snapshot(force = false) {
-        if (!force && this.served !== undefined && Date.now() - this.served.fetchedAtMs < this.options.refreshMs) {
-            return Promise.resolve(this.served);
-        }
-        this.pending ??= this.build()
-            .then((snapshot) => {
-            this.served = snapshot;
-            return snapshot;
-        })
-            .finally(() => { this.pending = undefined; });
-        return this.pending;
-    }
-    /**
-     * The snapshot that can serve one exact model.
-     *
-     * A model this build has never seen forces one revalidation even inside the
-     * TTL, because "unknown" and "newly added" look identical from here.
-     * @param id - the requested model id.
-     * @returns the snapshot holding the model.
-     * @throws {LlmError} `MODEL_METADATA_UNAVAILABLE` when the gateway advertises
-     *   the id but this build cannot configure it, naming the reason.
-     */
-    async forModel(id) {
-        let snapshot = await this.snapshot();
-        // A snapshot that cannot serve this id forces one revalidation, because
-        // "this build has not seen the id" and "the id was just published" are
-        // indistinguishable from here.
-        //
-        // The condition must not compare the snapshot with what was cached before
-        // the await: on a cold catalog there is nothing cached, so that comparison
-        // was false and the revalidation was skipped — an id missing from the
-        // very first build then failed as UNKNOWN_MODEL instead of being retried.
-        // Presence in `unavailable` is a positive statement (the gateway
-        // advertises the id but this build cannot configure it), so it needs no
-        // revalidation and is reported below.
-        if (!snapshot.facts.has(id) && !snapshot.unavailable.has(id)) {
-            snapshot = await this.snapshot(true);
-        }
-        const reason = snapshot.unavailable.get(id);
-        if (reason !== undefined) {
-            throw new LlmError(`opencode-go model "${id}" is advertised but cannot be configured: ${reason};`
-                + ' refresh the model list to retry', 'MODEL_METADATA_UNAVAILABLE');
-        }
-        return snapshot;
-    }
-    /** Revalidate every source, reusing the metadata document when it is unchanged. */
-    async build() {
-        const builtin = builtinModels(this.options.baseURL);
-        const readDocument = this.options.readDocument ?? fetchGoDocument;
-        const [listing, metadata, documentation] = await Promise.allSettled([
-            fetchModelIds(this.options.baseURL),
-            this.refreshMetadata(builtin),
-            readDocument(),
-        ]);
-        if (metadata.status === 'rejected') {
-            this.options.observers?.onFallback?.({
-                url: MODEL_METADATA_URL,
-                error: metadata.reason,
-                kept: this.lastMetadata?.models.size ?? 0,
-            });
-        }
-        if (documentation.status === 'fulfilled') {
-            this.document = documentation.value;
-        }
-        else {
-            // Not a page-stale event: the allowances keep their previous source, and
-            // the page says so wherever the frozen seed is in use.
-            this.options.observers?.onFallback?.({
-                url: GO_DOC_URLS[0] ?? 'the Go documentation',
-                error: documentation.reason,
-                kept: this.document?.quotas.size ?? 0,
-            });
-        }
-        if (listing.status === 'rejected') {
-            // Once observed, an outage must not resurrect retired models: the last
-            // successful listing stays authoritative until a new one arrives.
-            const previous = this.served;
-            this.options.observers?.onFallback?.({
-                url: `${this.options.baseURL.replace(/\/+$/, '')}/models`,
-                error: listing.reason,
-                kept: previous?.facts.size ?? 0,
-            });
-            const facts = previous?.facts ?? new Map();
-            return {
-                facts,
-                unavailable: previous?.unavailable ?? new Map(),
-                provider: buildProvider(this.options.baseURL, [...facts.values()].map(fact => toPiModel(fact, this.options.baseURL))),
-                live: false,
-                listingFailure: listing.reason,
-                fetchedAtMs: Date.now(),
-                ...this.documentQuotas(),
-            };
-        }
-        // A metadata outage keeps the last successful parse: the previous document
-        // is strictly better evidence than the installed catalog alone, because it
-        // carries the capacities, modalities, and lifecycle the catalog may not.
-        return this.assemble(listing.value, metadata.status === 'fulfilled' ? metadata.value : this.lastMetadata, builtin);
-    }
-    /** Merge the listing with the metadata document and the installed entries. */
-    assemble(ids, online, builtin) {
-        const facts = new Map();
-        const unavailable = new Map();
-        for (const id of ids) {
-            const parsed = online?.models.get(id);
-            if (parsed !== undefined) {
-                facts.set(id, parsed);
-                continue;
-            }
-            const reason = online?.errors.get(id);
-            if (reason !== undefined) {
-                // A malformed record is a data fault: report it rather than inventing
-                // capacities, because the model is described and the description is wrong.
-                unavailable.set(id, reason);
-                continue;
-            }
-            // The installed catalog may name a protocol this plugin cannot mount.
-            // pi-ai 1.3.0 labels `gemini-4-argon-contributor` as
-            // `google-generative-ai`, which `buildProvider` has no entry for, and
-            // the string used to reach the model list through an unchecked cast.
-            // Listing it as usable would defer the failure to the first stream —
-            // the one outcome this plugin refuses to ship — so it is refused here,
-            // exactly like a malformed record.
-            const unsupported = unsupportedBuiltinApi(builtin.get(id)?.api);
-            if (unsupported !== undefined) {
-                unavailable.set(id, `its wire protocol "${unsupported}" is not implemented by this plugin`);
-                continue;
-            }
-            // No source describes this id. The gateway's own provider default
-            // (`@ai-sdk/openai-compatible`) makes Chat Completions the best available
-            // guess, and the route defaults size it; the settings surface marks it as
-            // inferred so a wrong guess is visible and overridable.
-            facts.set(id, this.withDocumentedProtocol(this.inferredFacts(id, builtin)));
-        }
-        if (unavailable.size > 0) {
-            this.options.observers?.onUnconfigured?.([...unavailable].map(([id, reason]) => ({ id, reason })));
-        }
-        return {
-            facts,
-            unavailable,
-            provider: buildProvider(this.options.baseURL, [...facts.values()].map(fact => toPiModel(fact, this.options.baseURL))),
-            live: true,
-            fetchedAtMs: Date.now(),
-            ...this.documentQuotas(),
-        };
-    }
-    /** The document allowances as a snapshot field, absent until one fetch lands. */
-    documentQuotas() {
-        return this.document === undefined ? {} : { documentQuotas: this.document.quotas };
-    }
-    /**
-     * Prefer the documented protocol over anything below the installed catalog.
-     *
-     * The endpoint table is the provider's own statement, so it outranks both the
-     * family guess and models.dev's SDK hint — this turns an `inferred` badge into
-     * a known answer for ids the installed catalog misses. It never overrides a
-     * builtin entry or a configured override: those carry the wire quirks the
-     * adapter relies on.
-     */
-    withDocumentedProtocol(facts) {
-        if (facts.protocolSource !== 'inferred' && facts.protocolSource !== 'online')
-            return facts;
-        const documented = this.document?.protocols.get(facts.id);
-        return documented === undefined ? facts : { ...facts, api: documented, protocolSource: 'document' };
-    }
-    /** Facts for an id no source describes, from the ladder and the route defaults. */
-    inferredFacts(id, builtin) {
-        const exact = builtin.get(id);
-        // Guarded for the same reason `assemble` refuses these ids up front: the
-        // installed catalog states protocols this plugin cannot mount.
-        const builtinApi = asWireProtocol(exact?.api);
-        const api = builtinApi ?? inferFamily(id);
-        const contextWindow = exact !== undefined ? exact.contextWindow : this.options.defaults.contextWindow;
-        const maxTokens = exact !== undefined ? exact.maxTokens : this.options.defaults.maxTokens;
-        return {
-            id,
-            name: exact?.name ?? id,
-            api,
-            protocolSource: builtinApi === undefined ? 'inferred' : 'builtin',
-            contextWindow,
-            maxInputTokens: undefined,
-            maxTokens,
-            assumedLimits: exact === undefined,
-            input: exact?.input ?? this.options.defaults.input,
-            inputModalities: undefined,
-            reasoning: exact?.reasoning ?? false,
-            thinkingLevelMap: exact?.thinkingLevelMap,
-            compat: exact?.compat ?? {},
-            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-            deprecated: false,
-            releaseDate: undefined,
-        };
-    }
-    /** Conditional metadata GET: an unchanged document keeps its parsed form. */
-    async refreshMetadata(builtin) {
-        const response = await fetch(MODEL_METADATA_URL, {
-            redirect: 'error',
-            headers: {
-                ...attributionHeaders(),
-                accept: 'application/json',
-                'cache-control': 'no-cache',
-                ...this.metadataETag === undefined ? {} : { 'if-none-match': this.metadataETag },
-            },
-            signal: AbortSignal.timeout(METADATA_FETCH_TIMEOUT_MS),
-        });
-        if (response.status === 304 && this.metadataDocument !== undefined) {
-            await response.body?.cancel().catch(() => { });
-            const parsed = readOnlineMetadata(this.metadataDocument, {
-                builtin,
-                defaults: this.options.defaults,
-                overrides: this.options.overrides,
-            });
-            this.lastMetadata = parsed;
-            return parsed;
-        }
-        if (!response.ok) {
-            await response.body?.cancel().catch(() => { });
-            throw new Error(`models.dev answered ${response.status}`);
-        }
-        const document = await readBoundedJson(response, MODEL_METADATA_URL, MODEL_METADATA_MAX_BYTES);
-        this.metadataDocument = document;
-        this.metadataETag = response.headers.get('etag') ?? undefined;
-        const parsed = readOnlineMetadata(document, {
-            builtin,
-            defaults: this.options.defaults,
-            overrides: this.options.overrides,
-        });
-        this.lastMetadata = parsed;
-        return parsed;
-    }
-}
-/** The family rule, kept beside the ladder so both stay in one vocabulary. */
-function inferFamily(id) {
-    const lower = id.toLowerCase();
-    return ['grok', 'gpt', 'muse'].some(family => lower.startsWith(family))
-        ? 'openai-responses'
-        : 'openai-completions';
-}
-/**
- * Interrogate the gateway for explicit discovery, bypassing the TTL.
- * @param catalog - the catalog to revalidate.
- * @returns the advertised models, including the unconfigured ones so the
- *   settings surface can explain what is missing.
- * @throws {LlmError} `DISCOVERY_FAILED` when the listing itself failed.
- */
-export async function discoverCatalogModels(catalog) {
-    const snapshot = await catalog.snapshot(true);
-    if (!snapshot.live) {
-        const detail = snapshot.listingFailure instanceof LlmError
-            ? snapshot.listingFailure.message
-            : 'the live model listing is unreachable';
-        throw new LlmError(`dshopencodego: ${detail}; refresh the model list to retry`, 'DISCOVERY_FAILED', {
-            cause: snapshot.listingFailure,
-        });
-    }
-    return [
-        ...[...snapshot.facts.values()].map(fact => ({
-            id: fact.id,
-            name: fact.name,
-            contextWindow: fact.contextWindow,
-            maxTokens: fact.maxTokens,
-        })),
-        ...[...snapshot.unavailable].map(([id, reason]) => ({ id, name: `${id} (unconfigured: ${reason})` })),
-    ];
-}

package/lib/types/catalog/json-response.js

@@ -1,73 +0,0 @@
-/**
- * Bounded body reads shared by the catalog, the usage endpoint, and the Go
- * documentation fetch.
- *
- * Every outbound metadata read is capped before parsing: the documents are
- * third-party, and a truncated or oversized reply must surface as a named
- * failure rather than as memory growth.
- *
- * @module @dan-ai-studio/dshopencodego/catalog/json-response
- */
-import { LlmError } from '@deepseek-ai/dsh-llm';
-/**
- * Read a response body as JSON without trusting its length.
- * @param response - an OK response whose body is the document.
- * @param url - the URL, for diagnostics.
- * @param maxBytes - hard cap on the decoded document.
- * @returns the parsed JSON value.
- * @throws {LlmError} `DISCOVERY_FAILED` on a transport fault, an over-cap body,
- *   or invalid JSON.
- */
-export async function readBoundedJson(response, url, maxBytes) {
-    const declared = Number(response.headers.get('content-length') ?? Number.NaN);
-    if (Number.isFinite(declared) && declared > maxBytes) {
-        await response.body?.cancel().catch(() => { });
-        throw new LlmError(`${url} declares ${declared} bytes, over the ${maxBytes}-byte cap`, 'DISCOVERY_FAILED');
-    }
-    let text;
-    try {
-        text = await readBoundedText(response, maxBytes);
-    }
-    catch (error) {
-        if (error instanceof LlmError)
-            throw error;
-        throw new LlmError(`could not read ${url}`, 'DISCOVERY_FAILED', { cause: error });
-    }
-    try {
-        return JSON.parse(text);
-    }
-    catch (error) {
-        throw new LlmError(`${url} did not answer with JSON`, 'DISCOVERY_FAILED', { cause: error });
-    }
-}
-/** Decode a body as text, aborting once it passes the cap. */
-export async function readBoundedText(response, maxBytes) {
-    if (response.body === null)
-        return '';
-    const reader = response.body.getReader();
-    const chunks = [];
-    let total = 0;
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            total += value.byteLength;
-            if (total > maxBytes) {
-                await reader.cancel().catch(() => { });
-                throw new LlmError(`response exceeds the ${maxBytes}-byte cap`, 'DISCOVERY_FAILED');
-            }
-            chunks.push(value);
-        }
-    }
-    finally {
-        reader.releaseLock();
-    }
-    const merged = new Uint8Array(total);
-    let offset = 0;
-    for (const chunk of chunks) {
-        merged.set(chunk, offset);
-        offset += chunk.byteLength;
-    }
-    return new TextDecoder().decode(merged);
-}