@adaptiqai/deepseek-harness 0.2.12 → 0.2.13

package/lib/host.js

@@ -54,7 +54,7 @@ import { attributionHeaders as attributionHeaders2 } from "@deepseek-ai/dsh-llm"
 import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
 
 // src/host/adapter.ts
-import { attributionHeaders, LlmAdapter, LlmError, ProviderRequestId } from "@deepseek-ai/dsh-llm";
+import { attributionHeaders, IMAGE_OFFLOAD_REQUIRED_CODE, LlmAdapter, LlmError, ProviderRequestId } from "@deepseek-ai/dsh-llm";
 
 // ../core/lib/errors.js
 var CODES = {
@@ -122,21 +122,26 @@ function classifyFailure(status, raw, headers, model2, options = {}) {
     const library = /\blibrary is full/iu.test(detail.message ?? "");
     return { ...make(CODES.memoryFull, library ? MEMORY_FULL_LIBRARY : MEMORY_FULL, "memory-full"), memoryFull: library ? "library" : "no-room" };
   }
+  if (detail.code === "plan_usage_exhausted") {
+    const renewsAt = envelope.detail?.renews_at;
+    const failure = make(CODES.noLanes, detail.message ?? "Your plan's usage is used up for now. Rent extra lanes in the meantime.", "no-lanes");
+    return typeof renewsAt === "number" ? { ...failure, planRenewsAt: renewsAt } : failure;
+  }
   if (effective === 402 || detail.code === "rental_paused") {
     const releaseAt = envelope.detail?.release_at;
     const minutes = typeof releaseAt === "number" ? Math.max(1, Math.ceil((releaseAt * 1e3 - Date.now()) / 6e4)) : null;
     const keep = minutes === null ? "to continue" : `within ${minutes} minute${minutes === 1 ? "" : "s"} to keep them`;
-    const failure = make(CODES.outOfCredit, `Your balance ran out, so your lanes on ${name2} are paused. Add funds ${keep}.`, "out-of-credit");
+    const failure = make(CODES.outOfCredit, `Your balance ran out, so your lanes are paused. Add funds ${keep}.`, "out-of-credit");
     return minutes === null ? failure : { ...failure, minutesLeft: minutes };
   }
   if (effective === 401) {
     return make(CODES.signIn, "Your AdaptiqAI sign-in has expired. Open Settings \u2192 AdaptiqAI and sign in again.", "sign-in");
   }
   if (detail.code === "rental_stopped_unused") {
-    return make(CODES.noLanes, `Your lane on ${name2} stopped because it went unused, so nothing more was charged. Get access to start it again.`, "no-lanes");
+    return make(CODES.noLanes, "Your lane stopped because it went unused, so nothing more was charged. Get access to start it again.", "no-lanes");
   }
   if (has(detail, "AdaptiqLaneAccessRequired", "inference_entitlement_required", "instance_access_required", "lane_access") || effective === 403 && has(detail, "lane", "entitle", "model access")) {
-    return make(CODES.noLanes, `Your workspace has no lanes on ${name2} yet. Get access to start.`, "no-lanes");
+    return make(CODES.noLanes, "You need to rent a lane or subscribe to AdaptiqAI to continue.", "no-lanes");
   }
   if (effective === 403) {
     return make(CODES.signIn, "This AdaptiqAI connection isn't allowed to do that. Sign in again from Settings \u2192 AdaptiqAI.", "sign-in");
@@ -321,10 +326,10 @@ var REFRESH_MARGIN_MS = 2 * 6e4;
 var DEVICE_TIMEOUT_MS = 10 * 6e4;
 var UNREACHABLE = "AdaptiqAI can't be reached. Check your internet connection and try again.";
 function deviceLabel(value) {
-  let label = value.replace(/\.local$/iu, "").replace(/[\p{Cc}\p{Cf}]/gu, " ").replace(/\s+/gu, " ").trim() || "this computer";
-  while (Buffer.byteLength(label) > 80)
-    label = label.slice(0, -1);
-  return label;
+  let label2 = value.replace(/\.local$/iu, "").replace(/[\p{Cc}\p{Cf}]/gu, " ").replace(/\s+/gu, " ").trim() || "this computer";
+  while (Buffer.byteLength(label2) > 80)
+    label2 = label2.slice(0, -1);
+  return label2;
 }
 var defaultSleep = (ms, signal) => new Promise((resolve2, reject) => {
   if (signal.aborted) {
@@ -1274,15 +1279,19 @@ var en = {
   n_connected_body: "Your AdaptiqAI models are in the model picker.",
   n_compaction_title: "Nothing to compact",
   n_compaction_body: "AdaptiqAI keeps the whole conversation in memory, so nothing needs shortening.",
+  n_imagesTextOnly_title: "Images were not sent",
+  n_imagesTextOnly_body: "{model} reads text only, so the model got a short note in place of each image. Choose a model that reads images to ask about them.",
   n_signIn_title: "Sign in to keep going",
   n_signIn_body: "Your AdaptiqAI connection needs a fresh sign-in.",
   n_connect_body: "Connect your AdaptiqAI account to use this model.",
-  n_noLanes_title: "No lanes on {model}",
-  n_noLanes_body: "Your workspace has no lanes on {model} yet.",
-  n_laneStopped_body: "Your lane on {model} stopped because it went unused, so nothing more was charged.",
+  n_noLanes_title: "Rent a lane to continue",
+  n_noLanes_body: "You need to rent a lane or subscribe to AdaptiqAI to continue.",
+  n_laneStopped_body: "Your lane stopped because it went unused, so nothing more was charged.",
+  n_planUsedUp_body: "Your plan's usage is used up until {until}. Rent extra lanes in the meantime.",
+  n_planUsedUpNoDate_body: "Your plan's usage is used up for now. Rent extra lanes in the meantime.",
   n_credit_title: "Add funds to continue",
-  n_credit_body: "Your balance ran out, so your lanes on {model} are paused.",
-  n_creditMinutes_body: "Your balance ran out, so your lanes on {model} are paused. Add funds within {minutes} min to keep them.",
+  n_credit_body: "Your balance ran out, so your lanes are paused.",
+  n_creditMinutes_body: "Your balance ran out, so your lanes are paused. Add funds within {minutes} min to keep them.",
   n_busy_title: "All lanes are busy",
   n_busy_body: "Your request on {model} is waiting for a free lane and will retry by itself.",
   n_preparing_title: "Getting your conversation ready",
@@ -1674,8 +1683,8 @@ var str4 = (value) => typeof value === "string" && value.trim() !== "" ? value.t
 function say(title, body, params = {}) {
   return { title: fill(en[title], params), body: body === null ? "" : fill(en[body], params), text: { title, body, params } };
 }
-function button(id, label, extra = {}) {
-  return { id, label: en[label], labelKey: label, ...extra };
+function button(id, label2, extra = {}) {
+  return { id, label: en[label2], labelKey: label2, ...extra };
 }
 var count2 = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
 var PRIVATE_HELD = "A private conversation is not kept on AdaptiqAI, so it can't use this before it exists there. Turn Remember on for this conversation to add it.";
@@ -1842,7 +1851,7 @@ function copyFailure(error, model2) {
     case "model_mismatch":
       return str4(detail.message) ?? `This collection can't be made available for ${model2}.`;
     case "inference_entitlement_required":
-      return `Your workspace has no lanes on ${model2}.`;
+      return "You need to rent a lane or subscribe to AdaptiqAI to continue.";
     case "collection_not_found":
       return "This collection no longer exists.";
     case "sources_not_exportable":
@@ -2733,13 +2742,13 @@ var Workspace = class {
     this.publish();
   }
   /** A browser approval completed. */
-  signedIn(label) {
+  signedIn(label2) {
     if (this.state.defaultModel === void 0) {
       this.state = { ...this.state, defaultModel: "pending" };
       void this.persist();
     }
     this.clearNotices("sign-in");
-    this.raise({ kind: "connected", tone: "success", ...say("connectedTo", "n_connected_body", { workspace: label }), actions: [] });
+    this.raise({ kind: "connected", tone: "success", ...say("connectedTo", "n_connected_body", { workspace: label2 }), actions: [] });
     this.summaryMode = "unknown";
     this.summaryMissingAt = null;
     void this.refresh();
@@ -3325,6 +3334,14 @@ var Workspace = class {
       actions: [button("open-console", "n_openConsole", { url: this.links.console, primary: true })]
     });
   }
+  /**
+   * Say that a message's images were not sent because the model reads text only.
+   * @param sessionId - the conversation, when known.
+   * @param modelName - the model's display name.
+   */
+  imagesNotSent(sessionId2, modelName) {
+    this.raise({ kind: "images", tone: "warning", ...say("n_imagesTextOnly_title", "n_imagesTextOnly_body", { model: modelName }), actions: [], ...sessionId2 === void 0 ? {} : { sessionId: sessionId2 } });
+  }
   failed(sessionId2, model2, failure) {
     if (failure.code === CODES.compaction) {
       this.raise({ kind: "compaction", tone: "info", ...say("n_compaction_title", "n_compaction_body"), actions: [], ...sessionId2 === void 0 ? {} : { sessionId: sessionId2 } });
@@ -3366,11 +3383,13 @@ var Workspace = class {
         break;
       case "no-lanes": {
         const offer = this.offers.find((item) => item.model === model2) ?? this.offers.find((item) => item.name.toLowerCase() === name2.toLowerCase());
+        const body = failure.serverCode === "rental_stopped_unused" ? "n_laneStopped_body" : failure.planRenewsAt !== void 0 ? "n_planUsedUp_body" : failure.serverCode === "plan_usage_exhausted" ? "n_planUsedUpNoDate_body" : "n_noLanes_body";
+        const until = failure.planRenewsAt === void 0 ? "" : `${new Date(failure.planRenewsAt * 1e3).toISOString().slice(0, 16).replace("T", " ")} UTC`;
         this.raise({
           kind: "no-lanes",
           tone: "warning",
           modal: true,
-          ...say("n_noLanes_title", failure.serverCode === "rental_stopped_unused" ? "n_laneStopped_body" : "n_noLanes_body", { model: name2 }),
+          ...say("n_noLanes_title", body, { until }),
           actions: [button("get-access", "getAccess", { primary: true, ...offer === void 0 ? {} : { offerId: offer.id } }), button("dismiss", "notNow")]
         });
         break;
@@ -3380,7 +3399,7 @@ var Workspace = class {
           kind: "out-of-credit",
           tone: "error",
           modal: true,
-          ...failure.minutesLeft === void 0 ? say("n_credit_title", "n_credit_body", { model: name2 }) : say("n_credit_title", "n_creditMinutes_body", { model: name2, minutes: String(failure.minutesLeft) }),
+          ...failure.minutesLeft === void 0 ? say("n_credit_title", "n_credit_body") : say("n_credit_title", "n_creditMinutes_body", { minutes: String(failure.minutesLeft) }),
           actions: [button("add-funds", "n_addFunds", { url: this.links.models, primary: true }), button("dismiss", "notNow")]
         });
         break;
@@ -3560,7 +3579,7 @@ var Workspace = class {
     if (target === void 0)
       throw new Error("Choose an AdaptiqAI model first.");
     const modelName = this.modelName(target);
-    const label = modelName ?? target;
+    const label2 = modelName ?? target;
     let body;
     try {
       body = await this.deps.api.json(`/v1/memories/${encodeURIComponent(id)}/copies`, {
@@ -3576,7 +3595,7 @@ var Workspace = class {
         this.copies.set(copyKey(id, target), { source: id, from, target, copy: null, status: "building" });
         return { status: "building", model: target, modelName };
       }
-      throw new Error(copyFailure(error, label));
+      throw new Error(copyFailure(error, label2));
     }
     const copy = obj4(body?.copy);
     const status = copyStatus(str4(copy?.status));
@@ -4671,7 +4690,70 @@ async function* translate(events, hooks) {
   };
 }
 
+// src/host/images.ts
+var ENGINE_IMAGE_LIMITS = Object.freeze({
+  maxImages: 8,
+  maxImageBytes: 20 * 1024 * 1024,
+  maxPixels: 16e6
+});
+var ImageProblem = class extends Error {
+  name = "ImageProblem";
+};
+var startsWith = (data, bytes, at = 0) => data.length >= at + bytes.length && bytes.every((byte, index) => data[at + index] === byte);
+var ascii = (text2) => [...text2].map((char) => char.charCodeAt(0));
+function sniffImageType(data) {
+  if (startsWith(data, [137, 80, 78, 71, 13, 10, 26, 10])) return "image/png";
+  if (startsWith(data, [255, 216, 255])) return "image/jpeg";
+  if (startsWith(data, ascii("GIF87a")) || startsWith(data, ascii("GIF89a"))) return "image/gif";
+  if (startsWith(data, ascii("RIFF")) && startsWith(data, ascii("WEBP"), 8)) return "image/webp";
+  return null;
+}
+function fitPixels(width, height, maxPixels) {
+  if (width * height <= maxPixels) return { width, height };
+  const scale = Math.sqrt(maxPixels / (width * height));
+  let w = Math.max(1, Math.floor(width * scale));
+  let h = Math.max(1, Math.floor(height * scale));
+  while (w * h > maxPixels) {
+    if (w >= h) w--;
+    else h--;
+  }
+  return { width: w, height: h };
+}
+var carriesImages = (message) => message.role === "user" || message.role === "tool";
+function sentImages(messages) {
+  const out = [];
+  for (const message of messages) {
+    if (!carriesImages(message)) continue;
+    for (const block of message.content) if (block.type === "image" && block.offloaded !== true) out.push(block);
+  }
+  return out;
+}
+function hasImages(messages) {
+  return messages.some((message) => message.content.some((block) => block.type === "image"));
+}
+var mib = (bytes) => `${Math.round(bytes / (1024 * 1024) * 10) / 10} MB`;
+var label = (ref) => ref.name === void 0 ? "An image" : `The image "${ref.name}"`;
+async function prepareImages(messages, source, limits, signal) {
+  const refs = /* @__PURE__ */ new Map();
+  for (const block of sentImages(messages)) refs.set(String(block.attachment.attachmentId), block.attachment);
+  const entries = await Promise.all([...refs].map(async ([id, ref]) => {
+    const target = { ...fitPixels(ref.width, ref.height, limits.maxPixels), maxBytes: limits.maxImageBytes };
+    const version = await source.readImageRequest(ref, target, signal);
+    const mediaType = sniffImageType(version.data);
+    if (mediaType === null) throw new ImageProblem(`${label(ref)} is not a PNG, JPEG, WebP or GIF file, so AdaptiqAI can't read it. Attach it in one of those formats.`);
+    if (version.data.byteLength > limits.maxImageBytes) {
+      throw new ImageProblem(`${label(ref)} is ${mib(version.data.byteLength)}; AdaptiqAI takes images up to ${mib(limits.maxImageBytes)}. Attach a smaller copy.`);
+    }
+    if (version.width * version.height > limits.maxPixels) {
+      throw new ImageProblem(`${label(ref)} is ${version.width}\xD7${version.height} pixels, more than AdaptiqAI takes. Attach a smaller copy.`);
+    }
+    return [id, { url: `data:${mediaType};base64,${Buffer.from(version.data).toString("base64")}`, width: version.width, height: version.height }];
+  }));
+  return new Map(entries);
+}
+
 // src/host/wire.ts
+import { offloadedImageText, requestImageHandleText, textOnlyImageText } from "@deepseek-ai/dsh-llm";
 function sessionReferences(message) {
   if (message.role !== "user") return null;
   const source = message.source;
@@ -4763,16 +4845,62 @@ function userTurns(messages) {
 }
 var text = (blocks) => blocks.filter((block) => block.type === "text").map((block) => block.text).join("");
 var reasoning = (blocks) => blocks.filter((block) => block.type === "reasoning").map((block) => block.text).join("");
+var Parts = class {
+  parts = [];
+  glue = false;
+  text(value, own = false) {
+    if (value === "") return;
+    const last = this.parts.at(-1);
+    if (last?.type === "text") last.text += (own || this.glue ? "\n" : "") + value;
+    else this.parts.push({ type: "text", text: value });
+    this.glue = own;
+  }
+  image(url) {
+    this.parts.push({ type: "image_url", image_url: { url } });
+    this.glue = false;
+  }
+  get hasImage() {
+    return this.parts.some((part) => part.type === "image_url");
+  }
+  get joined() {
+    return this.parts.map((part) => part.type === "text" ? part.text : "").join("");
+  }
+};
+function putImage(block, images, parts, inline) {
+  const access2 = images?.access?.(block.attachment);
+  if (block.offloaded === true) {
+    parts.text(offloadedImageText(block.attachment, access2), true);
+    return null;
+  }
+  const sent = images?.sent?.get(String(block.attachment.attachmentId));
+  if (sent === void 0) {
+    parts.text(textOnlyImageText(block.attachment), true);
+    return null;
+  }
+  parts.text(requestImageHandleText(block.attachment, sent, access2), true);
+  if (!inline) return sent;
+  parts.image(sent.url);
+  return null;
+}
 function replayField(message) {
   const source = message.source;
   const state2 = source?.replayState;
   const field = state2?.response?.reasoningField;
   return typeof field === "string" && /^[a-z_]{1,32}$/u.test(field) ? field : "reasoning_content";
 }
-function wireMessages(options, recalled = /* @__PURE__ */ new Map()) {
+function wireMessages(options, recalled = /* @__PURE__ */ new Map(), images) {
   const out = [];
   if (options.system !== void 0 && options.system !== "") out.push({ role: "system", content: options.system });
+  let toolImages = [];
+  const flushToolImages = () => {
+    if (toolImages.length === 0) return;
+    const parts = [{ type: "text", text: toolImages.length === 1 ? "The image from the tool result above:" : "The images from the tool results above, in order:" }];
+    for (const image of toolImages) parts.push({ type: "image_url", image_url: { url: image.url } });
+    out.push({ role: "user", content: parts });
+    toolImages = [];
+  };
   options.messages.forEach((message, index) => {
+    if (message.role !== "tool") flushToolImages();
     switch (message.role) {
       case "system": {
         const content = text(message.content);
@@ -4784,6 +4912,15 @@ function wireMessages(options, recalled = /* @__PURE__ */ new Map()) {
         return;
       }
       case "user": {
+        if (message.content.some((block) => block.type === "image")) {
+          const parts = new Parts();
+          for (const block of message.content) {
+            if (block.type === "text") parts.text(block.text);
+            else if (block.type === "image") putImage(block, images, parts, true);
+          }
+          out.push({ role: "user", content: parts.hasImage ? parts.parts : parts.joined });
+          return;
+        }
         const references = recalled.size === 0 ? null : sessionReferences(message);
         const content = text(message.content);
         out.push({ role: "user", content: references === null ? content : recallSnapshot(content, references, recalled) });
@@ -4805,7 +4942,15 @@ function wireMessages(options, recalled = /* @__PURE__ */ new Map()) {
         return;
       }
       case "tool": {
-        const content = text(message.content);
+        const parts = new Parts();
+        for (const block of message.content) {
+          if (block.type === "text") parts.text(block.text);
+          else if (block.type === "image") {
+            const deferred = putImage(block, images, parts, false);
+            if (deferred !== null) toolImages.push(deferred);
+          }
+        }
+        const content = parts.joined;
         out.push({ role: "tool", tool_call_id: message.toolCallId, content: content === "" ? "(no output)" : content });
         return;
       }
@@ -4813,12 +4958,13 @@ function wireMessages(options, recalled = /* @__PURE__ */ new Map()) {
         return;
     }
   });
+  flushToolImages();
   return out;
 }
 function buildChatBody(options, model2, extras) {
   const body = {
     model: options.model,
-    messages: wireMessages(options, extras.recalled),
+    messages: wireMessages(options, extras.recalled, extras.images),
     stream: true,
     stream_options: { include_usage: extras.includeUsage ?? true }
   };
@@ -4970,6 +5116,41 @@ var AdaptiqAdapter = class extends LlmAdapter {
   stream(options) {
     return this.generate(options);
   }
+  /**
+   * The request's images, read from the harness's stored copies, when the
+   * model's card says it reads images. Otherwise each image goes as a short
+   * note and the person is told.
+   */
+  async images(options, model2, sessionId2, fail2, signal) {
+    if (!hasImages(options.messages)) return void 0;
+    const access2 = this.deps.imageAccess === void 0 ? void 0 : (ref) => {
+      try {
+        return this.deps.imageAccess?.(ref);
+      } catch {
+        return void 0;
+      }
+    };
+    const withAccess = access2 === void 0 ? {} : { access: access2 };
+    const problem = (message) => fail2({ code: CODES.invalidRequest, message, status: null, requestId: null, retryAfterMs: null, serverType: null, serverCode: null, notice: null });
+    if (model2?.input.includes("image") !== true) {
+      if (sentImages(options.messages).length > 0) this.deps.events.imagesNotSent?.(sessionId2, model2?.name ?? options.model);
+      return { sent: null, ...withAccess };
+    }
+    const limits = this.deps.imageLimits ?? ENGINE_IMAGE_LIMITS;
+    const excess = sentImages(options.messages).length - limits.maxImages;
+    if (excess > 0) {
+      throw new LlmError(`AdaptiqAI takes up to ${limits.maxImages} images per request; the ${excess} oldest ${excess === 1 ? "one goes" : "go"} as a note naming ${excess === 1 ? "it" : "them"}.`, IMAGE_OFFLOAD_REQUIRED_CODE, { offloadImages: excess });
+    }
+    const source = this.deps.attachments?.();
+    if (source === void 0) throw problem("This DeepSeek Harness has no attachment service, so images can't be sent. Update DeepSeek Harness and try again.");
+    try {
+      return { sent: await prepareImages(options.messages, source, limits, signal), ...withAccess };
+    } catch (error) {
+      if (error instanceof ImageProblem) throw problem(error.message);
+      if (signal.aborted) throw new LlmError("Request stopped.", CODES.aborted, { cause: error });
+      throw problem(`An attached image could not be read: ${error instanceof Error ? error.message : String(error)}. Attach it again.`);
+    }
+  }
   async *generate(options) {
     if (options.purpose === "compaction") {
       const message = "AdaptiqAI keeps the whole conversation in native memory, so it never needs compacting. Nothing was removed.";
@@ -5044,7 +5225,8 @@ var AdaptiqAdapter = class extends LlmAdapter {
         if (references.length > 0) recalled = await this.deps.recall(sessionId2, options.model, references, signal).catch(() => NOTHING_RECALLED);
       }
       const parent = options.sessionId === void 0 ? void 0 : this.deps.parentSession?.(String(options.sessionId));
-      let body = JSON.stringify(buildChatBody(options, model2, { remember, stored, recalled }));
+      const images = await this.images(options, model2, sessionId2, fail2, signal);
+      let body = JSON.stringify(buildChatBody(options, model2, { remember, stored, recalled, images }));
       this.deps.debug?.(`adaptiq: request ${sessionId2 ?? "-"}: ${options.messages.length} messages, ${body.length} bytes, ${recalled.size} read from memory, transcripts sent: ${body.includes("<referenced-sessions>") ? "yes" : "no"}`);
       let response;
       let refreshed = false;
@@ -5085,7 +5267,7 @@ var AdaptiqAdapter = class extends LlmAdapter {
           await response.body?.cancel().catch(() => {
           });
           stored = false;
-          body = JSON.stringify(buildChatBody(options, model2, { remember, stored, recalled }));
+          body = JSON.stringify(buildChatBody(options, model2, { remember, stored, recalled, images }));
           continue;
         }
         break;
@@ -6091,7 +6273,7 @@ Open **Settings \u2192 AdaptiqAI** to connect, or run \`/adaptiq signin\`.
 var ENTRY_PROTOCOL = 1;
 var RELOAD_SIGNATURE = true ? "ada3dfffa1b3d7b1" : "source";
 function pluginVersion() {
-  if (true) return "0.2.12";
+  if (true) return "0.2.13";
   try {
     return createRequire(import.meta.url)("../package.json").version;
   } catch {
@@ -6114,14 +6296,25 @@ async function harnessSessions(ctx) {
   return new Map(records.map((record) => {
     let title = null;
     try {
-      const label = typeof labels?.projectedLabels === "function" ? labels.projectedLabels(record).label : void 0;
-      if (typeof label === "string" && label.trim() !== "" && label !== record.header.id) title = label.trim();
+      const label2 = typeof labels?.projectedLabels === "function" ? labels.projectedLabels(record).label : void 0;
+      if (typeof label2 === "string" && label2.trim() !== "" && label2 !== record.header.id) title = label2.trim();
     } catch {
     }
     const subagent = record.header.origin === "subagent" || (record.header.delegationDepth ?? 0) > 0;
     return [record.header.id, { title, subagent }];
   }));
 }
+function attachmentService(ctx) {
+  const service = ctx.get("attachments");
+  return typeof service?.readImageRequest === "function" ? service : void 0;
+}
+function imageAccess(ctx, ref) {
+  const host = attachmentService(ctx)?.imageHostPath?.(ref);
+  if (host === void 0) return void 0;
+  const fs = ctx.get("fs");
+  const readonlyPath = fs?.processPathFromHostPath?.(host);
+  return readonlyPath === void 0 ? void 0 : { readonlyPath };
+}
 var VERSION = pluginVersion();
 async function apply(ctx, config) {
   await applyWith(ctx, config, void 0);
@@ -6146,8 +6339,8 @@ async function applyWith(ctx, raw, runtime) {
     onChange: () => {
       workspace?.authChanged();
     },
-    onSignedIn: (label) => {
-      workspace?.signedIn(label);
+    onSignedIn: (label2) => {
+      workspace?.signedIn(label2);
     }
   });
   const api = new AdaptiqApi(apiBase, auth, () => ({
@@ -6229,6 +6422,8 @@ async function applyWith(ctx, raw, runtime) {
     attachPending: (sessionId2) => owned.attachPending(sessionId2),
     events: owned,
     autoSleep: (model2) => owned.autoSleep(model2),
+    attachments: () => attachmentService(ctx),
+    imageAccess: (ref) => imageAccess(ctx, ref),
     ...process.env.DSH_ADAPTIQ_DEBUG_LOG === void 0 || process.env.DSH_ADAPTIQ_DEBUG_LOG === "" ? {} : { debug: (message) => {
       log("info", message);
     } }

package/lib/types/host/adapter.d.ts

@@ -7,6 +7,7 @@
 import { LlmAdapter, LlmError } from '@deepseek-ai/dsh-llm';
 import type { GenerateOptions, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, PreparedAdapterCall, ResolvedRetryPolicy, StreamChunk } from '@deepseek-ai/dsh-llm';
 import { type AdaptiqFailure, type AuthManager, type CatalogModel, type RequestEvents, type UserTurn } from '@adaptiqai/core';
+import { type ImageLimits, type ImageRef, type ImageSource } from './images.ts';
 import { type ParentSession, type ReferencedSession } from './wire.ts';
 /** What the adapter tells the rest of the plugin about each request. */
 export interface AdapterDeps {
@@ -42,6 +43,14 @@ export interface AdapterDeps {
     readonly events: RequestEvents;
     /** Whether the server behind a model puts idle conversations to sleep (it reports session history apart). */
     readonly autoSleep?: (model: string) => boolean;
+    /** The harness's attachment service, where attached images are stored (absent on hosts without one). */
+    attachments?(): ImageSource | undefined;
+    /** Where the model's tools can read the stored copy of an image. */
+    imageAccess?(ref: ImageRef): {
+        readonlyPath: string;
+    } | undefined;
+    /** The engine's image limits (tests use smaller ones). */
+    readonly imageLimits?: ImageLimits;
     /** Diagnostics for one request (no content), when a debug log is on. */
     debug?(message: string): void;
     readonly fetch?: typeof fetch;
@@ -78,5 +87,11 @@ export declare class AdaptiqAdapter extends LlmAdapter {
     resolveModel(provider: string, model: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
     prepareCall(provider: string, model: string, signal?: AbortSignal): Promise<PreparedAdapterCall>;
     stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    /**
+     * The request's images, read from the harness's stored copies, when the
+     * model's card says it reads images. Otherwise each image goes as a short
+     * note and the person is told.
+     */
+    private images;
     private generate;
 }

package/lib/types/host/images.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Images a person attached, as inline data the AdaptiqAI API accepts.
+ *
+ * The harness stores each attached image once, content-addressed (sha256), and
+ * hands the adapter a durable reference. The bytes sent are read from that
+ * stored copy, never from the file the person picked, so a history image is the
+ * same bytes on every turn (the engine dedupes by content hash) even when the
+ * original file has changed since.
+ */
+import type { ImageBlock, RequestMessage } from '@deepseek-ai/dsh-llm';
+/** One image reference as the harness stores it. */
+export type ImageRef = ImageBlock['attachment'];
+/** Image media types the engine accepts. */
+export type ImageMediaType = 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif';
+/** What the engine accepts per request. */
+export interface ImageLimits {
+    /** Image parts in one request (history included). */
+    readonly maxImages: number;
+    /** Encoded bytes of one image. */
+    readonly maxImageBytes: number;
+    /** Width × height of one image; larger ones are scaled down before sending. */
+    readonly maxPixels: number;
+}
+/** The engine's limits behind api.adaptiqai.com (8 images, 20 MiB and 16.8 MP each); pixels kept a little under. */
+export declare const ENGINE_IMAGE_LIMITS: ImageLimits;
+/** The request version the harness's attachment service makes of one stored image. */
+export interface RequestImageVersion {
+    readonly data: Uint8Array;
+    readonly mediaType: string;
+    readonly width: number;
+    readonly height: number;
+}
+/** The part of the harness's attachment service (`ctx.attachments`) the adapter reads images through. */
+export interface ImageSource {
+    readImageRequest(ref: ImageRef, target: {
+        width: number;
+        height: number;
+        maxBytes: number;
+    }, signal?: AbortSignal): Promise<RequestImageVersion>;
+}
+/** One image ready for the wire. */
+export interface WireImage {
+    /** `data:<mime>;base64,...` */
+    readonly url: string;
+    readonly width: number;
+    readonly height: number;
+}
+/** An image the engine would refuse, said in plain words. */
+export declare class ImageProblem extends Error {
+    readonly name = "ImageProblem";
+}
+/**
+ * The image format, read from the bytes themselves.
+ * @param data - encoded image bytes.
+ * @returns the media type, or null when the bytes are no PNG, JPEG, WebP or GIF.
+ */
+export declare function sniffImageType(data: Uint8Array): ImageMediaType | null;
+/**
+ * The size to send one image at: its own, or scaled down (aspect kept) to fit the pixel limit.
+ * @param width - stored width.
+ * @param height - stored height.
+ * @param maxPixels - width × height limit.
+ * @returns target width and height.
+ */
+export declare function fitPixels(width: number, height: number, maxPixels: number): {
+    width: number;
+    height: number;
+};
+/**
+ * The images a request sends (not offloaded by the harness), one entry per occurrence, oldest first.
+ * @param messages - the request history.
+ * @returns image blocks in request order.
+ */
+export declare function sentImages(messages: readonly RequestMessage[]): ImageBlock[];
+/**
+ * Whether any message of the request carries an image.
+ * @param messages - the request history.
+ * @returns true when one does.
+ */
+export declare function hasImages(messages: readonly RequestMessage[]): boolean;
+/**
+ * Read every image the request sends from the harness's stored copies, check
+ * it against the engine's limits and encode it as a data URL.
+ * @param messages - the request history.
+ * @param source - the harness's attachment service.
+ * @param limits - the engine's limits.
+ * @param signal - cancellation.
+ * @returns attachment id → wire image.
+ * @throws ImageProblem when an image is not one the engine accepts.
+ */
+export declare function prepareImages(messages: readonly RequestMessage[], source: ImageSource, limits: ImageLimits, signal?: AbortSignal): Promise<Map<string, WireImage>>;

package/lib/types/host/wire.d.ts

@@ -1,17 +1,13 @@
-/**
- * Harness request → OpenAI Chat Completions body. Model-specific behaviour
- * (thinking field and values, sampling defaults) comes only from the
- * model's catalog entry.
- */
 import type { GenerateOptions, RequestMessage } from '@deepseek-ai/dsh-llm';
 import { type CatalogModel, type SessionRole, type UserTurn } from '@adaptiqai/core';
+import type { ImageRef, WireImage } from './images.ts';
 /** One Chat Completions message. */
 export type WireMessage = {
     role: 'system';
     content: string;
 } | {
     role: 'user';
-    content: string;
+    content: string | WirePart[];
 } | {
     role: 'assistant';
     content: string | null;
@@ -22,6 +18,25 @@ export type WireMessage = {
     tool_call_id: string;
     content: string;
 };
+/** One part of a user message that carries images, in the person's order. */
+export type WirePart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image_url';
+    image_url: {
+        url: string;
+    };
+};
+/** How the images of a request go on the wire. */
+export interface WireImages {
+    /** Attachment id → inline image; null when the model reads text only (each image becomes a short note). */
+    readonly sent: ReadonlyMap<string, WireImage> | null;
+    /** Where the model's tools can read the harness's stored copy of an image. */
+    readonly access?: (ref: ImageRef) => {
+        readonlyPath: string;
+    } | undefined;
+}
 export interface WireToolCall {
     id: string;
     type: 'function';
@@ -40,6 +55,8 @@ export interface WireExtras {
     readonly includeUsage?: boolean;
     /** Referenced sessions attached to this conversation and ready, by session id → name. */
     readonly recalled?: ReadonlyMap<string, string>;
+    /** The request's images; without it every image becomes a short note. */
+    readonly images?: WireImages;
 }
 /** One session another message mentioned with `@`, as the harness snapshot records it. */
 export interface ReferencedSession {
@@ -94,9 +111,10 @@ export declare function userTurns(messages: readonly RequestMessage[]): UserTurn
  * Convert the harness history to Chat Completions messages.
  * @param options - the harness request.
  * @param recalled - referenced sessions read from memory: their snapshots become one line.
+ * @param images - the request's images; without it each image becomes a short note.
  * @returns the wire messages in order.
  */
-export declare function wireMessages(options: Pick<GenerateOptions, 'messages' | 'system'>, recalled?: ReadonlyMap<string, string>): WireMessage[];
+export declare function wireMessages(options: Pick<GenerateOptions, 'messages' | 'system'>, recalled?: ReadonlyMap<string, string>, images?: WireImages): WireMessage[];
 /**
  * Build the request body for one call.
  * @param options - the harness request.