dsh-plugin-subscriptions 0.5.0 → 0.5.1

package/lib/translate/chat-completions.js

@@ -0,0 +1,363 @@
+/**
+ * Translate between the harness message vocabulary and the OpenAI chat
+ * completions wire format the Copilot provider speaks: request message/tool
+ * assembly and a push-model SSE-chunk → StreamChunk state machine
+ * ({@link ChatCompletionsStreamTranslator}) mirroring the Responses
+ * translator, so tests need no streams.
+ */
+import { CallId, EMPTY_RESPONSE_CODE, LlmError } from '@deepseek-ai/dsh-llm';
+import { parseSse } from './sse.js';
+/** Flatten a tool result's content to plain text for a `tool` message. */
+function toolResultText(block) {
+    return block.content.map(part => (part.type === 'text' ? part.text : '')).join('');
+}
+/**
+ * Convert harness messages into chat completions `messages`. System-role
+ * messages become one leading `system` message; an explicit `system` argument
+ * wins over them when both exist. Reasoning blocks are not replayed (matching
+ * the Responses translator). Images must arrive pre-resolved; an unresolved
+ * ImageBlock is skipped because its bytes are unreachable here. A user message
+ * carrying only text collapses to a plain string body (some endpoints still
+ * reject content-part arrays); tool results become separate `tool` messages.
+ * @param messages - ordered conversation messages with resolved images.
+ * @param system - explicit system prompt, which takes precedence.
+ * @returns the wire `messages` array.
+ */
+export function toChatMessages(messages, system) {
+    const out = [];
+    const systemTexts = [];
+    for (const message of messages) {
+        if (message.role === 'system') {
+            for (const block of message.content) {
+                if (block.type === 'text')
+                    systemTexts.push(block.text);
+            }
+            continue;
+        }
+        if (message.role === 'user') {
+            // Tool results ride inside user-role messages; they become their own
+            // `tool` messages while ordinary blocks accumulate into one user entry.
+            let texts = [];
+            let parts = [];
+            const flushUser = () => {
+                if (parts.length > 0) {
+                    if (texts.length > 0)
+                        parts.unshift({ type: 'text', text: texts.join('\n') });
+                    out.push({ role: 'user', content: parts });
+                }
+                else if (texts.length > 0) {
+                    out.push({ role: 'user', content: texts.join('\n') });
+                }
+                texts = [];
+                parts = [];
+            };
+            for (const block of message.content) {
+                switch (block.type) {
+                    case 'text':
+                        texts.push(block.text);
+                        break;
+                    case 'image':
+                        if ('dataBase64' in block) {
+                            parts.push({
+                                type: 'image_url',
+                                image_url: { url: `data:${block.mediaType};base64,${block.dataBase64}` },
+                            });
+                        }
+                        break;
+                    case 'tool-result':
+                        flushUser();
+                        out.push({
+                            role: 'tool',
+                            tool_call_id: String(block.toolCallId),
+                            content: toolResultText(block),
+                        });
+                        break;
+                    default:
+                        break;
+                }
+            }
+            flushUser();
+            continue;
+        }
+        // assistant: text becomes content, tool calls become the tool_calls array.
+        const texts = [];
+        const toolCalls = [];
+        for (const block of message.content) {
+            switch (block.type) {
+                case 'text':
+                    texts.push(block.text);
+                    break;
+                case 'tool-call':
+                    toolCalls.push({
+                        id: String(block.id),
+                        type: 'function',
+                        function: { name: block.name, arguments: block.arguments },
+                    });
+                    break;
+                default:
+                    // reasoning (not replayed), unknown blocks.
+                    break;
+            }
+        }
+        if (texts.length === 0 && toolCalls.length === 0)
+            continue;
+        out.push({
+            role: 'assistant',
+            content: texts.join('\n'),
+            ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {},
+        });
+    }
+    const systemText = system ?? (systemTexts.length > 0 ? systemTexts.join('\n\n') : undefined);
+    if (systemText !== undefined)
+        out.unshift({ role: 'system', content: systemText });
+    return out;
+}
+/**
+ * Map harness tool schemas to chat completions function tools.
+ * @param tools - tool schemas from the request.
+ * @returns the wire `tools` array.
+ */
+export function toChatTools(tools) {
+    return tools.map(tool => ({
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+        },
+    }));
+}
+/**
+ * Map chat completions usage to disjoint harness counts (cached input is
+ * subtracted out of `inputTokens` and reported as `cacheReadTokens`).
+ * @param usage - wire usage from the terminal chunk.
+ * @returns harness token usage.
+ */
+export function mapChatCompletionsUsage(usage) {
+    const cached = usage.prompt_tokens_details?.cached_tokens;
+    const reasoning = usage.completion_tokens_details?.reasoning_tokens;
+    return {
+        inputTokens: usage.prompt_tokens - (cached ?? 0),
+        outputTokens: usage.completion_tokens,
+        ...cached !== undefined ? { cacheReadTokens: cached } : {},
+        ...reasoning !== undefined ? { reasoningTokens: reasoning } : {},
+    };
+}
+/** Assemble the final ContentBlock for one open block. */
+function closeBlock(block) {
+    switch (block.kind) {
+        case 'text':
+            return { type: 'text', text: block.text };
+        case 'reasoning':
+            return { type: 'reasoning', text: block.text };
+        case 'tool-call':
+            return {
+                type: 'tool-call',
+                id: CallId(block.callId),
+                name: block.name ?? '',
+                arguments: block.text,
+            };
+    }
+}
+/**
+ * Push-model chat completions SSE translator: feed each parsed chunk object
+ * to {@link push} and collect the emitted harness StreamChunks. The terminal
+ * `finish_reason` chunk closes every block but only ARMS the finish chunk —
+ * usage must precede the terminal finish, and where usage lives differs by
+ * upstream: OpenAI-style streams send a trailing usage-only chunk
+ * (stream_options.include_usage), while Copilot's Gemini models attach a
+ * (zero) usage object to EVERY chunk and fold the real usage into the
+ * finish chunk itself. A chunk therefore never early-returns on `usage`
+ * alone: its deltas are always processed, and the terminal pair is drained
+ * when the finish is armed and usage arrived (or when a usage-only chunk
+ * follows an armed finish). `flush()` emits whatever remains when the
+ * stream's `[DONE]` (or EOF) arrives.
+ */
+export class ChatCompletionsStreamTranslator {
+    /** Text/reasoning blocks keyed by kind; tool calls keyed by their wire index. */
+    blocks = new Map();
+    order = [];
+    nextIndex = 0;
+    sawToolCall = false;
+    pendingUsage;
+    armedFinish;
+    /** Set once the terminal finish chunk was emitted. */
+    terminated = false;
+    open(key, kind, chunks, callId = '', name) {
+        const block = {
+            index: this.nextIndex++,
+            kind,
+            text: '',
+            callId,
+            ...name === undefined ? {} : { name },
+        };
+        this.blocks.set(key, block);
+        this.order.push(block);
+        chunks.push({ type: 'block-start', index: block.index, blockType: kind });
+        return block;
+    }
+    close(key, chunks) {
+        const block = this.blocks.get(key);
+        if (block === undefined)
+            return;
+        this.blocks.delete(key);
+        chunks.push({ type: 'block-end', index: block.index, block: closeBlock(block) });
+    }
+    closeAll(chunks) {
+        for (const key of [...this.blocks.keys()])
+            this.close(key, chunks);
+    }
+    /** Build the terminal finish chunk for one wire finish reason. */
+    finishChunk(finishReason) {
+        if (this.order.length === 0) {
+            return {
+                type: 'finish',
+                reason: {
+                    kind: 'error',
+                    failure: { message: 'model returned a completed response with no content', code: EMPTY_RESPONSE_CODE },
+                },
+            };
+        }
+        switch (finishReason) {
+            case 'tool_calls':
+                return { type: 'finish', reason: { kind: 'tool-calls' } };
+            case 'length':
+                return { type: 'finish', reason: { kind: 'max-tokens' } };
+            case 'content_filter':
+                return {
+                    type: 'finish',
+                    reason: {
+                        kind: 'error',
+                        failure: { message: 'the response was blocked by the provider content filter', code: 'CONTENT_FILTER' },
+                    },
+                };
+            default:
+                return { type: 'finish', reason: { kind: this.sawToolCall ? 'tool-calls' : 'stop' } };
+        }
+    }
+    /** Usage, then the armed finish: the only order the harness accepts. */
+    drainTerminal(chunks) {
+        if (this.pendingUsage !== undefined) {
+            chunks.push({ type: 'usage', usage: mapChatCompletionsUsage(this.pendingUsage) });
+            this.pendingUsage = undefined;
+        }
+        if (this.armedFinish !== undefined) {
+            chunks.push(this.armedFinish);
+            this.armedFinish = undefined;
+            this.terminated = true;
+        }
+    }
+    /**
+     * Process one parsed chat-completion chunk.
+     * @param event - the parsed chunk object.
+     * @returns the StreamChunks this event produced (possibly none).
+     */
+    push(event) {
+        if (this.terminated)
+            return [];
+        const chunks = [];
+        const usage = event.usage;
+        const hasUsage = usage !== undefined && usage !== null;
+        if (hasUsage)
+            this.pendingUsage = usage;
+        const choice = event.choices?.[0];
+        const delta = choice?.delta;
+        if (delta !== undefined) {
+            if (typeof delta.content === 'string' && delta.content.length > 0) {
+                const block = this.blocks.get('content') ?? this.open('content', 'text', chunks);
+                block.text += delta.content;
+                chunks.push({ type: 'text-delta', index: block.index, text: delta.content });
+            }
+            const reasoning = typeof delta.reasoning_content === 'string' ? delta.reasoning_content
+                : typeof delta.reasoning_text === 'string' ? delta.reasoning_text
+                    : undefined;
+            if (reasoning !== undefined && reasoning.length > 0) {
+                const block = this.blocks.get('reasoning') ?? this.open('reasoning', 'reasoning', chunks);
+                block.text += reasoning;
+                chunks.push({ type: 'reasoning-delta', index: block.index, text: reasoning });
+            }
+            for (const call of delta.tool_calls ?? []) {
+                const key = `call:${String(call.index ?? 0)}`;
+                let block = this.blocks.get(key);
+                if (block === undefined) {
+                    this.sawToolCall = true;
+                    block = this.open(key, 'tool-call', chunks, call.id ?? '', call.function?.name);
+                    chunks.push({
+                        type: 'tool-call-delta',
+                        index: block.index,
+                        id: CallId(block.callId),
+                        ...block.name === undefined ? {} : { name: block.name },
+                        argumentsDelta: '',
+                    });
+                }
+                if (call.function?.arguments !== undefined && call.function.arguments.length > 0) {
+                    block.text += call.function.arguments;
+                    chunks.push({
+                        type: 'tool-call-delta',
+                        index: block.index,
+                        id: CallId(block.callId),
+                        argumentsDelta: call.function.arguments,
+                    });
+                }
+            }
+        }
+        if (choice?.finish_reason !== undefined && choice.finish_reason !== null) {
+            this.closeAll(chunks);
+            // Only arm: usage must be emitted before the terminal finish, and it
+            // may still arrive (OpenAI's trailing usage-only chunk) or may have
+            // arrived in this very chunk (Gemini folds it in). The drain below or
+            // flush() releases the pair.
+            if (this.armedFinish === undefined)
+                this.armedFinish = this.finishChunk(choice.finish_reason);
+        }
+        // Drain at the terminal point: this chunk carried usage AND either the
+        // finish is armed (usage + finish pair complete — same chunk for Gemini,
+        // trailing chunk for OpenAI) or the chunk is usage-only (no choices to
+        // process). Mid-stream usage carriers (Gemini's zero-usage deltas) keep
+        // their pendingUsage for a later drain; only the final real usage is
+        // emitted.
+        if (hasUsage && (this.armedFinish !== undefined || choice === undefined)) {
+            this.drainTerminal(chunks);
+        }
+        return chunks;
+    }
+    /**
+     * Emit whatever the stream left pending (`[DONE]` or EOF without a final
+     * usage chunk). Safe to call repeatedly.
+     * @returns the remaining terminal chunks.
+     */
+    flush() {
+        const chunks = [];
+        this.drainTerminal(chunks);
+        return chunks;
+    }
+}
+/**
+ * Consume a chat completions SSE byte stream and yield harness StreamChunks.
+ * @param stream - raw response body.
+ * @param onActivity - transport-activity callback for the idle watchdog.
+ * @returns the chunk stream; throws when the stream ends before any finish chunk.
+ */
+export async function* streamChatCompletions(stream, onActivity) {
+    const translator = new ChatCompletionsStreamTranslator();
+    for await (const sseEvent of parseSse(stream, onActivity)) {
+        if (sseEvent.data === '[DONE]') {
+            yield* translator.flush();
+            return;
+        }
+        let event;
+        try {
+            event = JSON.parse(sseEvent.data);
+        }
+        catch {
+            throw new LlmError(`malformed SSE payload: ${sseEvent.data.slice(0, 120)}`, 'MALFORMED_RESPONSE');
+        }
+        yield* translator.push(event);
+        if (translator.terminated)
+            return;
+    }
+    yield* translator.flush();
+    if (!translator.terminated) {
+        throw new LlmError('chat completions SSE stream ended before a finish chunk', 'STREAM_CLOSED');
+    }
+}

