dsh-subscriptions 0.1.3 → 0.1.5

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,30 @@ 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. Every host in our support window
+ * exports the equivalent as `IMAGE_OFFLOAD_REQUIRED_CODE`, from the window floor
+ * `0.1.7-rc.2` up, so this is not a newer-host path. The value is spelled out
+ * rather than imported so the plugin keeps building if a host stops exporting
+ * it.
+ */
+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,55 @@ 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. Every host in our support window
+ * exports the equivalent as `IMAGE_OFFLOAD_REQUIRED_CODE`, from the window floor
+ * `0.1.7-rc.2` up, so this is not a newer-host path. The value is spelled out
+ * rather than imported so the plugin keeps building if a host stops exporting
+ * it.
+ */
+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 +120,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 +147,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.3",
+  "version": "0.1.5",
   "description": "Unified subscription providers and usage dashboard for DeepSeek Harness",
   "icon": "./icon.svg",
   "license": "MIT",