dsh-lcx-codex 0.4.3 → 0.4.4-pre.1

package/lib/abort-error.js

@@ -0,0 +1,47 @@
+// @ts-check
+const ABORT_MESSAGE = "The operation was aborted";
+function abortInstance() {
+    if (typeof DOMException === "function")
+        return new DOMException(ABORT_MESSAGE, "AbortError");
+    const error = new Error(ABORT_MESSAGE);
+    error.name = "AbortError";
+    return error;
+}
+// `DOMException.prototype.code` is a getter-only accessor, so own properties are
+// defined rather than assigned. Both stay non-enumerable, like a native `cause`.
+function define(target, key, value) {
+    try {
+        Object.defineProperty(target, key, {
+            value,
+            configurable: true,
+            writable: true,
+            enumerable: false,
+        });
+    }
+    catch { }
+}
+function synthesize(reason) {
+    const error = abortInstance();
+    define(error, "code", "LCX_ABORTED");
+    if (reason !== undefined && reason !== null)
+        define(error, "cause", reason);
+    return error;
+}
+/**
+ * Normalize an abort reason into something safe to throw. `fallback` is used only when
+ * the reason is absent, preserving the older `signal.reason ?? error` behaviour.
+ */
+export function normalizeAbortReason(reason, fallback) {
+    if (reason instanceof Error)
+        return reason;
+    if (reason === undefined || reason === null) {
+        if (fallback instanceof Error)
+            return fallback;
+        return synthesize(undefined);
+    }
+    return synthesize(reason);
+}
+/** The error to throw for `signal`'s cancellation. */
+export function abortError(signal, fallback) {
+    return normalizeAbortReason(signal?.reason, fallback);
+}

package/lib/client.js

@@ -727,7 +727,6 @@
   // src/search-accounting.ts
   var object = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
   var count = (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
-  var zeroBuckets = () => ({ uncachedInputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 });
   var isSearchTool = (name) => name === "web_search" || name === "websearch_gpt_advanced";
   function auxiliaryUsageOf(event, toolName) {
     if (!object(event) || event.type !== "tool/result" || !object(event.data?.meta)) return [];
@@ -744,38 +743,6 @@
     }
     return result;
   }
-  function addUsage(base, records) {
-    if (!records.length) return base;
-    const next = { ...base };
-    for (const { usage: u } of records) {
-      next.uncachedInputTokens += u.inputTokens;
-      next.outputTokens += u.outputTokens;
-      next.cacheReadTokens += u.cacheReadTokens;
-      next.cacheWriteTokens += u.cacheWriteTokens;
-    }
-    if (!Object.values(next).every(count)) throw new Error("LCX search usage exceeds safe counters");
-    return next;
-  }
-  function mergeBuckets(base, extra) {
-    if (!object(base) || Object.values(extra).every((n) => n === 0)) return base;
-    const next = { ...base };
-    for (const key of Object.keys(extra)) {
-      if (count(base[key])) next[key] = base[key] + extra[key];
-    }
-    return next;
-  }
-  function addTurnUsage(base, records) {
-    if (!object(base) || !records.length || !count(base.totalTokens)) return base;
-    const next = mergeBuckets(base, addUsage(zeroBuckets(), records));
-    next.totalTokens = base.totalTokens + records.reduce((n, r) => n + r.usage.totalTokens, 0);
-    delete next.reasoningTokens;
-    if (Array.isArray(base.routes)) {
-      const routes = /* @__PURE__ */ new Map();
-      for (const r of [...base.routes, ...records]) routes.set(`${r.provider}\0${r.model}`, { provider: r.provider, model: r.model });
-      next.routes = [...routes.values()];
-    }
-    return next;
-  }
 
   // src/client/search-usage-ui.ts
   var searchUsageDefinition = {
@@ -803,64 +770,70 @@
       return scope === "turn" && s?.complete ? { kind: "turn", turn: s.turn, key: "lcx-search-usage", value: s.records } : null;
     }
   };
