dsh-subscriptions 0.1.2 → 0.1.4

package/lib/providers/replay.js

@@ -0,0 +1,50 @@
+import { createHash } from 'node:crypto';
+const REPLAY_KIND = 'subscriptions-account-replay';
+/** Bind opaque replay to the concrete account/model behind a route alias. */
+export async function* streamAccountWithReplay(adapter, options, account, model = options.model) {
+    const key = createHash('sha256')
+        .update(JSON.stringify([options.provider, account, model])).digest('hex');
+    const messages = options.messages.map(message => {
+        if (message.role !== 'assistant'
+            || message.source?.replayState === undefined)
+            return message;
+        const source = message.source;
+        if (source.replayState === null || typeof source.replayState !== 'object'
+            || !('response' in source.replayState))
+            return message;
+        const replay = source.replayState;
+        const response = replay.response;
+        if (response !== null && typeof response === 'object'
+            && 'kind' in response && response.kind === REPLAY_KIND) {
+            if ('version' in response && response.version === 1
+                && 'key' in response && response.key === key && 'state' in response) {
+                return { ...message, source: {
+                        ...source, provider: options.provider, model,
+                        replayState: { ...replay, response: response.state },
+                    } };
+            }
+            const { replayState: _discarded, ...withoutReplay } = source;
+            return { ...message, source: withoutReplay };
+        }
+        // Legacy replay has no originating-account identity. Preserve direct
+        // histories when provider/model match, as upstream does; switching
+        // accounts mid-session can therefore reuse the previous account's signed
+        // request prefix. An alias cannot identify the legacy concrete member.
+        if (source.provider === options.provider && source.model === model) {
+            return message;
+        }
+        const { replayState: _discarded, ...withoutReplay } = source;
+        return { ...message, source: withoutReplay };
+    });
+    for await (const chunk of adapter.streamAccount({
+        ...options, model, messages,
+    }, account)) {
+        if (chunk.type === 'finish' && chunk.replayState !== undefined) {
+            yield { ...chunk, replayState: { ...chunk.replayState, response: {
+                        kind: REPLAY_KIND, version: 1, key, state: chunk.replayState.response,
+                    } } };
+        }
+        else
+            yield chunk;
+    }
+}

package/lib/providers/reset-redemption.d.ts

@@ -0,0 +1,51 @@
+import type { ProviderUsage } from './common.js';
+export interface ResetConfirmation {
+    ticket: string;
+    expiresAt: number;
+    creditExpiresAt?: number;
+    weeklyUsedPercent: number;
+}
+/**
+ * Manual-only redemption with single-use tickets. An ambiguous submission parks
+ * the account to prevent an immediate blind retry. This block is process-local,
+ * not a durable rate limit: restarting the host clears it. Re-check credits and
+ * limits in Codex before retrying; a lost success response may have spent a
+ * credit already, and another submission can spend another credit.
+ * Rationale: [manual reset note](../../.agents/notes/implemented/provider/2026-10-04-codex-manual-reset.md).
+ */
+export declare class ResetRedemption {
+    private readonly read;
+    private readonly consume;
+    private readonly invalidate;
+    /**
+     * Stable identity for one real account: the same key the usage cache uses,
+     * so the guards and the cache invalidate together. The RPC carries whatever
+     * reference the browser holds — a canonical id, a legacy key, an email, a
+     * workspace id — and all of them resolve to one stored account.
+     *
+     * It must not fall back to the raw reference on failure. A fallback would
+     * re-key the state by whatever happened to arrive, so a transient lookup
+     * error could let a later alias past an uncertain park. Resolution here
+     * reads the local credential store only, so failing is safe and honest.
+     */
+    private readonly canonical;
+    private tickets;
+    private busy;
+    private uncertain;
+    constructor(read: (account: string, signal: AbortSignal) => Promise<ProviderUsage>, consume: (account: string, creditId: string, requestId: string, signal: AbortSignal) => Promise<void>, invalidate: (account: string) => void, 
+    /**
+     * Stable identity for one real account: the same key the usage cache uses,
+     * so the guards and the cache invalidate together. The RPC carries whatever
+     * reference the browser holds — a canonical id, a legacy key, an email, a
+     * workspace id — and all of them resolve to one stored account.
+     *
+     * It must not fall back to the raw reference on failure. A fallback would
+     * re-key the state by whatever happened to arrive, so a transient lookup
+     * error could let a later alias past an uncertain park. Resolution here
+     * reads the local credential store only, so failing is safe and honest.
+     */
+    canonical: (account: string, signal: AbortSignal) => Promise<string>);
+    private eligible;
+    prepare(account: string, signal: AbortSignal): Promise<ResetConfirmation>;
+    redeem(account: string, ticket: string, signal: AbortSignal): Promise<void>;
+}