package/lib/translate/responses.d.ts

@@ -14,17 +14,46 @@ export interface ResponsesRequestInput {
     /** Responses `input` items in conversation order. */
     input: Record<string, unknown>[];
 }
+/**
+ * One COMPLETED reasoning output item captured off a response, replayed as
+ * the complete item on a later request of the same conversation. The
+ * Responses input schema does not treat a reasoning item's `id` or
+ * `summary` as optional — a bare `{ type, encrypted_content }` is not a
+ * valid input item — so the capture keeps the item's gateway id (as it
+ * arrived on the done event), its summary parts, its status, and the
+ * encrypted payload. `encrypted_content` is the only required field here:
+ * items without one are simply never captured.
+ */
+export interface ReasoningReplayItem {
+    type: 'reasoning';
+    /** The item's gateway id as it arrived on the done event. */
+    id?: string;
+    /** Summary parts, passed through when the gateway disclosed them. */
+    summary?: unknown[];
+    /** Item lifecycle status, passed through when present (typically `completed`). */
+    status?: string;
+    /** Encrypted reasoning payload; the reason the item is worth replaying. */
+    encrypted_content: string;
+}
 /**
  * Convert harness messages into Responses `instructions` + `input` items.
  * System-role messages become `instructions`; an explicit `system` argument
- * wins over them when both exist. Reasoning blocks are not replayed (v1).
- * Images must arrive pre-resolved ({@link TranslatableMessage}); an unresolved
- * ImageBlock is skipped because its bytes are unreachable here.
+ * wins over them when both exist. Reasoning blocks are never replayed in
+ * their text form: a Responses model continuing past a tool call needs its
+ * reasoning back as the provider's completed reasoning items (id, summary,
+ * and the ENCRYPTED payload), so `reasoningFor` may resolve per-call
+ * captured items, replayed ahead of the matching function_call item. Images
+ * must arrive pre-resolved
+ * ({@link TranslatableMessage}); an unresolved ImageBlock is skipped because
+ * its bytes are unreachable here.
  * @param messages - ordered conversation messages with resolved images.
  * @param system - explicit system prompt, which takes precedence.
+ * @param reasoningFor - resolves one tool call id to the COMPLETED reasoning
+ *   items captured for it (id, summary, status, encrypted payload), replayed
+ *   ahead of the matching function_call item, when the adapter kept them.
  * @returns request fields ready to merge into the request body.
  */