+  function tokenCount(value) {
+    return String(value);
+  }
+  function recordsTotal(records) {
+    let total = 0;
+    for (const record2 of records) {
+      const value = record2.usage.totalTokens;
+      if (!Number.isSafeInteger(value) || value < 0) continue;
+      total += value;
+      if (!Number.isSafeInteger(total)) return 0;
+    }
+    return total;
+  }
+  function bucketsTotal(value) {
+    if (!object(value)) return 0;
+    let total = 0;
+    for (const key of ["uncachedInputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens"]) {
+      const count2 = value[key];
+      if (!Number.isSafeInteger(count2) || count2 < 0) return 0;
+      total += count2;
+      if (!Number.isSafeInteger(total)) return 0;
+    }
+    return total;
+  }
+  function usageView(createElement, scope, total, t) {
+    if (total <= 0) return null;
+    const label = t?.(scope === "turn" ? "usageTurn" : "usageSession") ?? "Search usage";
+    return createElement("span", {
+      className: `lcx-search-usage lcx-search-usage-${scope}`,
+      "data-lcx-search-usage": scope,
+      title: `${label}: ${tokenCount(total)}`
+    }, `${label}: ${tokenCount(total)}`);
+  }
+  function TurnTailUsage({ turn, t }, createElement) {
+    if (!createElement) return null;
+    return usageView(createElement, "turn", recordsTotal(turn.data.get("lcx-search-usage") ?? []), t);
+  }
+  function SessionUsage({ useProjection, t }, createElement) {
+    if (!createElement) return null;
+    const extra = useProjection("lcxSearchUsage");
+    const auxiliary = object(extra) ? extra.auxiliary : void 0;
+    return usageView(createElement, "session", bucketsTotal(auxiliary), t);
+  }
   function installUsageSlots(slots, createElement) {
+    const registrations = [
+      [
+        { name: "conversation.chat.turnTail", id: "lcx-search-usage-turn", order: 0, locale: "lcx-codex" },
+        (props) => TurnTailUsage(props, createElement)
+      ],
+      [
+        { name: "conversation.composer.dock", id: "lcx-search-usage-session", order: 10, locale: "lcx-codex" },
+        (props) => SessionUsage(props, createElement)
+      ]
+    ];
     const cleanups = [];
-    for (const [name, key] of [
-      ["conversation.composer.dock", "stats"],
-      ["conversation.composer.bar", ""],
-      ["conversation.chat.node", "turn-tail"]
-    ]) {
-      let effect;
+    for (const [name, component] of registrations) {
       try {
-        effect = slots.inject(name, () => {
-          let entries;
-          try {
-            entries = slots.entriesOfSlot(name);
-          } catch {
-            return;
-          }
-          if (!Array.isArray(entries) || entries.length === 0) return;
-          const candidates = key === "" ? [entries[0]] : entries.filter((e) => e?.options?.id === key || e?.options?.key === key);
-          if (candidates.length !== 1) return;
-          const base = candidates[0], original = base?.component;
-          if (!base || typeof original !== "function" || !base.options || typeof base.options !== "object") return;
-          const descriptor = Object.getOwnPropertyDescriptor(base, "component");
-          if (descriptor && descriptor.set === void 0 && descriptor.writable === false) return;
-          function WithSearchUsage(props) {
-            if (key === "turn-tail") {
-              const location = props?.node?.location;
-              const records = (location?.kind === "turn" || location?.kind === "step") && location.turn?.data?.get ? location.turn.data.get("lcx-search-usage") : void 0;
-              if (!records?.length) return createElement(original, props);
-              return createElement(original, { ...props, node: { ...props.node, data: { ...props.node.data, tokenUsage: addTurnUsage(props.node.data.tokenUsage, records) } } });
-            }
-            if (typeof props?.useProjection !== "function") return createElement(original, props);
-            const extra = props.useProjection("lcxSearchUsage");
-            const breakdown = props.useProjection("contextBreakdown");
-            const useProjection = (projection) => {
-              const value = props.useProjection(projection);
-              if (projection === "tokenUsage" && extra?.auxiliary) return mergeBuckets(value, extra.auxiliary);
-              if (projection === "contextPressure" && extra?.aggregateContext && object(breakdown)) {
-                const tokens = breakdown.systemTokens + breakdown.toolsTokens + breakdown.messageTokens;
-                if (Number.isSafeInteger(tokens) && tokens >= 0 && object(value)) return { ...value, pressureTokens: tokens, projectedTokens: tokens };
-              }
-              return value;
-            };
-            return createElement(original, { ...props, useProjection });
-          }
-          try {
-            base.component = WithSearchUsage;
-          } catch {
-            return;
-          }
-          if (base.component !== WithSearchUsage) return;
-          return () => {
-            if (base.component === WithSearchUsage) base.component = original;
-          };
+        const effect = slots.inject(name.name, () => {
+          const dispose = slots.register(name, component);
+          return typeof dispose === "function" ? dispose : void 0;
         });
+        if (typeof effect === "function") cleanups.push(effect);
       } catch {
-        continue;
       }
-      if (typeof effect === "function") cleanups.push(effect);
     }
     return () => {
       for (const dispose of cleanups.reverse()) dispose();
@@ -894,7 +867,7 @@
       const DEFAULTS = Object.fromEntries(
         FIELDS.map((field) => [field, false])
       );
-      const css = `.lcx-card{border:1px solid var(--dsw-alias-border-l2);border-radius:8px;list-style:none}.lcx-head{width:100%;display:flex;justify-content:space-between;padding:14px 16px;border:0;background:transparent;color:inherit}.lcx-body{border-top:1px solid var(--dsw-alias-border-l2);padding:12px 16px}.lcx-row{display:flex;gap:9px;padding:8px 0}.lcx-row small,.lcx-help{display:block;font-size:12px;line-height:17px;color:var(--dsw-alias-label-tertiary)}.lcx-group{border-top:1px solid var(--dsw-alias-border-l2);margin-top:10px;padding-top:14px}.lcx-group strong{font-size:14px}.lcx-foot{display:flex;justify-content:flex-end;gap:8px;margin-top:10px}.lcx-foot button{padding:6px 12px;border-radius:8px;border:1px solid var(--dsw-alias-border-l2);background:transparent;color:inherit}` + inlineMediaCss;
+      const css = `.lcx-card{border:1px solid var(--dsw-alias-border-l2);border-radius:8px;list-style:none}.lcx-head{width:100%;display:flex;justify-content:space-between;padding:14px 16px;border:0;background:transparent;color:inherit}.lcx-body{border-top:1px solid var(--dsw-alias-border-l2);padding:12px 16px}.lcx-row{display:flex;gap:9px;padding:8px 0}.lcx-row small,.lcx-help{display:block;font-size:12px;line-height:17px;color:var(--dsw-alias-label-tertiary)}.lcx-group{border-top:1px solid var(--dsw-alias-border-l2);margin-top:10px;padding-top:14px}.lcx-group strong{font-size:14px}.lcx-foot{display:flex;justify-content:flex-end;gap:8px;margin-top:10px}.lcx-foot button{padding:6px 12px;border-radius:8px;border:1px solid var(--dsw-alias-border-l2);background:transparent;color:inherit}.lcx-search-usage{display:inline-flex;align-items:center;gap:4px;margin:2px 0;color:var(--dsw-alias-label-tertiary);font:12px/18px system-ui}.lcx-search-usage-session{padding:0 4px}.lcx-search-usage-turn{padding:0 6px}` + inlineMediaCss;
       function mountCss() {
         if (typeof document === "undefined") return () => {
         };
@@ -910,6 +883,7 @@
       const copy = {
         zh: {
           title: "Responses / Codex \u80FD\u529B",
+          summary: "GPT Responses route \u4E0E\u641C\u7D22\u80FD\u529B",
           desc: "LCX \u8DDF\u968F DSH \u5F53\u524D\u4F1A\u8BDD\u9009\u62E9\u7684 GPT Responses route\uFF1B\u6A21\u578B\u3001endpoint \u548C credential \u7EE7\u7EED\u53EA\u7531 DSH \u7BA1\u7406\u3002",
           enabled: "\u542F\u7528 LCX\uFF08\u63A5\u7BA1\u5F53\u524D GPT Responses \u4F1A\u8BDD\uFF09",
           enabledHelp: "\u6B64\u5F00\u5173\u4EC5\u63A5\u7BA1 GPT Responses \u4F1A\u8BDD\uFF1BGrok \u539F\u751F\u641C\u7D22\u7531\u4E0B\u65B9\u72EC\u7ACB\u5F00\u5173\u63A7\u5236\uFF0C\u5176\u4ED6\u975E GPT \u6A21\u578B\u7EE7\u7EED\u4F7F\u7528 DSH \u539F\u751F\u8DEF\u5F84\u3002",
@@ -939,6 +913,8 @@
           mediaVideo: "\u89C6\u9891",
           mediaFilter: "\u5A92\u4F53\u7C7B\u578B",
           mediaOpen: "\u6253\u5F00\u539F\u59CB\u5A92\u4F53",
+          usageTurn: "\u672C\u8F6E\u641C\u7D22\u7528\u91CF",
+          usageSession: "\u641C\u7D22\u7528\u91CF",
           grokTitle: "Grok \u539F\u751F\u641C\u7D22",
           grokDesc: "\u4F7F\u7528 DSH \u5F53\u524D\u9009\u62E9\u7684 Grok \u6A21\u578B\u53CA\u5176\u670D\u52A1\u914D\u7F6E\uFF1B\u4E0E GPT \u529F\u80FD\u5F00\u5173\u72EC\u7ACB\u3002\u5F00\u542F\u4EFB\u4E00\u641C\u7D22\u540E\uFF0CGrok \u4EC5\u4F7F\u7528\u539F\u751F\u641C\u7D22\uFF0C\u7F51\u9875\u8BFB\u53D6\u548C\u5176\u4ED6\u5DE5\u5177\u4ECD\u53EF\u7528\u3002",
           grokWeb: "\u542F\u7528\u539F\u751F Web Search",
@@ -952,6 +928,7 @@
         },
         en: {
           title: "Responses / Codex capabilities",
+          summary: "GPT Responses route and search capabilities",
           desc: "LCX follows the GPT Responses route selected by the current DSH session. Model, endpoint and credentials remain DSH-owned.",
           enabled: "Enable LCX (own current GPT Responses conversation)",
           enabledHelp: "Applies only to GPT Responses conversations. Grok native search is controlled independently below; other non-GPT models continue through DSH normally.",
@@ -981,6 +958,8 @@
           mediaVideo: "Video",
           mediaFilter: "Media type",
           mediaOpen: "Open original media",
+          usageTurn: "Turn search usage",
+          usageSession: "Search usage",
           grokTitle: "Grok native search",
           grokDesc: "Uses the Grok model and provider profile currently selected in DSH, independently of the GPT switch. When either search is enabled, Grok uses native search while page reading and other tools remain available.",
           grokWeb: "Enable native Web Search",
@@ -1102,12 +1081,14 @@
         saveError;
         store;
         stop;
+        saveEpoch;
         constructor(scope) {
           this.scope = scope;
           this.draft = null;
           this.dirty = false;
           this.saving = false;
           this.saveError = false;
+          this.saveEpoch = 0;
           this.store = createSnapshotStore(this.projection());
           mediaStore.set({ enabled: this.value().searchMediaPreview });
           this.stop = scope.subscribe(() => {
@@ -1159,10 +1140,19 @@
           this.saveError = false;
           this.publish();
         }
+        leavePage() {
+          this.saveEpoch += 1;
+          this.draft = null;
+          this.dirty = false;
+          this.saving = false;
+          this.saveError = false;
+          this.publish();
+        }
         async save() {
           if (!this.dirty || this.saving || !this.snapshot().writable || this.snapshot().status !== "ready") return;
           const next = this.draftValue(), prev = this.value();
           const fields = FIELDS.filter((field) => next[field] !== prev[field]);
+          const saveEpoch = ++this.saveEpoch;
           this.saving = true;
           this.saveError = false;
           this.publish();
@@ -1173,16 +1163,20 @@
                 path: [field],
                 value: next[field]
               })));
+              if (saveEpoch !== this.saveEpoch) return;
               if (this.snapshot().status !== "ready" || fields.some((field) => this.value()[field] !== next[field]))
                 throw new Error("Settings mutation was not confirmed");
             }
+            if (saveEpoch !== this.saveEpoch) return;
             this.draft = null;
             this.dirty = false;
           } catch {
-            this.saveError = true;
+            if (saveEpoch === this.saveEpoch) this.saveError = true;
           } finally {
-            this.saving = false;
-            this.publish();
+            if (saveEpoch === this.saveEpoch) {
+              this.saving = false;
+              this.publish();
+            }
           }
         }
         inject() {
@@ -1194,7 +1188,8 @@
             setMediaPreview: (value) => this.edit("searchMediaPreview", value),
             edit: (field, value) => this.edit(field, value),
             save: () => void this.save(),
-            discard: () => this.discard()
+            discard: () => this.discard(),
+            leavePage: () => this.leavePage()
           };
         }
       }
@@ -1226,7 +1221,13 @@
       }
       function Card(props) {
         const t = props.t, s = props.useLcxCard((state) => state), [open, setOpen] = React.useState(false);
+        React.useEffect(
+          () => props.view === "page" ? () => props.leavePage() : void 0,
+          [props.view, props.leavePage]
+        );
         if (!s.available) return null;
+        if (props.view === "summary")
+          return React.createElement("span", { className: "lcx-summary" }, t("summary"));
         const disabled = !s.writable || s.saving;
         return React.createElement(
           "li",
@@ -1345,10 +1346,8 @@
       function apply(ctx) {
         const slots = ctx.slots ?? ctx.get("slots"), svc = ctx.settingsScope ?? ctx.get("settingsScope"), locale = ctx.locale ?? ctx.get("locale"), uiConversation = ctx.uiConversation ?? ctx.get("uiConversation");
         if (!slots || !svc || !locale || !uiConversation) return;
-        if (typeof slots.entriesOfSlot === "function") {
-          ctx.effect(() => uiConversation.events.register(searchUsageDefinition), "lcx search billing data");
-          ctx.effect(() => installUsageSlots(slots, React.createElement), "lcx search billing slots");
-        }
+        ctx.effect(() => uiConversation.events.register(searchUsageDefinition), "lcx search billing data");
+        ctx.effect(() => installUsageSlots(slots, React.createElement), "lcx search billing slots");
         ctx.effect(mountCss, "lcx-codex styles");
         for (const language of ["zh", "en"])
           ctx.effect(() => locale.register(NAMESPACE, language, copy[language]), `lcx-codex ${language} dictionary`);
@@ -1364,12 +1363,12 @@
         }, label);
         const controller = new Controller(svc.bind({ namespace: NAMESPACE }));
         installSlot(
-          "settings.plugin.item",
-          "lcx-codex settings slot",
+          "plugins.bundle.config",
+          "lcx-codex plugin configuration",
           () => slots.register(
             {
-              name: "settings.plugin.item",
-              key: NAMESPACE,
+              name: "plugins.bundle.config",
+              key: "dsh-lcx-codex",
               locale: NAMESPACE,
               inject: () => controller.inject()
             },

package/lib/dsh-responses.js

@@ -1,5 +1,6 @@
-import { offloadedImageText, offloadRequestImagesWithPolicy, requestImageHandleText, resolveImageAttachmentAccess, } from "@deepseek-ai/dsh-llm";
-import { convertResponsesMessages, convertResponsesTools, createGrammarToolInputProperties, getBuiltinModels, } from "./pi-responses-runtime.js";
+import { IMAGE_OFFLOAD_REQUIRED_CODE, LlmError, offloadedImageText, projectOffloadedImages, requiredImageOffload, requestImageHandleText, resolveImageAttachmentAccess, } from "@deepseek-ai/dsh-llm";
+import { requestImageDimensions } from "@deepseek-ai/dsh-attachment";
+import { convertResponsesMessages, convertResponsesTools, createGrammarToolInputProperties, getBuiltinModels, normalizeContext, } from "./pi-responses-runtime.js";
 const DEFAULT_MAX_REQUEST_IMAGE_BYTES = 20 * 1024 * 1024;
 const DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET = 2048 * 2048;
 const DEFAULT_REQUEST_IMAGE_MAX_BYTES = 1024 * 1024;
@@ -87,42 +88,45 @@ export async function resolveModelImageSupport(ctx, route, signal) {
         return "unknown";
     }
 }
-function attachmentResolver(ctx, options) {
+function attachmentResolver(ctx, options, requestImages) {
     const attachments = attachmentServices(ctx?.attachments);
     return async (block, signal) => {
         if (attachments === undefined)
             throw error("LCX requires the DSH request-image attachment API", "LCX_COMPACT_IMAGE_API_UNAVAILABLE");
-        const request = await attachments.store.readImageRequest(block.attachment, { maxPixels: options.requestImagePixelBudget, maxBytes: options.requestImageMaxBytes }, signal);
+        const request = requestImages === undefined
+            ? await attachments.store.readImageRequest(block.attachment, { ...requestImageDimensions(block.attachment.width, block.attachment.height, options.requestImagePixelBudget), maxBytes: options.requestImageMaxBytes }, signal)
+            : requestImages.get(String(block.attachment.attachmentId));
+        if (request === undefined)
+            throw error("DSH attachment returned no request-image bytes", "LCX_COMPACT_IMAGE_UNAVAILABLE");
         const data = request.data;
         const mediaType = request.mediaType ?? block.attachment.mediaType;
         if (!(data instanceof Uint8Array) && !Buffer.isBuffer(data))
             throw error("DSH attachment returned no request-image bytes", "LCX_COMPACT_IMAGE_UNAVAILABLE");
         if (typeof mediaType !== "string" || !mediaType.startsWith("image/"))
             throw error("DSH attachment returned an invalid request-image media type", "LCX_COMPACT_IMAGE_UNAVAILABLE");
-        const ref = request.attachment ?? block.attachment;
         return {
             data: Buffer.from(data),
             mediaType,
-            ref,
+            ref: block.attachment,
             request,
-            access: imageAccess(ctx, attachments, ref),
+            access: imageAccess(ctx, attachments, block.attachment),
         };
     };
 }
-async function imagePart(block, ctx, options, imageMap) {
+async function imagePart(block, ctx, options, imageMap, requestImages) {
     if (options.imageSupport === "unsupported")
         return { type: "input_text", text: "[image omitted because the target model does not support image input]" };
-    const image = await attachmentResolver(ctx, options)(block, options.signal);
+    const image = await attachmentResolver(ctx, options, requestImages)(block, options.signal);
     if (Math.ceil(image.data.byteLength / 3) * 4 > options.maxRequestImageBytes)
         throw error("one image exceeds the configured LCX request image bound", "LCX_COMPACT_IMAGE_TOO_LARGE");
     const imageUrl = `data:${image.mediaType};base64,${image.data.toString("base64")}`;
     imageMap.set(imageUrl, structuredClone(image.ref));
     return { type: "input_image", detail: "auto", image_url: imageUrl };
 }
-async function piImageParts(block, ctx, options, imageMap) {
+async function piImageParts(block, ctx, options, imageMap, requestImages) {
     if (options.imageSupport === "unsupported")
         return [{ type: "text", text: "[image omitted because the target model does not support image input]" }];
-    const image = await attachmentResolver(ctx, options)(block, options.signal);
+    const image = await attachmentResolver(ctx, options, requestImages)(block, options.signal);
     if (Math.ceil(image.data.byteLength / 3) * 4 > options.maxRequestImageBytes)
         throw error("one image exceeds the configured LCX request image bound", "LCX_COMPACT_IMAGE_TOO_LARGE");
     const data = image.data.toString("base64");
@@ -292,17 +296,17 @@ function toPiAssistant(message, onReplayDegrade) {
         return foreignAssistant(message);
     }
 }
-async function piToolContent(blocks, ctx, options, imageMap) {
+async function piToolContent(blocks, ctx, options, imageMap, requestImages) {
     const content = [];
     for (const block of blocks) {
         if (block.type === "text")
             content.push({ type: "text", text: block.text });
         else if (block.type === "image")
-            content.push(...(await piImageParts(block, ctx, options, imageMap)));
+            content.push(...(await piImageParts(block, ctx, options, imageMap, requestImages)));
         else if (block.type === "reasoning")
             continue;
         else if (block.type === "tool-result")
-            content.push(...(await piToolContent(block.content, ctx, options, imageMap)));
+            content.push(...(await piToolContent(block.content, ctx, options, imageMap, requestImages)));
         else
             throw unsupportedContent(block.type);
     }
@@ -331,12 +335,39 @@ function projectFiles(messages, ctx) {
         content: projectFileContent(message.content, fileRequestText),
     }));
 }
+function collectRequestImageRefs(blocks, refs) {
+    for (const block of blocks) {
+        if (block.type === "image") {
+            if (block.offloaded !== true)
+                refs.set(String(block.attachment.attachmentId), block.attachment);
+        }
+        else if (block.type === "tool-result") {
+            collectRequestImageRefs(block.content, refs);
+        }
+    }
+}
+async function prepareRequestImageVersions(messages, ctx, options) {
+    const attachments = attachmentServices(ctx?.attachments);
+    if (attachments === undefined)
+        return new Map();
+    const refs = new Map();
+    for (const message of messages)
+        collectRequestImageRefs(message.content, refs);
+    const versions = await Promise.all([...refs.values()].map(async (ref) => {
+        const target = {
+            ...requestImageDimensions(ref.width, ref.height, options.requestImagePixelBudget),
+            maxBytes: options.requestImageMaxBytes,
+        };
+        return [String(ref.attachmentId), await attachments.store.readImageRequest(ref, target, options.signal)];
+    }));
+    return new Map(versions);
+}
 function flattenMessageText(message) {
     return message.content
         .map((block) => (block.type === "text" ? block.text : ""))
         .join("");
 }
-async function dshToPiMessages(messages, ctx, options, imageMap) {
+async function dshToPiMessages(messages, ctx, options, imageMap, requestImages) {
     const result = [];
     const toolNames = new Map();
     for (const message of messages) {
@@ -370,7 +401,7 @@ async function dshToPiMessages(messages, ctx, options, imageMap) {
                 if (block.type === "text")
                     content.push({ type: "text", text: block.text });
                 else if (block.type === "image")
-                    content.push(...(await piImageParts(block, ctx, options, imageMap)));
+                    content.push(...(await piImageParts(block, ctx, options, imageMap, requestImages)));
             }
             if (content.length > 0)
                 result.push({ role: "user", content, timestamp: 0 });
@@ -379,7 +410,7 @@ async function dshToPiMessages(messages, ctx, options, imageMap) {
             if (block.type !== "tool-result")
                 continue;
             const toolCallId = String(block.toolCallId);
-            result.push({ role: "toolResult", toolCallId, toolName: toolNames.get(toolCallId) ?? "unknown", content: await piToolContent(block.content, ctx, options, imageMap), addedToolNames: [], isError: block.isError === true, timestamp: 0 });
+            result.push({ role: "toolResult", toolCallId, toolName: toolNames.get(toolCallId) ?? "unknown", content: await piToolContent(block.content, ctx, options, imageMap, requestImages), isError: block.isError === true, timestamp: 0 });
         }
     }
     return result;
@@ -419,34 +450,40 @@ export async function serializeDshMessages(messages, ctx, options = {}) {
     const imageMap = new Map();
     const fileProjected = projectFiles(messages, ctx);
     const attachments = attachmentServices(ctx?.attachments);
-    const projected = offloadRequestImagesWithPolicy(fileProjected, {
-        representation: "base64", maxBytes: normalized.maxRequestImageBytes, byteQuantum: 1,
-        byteLength: (ref) => Math.min(ref.bytes, normalized.requestImageMaxBytes),
-        placeholder: (ref) => offloadedImageText(ref, attachments === undefined ? undefined : imageAccess(ctx, attachments, ref)),
-    });
+    const requestImages = normalized.imageSupport === "unsupported"
+        ? new Map()
+        : await prepareRequestImageVersions(fileProjected, ctx, normalized);
+    const offloadImages = attachments === undefined || normalized.imageSupport === "unsupported"
+        ? 0
+        : requiredImageOffload(fileProjected, { representation: "base64", maxBytes: normalized.maxRequestImageBytes }, (block) => {
+            // `requiredImageOffload` applies the base64 expansion itself for a
+            // base64 representation, so this reports raw request-version bytes.
+            const request = requestImages.get(String(block.attachment.attachmentId));
+            return request?.bytes ?? block.attachment.bytes;
+        });
+    if (offloadImages > 0) {
+        throw new LlmError(`LCX request images exceed the configured base64 bound; ${offloadImages} more oldest occurrence(s) must be offloaded.`, IMAGE_OFFLOAD_REQUIRED_CODE, { offloadImages });
+    }
+    const projected = projectOffloadedImages(fileProjected, (ref) => offloadedImageText(ref, attachments === undefined ? undefined : imageAccess(ctx, attachments, ref)));
     const model = resolvePiResponsesModel(normalized);
-    const context = { systemPrompt: normalized.systemPrompt, messages: await dshToPiMessages(projected, ctx, normalized, imageMap), tools: [...normalized.tools] };
+    const dshContext = { systemPrompt: normalized.systemPrompt, messages: await dshToPiMessages(projected, ctx, normalized, imageMap, requestImages), tools: [...normalized.tools] };
     const compat = isObject(model.compat) ? model.compat : {};
     const supportsStrictMode = compat.supportsStrictMode === true;
     const supportsOpenAIGrammarTools = compat.supportsOpenAIGrammarTools === true;
     const supportsAdditionalTools = compat.supportsAdditionalTools === true;
     const supportsToolSearch = compat.supportsToolSearch === true;
     const deferredToolsMode = supportsAdditionalTools ? "additional-tools" : supportsToolSearch ? "tool-search" : undefined;
-    const grammarToolInputProperties = createGrammarToolInputProperties(context.tools, supportsOpenAIGrammarTools);
+    const grammarToolInputProperties = createGrammarToolInputProperties(dshContext.tools, supportsOpenAIGrammarTools);
     // DSH has no authoritative added-tool provenance; keep its full catalog immediate.
     const immediateTools = new Map();
-    for (const tool of context.tools)
+    for (const tool of dshContext.tools)
         if (tool.name)
             immediateTools.set(tool.name, tool);
-    const toolOptions = { supportsStrictMode, supportsOpenAIGrammarTools };
-    const piContext = {
-        systemPrompt: context.systemPrompt,
-        messages: context.messages,
-        tools: context.tools,
-    };
+    const toolOptions = { supportsStrictMode, supportsOpenAIGrammarTools, toolSearchResult: false };
+    const piContext = normalizeContext(dshContext);
     const piModel = model;
-    const convertedInput = convertResponsesMessages(piModel, piContext, new Set(["openai", "openai-codex", "opencode"]), { includeSystemPrompt: normalized.includeSystemPrompt, grammarToolInputProperties, deferredTools: new Map(), deferredToolsMode, toolOptions });
-    const input = restorePortableAssistantPhases(convertedInput, context.messages, { provider: model.provider, id: model.id, api: model.api });
+    const convertedInput = convertResponsesMessages(piModel, piContext, new Set(["openai", "openai-codex", "opencode"]), { includeSystemPrompt: normalized.includeSystemPrompt, grammarToolInputProperties, supportsAdditionalTools, supportsToolSearch, toolOptions });
+    const input = restorePortableAssistantPhases(convertedInput, dshContext.messages, { provider: model.provider, id: model.id, api: model.api });
     const tools = options.tools === undefined ? undefined : convertResponsesTools([...immediateTools.values()], toolOptions);
     return { input, imageMap, tools, model: piModel, grammarToolInputProperties, deferredToolsMode };
 }

package/lib/index.js

@@ -1045,25 +1045,41 @@ function installInjected(ctx, configInput = {}) {
     ctx.inject(["compaction"], (compactionCtx) => {
         patchCompactionPressureService(resolveContextService(compactionCtx, "compaction"), state, () => runtimeConfig, ctx, compactionPatchRecords);
     });
-    ctx.on("agent/created", ({ agent }) => {
+    /**
+     * LCX instrumentation is optional capability, never a creation precondition.
+     * DSH 0.1.6 awaits `agent/created` serially, so an escaping failure would make
+     * an otherwise valid Agent uncreatable; `agent/status` stays a contained emit.
+     * Both edges therefore fail closed locally: the Agent runs uninstrumented and
+     * the reason is logged, rather than propagating into the host lifecycle.
+     */
+    const instrumentAgent = (agent, edge) => {
+        try {
+            managedAgents.add(agent);
+            syncAgentTools(agent);
+            const installed = patchCompactionPressureForAgent(agent, state, () => runtimeConfig, ctx, compactionPatchRecords);
+            if (installed)
+                ctx.logger?.info?.("[lcx-codex] pressure coordination installed through AgentPresets service resolver");
+        }
+        catch (error) {
+            ctx.logger?.warn?.(`[lcx-codex] agent instrumentation skipped on ${edge}: ${String(error)}`);
+        }
+    };
+    /** DSH 0.1.6 lifecycle source, recorded for diagnostics only. */
+    const startSource = (value) => typeof value === "string" && /^[a-z]+$/u.test(value) ? value : "unknown";
+    ctx.on("agent/created", (payload) => {
+        const agent = payload?.agent;
         if (agent === null || typeof agent !== "object")
             return;
-        managedAgents.add(agent);
-        syncAgentTools(agent);
-        const installed = patchCompactionPressureForAgent(agent, state, () => runtimeConfig, ctx, compactionPatchRecords);
-        if (installed)
-            ctx.logger?.info?.("[lcx-codex] pressure coordination installed through AgentPresets service resolver");
+        // `source` is startup | resume | clear | compact. Recorded, not branched on:
+        // no runtime evidence yet that a source needs different instrumentation.
+        instrumentAgent(agent, `agent/created(${startSource(payload?.source)})`);
     }, { global: true });
     ctx.on("agent/status", ({ agent, status }) => {
         if (status !== "running" ||
             agent === null ||
             typeof agent !== "object")
             return;
-        managedAgents.add(agent);
-        syncAgentTools(agent);
-        const installed = patchCompactionPressureForAgent(agent, state, () => runtimeConfig, ctx, compactionPatchRecords);
-        if (installed)
-            ctx.logger?.info?.("[lcx-codex] pressure coordination installed through AgentPresets service resolver");
+        instrumentAgent(agent, "agent/status(running)");
     }, { global: true });
     ctx.on("llm/stream", (options, next) => {
         if (options.purpose === "session-title")