package/lib/providers/reset-redemption.js

@@ -0,0 +1,102 @@
+import { randomUUID } from 'node:crypto';
+/**
+ * Manual-only redemption with single-use tickets. An ambiguous submission parks
+ * the account to prevent an immediate blind retry. This block is process-local,
+ * not a durable rate limit: restarting the host clears it. Re-check credits and
+ * limits in Codex before retrying; a lost success response may have spent a
+ * credit already, and another submission can spend another credit.
+ * Rationale: [manual reset note](../../.agents/notes/implemented/provider/2026-10-04-codex-manual-reset.md).
+ */
+export class ResetRedemption {
+    read;
+    consume;
+    invalidate;
+    canonical;
+    tickets = new Map();
+    busy = new Set();
+    uncertain = new Set();
+    constructor(read, consume, invalidate, 
+    /**
+     * Stable identity for one real account: the same key the usage cache uses,
+     * so the guards and the cache invalidate together. The RPC carries whatever
+     * reference the browser holds — a canonical id, a legacy key, an email, a
+     * workspace id — and all of them resolve to one stored account.
+     *
+     * It must not fall back to the raw reference on failure. A fallback would
+     * re-key the state by whatever happened to arrive, so a transient lookup
+     * error could let a later alias past an uncertain park. Resolution here
+     * reads the local credential store only, so failing is safe and honest.
+     */
+    canonical) {
+        this.read = read;
+        this.consume = consume;
+        this.invalidate = invalidate;
+        this.canonical = canonical;
+    }
+    eligible(usage) {
+        const weekly = usage.windows?.find(w => w.kind === 'weekly' && w.scope === undefined);
+        if (!weekly || !Number.isFinite(weekly.usedPercent) || weekly.usedPercent < 80
+            || weekly.resetsAt === undefined || weekly.resetsAt <= Date.now()) {
+            throw new Error('Reset blocked: fresh weekly usage must be at least 80%.');
+        }
+        if (usage.resetCreditsError)
+            throw new Error('Reset credits could not be verified.');
+        return weekly.usedPercent;
+    }
+    async prepare(account, signal) {
+        const who = await this.canonical(account, signal);
+        if (this.busy.has(who) || this.uncertain.has(who))
+            throw new Error('Reset blocked: an operation is pending or its outcome is uncertain. Check Codex before retrying.');
+        const usage = await this.read(account, signal);
+        // Re-check after the read. A confirmation prepared while another client was
+        // redeeming would otherwise be minted against a park that has since been
+        // cleared, letting the next click spend a second credit.
+        if (this.busy.has(who) || this.uncertain.has(who))
+            throw new Error('Reset blocked: an operation is pending or its outcome is uncertain. Check Codex before retrying.');
+        const weeklyUsedPercent = this.eligible(usage);
+        const credit = usage.resetCredits?.filter(c => c.id && (c.expiresAt === undefined || c.expiresAt > Date.now()))
+            .sort((a, b) => (a.expiresAt ?? Infinity) - (b.expiresAt ?? Infinity))[0];
+        if (!credit?.id)
+            throw new Error('No available reset credit.');
+        for (const [key, value] of this.tickets)
+            if (value.account === who || value.expiresAt <= Date.now())
+                this.tickets.delete(key);
+        const ticket = randomUUID();
+        const expiresAt = Date.now() + 60_000;
+        this.tickets.set(ticket, { account: who, creditId: credit.id, expiresAt });
+        return { ticket, expiresAt, weeklyUsedPercent, ...(credit.expiresAt === undefined ? {} : { creditExpiresAt: credit.expiresAt }) };
+    }
+    async redeem(account, ticket, signal) {
+        const who = await this.canonical(account, signal);
+        const pending = this.tickets.get(ticket);
+        this.tickets.delete(ticket);
+        if (!pending || pending.account !== who || pending.expiresAt <= Date.now())
+            throw new Error('Confirmation expired. Start again.');
+        if (this.busy.has(who) || this.uncertain.has(who))
+            throw new Error('Reset blocked: operation pending or uncertain.');
+        this.busy.add(who);
+        try {
+            const usage = await this.read(account, signal);
+            // The ticket bounds how long the confirmation counts. A read that
+            // outlives it must not go on to submit, so this comes first.
+            if (pending.expiresAt <= Date.now())
+                throw new Error('Confirmation expired. Start again.');
+            this.eligible(usage);
+            if (!usage.resetCredits?.some(c => c.id === pending.creditId && (c.expiresAt === undefined || c.expiresAt > Date.now())))
+                throw new Error('The selected reset is no longer available.');
+            // Mark before submission: no blind retry after transport or response ambiguity.
+            this.uncertain.add(who);
+            try {
+                await this.consume(account, pending.creditId, randomUUID(), signal);
+            }
+            catch {
+                throw new Error('Reset outcome could not be confirmed. Do not retry or restart to bypass this block; verify credits and limits in Codex first.');
+            }
+            this.uncertain.delete(who);
+        }
+        finally {
+            this.invalidate(who);
+            this.busy.delete(who);
+        }
+    }
+}

