@opengeni/worker-bundle 3.0.1-canary.38872461489001 → 3.1.2

package/dist/activities/agent-turn/errors.d.ts

@@ -20,6 +20,7 @@ export declare const PROVIDER_RATE_LIMIT_BACKOFF_MS: readonly [10000, 20000, 400
 /** Positive-only spread: never shorten the provider's minimum delay. */
 export declare function providerRecoveryJitterMs(delayMs: number, sample: number): number;
 export declare const POST_COMPACTION_CONTINUATION_EMPTY_CODE = "post_compaction_continuation_empty";
+export declare const RETAINED_ATTACHMENT_UNAVAILABLE_CODE = "retained_attachment_unavailable";
 export declare class PostCompactionContinuationEmptyError extends Error {
     readonly code = "post_compaction_continuation_empty";
     constructor();

package/dist/activities/run-input.d.ts

@@ -69,6 +69,18 @@ export declare const MAX_RETAINED_MODEL_ATTACHMENT_BYTES: number;
 export declare class RetainedAttachmentTransportLimitError extends Error {
     constructor();
 }
+/**
+ * A retained image the conversation already sent could not be read from
+ * object storage, for example while a storage replica catches up after an
+ * outage. Its pixels are part of the accepted prompt, so the turn waits and
+ * retries rather than continuing without them. Integrity mismatches are not
+ * this error: retrying cannot repair different bytes.
+ */
+export declare class RetainedAttachmentUnavailableError extends Error {
+    readonly fileIds: readonly string[];
+    constructor(fileIds: readonly string[]);
+}
+export type ModelAttachmentReadFailure = "unavailable" | "integrity_mismatch";
 export type ModelAttachmentContent = {
     kind: "image" | "file";
     fileId: string;
@@ -87,11 +99,15 @@ export type ModelAttachmentInputPolicy = {
 };
 export declare function modelAttachmentContentForFiles(files: FileAsset[], readFileBytes: (file: FileAsset) => Promise<Uint8Array>, options?: {
     retainAll?: boolean;
+    /** Why a selected file produced no content; omitted files are not reported. */
+    onReadFailure?: (fileId: string, failure: ModelAttachmentReadFailure) => void;
 }): Promise<ModelAttachmentContent[]>;
 /**
  * Build one turn-scoped durable-attachment projector. Resolve active refs under
  * current file authority and memoize metadata/bytes for retries and compaction.
  * A turn boundary never changes an authorized attachment's representation.
+ * Images of a message stamped with an image bound are shown downscaled to fit
+ * it; unstamped (older) messages keep their full-resolution projection.
  */
 export declare function createModelHistoryAttachmentProjector(policy: ModelAttachmentInputPolicy, readFileBytes?: (file: FileAsset) => Promise<Uint8Array>, loadAuthorizedFiles?: (fileIds: readonly string[]) => Promise<readonly FileAsset[]>): ModelHistoryAttachmentProjector;
 /** Add current trigger refs only when older/local history predates durable stamping. */

package/dist/{activities-control-3PJDM3QQ.js → activities-control-ROJJNNTJ.js}

@@ -22,7 +22,7 @@ import {
   withFirstPartyTools,
   workflowIdForSession,
   writeSessionUsageReceipts
-} from "./chunk-QCD6PEBU.js";
+} from "./chunk-6SHXF4SU.js";
 import {
   agentRunAdmissionDenial,
   createSiteAuthMaintenanceActivities
@@ -6142,4 +6142,4 @@ export {
   createControlActivities,
   createControlActivitiesFromServices
 };
-//# sourceMappingURL=activities-control-3PJDM3QQ.js.map
+//# sourceMappingURL=activities-control-ROJJNNTJ.js.map

package/dist/{activities-turn-2ILW6PRK.js → activities-turn-4SWYWKI5.js}

@@ -111,7 +111,7 @@ import {
   wakeSubscriptionCoreWaitersAndDeliver,
   withFirstPartyTools,
   withModelRoutePresentation
-} from "./chunk-QCD6PEBU.js";
+} from "./chunk-6SHXF4SU.js";
 import {
   createFreshSandboxReadinessReplacementBudget,
   establishSelfhostedTurnSession,
@@ -42524,4 +42524,4 @@ export {
   createTurnActivities,
   createTurnActivitiesFromServices
 };
-//# sourceMappingURL=activities-turn-2ILW6PRK.js.map
+//# sourceMappingURL=activities-turn-4SWYWKI5.js.map

package/dist/{chunk-QCD6PEBU.js → chunk-6SHXF4SU.js}

@@ -6183,6 +6183,7 @@ import {
   MODEL_ATTACHMENT_REFS_FIELD,
   MODEL_ATTACHMENT_CATALOG_MARKER,
   MODEL_ATTACHMENT_CATALOG_RENDERED_FIELD,
+  MODEL_ATTACHMENT_IMAGE_MAX_DIMENSION_FIELD,
   FileResourceRef,
   resourceMountPath,
   readTurnExecutionPolicyV1 as readTurnExecutionPolicyV14,
@@ -6198,6 +6199,7 @@ import {
   readSubscriptionHistoryProvenance
 } from "@opengeni/db";
 import {
+  createModelImageSizer,
   projectHistoryForProvider,
   projectRejectedProviderArtifactsFromSerializedRunState,
   projectRejectedReasoningArtifact,
@@ -6295,6 +6297,14 @@ var RetainedAttachmentTransportLimitError = class extends Error {
     this.name = "RetainedAttachmentTransportLimitError";
   }
 };
+var RetainedAttachmentUnavailableError = class extends Error {
+  fileIds;
+  constructor(fileIds) {
+    super("An image attached earlier in this conversation can't be read from storage right now.");
+    this.name = "RetainedAttachmentUnavailableError";
+    this.fileIds = [...fileIds];
+  }
+};
 var MODEL_IMAGE_CONTENT_TYPES = /* @__PURE__ */ new Set(["image/gif", "image/jpeg", "image/png", "image/webp"]);
 var MODEL_FILE_CONTENT_TYPES = /* @__PURE__ */ new Set([
   "application/json",
@@ -6349,12 +6359,14 @@ async function modelAttachmentContentForFiles(files, readFileBytes, options = {}
             expectedSizeBytes: file.sizeBytes,
             actualSizeBytes: bytes.byteLength
           });
+          options.onReadFailure?.(file.id, "integrity_mismatch");
           continue;
         }
         if (createHash4("sha256").update(bytes).digest("hex") !== checksum) {
           console.error("model attachment checksum did not match finalized metadata", {
             fileId: file.id
           });
+          options.onReadFailure?.(file.id, "integrity_mismatch");
           continue;
         }
         attachments[index] = {
@@ -6369,6 +6381,7 @@ async function modelAttachmentContentForFiles(files, readFileBytes, options = {}
           fileId: file.id,
           errorType: safeErrorType(error)
         });
+        options.onReadFailure?.(file.id, "unavailable");
       }
     }
   };
@@ -6395,12 +6408,43 @@ function attachmentReceiptText(ref) {
 function unavailableAttachmentReceiptText(ref) {
   return requesterUnavailableReceiptText(`Attachment: fileId=${ref.fileId}`, "file");
 }
+function attachmentImageBound(item) {
+  const raw = item[MODEL_ATTACHMENT_IMAGE_MAX_DIMENSION_FIELD];
+  return typeof raw === "number" && Number.isSafeInteger(raw) && raw >= 64 && raw <= 8192 ? raw : void 0;
+}
+var boundedImageSizers = /* @__PURE__ */ new Map();
+async function boundedAttachmentImage(attachment, bound) {
+  const original = { image: attachment.dataUrl, note: "" };
+  const comma = attachment.dataUrl.indexOf(",");
+  if (comma < 0) return original;
+  const data = attachment.dataUrl.slice(comma + 1);
+  let sizer = boundedImageSizers.get(bound);
+  if (!sizer) {
+    sizer = createModelImageSizer(bound, 10 * 1024 * 1024, { jpegQuality: 85 });
+    boundedImageSizers.set(bound, sizer);
+  }
+  try {
+    const sized = await sizer(data, attachment.contentType);
+    if (sized.data === data && sized.mediaType === attachment.contentType) return original;
+    return {
+      image: `data:${sized.mediaType};base64,${sized.data}`,
+      note: ` Shown to you downscaled to ${sized.width}x${sized.height} from ${sized.originalWidth}x${sized.originalHeight}; the file itself is full resolution.`
+    };
+  } catch (error) {
+    console.error("model attachment image could not be resized; sending original", {
+      fileId: attachment.fileId,
+      errorType: safeErrorType(error)
+    });
+    return original;
+  }
+}
 function createModelHistoryAttachmentProjector(policy, readFileBytes, loadAuthorizedFiles) {
   const contentById = /* @__PURE__ */ new Map();
   const attemptedContentIds = /* @__PURE__ */ new Set();
   const fileById = /* @__PURE__ */ new Map();
   const resolvedFileIds = /* @__PURE__ */ new Set();
   const retainedByteSizes = /* @__PURE__ */ new Map();
+  const boundedById = /* @__PURE__ */ new Map();
   return async (items, options = {}) => {
     for (const file of options.inlineFiles ?? []) {
       fileById.set(file.id, file);
@@ -6451,18 +6495,37 @@ function createModelHistoryAttachmentProjector(policy, readFileBytes, loadAuthor
         return Boolean(descriptor && descriptor.kind === "image" && policy.supportsImageInput);
       });
       for (const file of readable) attemptedContentIds.add(file.id);
+      const readFailures = /* @__PURE__ */ new Map();
       const content = await modelAttachmentContentForFiles(readable, readFileBytes, {
-        retainAll: true
+        retainAll: true,
+        onReadFailure: (fileId, failure) => readFailures.set(fileId, failure)
       });
       const loadedIds = new Set(content.map((entry) => entry.fileId));
-      for (const file of readable) {
-        if (file.status === "ready" && file.sizeBytes <= MAX_INLINE_MODEL_ATTACHMENT_BYTES && /^[a-f0-9]{64}$/i.test(file.sha256 ?? "") && !loadedIds.has(file.id)) {
-          for (const candidate of readable) attemptedContentIds.delete(candidate.id);
-          throw new Error(`Retained attachment bytes unavailable or invalid: ${file.id}`);
+      const missing = readable.filter(
+        (file) => file.status === "ready" && file.sizeBytes <= MAX_INLINE_MODEL_ATTACHMENT_BYTES && /^[a-f0-9]{64}$/i.test(file.sha256 ?? "") && !loadedIds.has(file.id)
+      );
+      if (missing.length > 0) {
+        for (const candidate of readable) attemptedContentIds.delete(candidate.id);
+        const corrupt = missing.find((file) => readFailures.get(file.id) === "integrity_mismatch");
+        if (corrupt) {
+          throw new Error(`Retained attachment bytes unavailable or invalid: ${corrupt.id}`);
         }
+        throw new RetainedAttachmentUnavailableError(missing.map((file) => file.id));
       }
       for (const attachment of content) contentById.set(attachment.fileId, attachment);
     }
+    for (const [index, refs] of refsByIndex) {
+      const item = items[index];
+      if (item[MODEL_ATTACHMENT_CATALOG_MARKER] === true) continue;
+      const bound = attachmentImageBound(item);
+      if (bound === void 0) continue;
+      for (const ref of refs) {
+        const attachment = fileById.has(ref.fileId) ? contentById.get(ref.fileId) : void 0;
+        const key = `${bound}:${ref.fileId}`;
+        if (!attachment || attachment.kind !== "image" || boundedById.has(key)) continue;
+        boundedById.set(key, await boundedAttachmentImage(attachment, bound));
+      }
+    }
     const projected = [...items];
     for (const [index, refs] of refsByIndex) {
       const original = items[index];
@@ -6478,14 +6541,20 @@ function createModelHistoryAttachmentProjector(policy, readFileBytes, loadAuthor
         const currentFile = catalog ? void 0 : fileById.get(ref.fileId);
         const excluded = !catalog && loadAuthorizedFiles !== void 0 && resolvedFileIds.has(ref.fileId) && currentFile === void 0;
         const attachment = currentFile ? contentById.get(ref.fileId) : void 0;
-        const receipt = {
-          type: "input_text",
-          text: excluded ? unavailableAttachmentReceiptText(ref) : attachmentReceiptText(ref)
-        };
         if (!attachment || attachment.kind !== "image") {
-          return [receipt];
+          return [
+            {
+              type: "input_text",
+              text: excluded ? unavailableAttachmentReceiptText(ref) : attachmentReceiptText(ref)
+            }
+          ];
         }
-        return [receipt, { type: "input_image", image: attachment.dataUrl }];
+        const bound = attachmentImageBound(original);
+        const bounded = bound === void 0 ? void 0 : boundedById.get(`${bound}:${ref.fileId}`);
+        return [
+          { type: "input_text", text: attachmentReceiptText(ref) + (bounded?.note ?? "") },
+          { type: "input_image", image: bounded?.image ?? attachment.dataUrl }
+        ];
       });
       const clone = {
         ...original,
@@ -7033,6 +7102,8 @@ function providerRecoverySubject(input) {
       return "A required MCP server is unreachable";
     case "sandbox_command_start_unavailable":
       return "The sandbox isn't ready yet";
+    case "retained_attachment_unavailable":
+      return "An image from earlier in this conversation can't be read from storage";
     case "turn_execution_policy_definition_mismatch":
       return "Opengeni is applying a configuration update";
     default:
@@ -7059,6 +7130,18 @@ function providerRecoveryJitterMs(delayMs, sample) {
   return Math.floor(Math.min(5e3, delayMs * 0.2) * bounded);
 }
 var POST_COMPACTION_CONTINUATION_EMPTY_CODE = "post_compaction_continuation_empty";
+var RETAINED_ATTACHMENT_UNAVAILABLE_CODE = "retained_attachment_unavailable";
+function findRetainedAttachmentUnavailableError(error) {
+  let current = error;
+  const seen = /* @__PURE__ */ new Set();
+  for (let depth = 0; depth < 6 && current && typeof current === "object"; depth += 1) {
+    if (current instanceof RetainedAttachmentUnavailableError) return current;
+    if (seen.has(current)) break;
+    seen.add(current);
+    current = current.cause;
+  }
+  return null;
+}
 var PostCompactionContinuationEmptyError = class extends Error {
   code = POST_COMPACTION_CONTINUATION_EMPTY_CODE;
   constructor() {
@@ -7095,7 +7178,7 @@ function providerRecoveryResult(input) {
       Math.max(Math.trunc(input.attemptNumber) - 1, 0),
       PROVIDER_RATE_LIMIT_BACKOFF_MS.length - 1
     )]
-  ) : overload || input.failureCode === "provider_unavailable" || input.failureCode === "upstream_connectivity_unavailable" || input.failureCode === "sandbox_command_start_unavailable" || input.failureCode === "mcp_transport_timeout" || input.failureCode === "mcp_transport_unavailable" || input.failureCode === "turn_execution_policy_definition_mismatch" || input.failureCode === POST_COMPACTION_CONTINUATION_EMPTY_CODE ? Math.max(
+  ) : overload || input.failureCode === "provider_unavailable" || input.failureCode === "upstream_connectivity_unavailable" || input.failureCode === "sandbox_command_start_unavailable" || input.failureCode === RETAINED_ATTACHMENT_UNAVAILABLE_CODE || input.failureCode === "mcp_transport_timeout" || input.failureCode === "mcp_transport_unavailable" || input.failureCode === "turn_execution_policy_definition_mismatch" || input.failureCode === POST_COMPACTION_CONTINUATION_EMPTY_CODE ? Math.max(
     providerDelay ?? 0,
     PROVIDER_CONNECTIVITY_BACKOFF_MS[Math.min(
       Math.max(Math.trunc(input.attemptNumber) - 1, 0),
@@ -7948,6 +8031,13 @@ function baseAgentRunFailurePayload(error, options = {}) {
   if (error instanceof RetainedAttachmentTransportLimitError) {
     return { error: error.message, code: "retained_attachment_transport_limit", retryable: false };
   }
+  if (findRetainedAttachmentUnavailableError(error)) {
+    return {
+      error: "An image attached earlier in this conversation can't be read from storage right now. The same turn will retry after a short delay.",
+      code: RETAINED_ATTACHMENT_UNAVAILABLE_CODE,
+      retryable: true
+    };
+  }
   if (error instanceof MandatoryHistoryPersistenceError) {
     const databaseFailure = isSessionEventPersistenceError(error.cause) || findPostgresDriverError(error.cause) !== null || isRawDatabaseQueryError(error.cause);
     const underlying = databaseFailure ? agentRunFailurePayload(error.cause, options) : {
@@ -8501,4 +8591,4 @@ export {
   codexUsageLimitFailurePayload,
   classifyClaudeProviderError
 };
-//# sourceMappingURL=chunk-QCD6PEBU.js.map
+//# sourceMappingURL=chunk-6SHXF4SU.js.map