@askdkc/dsh-cli 0.12.3 → 0.13.0

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

@@ -0,0 +1,93 @@
+/** Convert DSH conversation blocks into low-level SDK prompts without an agent loop. */
+import { LlmError, projectToolUpdates, fileHandleText } from '@deepseek-ai/dsh-llm';
+import { projectReplay, requireReplaySignature } from './opencode-replay.js';
+export async function encodePrompt(options, model, attachments, warn) {
+    const prompt = [];
+    const names = new Map();
+    const callIds = new Map();
+    if (options.system)
+        prompt.push({ role: 'system', content: options.system });
+    const projection = projectToolUpdates(options.messages, options.tools, undefined, options.toolHistory);
+    let imageBytes = 0;
+    const imagePart = async (block) => {
+        if (block.offloaded || !model.inputModalities.includes('image'))
+            return { type: 'text', text: '[image omitted from this request]' };
+        const store = attachments?.();
+        if (!store)
+            throw new LlmError('Image attachment service unavailable', 'ATTACHMENT_UNAVAILABLE');
+        const { requestImageDimensions } = await import('@deepseek-ai/dsh-attachment');
+        const image = await store.readImageRequest(block.attachment, { ...requestImageDimensions(block.attachment.width, block.attachment.height, 4_194_304), maxBytes: 1024 * 1024 }, options.signal);
+        imageBytes += Math.ceil(image.bytes / 3) * 4;
+        if (imageBytes > 20 * 1024 * 1024)
+            throw new LlmError('Image request exceeds 20 MiB', 'IMAGE_OFFLOAD_REQUIRED', { offloadImages: 1 });
+        return { type: 'file', mediaType: image.mediaType, data: { type: 'data', data: image.data } };
+    };
+    for (const message of projection.messages) {
+        if (message.role === 'system') {
+            prompt.push({ role: 'system', content: message.content.filter(block => block.type === 'text').map(block => block.text).join('\n') });
+            continue;
+        }
+        if (message.role === 'developer') {
+            const text = message.content.filter(block => block.type === 'text').map(block => block.text).join('\n');
+            if (text)
+                prompt.push({ role: 'system', content: text });
+            continue;
+        }
+        if (message.role === 'tool') {
+            const toolName = names.get(message.toolCallId);
+            if (!toolName)
+                throw new LlmError('Stored tool result has no matching call', 'INVALID_REPLAY_STATE');
+            const parts = [];
+            for (const block of message.content) {
+                if (block.type === 'text')
+                    parts.push({ type: 'text', text: block.text });
+                else if (block.type === 'file')
+                    parts.push({ type: 'text', text: fileHandleText(block.attachment, attachments?.()?.fileHostPath(block.attachment)) });
+                else if (block.type === 'image')
+                    parts.push(await imagePart(block));
+            }
+            prompt.push({ role: 'tool', content: [{ type: 'tool-result', toolCallId: callIds.get(message.toolCallId) ?? message.toolCallId, toolName,
+                        output: message.isError ? { type: 'error-text', value: parts.map(part => part.type === 'text' ? part.text : '[image]').join('\n') } : { type: 'content', value: parts } }] });
+            continue;
+        }
+        const content = [];
+        const replay = projectReplay('source' in message ? message.source : undefined, message.content, model, options.provider, warn);
+        for (const [original, wire] of replay.callIds)
+            callIds.set(original, wire);
+        for (const [index, block] of message.content.entries()) {
+            const providerOptions = replay.blocks[index];
+            if (block.type === 'text')
+                content.push({ type: 'text', text: block.text, providerOptions });
+            else if (block.type === 'file')
+                content.push({ type: 'text', text: fileHandleText(block.attachment, attachments?.()?.fileHostPath(block.attachment)) });
+            else if (block.type === 'reasoning' && message.role === 'assistant') {
+                requireReplaySignature(block, model.protocol, providerOptions);
+                content.push({ type: 'reasoning', text: block.text, providerOptions });
+            }
+            else if (block.type === 'tool-call' && message.role === 'assistant') {
+                if (model.protocol === 'responses' && block.id.includes('|') && !replay.callIds.has(block.id))
+                    throw new LlmError('Cannot restore legacy Responses tool call pairing', 'INVALID_REPLAY_STATE');
+                if (names.has(block.id))
+                    throw new LlmError('Duplicate stored tool call id', 'INVALID_REPLAY_STATE');
+                if (model.protocol === 'google' && model.reasoning && !providerOptions?.google?.thoughtSignature && !message.content.slice(0, index).some(part => part.type === 'tool-call'))
+                    throw new LlmError('Cannot replay Google tool call without its verified thought signature', 'INVALID_REPLAY_STATE');
+                names.set(block.id, block.name);
+                let input;
+                try {
+                    input = JSON.parse(block.arguments);
+                }
+                catch {
+                    throw new LlmError('Stored tool arguments are not valid JSON', 'INVALID_REPLAY_STATE');
+                }
+                content.push({ type: 'tool-call', toolCallId: callIds.get(block.id) ?? block.id, toolName: block.name, input, providerOptions });
+            }
+            else if (block.type === 'image') {
+                if (message.role === 'assistant')
+                    throw new LlmError('Structured assistant image output is unsupported', 'UNSUPPORTED_CONTENT');
+                content.push(await imagePart(block));
+            }
+        }
+        prompt.push({ role: message.role, content });
+    }
+    return prompt;
+}

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