-export declare function toResponsesInput(messages: readonly TranslatableMessage[], system?: string): ResponsesRequestInput;
+export declare function toResponsesInput(messages: readonly TranslatableMessage[], system?: string, reasoningFor?: (callId: string) => readonly ReasoningReplayItem[] | undefined): ResponsesRequestInput;
 /**
  * Map harness tool schemas to Responses function tools.
  * @param tools - tool schemas from the request.
@@ -35,6 +64,12 @@ export declare function toResponsesTools(tools: readonly ToolSchema[]): Record<s
 export interface ResponsesStreamEvent {
     type: string;
     item_id?: string;
+    /**
+     * Position of the event's item in the response's output array. The spec
+     * carries it on output_item/delta events; Copilot's adapter uses it as the
+     * stable item correlator when the gateway mints fresh ids per event.
+     */
+    output_index?: number;
     content_index?: number;
     summary_index?: number;
     delta?: string;
@@ -44,6 +79,12 @@ export interface ResponsesStreamEvent {
         call_id?: string;
         name?: string;
         arguments?: string;
+        /** Encrypted reasoning payload, present when the request asked to include it. */
+        encrypted_content?: string;
+        /** Summary parts of a completed reasoning item, when the gateway disclosed them. */
+        summary?: unknown[];
+        /** Item lifecycle status (e.g. `completed`), when present. */
+        status?: string;
         content?: Array<{
             type?: string;
             text?: string;
@@ -122,6 +163,9 @@ export declare class ResponsesStreamTranslator {
  * Consume a Responses SSE byte stream and yield harness StreamChunks.
  * @param stream - raw response body.
  * @param onActivity - transport-activity callback for the idle watchdog.
+ * @param transform - optional per-event rewrite applied before translation
+ *   (Copilot's gateway mints a fresh item id per event; the adapter rewrites
+ *   them into stable per-item keys).
  * @returns the chunk stream; throws when the stream ends before `response.completed`.
  */
-export declare function streamResponses(stream: ReadableStream<Uint8Array>, onActivity?: () => void): AsyncGenerator<StreamChunk>;
+export declare function streamResponses(stream: ReadableStream<Uint8Array>, onActivity?: () => void, transform?: (event: ResponsesStreamEvent) => ResponsesStreamEvent): AsyncGenerator<StreamChunk>;

package/lib/translate/responses.js

@@ -13,16 +13,29 @@ function toolResultText(block) {
 /**
  * Convert harness messages into Responses `instructions` + `input` items.
  * System-role messages become `instructions`; an explicit `system` argument
- * wins over them when both exist. Reasoning blocks are not replayed (v1).
- * Images must arrive pre-resolved ({@link TranslatableMessage}); an unresolved
- * ImageBlock is skipped because its bytes are unreachable here.
+ * wins over them when both exist. Reasoning blocks are never replayed in
+ * their text form: a Responses model continuing past a tool call needs its
+ * reasoning back as the provider's completed reasoning items (id, summary,
+ * and the ENCRYPTED payload), so `reasoningFor` may resolve per-call
+ * captured items, replayed ahead of the matching function_call item. Images
+ * must arrive pre-resolved
+ * ({@link TranslatableMessage}); an unresolved ImageBlock is skipped because
+ * its bytes are unreachable here.
  * @param messages - ordered conversation messages with resolved images.
  * @param system - explicit system prompt, which takes precedence.
+ * @param reasoningFor - resolves one tool call id to the COMPLETED reasoning
+ *   items captured for it (id, summary, status, encrypted payload), replayed
+ *   ahead of the matching function_call item, when the adapter kept them.
  * @returns request fields ready to merge into the request body.
  */
-export function toResponsesInput(messages, system) {
+export function toResponsesInput(messages, system, reasoningFor) {
     const input = [];
     const systemTexts = [];
+    // [2026-08-23]-[reasoning models lose their chain of thought across a tool
+    // round trip unless the completed reasoning items ride back in; dedupe by
+    // ARRAY REFERENCE so parallel calls of one response (which share one array
+    // instance) replay the items once, before the first of them]
+    let lastReplay;
     for (const message of messages) {
         if (message.role === 'system') {
             for (const block of message.content) {
@@ -44,8 +57,21 @@ export function toResponsesInput(messages, system) {
                 case 'text':
                     content.push({ type: role === 'assistant' ? 'output_text' : 'input_text', text: block.text });
                     break;
-                case 'tool-call':
+                case 'tool-call': {
                     flushMessage();
+                    const encrypted = reasoningFor?.(String(block.id));
+                    if (encrypted !== undefined && encrypted !== lastReplay) {
+                        for (const item of encrypted) {
+                            input.push({
+                                type: 'reasoning',
+                                ...item.id === undefined ? {} : { id: item.id },
+                                ...item.summary === undefined ? {} : { summary: item.summary },
+                                ...item.status === undefined ? {} : { status: item.status },
+                                encrypted_content: item.encrypted_content,
+                            });
+                        }
+                        lastReplay = encrypted;
+                    }
                     input.push({
                         type: 'function_call',
                         call_id: String(block.id),
@@ -53,6 +79,7 @@ export function toResponsesInput(messages, system) {
                         arguments: block.arguments,
                     });
                     break;
+                }
                 case 'tool-result':
                     flushMessage();
                     input.push({
@@ -72,7 +99,8 @@ export function toResponsesInput(messages, system) {
                     // adapter resolves images before translation, so this is skipped.
                     break;
                 default:
-                    // reasoning (not replayed), unknown blocks.
+                    // reasoning's text form is not replayed (encrypted replay rides
+                    // reasoningFor), unknown blocks.
                     break;
             }
         }
@@ -332,9 +360,12 @@ export class ResponsesStreamTranslator {
  * Consume a Responses SSE byte stream and yield harness StreamChunks.
  * @param stream - raw response body.
  * @param onActivity - transport-activity callback for the idle watchdog.
+ * @param transform - optional per-event rewrite applied before translation
+ *   (Copilot's gateway mints a fresh item id per event; the adapter rewrites
+ *   them into stable per-item keys).
  * @returns the chunk stream; throws when the stream ends before `response.completed`.
  */
-export async function* streamResponses(stream, onActivity) {
+export async function* streamResponses(stream, onActivity, transform) {
     const translator = new ResponsesStreamTranslator();
     for await (const sseEvent of parseSse(stream, onActivity)) {
         let event;
@@ -344,6 +375,8 @@ export async function* streamResponses(stream, onActivity) {
         catch {
             throw new LlmError(`malformed SSE payload: ${sseEvent.data.slice(0, 120)}`, 'MALFORMED_RESPONSE');
         }
+        if (transform !== undefined)
+            event = transform(event);
         yield* translator.push(event);
         if (translator.terminated)
             return;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-plugin-subscriptions",
-  "version": "0.5.0",
-  "description": "Use ChatGPT (Codex), Claude, and Grok (X Premium) subscriptions as DeepSeek Harness LLM providers, with OAuth login from the web Settings page",
+  "version": "0.5.1",
+  "description": "Use ChatGPT (Codex), Claude, Grok (X Premium), and GitHub Copilot subscriptions as DeepSeek Harness LLM providers, with OAuth login from the web Settings page",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -15,7 +15,8 @@
     "chatgpt",
     "codex",
     "claude",
-    "grok"
+    "grok",
+    "github-copilot"
   ],
   "type": "module",
   "main": "lib/index.js",
@@ -48,12 +49,6 @@
       ]
     }
   },
-  "scripts": {
-    "build": "tsc && tsdown",
-    "test": "tsc -p tsconfig.test.json && node --test lib-test/test/",
-    "prepare": "tsdown -c tsdown.prepare.config.ts",
-    "prepublishOnly": "pnpm build && pnpm test"
-  },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-attachment": "^0.1.0-rc.5",
@@ -83,5 +78,9 @@
     "react": "^18.2.0",
     "tsdown": "^0.15.0",
     "typescript": "^5.8.0"
+  },
+  "scripts": {
+    "build": "tsc && tsdown",
+    "test": "tsc -p tsconfig.test.json && node --test lib-test/test/"
   }
-}
+}