tinker-agent 2.0.0 → 2.2.0

package/src/context/compiled-context-validator.ts

@@ -1,4 +1,5 @@
 import type { AgentMessage } from "../agent/types";
+import { toolResultDisplayText, toolResultText } from "../agent/tool-result-content";
 import { stableJsonStringify } from "../model/model-request-preflight";
 import { formatMessageSource } from "./context-source";
 import type { CompiledRevisionContext, SwapOverride } from "./context-revision";
@@ -157,7 +158,7 @@ export class CompiledContextValidator {
         entry.message.toolCallId !== record.toolCallId ||
         entry.message.providerToolCallId !== record.providerToolCallId ||
         entry.message.name !== record.name ||
-        entry.message.content !== override.renderedContent
+        toolResultText(entry.message.content) !== override.renderedContent
       ) {
         fail(
           `Swapped tool entry changed protocol identity at ordinal ${entry.ordinal}.`,
@@ -197,7 +198,11 @@ function validateOverrideIdentity(
     fail(`Swap override changed canonical identity at ordinal ${record.ordinal}.`);
   }
   const originalBytes = Buffer.byteLength(
-    record.role === "assistant" ? (record.content ?? "") : record.content,
+    record.role === "assistant"
+      ? (record.content ?? "")
+      : record.role === "tool"
+        ? record.displayText
+        : record.content,
     "utf8",
   );
   const renderedBytes = Buffer.byteLength(override.renderedContent, "utf8");
@@ -208,8 +213,11 @@ function validateOverrideIdentity(
     override.originalBytes !== originalBytes ||
     override.renderedBytes !== renderedBytes ||
     override.byteSavings !== originalBytes - renderedBytes ||
-    (rendererFormat === "swap-observation-v1" && override.byteSavings <= 0) ||
+    ((rendererFormat === "swap-observation-v1" ||
+      rendererFormat === "skill-activation-receipt-v1") &&
+      override.byteSavings <= 0) ||
     (rendererFormat !== "swap-observation-v1" &&
+      rendererFormat !== "swap-tool-image-v1" &&
       rendererFormat !== "skill-activation-receipt-v1")
   ) {
     fail(`Swap override metadata is invalid at ordinal ${record.ordinal}.`);
@@ -266,7 +274,8 @@ function assertSameMessage(actual: AgentMessage, record: CanonicalMessageRecord)
         actual.toolCallId !== record.toolCallId ||
         actual.providerToolCallId !== record.providerToolCallId ||
         actual.name !== record.name ||
-        actual.content !== record.content
+        stableJsonStringify(actual.content) !== stableJsonStringify(record.content) ||
+        toolResultDisplayText(actual.content) !== record.displayText
       ) {
         fail(`Canonical entry changed tool data at ordinal ${record.ordinal}.`);
       }

package/src/context/context-protocol-validator.ts

@@ -1,8 +1,14 @@
 import type { MessageId, ProtocolFrameId, ToolCallId } from "../ids/runtime-id";
+import {
+  canonicalToolResultContentHash,
+  toolResultDisplayText,
+  validateToolResultContent,
+} from "../agent/tool-result-content";
 import {
   contentHash,
   userMessageHash,
   rawResultHash,
+  validateReturnedToolObservation,
   type CanonicalMessageRecord,
   type ProtocolContextView,
   type ProtocolFrame,
@@ -113,7 +119,9 @@ export class ContextProtocolValidator {
                   ? {}
                   : { attachments: message.attachments }),
               })
-            : contentHash(message.content))
+            : message.role === "tool"
+              ? canonicalToolResultContentHash(message.content)
+              : contentHash(message.content))
       ) {
         fail(
           "content_hash_mismatch",
@@ -405,11 +413,19 @@ function validateToolExchange(
       );
     }
     const result = requireItem(results, 0, "tool result");
+    validateToolResultContent(message.content);
+    if (message.displayText !== toolResultDisplayText(message.content)) {
+      fail(
+        "content_hash_mismatch",
+        `Tool display projection does not match message ${message.messageId}.`,
+        identityForMessage(message),
+      );
+    }
     if (
       result.sessionId !== frame.sessionId ||
       result.frameId !== frame.frameId ||
       result.toolMessageId !== message.messageId ||
-      result.observationSha256 !== contentHash(message.content)
+      result.observationSha256 !== canonicalToolResultContentHash(message.content)
     ) {
       fail(
         "tool_result_mismatch",
@@ -428,6 +444,21 @@ function validateToolExchange(
         { ...identityForMessage(message), toolCallId: call.toolCallId },
       );
     }
+    if (input.fullIntegrity && result.completion.kind === "returned") {
+      try {
+        validateReturnedToolObservation({
+          toolName: message.name,
+          raw: result.completion.raw,
+          content: message.content,
+        });
+      } catch (error) {
+        fail(
+          "tool_result_mismatch",
+          `Tool result for ${call.toolCallId} has invalid canonical content: ${error instanceof Error ? error.message : String(error)}`,
+          { ...identityForMessage(message), toolCallId: call.toolCallId },
+        );
+      }
+    }
     input.usedResultCallIds.add(call.toolCallId);
   }
 }