@@ -0,0 +1,113 @@
+/** Generated from official rosters and exact-route models.dev metadata. */
+export declare const OPEN_CODE_SNAPSHOTS: {
+    opencode: {
+        version: number;
+        provider: string;
+        fetchedAt: number;
+        roster: string[];
+        models: ({
+            id: string;
+            name: string;
+            protocol: string;
+            contextWindow: number;
+            maxTokens: number;
+            inputModalities: string[];
+            toolCall: boolean;
+            reasoning: boolean;
+            temperature: boolean;
+            efforts: string[];
+            cost: {
+                input: number;
+                output: number;
+                cache_read: number;
+                cache_write: number;
+                input_audio?: undefined;
+            };
+        } | {
+            id: string;
+            name: string;
+            protocol: string;
+            contextWindow: number;
+            maxTokens: number;
+            inputModalities: string[];
+            toolCall: boolean;
+            reasoning: boolean;
+            temperature: boolean;
+            efforts: string[];
+            cost: {
+                input: number;
+                output: number;
+                cache_read: number;
+                cache_write?: undefined;
+                input_audio?: undefined;
+            };
+        } | {
+            id: string;
+            name: string;
+            protocol: string;
+            contextWindow: number;
+            maxTokens: number;
+            inputModalities: string[];
+            toolCall: boolean;
+            reasoning: boolean;
+            temperature: boolean;
+            efforts: string[];
+            cost: {
+                input: number;
+                output: number;
+                cache_read: number;
+                input_audio: number;
+                cache_write?: undefined;
+            };
+        })[];
+        excluded: {
+            id: string;
+            reason: string;
+        }[];
+    };
+    "opencode-go": {
+        version: number;
+        provider: string;
+        fetchedAt: number;
+        roster: string[];
+        models: ({
+            id: string;
+            name: string;
+            protocol: string;
+            contextWindow: number;
+            maxTokens: number;
+            inputModalities: string[];
+            toolCall: boolean;
+            reasoning: boolean;
+            temperature: boolean;
+            efforts: string[];
+            cost: {
+                input: number;
+                output: number;
+                cache_read: number;
+                cache_write?: undefined;
+            };
+        } | {
+            id: string;
+            name: string;
+            protocol: string;
+            contextWindow: number;
+            maxTokens: number;
+            inputModalities: string[];
+            toolCall: boolean;
+            reasoning: boolean;
+            temperature: boolean;
+            efforts: string[];
+            cost: {
+                input: number;
+                output: number;
+                cache_read: number;
+                cache_write: number;
+            };
+        })[];
+        excluded: {
+            id: string;
+            reason: string;
+        }[];
+    };
+};