@askdkc/dsh-cli 0.12.3 → 0.13.0

package/node_modules/@askdkc/dsh-auth/lib/interaction.d.ts

@@ -29,7 +29,7 @@
  * @module dsh-auth/interaction
  */
 import type { AskUserQuestionItem, AskUserQuestionAnswer } from '@deepseek-ai/dsh-user-questions';
-import type { PiAiAuthEvent, PiAiAuthInteraction, PiAiAuthPrompt } from './pi-ai.js';
+import type { AuthEvent, AuthInteraction, AuthPrompt } from './auth-contract.js';
 /** The ask surface this bridge drives (usually `ctx.userQuestions.ask`). */
 export type AskFn = (request: {
     questions: AskUserQuestionItem[];
@@ -41,13 +41,13 @@ export interface QuestionBridgeHelpers {
     copyText?: (text: string) => Promise<boolean>;
 }
 /** Human-readable copy for one notify event. */
-export declare function describeEvent(event: PiAiAuthEvent): string;
+export declare function describeEvent(event: AuthEvent): string;
 /**
  * The bridge for one login run. At most one waiting panel exists at a time;
  * `settle()` retires it when the flow ends (any outcome), so a completed or
  * failed login never leaves an interactive dead end on screen.
  */
-export declare class QuestionBridge implements PiAiAuthInteraction {
+export declare class QuestionBridge implements AuthInteraction {
     private readonly ask;
     private readonly runAbort;
     readonly signal: AbortSignal;
@@ -56,8 +56,8 @@ export declare class QuestionBridge implements PiAiAuthInteraction {
     private waiting;
     private waitingClosed;
     constructor(ask: AskFn, runAbort: AbortController, helpers?: QuestionBridgeHelpers);
-    prompt(prompt: PiAiAuthPrompt): Promise<string>;
-    notify(event: PiAiAuthEvent): void;
+    prompt(prompt: AuthPrompt): Promise<string>;
+    notify(event: AuthEvent): void;
     /** Close the waiting panel (if any) and stop answering for this run. */
     settle(): Promise<void>;
     /**

package/node_modules/@askdkc/dsh-auth/lib/opencode-adapter.d.ts

@@ -0,0 +1,37 @@
+/** Native DSH adapter for Zen/Go; catalog and wire dispatch never consult pi. */
+import { LlmAdapter, type GenerateOptions, type StreamChunk, type PreparedAdapterCall, type LlmResolvedModelInfo } from '@deepseek-ai/dsh-llm';
+import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
+import { type OpenCodeCatalog, type OpenCodeRoute } from './opencode-catalog.js';
+import type { CredentialFile } from './credentials.js';
+interface Options {
+    catalogs: ReadonlyMap<OpenCodeRoute, OpenCodeCatalog>;
+    store: CredentialFile;
+    attachments?: () => AttachmentStore | undefined;
+    fetcher?: typeof fetch;
+    overrides?: Record<string, Record<string, {
+        contextWindow?: number;
+        maxTokens?: number;
+    }>>;
+    warn?: (reason: string) => void;
+}
+export declare class OpenCodeAdapter extends LlmAdapter {
+    private readonly options;
+    constructor(options: Options);
+    providerInfo(provider: string): {
+        id: string;
+        name: string;
+    };
+    private descriptor;
+    listModels(provider: string): Promise<{
+        provider: string;
+        id: string;
+        name: string;
+        inputModalities: ("text" | "image")[];
+    }[]>;
+    private resolved;
+    resolveModel(provider: string, model: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
+    prepareCall(provider: string, model: string, signal?: AbortSignal): Promise<PreparedAdapterCall>;
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    private dispatch;
+}
+export {};

package/node_modules/@askdkc/dsh-auth/lib/opencode-adapter.js

@@ -0,0 +1,197 @@
+/** Native DSH adapter for Zen/Go; catalog and wire dispatch never consult pi. */
+import { LlmAdapter, LlmError, attributionHeaders } from '@deepseek-ai/dsh-llm';
+import { encodePrompt } from './opencode-codec.js';
+import { createTransport } from './opencode-transport.js';
+import { abortable } from './abortable.js';
+import { randomUUID } from 'node:crypto';
+import { record, mergeMetadata } from './opencode-replay.js';
+export class OpenCodeAdapter extends LlmAdapter {
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+        for (const [provider, models] of Object.entries(options.overrides ?? {}))
+            for (const [id, override] of Object.entries(models)) {
+                if (!options.catalogs.has(provider))
+                    continue;
+                this.descriptor(provider, id);
+                for (const value of Object.values(override))
+                    if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0))
+                        throw new Error(`Invalid model override for ${provider}/${id}`);
+            }
+    }
+    providerInfo(provider) { return { id: provider, name: provider === 'opencode' ? 'OpenCode Zen' : 'OpenCode Go' }; }
+    descriptor(provider, id) {
+        const catalog = this.options.catalogs.get(provider);
+        const found = catalog?.models().find(model => model.id === id);
+        if (!found)
+            throw new LlmError(`OpenCode model ${provider}/${id} unavailable: ${catalog?.status().excluded.find(model => model.id === id)?.reason ?? 'not on the verified roster'}`, 'MODEL_NOT_FOUND');
+        const override = this.options.overrides?.[provider]?.[id];
+        return { ...found, ...override };
+    }
+    async listModels(provider) {
+        if (!(await this.options.store.read(provider)))
+            return [];
+        return (this.options.catalogs.get(provider)?.models() ?? []).map(model => ({ provider, id: model.id, name: model.name, inputModalities: model.inputModalities }));
+    }
+    resolved(provider, descriptor) {
+        return { provider, id: descriptor.id, name: descriptor.name, inputModalities: descriptor.inputModalities, context: { contextWindow: descriptor.contextWindow }, defaultMaxTokens: descriptor.maxTokens,
+            ...(descriptor.efforts.length ? { reasoning: { efforts: descriptor.efforts.map(id => ({ id: id, name: id })) } } : {}) };
+    }
+    async resolveModel(provider, model, signal) { signal?.throwIfAborted(); return this.resolved(provider, this.descriptor(provider, model)); }
+    async prepareCall(provider, model, signal) {
+        signal?.throwIfAborted();
+        const descriptor = this.descriptor(provider, model);
+        return { model: this.resolved(provider, descriptor), stream: options => {
+                if (options.provider !== provider || options.model !== model)
+                    throw new LlmError('Prepared OpenCode call identity mismatch', 'INVALID_PREPARED_CALL');
+                return this.dispatch(options, descriptor);
+            } };
+    }
+    stream(options) { return this.dispatch(options, this.descriptor(options.provider, options.model)); }
+    async *dispatch(options, descriptor) {
+        options.signal?.throwIfAborted();
+        if (options.tools?.length && !descriptor.toolCall)
+            throw new LlmError('This OpenCode model does not support tool calls', 'UNSUPPORTED_CAPABILITY');
+        if (options.reasoningEffort && !descriptor.efforts.includes(options.reasoningEffort))
+            throw new LlmError('Unsupported reasoning effort for this model', 'UNSUPPORTED_CAPABILITY');
+        const prompt = await encodePrompt(options, descriptor, this.options.attachments, this.options.warn);
+        const credential = await this.options.store.read(options.provider);
+        if (credential?.type !== 'api_key' || !credential.key?.trim())
+            throw new LlmError(`Run /auth login ${options.provider}`, 'AUTH');
+        const headers = { ...attributionHeaders(), 'x-opencode-session': options.sessionId ?? randomUUID() };
+        const model = createTransport(descriptor, options, credential.key, headers, prompt, this.options.fetcher);
+        const abort = new AbortController();
+        const signal = AbortSignal.any([abort.signal, ...(options.signal ? [options.signal] : [])]);
+        let timer = setTimeout(() => abort.abort(new Error('OpenCode stream idle timeout')), 300_000);
+        timer.unref();
+        let reader;
+        try {
+            const result = await abortable(model.doStream({ prompt, abortSignal: signal, maxOutputTokens: options.maxTokens ?? descriptor.maxTokens,
+                ...(descriptor.temperature ? { temperature: options.temperature } : {}), stopSequences: options.stop,
+                tools: options.tools?.map(tool => ({ type: 'function', name: tool.name, description: tool.description, inputSchema: tool.parameters })),
+                providerOptions: descriptor.protocol === 'responses' ? { openai: { store: false } } : undefined }), signal);
+            reader = result.stream.getReader();
+            const blocks = new Map();
+            let responseId;
+            while (true) {
+                const item = await abortable(reader.read(), signal);
+                if (item.done)
+                    throw new LlmError('OpenCode stream ended without a finish event', 'PROTOCOL_ERROR');
+                clearTimeout(timer);
+                timer = setTimeout(() => abort.abort(new Error('OpenCode stream idle timeout')), 300_000);
+                timer.unref();
+                const part = item.value;
+                if (part.type === 'error')
+                    throw part.error;
+                if (part.type === 'response-metadata') {
+                    responseId = part.id;
+                    continue;
+                }
+                if (part.type === 'text-start' || part.type === 'reasoning-start' || part.type === 'tool-input-start') {
+                    const block = part.type === 'tool-input-start' ? { type: 'tool-call', id: part.id, name: part.toolName, arguments: '' } : { type: part.type === 'text-start' ? 'text' : 'reasoning', text: '' };
+                    const entry = { index: blocks.size, block, ended: false, providerOptions: part.providerMetadata };
+                    blocks.set(part.id, entry);
+                    yield { type: 'block-start', index: entry.index, blockType: block.type };
+                    continue;
+                }
+                if (part.type === 'text-delta' || part.type === 'reasoning-delta' || part.type === 'tool-input-delta') {
+                    const entry = blocks.get(part.id);
+                    if (!entry || entry.ended || entry.inputEnded)
+                        throw new LlmError('Unmatched stream delta', 'PROTOCOL_ERROR');
+                    if (entry.block.type === 'tool-call') {
+                        entry.block.arguments += part.delta;
+                        yield { type: 'tool-call-delta', index: entry.index, id: entry.block.id, argumentsDelta: part.delta };
+                    }
+                    else if (entry.block.type === 'text' || entry.block.type === 'reasoning') {
+                        entry.block.text += part.delta;
+                        yield { type: entry.block.type === 'text' ? 'text-delta' : 'reasoning-delta', index: entry.index, text: part.delta };
+                    }
+                    if (part.providerMetadata)
+                        entry.providerOptions = mergeMetadata(entry.providerOptions, part.providerMetadata);
+                    continue;
+                }
+                if (part.type === 'text-end' || part.type === 'reasoning-end' || part.type === 'tool-input-end') {
+                    const entry = blocks.get(part.id);
+                    if (!entry || entry.ended)
+                        throw new LlmError('Unmatched stream end', 'PROTOCOL_ERROR');
+                    if (part.providerMetadata)
+                        entry.providerOptions = mergeMetadata(entry.providerOptions, part.providerMetadata);
+                    if (entry.block.type === 'tool-call') {
+                        entry.inputEnded = true;
+                        continue;
+                    }
+                    entry.ended = true;
+                    yield { type: 'block-end', index: entry.index, block: entry.block };
+                    continue;
+                }
+                if (part.type === 'tool-call') {
+                    if (part.providerExecuted)
+                        throw new LlmError('Unexpected provider-executed tool', 'PROTOCOL_ERROR');
+                    if (!blocks.has(part.toolCallId)) {
+                        const block = { type: 'tool-call', id: part.toolCallId, name: part.toolName, arguments: part.input };
+                        const index = blocks.size;
+                        blocks.set(part.toolCallId, { index, block, ended: true, providerOptions: part.providerMetadata });
+                        yield { type: 'block-start', index, blockType: 'tool-call' };
+                        yield { type: 'block-end', index, block };
+                    }
+                    else {
+                        const entry = blocks.get(part.toolCallId);
+                        if (entry.block.type !== 'tool-call' || entry.ended || entry.block.name !== part.toolName)
+                            throw new LlmError('Mismatched final tool call', 'PROTOCOL_ERROR');
+                        // Some providers send the complete arguments only in the final
+                        // tool event. Preserve streamed raw JSON when it was supplied.
+                        if (!entry.block.arguments)
+                            entry.block.arguments = part.input;
+                        if (part.providerMetadata)
+                            entry.providerOptions = mergeMetadata(entry.providerOptions, part.providerMetadata);
+                        entry.ended = true;
+                        yield { type: 'block-end', index: entry.index, block: entry.block };
+                    }
+                    continue;
+                }
+                if (part.type === 'finish') {
+                    for (const entry of blocks.values())
+                        if (!entry.ended) {
+                            entry.ended = true;
+                            yield { type: 'block-end', index: entry.index, block: entry.block };
+                        }
+                    const input = part.usage.inputTokens;
+                    const output = part.usage.outputTokens;
+                    yield { type: 'usage', usage: { inputTokens: input.noCache ?? Math.max(0, (input.total ?? 0) - (input.cacheRead ?? 0) - (input.cacheWrite ?? 0)), outputTokens: output.total ?? 0, cacheReadTokens: input.cacheRead, cacheWriteTokens: input.cacheWrite, reasoningTokens: output.reasoning, ...(input.total !== undefined && output.total !== undefined ? { totalTokens: input.total + output.total } : {}) } };
+                    if (!blocks.size)
+                        throw new LlmError('OpenCode returned no content', 'EMPTY_RESPONSE');
+                    const finish = part.finishReason.unified;
+                    if (finish === 'error' || finish === 'content-filter' || finish === 'other')
+                        throw new LlmError(`OpenCode generation ended: ${finish}`, 'PROVIDER_ERROR');
+                    yield { type: 'finish', reason: { kind: finish === 'tool-calls' ? 'tool-calls' : finish === 'length' ? 'max-tokens' : 'stop' }, replayState: { response: { kind: 'dsh-opencode', version: 1, protocol: descriptor.protocol, provider: options.provider, model: descriptor.id, responseId }, blocks: [...blocks.values()].map(entry => ({ type: entry.block.type, ...(entry.providerOptions ? { providerOptions: entry.providerOptions } : {}) })) } };
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            if (options.signal?.aborted)
+                throw options.signal.reason;
+            if (signal.aborted)
+                throw new LlmError('OpenCode stream idle timeout', 'TIMEOUT');
+            if (error instanceof LlmError)
+                throw error;
+            const raw = record(error);
+            const status = typeof raw?.statusCode === 'number' ? raw.statusCode : undefined;
+            const responseHeaders = record(raw?.responseHeaders);
+            const retryHeader = responseHeaders?.['retry-after'];
+            const seconds = Number(retryHeader);
+            const retry = typeof retryHeader === 'string' ? Number.isFinite(seconds) ? seconds * 1000 : Date.parse(retryHeader) - Date.now() : undefined;
+            const requestId = responseHeaders?.['x-request-id'] ?? responseHeaders?.['request-id'];
+            throw new LlmError(`OpenCode request failed${status ? `: HTTP ${status}` : ''}`, status === 401 || status === 403 ? 'AUTH' : status === 429 ? 'RATE_LIMIT' : status && status >= 500 ? 'SERVER' : status ? 'PROVIDER_ERROR' : 'TRANSPORT', { status, ...(retry !== undefined && retry > 0 ? { providerRetryAfterMs: retry } : {}), ...(typeof requestId === 'string' && requestId.trim() ? { requestId: requestId } : {}) });
+        }
+        finally {
+            clearTimeout(timer);
+            abort.abort();
+            if (reader) {
+                void reader.cancel().catch(() => undefined);
+                reader.releaseLock();
+            }
+        }
+    }
+}

package/node_modules/@askdkc/dsh-auth/lib/opencode-catalog.d.ts

@@ -0,0 +1,72 @@
+export declare const OPEN_CODE_ROUTES: readonly ["opencode", "opencode-go"];
+export type OpenCodeRoute = typeof OPEN_CODE_ROUTES[number];
+export type OpenCodeProtocol = 'messages' | 'responses' | 'chat' | 'google';
+export declare const OPEN_CODE_URLS: Record<OpenCodeRoute, string>;
+export interface OpenCodeModel {
+    id: string;
+    name: string;
+    protocol: OpenCodeProtocol;
+    contextWindow: number;
+    maxTokens: number;
+    inputModalities: ('text' | 'image')[];
+    toolCall: boolean;
+    reasoning: boolean;
+    temperature: boolean;
+    efforts: string[];
+    cost?: Record<string, number>;
+}
+export interface OpenCodeSnapshot {
+    version: 1;
+    provider: OpenCodeRoute;
+    fetchedAt: number;
+    roster: string[];
+    models: OpenCodeModel[];
+    excluded: {
+        id: string;
+        reason: string;
+    }[];
+}
+export interface OpenCodeCatalogStatus {
+    provider: OpenCodeRoute;
+    source: 'bundled' | 'cache' | 'live';
+    fetchedAt: number;
+    available: number;
+    excluded: readonly {
+        id: string;
+        reason: string;
+    }[];
+    warning?: string;
+}
+export declare function rosterIds(payload: unknown): string[];
+/** Normalize only exact-route metadata; every roster id has an explicit outcome. */
+export declare function normalizeCatalog(provider: OpenCodeRoute, roster: readonly string[], metadata: unknown, fetchedAt: number, previous?: OpenCodeSnapshot): OpenCodeSnapshot;
+/** Validate cache/snapshot data using the same normalizer as fetched metadata. */
+export declare function parseSnapshot(value: unknown, provider: OpenCodeRoute): OpenCodeSnapshot;
+export declare function fetchCatalogJson(url: string, fetcher: typeof fetch, signal?: AbortSignal): Promise<unknown>;
+export declare class OpenCodeCatalog {
+    readonly provider: OpenCodeRoute;
+    private readonly options;
+    private snapshot;
+    private source;
+    private warning?;
+    private pending?;
+    private disposed;
+    private abort;
+    private timer?;
+    private started;
+    constructor(provider: OpenCodeRoute, bundled: unknown, options?: {
+        directory?: string;
+        fetcher?: typeof fetch;
+        changed?: () => void;
+        now?: () => number;
+    });
+    private get path();
+    models(): readonly OpenCodeModel[];
+    status(): OpenCodeCatalogStatus;
+    start(): Promise<void>;
+    refresh(): Promise<OpenCodeCatalogStatus>;
+    private update;
+    /** Compare and replace under a bounded cross-process lock; failed writes retain the old cache. */
+    private save;
+    dispose(): void;
+}

package/node_modules/@askdkc/dsh-auth/lib/opencode-catalog.js

@@ -0,0 +1,252 @@
+/** Owned OpenCode catalog. Public listings are untrusted; no pi catalog participates. */
+import { mkdir, readFile, rename, writeFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { abortable } from './abortable.js';
+import { randomUUID } from 'node:crypto';
+export const OPEN_CODE_ROUTES = ['opencode', 'opencode-go'];
+export const OPEN_CODE_URLS = {
+    opencode: 'https://opencode.ai/zen/v1', 'opencode-go': 'https://opencode.ai/zen/go/v1',
+};
+const PROTOCOLS = {
+    '@ai-sdk/anthropic': 'messages', '@ai-sdk/openai': 'responses',
+    '@ai-sdk/openai-compatible': 'chat', '@ai-sdk/google': 'google',
+};
+function object(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('catalog expected an object');
+    return value;
+}
+function positive(value) { return typeof value === 'number' && Number.isSafeInteger(value) && value > 0; }
+export function rosterIds(payload) {
+    const data = object(payload).data;
+    if (!Array.isArray(data) || !data.length)
+        throw new Error('catalog has no non-empty model roster');
+    return [...new Set(data.map(row => {
+            const id = object(row).id;
+            if (typeof id !== 'string' || !id.trim() || id.length > 512)
+                throw new Error('catalog has an invalid model id');
+            return id;
+        }))].sort();
+}
+/** Normalize only exact-route metadata; every roster id has an explicit outcome. */
+export function normalizeCatalog(provider, roster, metadata, fetchedAt, previous) {
+    const section = object(metadata);
+    const entries = object(section.models);
+    const models = [];
+    const excluded = [];
+    for (const id of [...new Set(roster)].sort()) {
+        try {
+            if (entries[id] === undefined) {
+                const old = previous?.provider === provider ? previous.models.find(model => model.id === id) : undefined;
+                if (old) {
+                    models.push(structuredClone(old));
+                    continue;
+                }
+                throw new Error('metadata unavailable for this route and id');
+            }
+            const raw = object(entries[id]);
+            const wire = raw.provider === undefined ? section.npm : object(raw.provider).npm;
+            const protocol = typeof wire === 'string' && Object.hasOwn(PROTOCOLS, wire) ? PROTOCOLS[wire] : undefined;
+            const limit = object(raw.limit);
+            const modalities = object(raw.modalities);
+            if (!protocol)
+                throw new Error('unsupported or unknown wire protocol');
+            if (!positive(limit.context) || !positive(limit.output))
+                throw new Error('context or output limit unavailable');
+            if (!Array.isArray(modalities.input) || !modalities.input.includes('text') || !Array.isArray(modalities.output) || !modalities.output.includes('text'))
+                throw new Error('not a verified text-generation model');
+            if (typeof raw.tool_call !== 'boolean' || typeof raw.reasoning !== 'boolean' || typeof raw.temperature !== 'boolean')
+                throw new Error('model capabilities unavailable');
+            const effortOption = Array.isArray(raw.reasoning_options) ? raw.reasoning_options.map(object).find(option => option.type === 'effort') : undefined;
+            const efforts = effortOption?.values ?? [];
+            if (!Array.isArray(efforts) || !efforts.every(value => typeof value === 'string'))
+                throw new Error('invalid reasoning efforts');
+            const cost = Object.fromEntries(Object.entries(raw.cost === undefined ? {} : object(raw.cost)).filter(([, value]) => typeof value === 'number' && Number.isFinite(value) && value >= 0));
+            models.push({ id, name: typeof raw.name === 'string' ? raw.name : id, protocol, contextWindow: limit.context, maxTokens: limit.output,
+                inputModalities: modalities.input.includes('image') ? ['text', 'image'] : ['text'], toolCall: raw.tool_call, reasoning: raw.reasoning,
+                temperature: raw.temperature, efforts: [...efforts], ...(Object.keys(cost).length ? { cost } : {}) });
+        }
+        catch (error) {
+            excluded.push({ id, reason: error instanceof Error ? error.message : 'invalid metadata' });
+        }
+    }
+    return { version: 1, provider, fetchedAt, roster: [...new Set(roster)].sort(), models, excluded };
+}
+/** Validate cache/snapshot data using the same normalizer as fetched metadata. */
+export function parseSnapshot(value, provider) {
+    const raw = object(value);
+    if (raw.version !== 1 || raw.provider !== provider || typeof raw.fetchedAt !== 'number' || !Number.isSafeInteger(raw.fetchedAt) || raw.fetchedAt < 0 || !Array.isArray(raw.roster) || !raw.roster.length || !raw.roster.every(id => typeof id === 'string' && id.trim() && id.length <= 512) || !Array.isArray(raw.models) || !Array.isArray(raw.excluded))
+        throw new Error('invalid catalog snapshot');
+    const roster = raw.roster;
+    if (new Set(roster).size !== roster.length)
+        throw new Error('duplicate snapshot roster id');
+    const models = raw.models.map(value => {
+        const model = object(value);
+        if (typeof model.id !== 'string' || typeof model.protocol !== 'string' || !Object.values(PROTOCOLS).includes(model.protocol) || !positive(model.contextWindow) || !positive(model.maxTokens) || typeof model.name !== 'string' || !model.name || !Array.isArray(model.inputModalities) || !model.inputModalities.includes('text') || model.inputModalities.some(v => v !== 'text' && v !== 'image') || !Array.isArray(model.efforts) || !model.efforts.every(v => typeof v === 'string' && v.length > 0) || [model.toolCall, model.reasoning, model.temperature].some(v => typeof v !== 'boolean'))
+            throw new Error('invalid cached model');
+        const cost = model.cost === undefined ? undefined : object(model.cost);
+        if (cost && Object.values(cost).some(value => typeof value !== 'number' || !Number.isFinite(value) || value < 0))
+            throw new Error('invalid cached cost');
+        return { id: model.id, name: model.name, protocol: model.protocol, contextWindow: model.contextWindow, maxTokens: model.maxTokens,
+            inputModalities: [...new Set(model.inputModalities)], efforts: [...new Set(model.efforts)],
+            toolCall: model.toolCall, reasoning: model.reasoning, temperature: model.temperature,
+            ...(cost ? { cost: { ...cost } } : {}) };
+    });
+    const excluded = raw.excluded.map(value => { const entry = object(value); if (typeof entry.id !== 'string' || typeof entry.reason !== 'string' || !entry.reason)
+        throw new Error('invalid exclusion reason'); return { id: entry.id, reason: entry.reason }; });
+    const ids = [...models, ...excluded].map(model => model.id);
+    if (new Set(ids).size !== ids.length || ids.length !== roster.length || ids.some(id => !roster.includes(id)))
+        throw new Error('incomplete catalog snapshot');
+    return { version: 1, provider, fetchedAt: raw.fetchedAt, roster: [...roster], models, excluded };
+}
+export async function fetchCatalogJson(url, fetcher, signal) {
+    const timeout = AbortSignal.any([AbortSignal.timeout(30_000), ...(signal ? [signal] : [])]);
+    const response = await abortable(fetcher(url, { signal: timeout, headers: { accept: 'application/json' }, redirect: 'error' }), timeout);
+    if (!response.ok)
+        throw new Error(`catalog request failed: HTTP ${response.status}`);
+    if (!response.body)
+        throw new Error('empty catalog response');
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const item = await abortable(reader.read(), timeout);
+            if (item.done)
+                break;
+            size += item.value.byteLength;
+            if (size > 32 * 1024 * 1024)
+                throw new Error('catalog exceeds 32 MiB');
+            chunks.push(item.value);
+        }
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    finally {
+        void reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+}
+export class OpenCodeCatalog {
+    provider;
+    options;
+    snapshot;
+    source = 'bundled';
+    warning;
+    pending;
+    disposed = false;
+    abort = new AbortController();
+    timer;
+    started = false;
+    constructor(provider, bundled, options = {}) {
+        this.provider = provider;
+        this.options = options;
+        this.snapshot = parseSnapshot(bundled, provider);
+    }
+    get path() { return join(this.options.directory ?? join(process.env.DSH_HOME ?? join(homedir(), '.dsh'), 'dsh-auth', 'catalog-v1'), `${this.provider}.json`); }
+    models() { return structuredClone(this.snapshot.models); }
+    status() { return { provider: this.provider, source: this.source, fetchedAt: this.snapshot.fetchedAt, available: this.snapshot.models.length, excluded: structuredClone(this.snapshot.excluded), ...(this.warning ? { warning: this.warning } : {}) }; }
+    async start() {
+        if (this.started || this.disposed)
+            return;
+        this.started = true;
+        try {
+            const cached = parseSnapshot(JSON.parse(await readFile(this.path, 'utf8')), this.provider);
+            if (!this.disposed && cached.fetchedAt > this.snapshot.fetchedAt) {
+                this.snapshot = cached;
+                this.source = 'cache';
+                this.options.changed?.();
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                this.warning = 'catalog cache unreadable; using bundled information';
+        }
+        if (this.disposed)
+            return;
+        if ((this.options.now?.() ?? Date.now()) - this.snapshot.fetchedAt >= 3_600_000)
+            void this.refresh();
+        this.timer = setInterval(() => { void this.refresh(); }, 3_600_000);
+        this.timer.unref();
+    }
+    refresh() {
+        if (this.disposed)
+            return Promise.reject(new Error('catalog disposed'));
+        if (this.pending)
+            return this.pending;
+        this.pending = this.update().finally(() => { this.pending = undefined; });
+        return this.pending;
+    }
+    async update() {
+        const startedAt = this.options.now?.() ?? Date.now();
+        try {
+            const [listing, details] = await Promise.all([fetchCatalogJson(`${OPEN_CODE_URLS[this.provider]}/models`, this.options.fetcher ?? fetch, this.abort.signal), fetchCatalogJson('https://models.dev/api.json', this.options.fetcher ?? fetch, this.abort.signal).then(value => ({ value, failed: false }), () => ({ value: undefined, failed: true }))]);
+            let section = { models: {} };
+            let detailsUnavailable = details.failed;
+            if (!details.failed) {
+                try {
+                    section = object(details.value)[this.provider] ?? { models: {} };
+                }
+                catch {
+                    detailsUnavailable = true;
+                }
+            }
+            const next = normalizeCatalog(this.provider, rosterIds(listing), section, startedAt, this.snapshot);
+            if (this.disposed || next.fetchedAt < this.snapshot.fetchedAt)
+                return this.status();
+            this.snapshot = next;
+            this.source = 'live';
+            this.warning = detailsUnavailable ? 'model details unavailable; reusing exact-route verified metadata' : undefined;
+            this.options.changed?.();
+            try {
+                await this.save(next);
+            }
+            catch {
+                if (!this.disposed)
+                    this.warning = 'catalog updated in memory; cache save failed';
+            }
+        }
+        catch {
+            if (!this.disposed)
+                this.warning = 'catalog refresh failed; retaining last verified information';
+        }
+        return this.status();
+    }
+    /** Compare and replace under a bounded cross-process lock; failed writes retain the old cache. */
+    async save(next) {
+        await mkdir(join(this.path, '..'), { recursive: true });
+        const lock = `${this.path}.lock`;
+        const deadline = Date.now() + 5000;
+        while (true) {
+            this.abort.signal.throwIfAborted();
+            try {
+                await mkdir(lock);
+                break;
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST' || Date.now() >= deadline)
+                    throw error;
+                await new Promise(resolve => setTimeout(resolve, 25));
+            }
+        }
+        const temp = `${this.path}.${randomUUID()}.tmp`;
+        try {
+            try {
+                const current = parseSnapshot(JSON.parse(await readFile(this.path, 'utf8')), this.provider);
+                if (current.fetchedAt > next.fetchedAt)
+                    return;
+            }
+            catch { /* An invalid cache may be replaced by verified public data. */ }
+            this.abort.signal.throwIfAborted();
+            await writeFile(temp, JSON.stringify(next), { mode: 0o600 });
+            this.abort.signal.throwIfAborted();
+            await rename(temp, this.path);
+        }
+        finally {
+            await rm(temp, { force: true });
+            await rm(lock, { recursive: true });
+        }
+    }
+    dispose() { this.disposed = true; this.abort.abort(); if (this.timer)
+        clearInterval(this.timer); }
+}

package/node_modules/@askdkc/dsh-auth/lib/opencode-codec.d.ts

@@ -0,0 +1,6 @@
+/** Convert DSH conversation blocks into low-level SDK prompts without an agent loop. */
+import { type GenerateOptions } from '@deepseek-ai/dsh-llm';
+import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
+import type { LanguageModelV4Prompt } from '@ai-sdk/provider';
+import type { OpenCodeModel } from './opencode-catalog.js';
+export declare function encodePrompt(options: GenerateOptions, model: OpenCodeModel, attachments?: () => AttachmentStore | undefined, warn?: (reason: string) => void): Promise<LanguageModelV4Prompt>;