package/src/context/context-revision-compiler.ts

@@ -1,4 +1,5 @@
 import type { AgentMessage } from "../agent/types";
+import { textToolResultContent } from "../agent/tool-result-content";
 import type { ContextRevisionId } from "../ids/runtime-id";
 import { CompiledContextValidator } from "./compiled-context-validator";
 import {
@@ -263,7 +264,7 @@ function swappedToolMessage(
   }
   return {
     ...message,
-    content: override.renderedContent,
+    content: textToolResultContent(override.renderedContent),
   };
 }
 

package/src/context/context-revision.ts

@@ -133,12 +133,18 @@ export type SwapOverride = {
   readonly originalBytes: number;
   readonly renderedBytes: number;
   readonly byteSavings: number;
-  readonly rendererFormat?: "swap-observation-v1" | "skill-activation-receipt-v1";
+  readonly rendererFormat?:
+    | "swap-observation-v1"
+    | "swap-tool-image-v1"
+    | "skill-activation-receipt-v1";
 };
 
 export type StoredContextOverrideV8 = SwapOverride & {
   readonly introducedRevisionId: ContextRevisionId;
-  readonly rendererFormat: "swap-observation-v1" | "skill-activation-receipt-v1";
+  readonly rendererFormat:
+    | "swap-observation-v1"
+    | "swap-tool-image-v1"
+    | "skill-activation-receipt-v1";
   readonly createdAt: string;
 };
 

package/src/context/context-swap-renderer.ts

@@ -9,6 +9,7 @@ const MAX_METADATA_BYTES = 1_024;
 const MAX_SCALAR_BYTES = 256;
 
 export const SWAP_OBSERVATION_FORMAT = "swap-observation-v1" as const;