package/lib/translate/anthropic.d.ts

@@ -32,6 +32,23 @@ export declare const CACHE_BLOCK_STRIDE = 15;
  * blocks before a read is lost.
  */
 export declare const MESSAGE_CACHE_BREAKPOINTS = 3;
+/**
+ * How long Anthropic keeps a cache entry after its last use: five minutes
+ * (the API default) or one hour. A one-hour entry is written at twice the base
+ * input price instead of 1.25×, and reads cost the same either way.
+ */
+export type PromptCacheTtl = '5m' | '1h';
+/** The API default; a marker at this TTL carries no `ttl` field at all. */
+export declare const DEFAULT_PROMPT_CACHE_TTL: PromptCacheTtl;
+/**
+ * Build one `cache_control` marker.
+ *
+ * Five minutes is spelled by omitting `ttl`, so a request that does not opt in
+ * stays byte-identical to what earlier releases sent.
+ * @param ttl - cache lifetime; defaults to five minutes.
+ * @returns a fresh marker object (callers attach it to one block each).
+ */
+export declare function cacheControl(ttl?: PromptCacheTtl): Record<string, unknown>;
 /** One Anthropic request message. */
 export interface AnthropicMessage {
     role: 'user' | 'assistant';
@@ -62,17 +79,19 @@ export declare function toAnthropicMessages(messages: readonly TranslatableMessa
  * Marks are counted across the flattened block sequence, not per message,
  * because the lookback window Anthropic walks counts blocks the same way.
  * @param messages - assembled Anthropic messages, marked in place.
+ * @param ttl - cache lifetime for every mark; defaults to five minutes.
  */
-export declare function markMessageCache(messages: readonly AnthropicMessage[]): void;
+export declare function markMessageCache(messages: readonly AnthropicMessage[], ttl?: PromptCacheTtl): void;
 /**
  * Build the Anthropic `system` array: the mandatory Claude Code identity
  * block, then the explicit system prompt, then any system-role messages.
  * @param system - explicit system prompt, when set.
  * @param messages - conversation messages; the system-role text preceding the
  * conversation is appended, and a later one is left to {@link toAnthropicMessages}.
+ * @param ttl - cache lifetime for the tools+system mark; defaults to five minutes.
  * @returns the system content blocks.
  */
-export declare function toAnthropicSystem(system?: string, messages?: readonly TranslatableMessage[]): Record<string, unknown>[];
+export declare function toAnthropicSystem(system?: string, messages?: readonly TranslatableMessage[], ttl?: PromptCacheTtl): Record<string, unknown>[];
 /**
  * Map harness tool schemas to Anthropic tools, in name order.
  *

package/lib/translate/anthropic.js

@@ -32,6 +32,19 @@ export const CACHE_BLOCK_STRIDE = 15;
  * blocks before a read is lost.
  */
 export const MESSAGE_CACHE_BREAKPOINTS = 3;
+/** The API default; a marker at this TTL carries no `ttl` field at all. */
+export const DEFAULT_PROMPT_CACHE_TTL = '5m';
+/**
+ * Build one `cache_control` marker.
+ *
+ * Five minutes is spelled by omitting `ttl`, so a request that does not opt in
+ * stays byte-identical to what earlier releases sent.
+ * @param ttl - cache lifetime; defaults to five minutes.
+ * @returns a fresh marker object (callers attach it to one block each).
+ */
+export function cacheControl(ttl = DEFAULT_PROMPT_CACHE_TTL) {
+    return ttl === '1h' ? { type: 'ephemeral', ttl: '1h' } : { type: 'ephemeral' };
+}
 /** Preserve native image blocks, retaining the existing text-only wire shape. */
 function toolResultContent(block) {
     if (!block.content.some(part => part.type === 'image' && 'dataBase64' in part)) {
@@ -217,14 +230,15 @@ export function toAnthropicMessages(messages) {
  * Marks are counted across the flattened block sequence, not per message,
  * because the lookback window Anthropic walks counts blocks the same way.
  * @param messages - assembled Anthropic messages, marked in place.
+ * @param ttl - cache lifetime for every mark; defaults to five minutes.
  */
-export function markMessageCache(messages) {
+export function markMessageCache(messages, ttl) {
     const blocks = messages.flatMap(message => message.content);
     for (let mark = 0; mark < MESSAGE_CACHE_BREAKPOINTS; mark++) {
         const at = blocks.length - 1 - mark * CACHE_BLOCK_STRIDE;
         if (at < 0)
             return;
-        blocks[at].cache_control = { type: 'ephemeral' };
+        blocks[at].cache_control = cacheControl(ttl);
     }
 }
 /**
@@ -233,9 +247,10 @@ export function markMessageCache(messages) {
  * @param system - explicit system prompt, when set.
  * @param messages - conversation messages; the system-role text preceding the
  * conversation is appended, and a later one is left to {@link toAnthropicMessages}.
+ * @param ttl - cache lifetime for the tools+system mark; defaults to five minutes.
  * @returns the system content blocks.
  */
-export function toAnthropicSystem(system, messages) {
+export function toAnthropicSystem(system, messages, ttl) {
     const blocks = [{ type: 'text', text: CLAUDE_CODE_IDENTITY }];
     if (system !== undefined && system.length > 0)
         blocks.push({ type: 'text', text: system });
@@ -249,7 +264,11 @@ export function toAnthropicSystem(system, messages) {
     // `tools` renders ahead of `system`, so this one marker caches both. It is
     // deliberately separate from the message marks: a tool_choice or thinking
     // change invalidates the messages tier only, and this entry survives it.
-    blocks[blocks.length - 1].cache_control = { type: 'ephemeral' };
+    //
+    // Anthropic processes `tools`, `system`, then `messages`, and rejects a
+    // one-hour mark that follows a five-minute one (HTTP 400). This mark and the
+    // message marks therefore share one TTL, which can never hit that ordering.
+    blocks[blocks.length - 1].cache_control = cacheControl(ttl);
     return blocks;
 }
 /**
@@ -294,16 +313,21 @@ function closeBlock(block) {
  * @returns the mapped error.
  */
 export function anthropicFailure(error) {
+    // Safe here means this diagnostic path carries no provider-controlled free text,
+    // not that no secret can exist anywhere. Raw values remain local classification inputs.
     const type = error?.type ?? 'unknown_error';
     const message = error?.message ?? `Anthropic reported ${type}`;
+    let classification = 'SERVER';
     if (type === 'invalid_request_error' && /prompt is too long/i.test(message)) {
-        return new LlmError(message, CONTEXT_WINDOW_EXCEEDED_CODE);
+        classification = CONTEXT_WINDOW_EXCEEDED_CODE;
+    }
+    else if (type === 'rate_limit_error') {
+        classification = 'RATE_LIMIT';
+    }
+    else if (type === 'authentication_error') {
+        classification = 'AUTH';
     }
-    if (type === 'rate_limit_error')
-        return new LlmError(message, 'RATE_LIMIT');
-    if (type === 'authentication_error')
-        return new LlmError(message, 'AUTH');
-    return new LlmError(message, 'SERVER');
+    return new LlmError(`Anthropic failure (${classification}): [provider response body omitted]`, classification);
 }
 /**
  * Push-model Anthropic SSE translator: feed each parsed event object to
@@ -505,7 +529,7 @@ export async function* streamAnthropic(stream, onActivity) {
             event = JSON.parse(sseEvent.data);
         }
         catch {
-            throw new LlmError(`malformed SSE payload: ${sseEvent.data.slice(0, 120)}`, 'MALFORMED_RESPONSE');
+            throw new LlmError('malformed SSE payload (MALFORMED_RESPONSE): [provider response body omitted]', 'MALFORMED_RESPONSE');
         }
         yield* translator.push(event);
         if (translator.terminated)

package/lib/translate/antigravity.js

@@ -15,9 +15,11 @@ import { antigravityToolParameters } from './antigravity-schema.js';
  * `FunctionResponse.response` field requires. That field maps to a singular
  * protobuf `Struct`, so a bare array, string, number or boolean is rejected
  * by the endpoint with "Proto field is not repeating, cannot start list".
- * Only a non-array JSON object survives verbatim; every other JSON value is
+ * Non-array JSON objects use their own fields; every other JSON value is
  * wrapped in the same "output" envelope the non-JSON path already uses --
  * the shape other Cloud Code Assist clients send for every tool result.
+ * Failed results carry top-level `isError: true`, overriding a payload field;
+ * successful results retain their existing serialized shape.
  */
 function toolResultValue(block) {
     const text = block.content.map(part => part.type === 'text' ? part.text : '').join('');
@@ -28,9 +30,11 @@ function toolResultValue(block) {
     catch {
         return { output: text, ...block.isError === true ? { isError: true } : {} };
     }
-    if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed))
-        return parsed;
-    return { output: parsed };
+    if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) {
+        const value = parsed;
+        return block.isError === true ? { ...value, isError: true } : value;
+    }
+    return { output: parsed, ...block.isError === true ? { isError: true } : {} };
 }
 /** Safely read per-block replay metadata emitted by this adapter. */
 function replayBlocks(message, model) {
@@ -88,7 +92,10 @@ export function toAntigravityContents(messages, model) {
             const part = { functionResponse: {
                     id,
                     name: callNames.get(id) ?? '',
-                    response: toolResultValue({ type: 'tool-result', toolCallId: ToolCallId(id), content: message.content }),
+                    response: toolResultValue({
+                        type: 'tool-result', toolCallId: ToolCallId(id), content: message.content,
+                        ...message.isError === undefined ? {} : { isError: message.isError },
+                    }),
                 } };
             const previous = out.at(-1);
             if (previous?.role === 'user')
@@ -350,7 +357,7 @@ export async function* streamAntigravity(stream, onActivity) {
             parsed = JSON.parse(event.data);
         }
         catch {
-            throw new LlmError(`malformed Antigravity SSE payload: ${event.data.slice(0, 120)}`, 'MALFORMED_RESPONSE');
+            throw new LlmError('malformed Antigravity SSE payload (MALFORMED_RESPONSE): [provider response body omitted]', 'MALFORMED_RESPONSE');
         }
         yield* translator.push(parsed);
         if (translator.terminated)

package/lib/translate/chat-completions.js

@@ -369,7 +369,7 @@ export async function* streamChatCompletions(stream, onActivity) {
             event = JSON.parse(sseEvent.data);
         }
         catch {
-            throw new LlmError(`malformed SSE payload: ${sseEvent.data.slice(0, 120)}`, 'MALFORMED_RESPONSE');
+            throw new LlmError('malformed SSE payload (MALFORMED_RESPONSE): [provider response body omitted]', 'MALFORMED_RESPONSE');
         }
         yield* translator.push(event);
         if (translator.terminated)

package/lib/translate/resolved.d.ts

@@ -50,6 +50,27 @@ export interface ImageRequestLimit {
     /** Encoded-byte target before base64 expansion. */
     maxBytes: number;
 }
+/**
+ * Failure code a host's image-offload executor answers by replacing the oldest
+ * retained images with text and retrying (`IMAGE_OFFLOAD_REQUIRED_CODE` in
+ * dsh-llm 0.2+). Spelled out so the build links against older hosts too.
+ */
+export declare const IMAGE_OFFLOAD_REQUIRED = "IMAGE_OFFLOAD_REQUIRED";
+/**
+ * Whether the installed host records image offloads. Hosts that predate the
+ * executor never mark images `offloaded`, so asking them to would fail every
+ * later request instead of shrinking it.
+ */
+export declare function hostSupportsImageOffload(): boolean;
+/**
+ * How many of the oldest images still sent inline must be offloaded before
+ * the resolved request fits `maxBase64Bytes` of image data; zero when it fits.
+ * Images are counted depth-first in request order, skipping assistant
+ * messages, the same order the host's executor selects occurrences in.
+ * @param messages - the resolved request, after {@link resolveImages}.
+ * @param maxBase64Bytes - the route's budget for all inline image data.
+ */
+export declare function requiredImageOffloadCount(messages: readonly TranslatableMessage[], maxBase64Bytes: number): number;
 /**
  * The request projection for one oversized image, or undefined when it fits.
  * Hosts before DSH 0.1.7 read a pixel budget (`maxPixels`), later ones the

package/lib/translate/resolved.js

@@ -6,6 +6,7 @@
  * base64 data.
  */
 import { LlmError } from '@deepseek-ai/dsh-llm';
+import * as llm from '@deepseek-ai/dsh-llm';
 /**
  * Wires with text-only tool outputs receive images in a following user turn.
  * Defer that turn until all consecutive user messages have been processed:
@@ -42,6 +43,52 @@ export function withToolResultImages(messages) {
     flush();
     return out;
 }
+/**
+ * Failure code a host's image-offload executor answers by replacing the oldest
+ * retained images with text and retrying (`IMAGE_OFFLOAD_REQUIRED_CODE` in
+ * dsh-llm 0.2+). Spelled out so the build links against older hosts too.
+ */
+export const IMAGE_OFFLOAD_REQUIRED = 'IMAGE_OFFLOAD_REQUIRED';
+/**
+ * Whether the installed host records image offloads. Hosts that predate the
+ * executor never mark images `offloaded`, so asking them to would fail every
+ * later request instead of shrinking it.
+ */
+export function hostSupportsImageOffload() {
+    const exports = llm;
+    return exports['IMAGE_OFFLOAD_REQUIRED_CODE'] === IMAGE_OFFLOAD_REQUIRED
+        && typeof exports['offloadedImageText'] === 'function';
+}
+/**
+ * How many of the oldest images still sent inline must be offloaded before
+ * the resolved request fits `maxBase64Bytes` of image data; zero when it fits.
+ * Images are counted depth-first in request order, skipping assistant
+ * messages, the same order the host's executor selects occurrences in.
+ * @param messages - the resolved request, after {@link resolveImages}.
+ * @param maxBase64Bytes - the route's budget for all inline image data.
+ */
+export function requiredImageOffloadCount(messages, maxBase64Bytes) {
+    const lengths = [];
+    const visit = (blocks) => {
+        for (const block of blocks) {
+            if (block.type === 'image' && 'dataBase64' in block)
+                lengths.push(block.dataBase64.length);
+            else if (block.type === 'tool-result')
+                visit(block.content);
+        }
+    };
+    for (const message of messages) {
+        if (message.role !== 'assistant')
+            visit(message.content);
+    }
+    let excess = lengths.reduce((sum, bytes) => sum + bytes, 0) - maxBase64Bytes;
+    let count = 0;
+    while (excess > 0 && count < lengths.length) {
+        excess -= lengths[count];
+        count += 1;
+    }
+    return count;
+}
 /**
  * The request projection for one oversized image, or undefined when it fits.
  * Hosts before DSH 0.1.7 read a pixel budget (`maxPixels`), later ones the
@@ -70,8 +117,11 @@ export function imageRequestTarget(ref, limit) {
  * @returns the same messages with image blocks resolved for the translators.
  */
 export async function resolveImages(messages, attachments, signal, limit) {
-    const hasImage = messages.some(message => message.content.some(block => block.type === 'image'));
-    if (hasImage && attachments === undefined) {
+    const hasRetainedImage = (block) => block.type === 'image'
+        ? !('offloaded' in block && block.offloaded === true)
+        : block.type === 'tool-result' && block.content.some(hasRetainedImage);
+    if (attachments === undefined
+        && messages.some(message => message.content.some(hasRetainedImage))) {
         throw new LlmError('dsh-subscriptions: the request carries an image but no attachments service is mounted; '
             + 'image input requires the harness attachment store', 'UNSUPPORTED');
     }
@@ -94,8 +144,18 @@ export async function resolveImages(messages, attachments, signal, limit) {
         return { data: stored.data, mediaType: stored.ref.mediaType, ref: stored.ref };
     };
     const resolveBlock = async (block) => {
-        if (block.type !== 'image')
+        if (block.type === 'tool-result') {
+            return [{ ...block, content: (await Promise.all(block.content.map(resolveBlock))).flat() }];
+        }
+        if (block.type !== 'image' || 'dataBase64' in block)
             return [block];
+        if ('offloaded' in block && block.offloaded === true) {
+            // The host owns omission decisions. Never restore offloaded bytes, even
+            // when the original attachment is unreadable or no store is mounted.
+            const format = llm.offloadedImageText;
+            return [{ type: 'text', text: format?.(block.attachment)
+                        ?? `[image omitted to fit request image limits; ${block.attachment.attachmentId}]` }];
+        }
         const { data, mediaType: sentType, ref } = await readForRequest(block.attachment);
         const { attachmentId, mediaType, bytes, width, height, name } = ref;
         return [{

package/lib/translate/responses.js

@@ -168,15 +168,17 @@ export function mapResponsesUsage(usage) {
  * @returns the mapped error (context overflow, quota, otherwise SERVER).
  */
 export function responsesFailure(code, message) {
-    const text = message ?? code ?? 'the provider reported a failed response';
+    // Safe here means this diagnostic path carries no provider-controlled free text,
+    // not that no secret can exist anywhere. Raw values remain local classification inputs.
     const detail = `${code ?? ''} ${message ?? ''}`;
+    let classification = 'SERVER';
     if (code === 'context_window_exceeded' || isContextWindowExceededError(detail)) {
-        return new LlmError(text, CONTEXT_WINDOW_EXCEEDED_CODE);
+        classification = CONTEXT_WINDOW_EXCEEDED_CODE;
     }
-    if ((code !== undefined && /insufficient|quota/i.test(code)) || isQuotaExceededError(detail)) {
-        return new LlmError(text, QUOTA_EXCEEDED_CODE);
+    else if ((code !== undefined && /insufficient|quota/i.test(code)) || isQuotaExceededError(detail)) {
+        classification = QUOTA_EXCEEDED_CODE;
     }
-    return new LlmError(text, 'SERVER');
+    return new LlmError(`Responses failure (${classification}): [provider response body omitted]`, classification);
 }
 /** Assemble the final ContentBlock for one open block. */
 function closeBlock(block) {
@@ -396,7 +398,7 @@ export async function* streamResponses(stream, onActivity, transform) {
             event = JSON.parse(sseEvent.data);
         }
         catch {
-            throw new LlmError(`malformed SSE payload: ${sseEvent.data.slice(0, 120)}`, 'MALFORMED_RESPONSE');
+            throw new LlmError('malformed SSE payload (MALFORMED_RESPONSE): [provider response body omitted]', 'MALFORMED_RESPONSE');
         }
         if (transform !== undefined)
             event = transform(event);

package/lib/translate/sse.js

@@ -51,6 +51,14 @@ export async function* parseSse(stream, onActivity) {
         }
     }
     finally {
+        // A terminal SSE frame can precede HTTP EOF; returning or decoding failure
+        // must close the remaining body rather than leave the connection reading.
+        try {
+            await reader.cancel();
+        }
+        catch {
+            // Cleanup failure must not mask the original stream outcome.
+        }
         reader.releaseLock();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-subscriptions",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Unified subscription providers and usage dashboard for DeepSeek Harness",
   "icon": "./icon.svg",
   "license": "MIT",