+export const SWAP_TOOL_IMAGE_FORMAT = "swap-tool-image-v1" as const;
 
 export const SWAPPABLE_RAW_KINDS = Object.freeze([
   "read",
@@ -19,6 +20,7 @@ export const SWAPPABLE_RAW_KINDS = Object.freeze([
   "web_search",
   "web_fetch",
   "mcp",
+  "view_image",
 ] as const satisfies readonly ToolRawResultKind[]);
 
 export type SwappableRawKind = (typeof SWAPPABLE_RAW_KINDS)[number];
@@ -66,19 +68,21 @@ export class ContextSwapRenderer {
     assertHistoricalRawIsStable(raw);
 
     const source = formatMessageSource(message.messageId);
-    const metadata = renderMetadata(raw);
-    const renderedContent = [
-      "[Tinker historical tool observation swapped]",
-      `source=${source}`,
-      `contentSha256=${message.contentSha256}`,
-      `tool=${stableJsonStringify(compactExternalString(message.name))}`,
-      `metadata=${metadata}`,
-      "historical=Use RecallGet with source to recover the original observation.",
-      `current=${currentGuidance(raw.kind)}`,
-    ].join("\n");
-    const originalBytes = utf8Bytes(message.content);
+    const renderedContent =
+      raw.kind === "view_image"
+        ? renderImagePlaceholder(raw)
+        : [
+            "[Tinker historical tool observation swapped]",
+            `source=${source}`,
+            `contentSha256=${message.contentSha256}`,
+            `tool=${stableJsonStringify(compactExternalString(message.name))}`,
+            `metadata=${renderMetadata(raw)}`,
+            "historical=Use RecallGet with source to recover the original observation.",
+            `current=${currentGuidance(raw.kind)}`,
+          ].join("\n");
+    const originalBytes = utf8Bytes(message.displayText);
     const renderedBytes = utf8Bytes(renderedContent);
-    if (renderedBytes >= originalBytes) {
+    if (raw.kind !== "view_image" && renderedBytes >= originalBytes) {
       throw new SwapRenderUnsupportedError(
         "placeholder_not_smaller",
         "Rendered placeholder is not smaller than its canonical observation.",
@@ -95,6 +99,7 @@ export class ContextSwapRenderer {
       originalBytes,
       renderedBytes,
       byteSavings: originalBytes - renderedBytes,
+      ...(raw.kind === "view_image" ? { rendererFormat: SWAP_TOOL_IMAGE_FORMAT } : {}),
     });
   }
 }
@@ -123,6 +128,25 @@ function assertHistoricalRawIsStable(
       "Running task output cannot be rendered as a historical placeholder.",
     );
   }
+  if (raw.kind === "view_image" && (!raw.ok || raw.asset === undefined)) {
+    throw new SwapRenderUnsupportedError(
+      "unsuccessful_image",
+      "Only successful ViewImage results can use the image swap renderer.",
+    );
+  }
+}
+
+function renderImagePlaceholder(
+  raw: Extract<ToolRawResult, { kind: "view_image" }>,
+): string {
+  if (!raw.ok || raw.asset === undefined) {
+    throw new SwapRenderUnsupportedError(
+      "unsuccessful_image",
+      "Only successful ViewImage results can use the image swap renderer.",
+    );
+  }
+  const asset = raw.asset;
+  return `[Tool image omitted from compacted context: ViewImage ${raw.filePath}, ${asset.mimeType}, ${asset.width}x${asset.height}, asset=${asset.assetId.slice(0, 12)}…. Use ViewImage again if the current image is required.]`;
 }
 
 function renderMetadata(
@@ -213,6 +237,14 @@ function metadataEntries(
         ["isError", raw.isError],
         ["contentBlockCount", raw.contentBlockCount],
       ];
+    case "view_image":
+      return [
+        ["filePath", raw.filePath],
+        ["mimeType", raw.asset?.mimeType],
+        ["width", raw.asset?.width],
+        ["height", raw.asset?.height],
+        ["assetId", raw.asset?.assetId],
+      ];
   }
 }
 
@@ -234,6 +266,8 @@ function currentGuidance(kind: SwappableRawKind): string {
       return "Use WebFetch when the current page content is required.";
     case "mcp":
       return "Call the MCP tool again only when current external state is required.";
+    case "view_image":
+      return "Use ViewImage again if the current image is required.";
   }
 }
 

package/src/context/prefix-retirement-planner.ts

@@ -7,7 +7,11 @@ import {
   type PromptPrefixFingerprint,
 } from "../model/prompt-prefix-hash";
 import { sha256, stableJsonStringify } from "../model/model-request-preflight";
-import { estimatePromptSegments } from "../model/token-estimator";
+import {
+  estimatePromptSegments,
+  guardedContextTokens,
+  type RawContextBreakdown,
+} from "../model/token-estimator";
 import type { ToolDefinition } from "../tools/types";
 import {
   activeOverrideManifestHash,
@@ -150,11 +154,10 @@ export class PrefixRetirementPlanner {
     validatePlanningInput(input);
     const activeFingerprint = promptPrefixFingerprint(input.activePrepared);
     assertActiveFingerprint(input, activeFingerprint);
-    const rawTokensBefore = estimatePromptSegments(
-      input.activePrepared.promptSegments,
-    ).totalTokens;
+    const activeBreakdown = estimatePromptSegments(input.activePrepared.promptSegments);
+    const rawTokensBefore = activeBreakdown.totalTokens;
     const guardedTokensBefore = guardTokens(
-      rawTokensBefore,
+      activeBreakdown,
       input.activeUsage.correctionFactor,
     );
     const targetTokens = planningTarget(input);
@@ -223,7 +226,8 @@ export class PrefixRetirementPlanner {
         );
       }
       assertProspectiveConfiguration(input.activePrepared, prepared);
-      const rawTokens = estimatePromptSegments(prepared.promptSegments).totalTokens;
+      const breakdown = estimatePromptSegments(prepared.promptSegments);
+      const rawTokens = breakdown.totalTokens;
       const projection = Object.freeze({
         candidateIndex,
         boundary,
@@ -231,7 +235,7 @@ export class PrefixRetirementPlanner {
         compiled,
         prepared,
         rawTokens,
-        guardedTokens: guardTokens(rawTokens, input.activeUsage.correctionFactor),
+        guardedTokens: guardTokens(breakdown, input.activeUsage.correctionFactor),
       });
       projections.set(candidateIndex, projection);
       return projection;
@@ -603,8 +607,8 @@ function createPlan(input: {
   });
 }
 
-function guardTokens(rawTokens: number, correctionFactor: number): number {
-  return Math.ceil(rawTokens * correctionFactor);
+function guardTokens(breakdown: RawContextBreakdown, correctionFactor: number): number {
+  return guardedContextTokens(breakdown, correctionFactor);
 }
 
 function fail(code: string, message: string): never {

package/src/context/protocol-frame.ts

@@ -6,18 +6,26 @@ import type {
   AssistantMessage,
   IterationIdentity,
   ToolCall,
+  ToolResultContent,
   TurnIdentity,
 } from "../agent/types";
+import {
+  canonicalToolResultContentHash,
+  textToolResultContent,
+  toolResultDisplayText,
+  validateToolResultContent,
+} from "../agent/tool-result-content";
 import {
   canonicalUserMessageHash,
+  validateImageAssetRef,
+  validateOriginalImageName,
   validateUserMessage,
   type UserImageAttachment,
   type UserMessage,
 } from "../image/image-types";
 
-export const CURRENT_TOOL_OBSERVATION_FORMAT = "tool-observation-v3" as const;
+export const CURRENT_TOOL_OBSERVATION_FORMAT = "tool-observation-v4" as const;
 export const SUPPORTED_TOOL_OBSERVATION_FORMATS = [
-  "tool-observation-v2",
   CURRENT_TOOL_OBSERVATION_FORMAT,
 ] as const;
 export type SupportedToolObservationFormat =
@@ -63,7 +71,8 @@ export type CanonicalMessageRecord =
       readonly toolCallId: ToolCall["toolCallId"];
       readonly providerToolCallId: string;
       readonly name: string;
-      readonly content: string;
+      readonly content: readonly ToolResultContent[];
+      readonly displayText: string;
       readonly origin: "tool" | "runtime";
     });
 
@@ -123,7 +132,7 @@ export type ReturnedToolCompletionInput = {
   readonly call: ToolCall;
   readonly kind: "returned";
   readonly raw: ToolRawResult;
-  readonly observation: string;
+  readonly observation: readonly ToolResultContent[];
 };
 
 export type SyntheticToolCompletionInput = {
@@ -193,12 +202,13 @@ export function materializeAgentMessages(
         return message;
       }
       case "tool":
+        validateToolResultContent(record.content);
         return {
           role: "tool",
           toolCallId: record.toolCallId,
           providerToolCallId: record.providerToolCallId,
           name: record.name,
-          content: record.content,
+          content: canonicalClone(record.content),
         };
     }
   });
@@ -243,12 +253,69 @@ export function interruptedCompletionInputs(
   }));
 }
 
-export function observationForCompletion(input: ToolCompletionInput): string {
+export function observationForCompletion(
+  input: ToolCompletionInput,
+): readonly ToolResultContent[] {
   return input.kind === "returned"
     ? input.observation
-    : renderSyntheticToolObservation(input.reason, input.detail);
+    : textToolResultContent(renderSyntheticToolObservation(input.reason, input.detail));
+}
+
+export function displayTextForCompletion(input: ToolCompletionInput): string {
+  return toolResultDisplayText(observationForCompletion(input));
+}
+
+export function validateReturnedToolObservation(input: {
+  readonly toolName: string;
+  readonly raw: ToolRawResult;
+  readonly content: readonly ToolResultContent[];
+}): void {
+  validateToolResultContent(input.content);
+  if (input.raw.kind !== "view_image") {
+    return;
+  }
+  if (input.toolName !== "ViewImage") {
+    throw new Error("ViewImage raw result has an invalid tool name.");
+  }
+  const raw = input.raw;
+  if (!raw.ok) {
+    if (raw.asset !== undefined || raw.originalName !== undefined) {
+      throw new Error("Failed ViewImage result cannot contain image metadata.");
+    }
+    const expected = `ViewImage failed for ${raw.filePath || "(unknown path)"}: ${raw.error ?? "Unknown error."}`;
+    if (
+      input.content.length !== 1 ||
+      input.content[0]?.type !== "text" ||
+      input.content[0].text !== expected
+    ) {
+      throw new Error("Failed ViewImage observation is not canonical.");
+    }
+    return;
+  }
+  if (
+    raw.asset === undefined ||
+    raw.originalName === undefined ||
+    raw.filePath.trim() === "" ||
+    raw.error !== undefined
+  ) {
+    throw new Error("Successful ViewImage result is missing required metadata.");
+  }
+  validateImageAssetRef(raw.asset);
+  validateOriginalImageName(raw.originalName);
+  const expectedText = `Viewed image ${raw.filePath} (${raw.asset.mimeType}, ${raw.asset.width}x${raw.asset.height}, ${raw.asset.byteLength} bytes, asset=${raw.asset.assetId.slice(0, 12)}…).`;
+  if (
+    input.content.length !== 2 ||
+    input.content[0]?.type !== "text" ||
+    input.content[0].text !== expectedText ||
+    input.content[1]?.type !== "image" ||
+    stableJsonStringify(input.content[1].asset) !== stableJsonStringify(raw.asset)
+  ) {
+    throw new Error("Successful ViewImage observation is not canonical.");
+  }
 }
 
+export { canonicalToolResultContentHash };
+
 function requireSyntheticDetail(detail: string | undefined): string {
   if (detail === undefined || detail.trim() === "") {
     throw new Error("failed_active synthetic completion requires error detail.");

package/src/context/swap-planner.ts

@@ -7,7 +7,11 @@ import {
   type PromptPrefixFingerprint,
 } from "../model/prompt-prefix-hash";
 import { sha256, stableJsonStringify } from "../model/model-request-preflight";
-import { estimatePromptSegments } from "../model/token-estimator";
+import {
+  estimatePromptSegments,
+  guardedContextTokens,
+  type RawContextBreakdown,
+} from "../model/token-estimator";
 import type { ToolDefinition } from "../tools/types";
 import { activeOverrideManifestHash } from "./compiled-context-hash";
 import { CompiledContextError } from "./compiled-context-validator";
@@ -148,11 +152,10 @@ export class SwapPlanner {
     validatePlanningInput(input);
     const activeFingerprint = promptPrefixFingerprint(input.activePrepared);
     assertActiveFingerprint(input, activeFingerprint);
-    const rawTokensBefore = estimatePromptSegments(
-      input.activePrepared.promptSegments,
-    ).totalTokens;
+    const activeBreakdown = estimatePromptSegments(input.activePrepared.promptSegments);
+    const rawTokensBefore = activeBreakdown.totalTokens;
     const guardedTokensBefore = guardTokens(
-      rawTokensBefore,
+      activeBreakdown,
       input.activeUsage.correctionFactor,
     );
     const targetTokens = planningTarget(input);
@@ -238,12 +241,13 @@ export class SwapPlanner {
         );
       }
       assertProspectiveConfiguration(input.activePrepared, prepared);
-      const rawTokens = estimatePromptSegments(prepared.promptSegments).totalTokens;
+      const breakdown = estimatePromptSegments(prepared.promptSegments);
+      const rawTokens = breakdown.totalTokens;
       const projection = Object.freeze({
         count,
         prepared,
         rawTokens,
-        guardedTokens: guardTokens(rawTokens, input.activeUsage.correctionFactor),
+        guardedTokens: guardTokens(breakdown, input.activeUsage.correctionFactor),
       });
       projectionCache.set(count, projection);
       return projection;
@@ -615,15 +619,16 @@ function basicExclusionReason(input: {
   ) {
     return "active_turn_unconsumed";
   }
-  if (
-    Buffer.byteLength(input.message.content, "utf8") < input.minimumObservationBytes
-  ) {
-    return "observation_too_small";
-  }
   const raw = input.result.completion.raw;
   if (!isSwappableRawResult(raw)) {
     return "raw_kind_not_allowlisted";
   }
+  if (
+    raw.kind !== "view_image" &&
+    Buffer.byteLength(input.message.displayText, "utf8") < input.minimumObservationBytes
+  ) {
+    return "observation_too_small";
+  }
   if (
     (raw.kind === "bash" && raw.status === "running") ||
     (raw.kind === "task_output" &&
@@ -742,8 +747,8 @@ function increment(counts: Map<string, number>, key: string): void {
   counts.set(key, (counts.get(key) ?? 0) + 1);
 }
 
-function guardTokens(rawTokens: number, correctionFactor: number): number {
-  return Math.ceil(rawTokens * correctionFactor);
+function guardTokens(breakdown: RawContextBreakdown, correctionFactor: number): number {
+  return guardedContextTokens(breakdown, correctionFactor);
 }
 
 function isCanonicalPlanningError(error: unknown): boolean {

package/src/events/observation-text-log.ts

@@ -209,7 +209,7 @@ function toolCallSummary(call: ToolCall): string {
 }
 
 function observationContent(observation: ToolObservation): string {
-  return observation.content;
+  return observation.displayText;
 }
 
 function asRecord(value: unknown): Record<string, unknown> {

package/src/events/stdout-event-printer.ts

@@ -122,6 +122,9 @@ export class StdoutEventPrinter implements EventSink {
           `${formatToolLine("tool.finished", event.data.call).trimEnd()} ok=${event.data.ok}\n`,
         );
         break;
+      case "tool.observation":
+        this.stdout.write(`${event.data.observation.displayText}\n`);
+        break;
       case "tool.confirmation.requested":
         this.stdout.write(
           `tool.confirmation.requested toolCallId=${event.toolCallId} reason=${JSON.stringify(event.data.reason)} command=${JSON.stringify(event.data.command)}\n`,
@@ -217,6 +220,7 @@ function formatToolRawResult(call: ToolCall, raw: ToolRawResult): string[] {
     case "skill":
       return [formatSkillResult(raw)];
     case "read":
+    case "view_image":
     case "delete":
     case "glob":
     case "grep":
@@ -224,6 +228,8 @@ function formatToolRawResult(call: ToolCall, raw: ToolRawResult): string[] {
     case "web_fetch":
     case "recall":
     case "memory_search":
+    case "memory_get":
+    case "wait":
     case "mcp":
     case "generic":
       return [];

package/src/image/image-asset-store.ts

@@ -70,18 +70,45 @@ export class ImageAssetStore {
       signal?: AbortSignal;
       accept?: (asset: ImageAssetRef) => void;
     } = {},
+  ): Promise<ImportedImageAsset> {
+    return this.importFileInternal(sourcePath, true, options);
+  }
+
+  async importFile(
+    sourcePath: string,
+    options: {
+      signal?: AbortSignal;
+    } = {},
+  ): Promise<ImportedImageAsset> {
+    return this.importFileInternal(sourcePath, false, options);
+  }
+
+  private async importFileInternal(
+    sourcePath: string,
+    workspaceOnly: boolean,
+    options: {
+      signal?: AbortSignal;
+      accept?: (asset: ImageAssetRef) => void;
+    },
   ): Promise<ImportedImageAsset> {
     throwIfAborted(options.signal);
+    if (typeof sourcePath !== "string" || sourcePath.trim() === "") {
+      throw new Error("Image source path must be a non-empty string.");
+    }
     const candidate = path.isAbsolute(sourcePath)
       ? path.normalize(sourcePath)
       : path.resolve(this.workspaceRoot, sourcePath);
-    assertContained(this.workspaceRoot, candidate, "Image source path");
+    if (workspaceOnly || !path.isAbsolute(sourcePath)) {
+      assertContained(this.workspaceRoot, candidate, "Image source path");
+    }
     const pathStat = await lstat(candidate);
     if (pathStat.isSymbolicLink() || !pathStat.isFile()) {
       throw new Error("Image source must be a regular non-symlink file.");
     }
     const canonicalSource = await realpath(candidate);
-    assertContained(this.workspaceRoot, canonicalSource, "Image source realpath");
+    if (workspaceOnly || !path.isAbsolute(sourcePath)) {
+      assertContained(this.workspaceRoot, canonicalSource, "Image source realpath");
+    }
 
     const handle = await open(canonicalSource, constants.O_RDONLY | noFollowFlag());
     let bytes: Buffer;
@@ -102,7 +129,9 @@ export class ImageAssetStore {
           `Image is ${handleStat.size} bytes; maximum is ${IMAGE_INPUT_POLICY.maxBytesPerImage}.`,
         );
       }
-      bytes = await handle.readFile();
+      bytes = await handle.readFile(
+        options.signal === undefined ? undefined : { signal: options.signal },
+      );
     } finally {
       await handle.close();
     }