tinker-agent 1.10.1 → 2.0.0

package/src/agent/session-ledger.ts

@@ -100,6 +100,9 @@ export type PendingLedgerTurn = {
 };
 
 export type AgentTurnLedger = {
+  appendSteeringUserMessages(
+    messages: readonly UserMessage[],
+  ): readonly CanonicalMessageRecord[];
   appendAssistant(input: {
     iteration: IterationIdentity;
     message: AssistantMessage;
@@ -129,6 +132,13 @@ export type LedgerMutation =
       admissionBase?: AdmissionBaseToken;
       next: ProtocolContextView;
     }
+  | {
+      kind: "append_steering_users";
+      turn: TurnIdentity;
+      frames: readonly ProtocolFrame[];
+      messages: readonly CanonicalMessageRecord[];
+      next: ProtocolContextView;
+    }
   | {
       kind: "append_assistant";
       iteration: IterationIdentity;
@@ -396,6 +406,74 @@ export class InMemorySessionLedger implements SessionLedger {
     this.pending = undefined;
   }
 
+  appendSteeringUserMessages(
+    pending: InMemoryPendingLedgerTurn,
+    userMessages: readonly UserMessage[],
+  ): readonly CanonicalMessageRecord[] {
+    this.requirePending(pending, "append steering user messages");
+    this.assertNoOpenFrame();
+    if (userMessages.length === 0) {
+      return Object.freeze([]);
+    }
+    for (const userMessage of userMessages) {
+      validateUserMessage(userMessage);
+    }
+
+    const frames: ProtocolFrame[] = [];
+    const messages: CanonicalMessageRecord[] = [];
+    for (const userMessage of userMessages) {
+      const createdAt = this.clock();
+      const ordinal = this.view.messages.length + messages.length + 1;
+      const frameId = this.input.idFactory.createProtocolFrameId();
+      messages.push(
+        immutableRecord<CanonicalMessageRecord>({
+          messageId: this.input.idFactory.createMessageId(),
+          sessionId: this.input.sessionId,
+          frameId,
+          ordinal,
+          contentSha256: userMessageHash(userMessage),
+          createdAt,
+          role: "user",
+          turnId: pending.turn.turnId,
+          content: userMessage.content,
+          ...(userMessage.attachments === undefined
+            ? {}
+            : {
+                attachments: Object.freeze(
+                  immutableCanonicalClone(userMessage.attachments),
+                ),
+              }),
+          origin: "user",
+        }),
+      );
+      frames.push(
+        immutableRecord<ProtocolFrame>({
+          frameId,
+          sessionId: this.input.sessionId,
+          turnId: pending.turn.turnId,
+          kind: "user",
+          state: "closed",
+          firstOrdinal: ordinal,
+          lastOrdinal: ordinal,
+          createdAt,
+          closedAt: createdAt,
+        }),
+      );
+    }
+    const immutableFrames = Object.freeze(frames);
+    const immutableMessages = Object.freeze(messages);
+    const next = appendView(this.view, immutableFrames, immutableMessages, []);
+    this.validator.validate(next, { fullIntegrity: true });
+    this.commit({
+      kind: "append_steering_users",
+      turn: pending.turn,
+      frames: immutableFrames,
+      messages: immutableMessages,
+      next,
+    });
+    return immutableMessages;
+  }
+
   appendAssistant(
     pending: InMemoryPendingLedgerTurn,
     input: {
@@ -776,6 +854,8 @@ class InMemoryPendingLedgerTurn implements PendingLedgerTurn {
     readonly turn: TurnIdentity,
   ) {
     this.agent = {
+      appendSteeringUserMessages: (messages) =>
+        this.ledger.appendSteeringUserMessages(this, messages),
       appendAssistant: (input) => this.ledger.appendAssistant(this, input),
       assertCanExecuteTool: (call) => this.ledger.assertCanExecuteTool(this, call),
       commitToolCompletions: (completions) =>

package/src/cli/config.ts

@@ -14,7 +14,6 @@ import {
   type ModelInputModality,
   type ModelProfile,
   type ModelProfiles,
-  type ModelTokenEstimatorProfile,
   unknownProfileError,
 } from "./model-profiles";
 import type { MemoryEmbeddingConfig } from "../memory/contracts";
@@ -40,7 +39,6 @@ export type RunnerConfig = {
   readonly contextBudget: ModelContextBudget;
   readonly profileName?: string;
   readonly inputModalities: readonly ModelInputModality[];
-  readonly tokenEstimator?: ModelTokenEstimatorProfile;
   readonly bashGuardMode: "guard" | "yolo";
   readonly bashGuardSource: "default" | "environment" | "cli";
 };
@@ -184,9 +182,6 @@ function runnerConfigTemplateFromProfile(
     inputModalities: profile.inputModalities,
     bashGuardMode: environment.bashGuardMode,
     bashGuardSource: environment.bashGuardSource,
-    ...(profile.tokenEstimator === undefined
-      ? {}
-      : { tokenEstimator: profile.tokenEstimator }),
   });
 }
 

package/src/cli/model-profiles.ts

@@ -10,9 +10,6 @@ import {
   MODEL_PROFILE_FIELDS,
   MODEL_PROFILES_DOCUMENT_FIELDS,
   MODEL_REASONING_FIELDS,
-  MODEL_TOKEN_ESTIMATOR_FIELDS,
-  type ModelTokenEstimatorKind,
-  type ModelTokenEstimatorMaxRetries,
 } from "./public-config-contract";
 import type { MemoryEmbeddingConfig } from "../memory/contracts";
 import type { ReasoningEffortConfig } from "../model/reasoning-effort";
@@ -29,20 +26,10 @@ export type ModelProfile = {
   readonly includeReasoningContent: boolean;
   readonly stream: boolean;
   readonly inputModalities: readonly ModelInputModality[];
-  readonly tokenEstimator?: ModelTokenEstimatorProfile;
 };
 
 export type ModelInputModality = "text" | "image";
 
-export type ModelTokenEstimatorProfile = {
-  readonly kind: ModelTokenEstimatorKind;
-  readonly model: string;
-  readonly apiBase: string;
-  readonly apiKey: string;
-  readonly timeoutMs: number;
-  readonly maxRetries: ModelTokenEstimatorMaxRetries;
-};
-
 export type ModelProfiles = {
   readonly defaultProfile: string;
   readonly profiles: ReadonlyMap<string, ModelProfile>;
@@ -285,16 +272,6 @@ function parseProfile(
     value.inputModalities,
     `${where}: "inputModalities"`,
   );
-  const tokenEstimator =
-    value.tokenEstimator === undefined
-      ? undefined
-      : parseTokenEstimator(value.tokenEstimator, `${where}: "tokenEstimator"`);
-  if (inputModalities.includes("image") && tokenEstimator === undefined) {
-    throw new Error(
-      `${where}: image input requires a complete "tokenEstimator" configuration.`,
-    );
-  }
-
   createModelContextProfile({
     contextWindowTokens,
     maxSupportedOutputTokens,
@@ -312,7 +289,6 @@ function parseProfile(
     includeReasoningContent,
     stream,
     inputModalities,
-    ...(tokenEstimator === undefined ? {} : { tokenEstimator }),
   });
 }
 
@@ -434,54 +410,7 @@ function parseInputModalities(
   );
 }
 
-function parseTokenEstimator(value: unknown, name: string): ModelTokenEstimatorProfile {
-  if (!isRecord(value)) {
-    throw new Error(`${name} must be an object.`);
-  }
-  assertKnownKeys(
-    value,
-    MODEL_TOKEN_ESTIMATOR_FIELDS.map((field) => field.name),
-    name,
-  );
-  const kindField = tokenEstimatorField("kind");
-  if (value.kind !== kindField.literalValue) {
-    throw new Error(`${name}.kind must be ${JSON.stringify(kindField.literalValue)}.`);
-  }
-  const model = parseTokenEstimatorString(value, "model", name);
-  const apiBase = parseTokenEstimatorString(value, "apiBase", name);
-  const apiKey = parseTokenEstimatorString(value, "apiKey", name);
-  const timeoutField = tokenEstimatorField("timeoutMs");
-  if (timeoutField.valueKind !== "positive-integer") {
-    throw new Error("Token estimator timeoutMs contract kind is invalid.");
-  }
-  const timeoutMs = requirePositiveInteger(value.timeoutMs, `${name}.timeoutMs`);
-  if (
-    timeoutField.minimum === undefined ||
-    timeoutField.maximum === undefined ||
-    timeoutMs < timeoutField.minimum ||
-    timeoutMs > timeoutField.maximum
-  ) {
-    throw new Error(
-      `${name}.timeoutMs must be between ${timeoutField.minimum} and ${timeoutField.maximum}.`,
-    );
-  }
-  const maxRetriesField = tokenEstimatorField("maxRetries");
-  if (value.maxRetries !== maxRetriesField.literalValue) {
-    throw new Error(`${name}.maxRetries must be ${maxRetriesField.literalValue}.`);
-  }
-  return Object.freeze({
-    kind: kindField.literalValue,
-    model,
-    apiBase,
-    apiKey,
-    timeoutMs,
-    maxRetries: maxRetriesField.literalValue,
-  });
-}
-
 type ModelProfileFieldName = (typeof MODEL_PROFILE_FIELDS)[number]["name"];
-type ModelTokenEstimatorFieldName =
-  (typeof MODEL_TOKEN_ESTIMATOR_FIELDS)[number]["name"];
 
 function modelProfileField<Name extends ModelProfileFieldName>(
   name: Name,
@@ -496,21 +425,6 @@ function modelProfileField<Name extends ModelProfileFieldName>(
   >;
 }
 
-function tokenEstimatorField<Name extends ModelTokenEstimatorFieldName>(
-  name: Name,
-): Extract<(typeof MODEL_TOKEN_ESTIMATOR_FIELDS)[number], { readonly name: Name }> {
-  const field = MODEL_TOKEN_ESTIMATOR_FIELDS.find(
-    (candidate) => candidate.name === name,
-  );
-  if (field === undefined) {
-    throw new Error(`Missing token estimator field contract for ${name}.`);
-  }
-  return field as Extract<
-    (typeof MODEL_TOKEN_ESTIMATOR_FIELDS)[number],
-    { readonly name: Name }
-  >;
-}
-
 function parseProfileString(
   value: Record<string, unknown>,
   name: "model" | "apiBase" | "apiKey",
@@ -555,18 +469,6 @@ function parseProfileBoolean(
     : parseBoolean(value[name], `${where}: ${JSON.stringify(name)}`);
 }
 
-function parseTokenEstimatorString(
-  value: Record<string, unknown>,
-  name: "model" | "apiBase" | "apiKey",
-  where: string,
-): string {
-  const field = tokenEstimatorField(name);
-  if (field.valueKind !== "non-empty-string") {
-    throw new Error(`Token estimator field ${name} has an invalid contract kind.`);
-  }
-  return requireString(value[name], `${where}.${name}`);
-}
-
 function assertKnownKeys(
   value: Record<string, unknown>,
   allowed: readonly string[],

package/src/cli/public-config-contract.ts

@@ -242,11 +242,7 @@ export const PUBLIC_CONFIG_FIELDS = Object.freeze([
 
 export type ModelProfileField = {
   readonly name: string;
-  readonly valueKind:
-    | PublicConfigValueKind
-    | "input-modalities"
-    | "reasoning"
-    | "token-estimator";
+  readonly valueKind: PublicConfigValueKind | "input-modalities" | "reasoning";
   readonly required: boolean;
   readonly defaultValue?: string | number | boolean | readonly string[];
   readonly secret: boolean;
@@ -337,13 +333,6 @@ export const MODEL_PROFILE_FIELDS = Object.freeze([
     description:
       'Accepted model input modalities; normalizes to ["text"] or ["text", "image"].',
   }),
-  profileField({
-    name: "tokenEstimator",
-    valueKind: "token-estimator",
-    required: false,
-    secret: true,
-    description: "Independent token estimator required for image profiles.",
-  }),
 ]);
 
 export type ModelReasoningField = {
@@ -375,82 +364,6 @@ export const MODEL_REASONING_FIELDS = Object.freeze([
   }),
 ]);
 
-export type ModelTokenEstimatorField = {
-  readonly name: string;
-  readonly valueKind: PublicConfigValueKind | "literal-string" | "literal-number";
-  readonly required: true;
-  readonly secret: boolean;
-  readonly literalValue?: string | number;
-  readonly minimum?: number;
-  readonly maximum?: number;
-  readonly description: string;
-};
-
-function estimatorField<const T extends ModelTokenEstimatorField>(
-  field: T,
-): Readonly<T> {
-  return Object.freeze(field);
-}
-
-export const MODEL_TOKEN_ESTIMATOR_FIELDS = Object.freeze([
-  estimatorField({
-    name: "kind",
-    valueKind: "literal-string",
-    required: true,
-    secret: false,
-    literalValue: "moonshot-estimate-token-count-v1",
-    description: "Estimator protocol discriminator.",
-  }),
-  estimatorField({
-    name: "model",
-    valueKind: "non-empty-string",
-    required: true,
-    secret: false,
-    description: "Estimator model name.",
-  }),
-  estimatorField({
-    name: "apiBase",
-    valueKind: "non-empty-string",
-    required: true,
-    secret: false,
-    description: "Estimator API base URL.",
-  }),
-  estimatorField({
-    name: "apiKey",
-    valueKind: "non-empty-string",
-    required: true,
-    secret: true,
-    description: "Estimator API credential.",
-  }),
-  estimatorField({
-    name: "timeoutMs",
-    valueKind: "positive-integer",
-    required: true,
-    secret: false,
-    minimum: 1_000,
-    maximum: 60_000,
-    description: "Estimator request timeout in milliseconds.",
-  }),
-  estimatorField({
-    name: "maxRetries",
-    valueKind: "literal-number",
-    required: true,
-    secret: false,
-    literalValue: 0,
-    description: "Estimator retry count; retries are disabled.",
-  }),
-]);
-
-export type ModelTokenEstimatorKind = Extract<
-  (typeof MODEL_TOKEN_ESTIMATOR_FIELDS)[number],
-  { readonly name: "kind" }
->["literalValue"];
-
-export type ModelTokenEstimatorMaxRetries = Extract<
-  (typeof MODEL_TOKEN_ESTIMATOR_FIELDS)[number],
-  { readonly name: "maxRetries" }
->["literalValue"];
-
 export type MemoryConfigField = {
   readonly name: "profile" | "embedding";
   readonly valueKind: "non-empty-string" | "embedding-profile";

package/src/cli/runner-dependencies.ts

@@ -66,7 +66,6 @@ export function createModelClient(
     | "apiKey"
     | "apiBase"
     | "inputModalities"
-    | "tokenEstimator"
   >,
   env: NodeJS.ProcessEnv = process.env,
   reasoningEffort?: ReasoningEffortController,
@@ -82,9 +81,6 @@ export function createModelClient(
       ...(activeReasoningEffort === undefined
         ? {}
         : { reasoningEffort: activeReasoningEffort }),
-      ...(config.tokenEstimator === undefined
-        ? {}
-        : { tokenEstimator: config.tokenEstimator }),
       ...(env.TINKER_TEST_FAKE_MODEL_REQUEST_LOG === undefined ||
       env.TINKER_TEST_FAKE_MODEL_REQUEST_LOG === ""
         ? {}
@@ -102,9 +98,6 @@ export function createModelClient(
     ...(activeReasoningEffort === undefined
       ? {}
       : { reasoningEffort: activeReasoningEffort }),
-    ...(config.tokenEstimator === undefined
-      ? {}
-      : { tokenEstimator: config.tokenEstimator }),
   };
   if (config.api === "responses") {
     return new OpenAIResponsesModelClient(common);

package/src/cli/tui-memory.ts

@@ -47,9 +47,6 @@ export async function initializeTuiMemory(input: {
             stream: profile.stream,
             contextBudget: memoryConfig.contextBudget,
             inputModalities: profile.inputModalities,
-            ...(profile.tokenEstimator === undefined
-              ? {}
-              : { tokenEstimator: profile.tokenEstimator }),
           },
           input.env,
         );

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

@@ -35,6 +35,10 @@ export function renderObservationLogEvent(event: AgentEvent): string | undefined
       ].join("\n");
     case "turn.started":
       return renderTurnStarted(event);
+    case "turn.steering.applied":
+      return ["## User follow-up", "", event.data.userPrompt.text, "", "---", ""].join(
+        "\n",
+      );
     case "assistant.progress":
       return renderAssistantProgress(event);
     case "tool.observation":

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

@@ -37,6 +37,11 @@ export class StdoutEventPrinter implements EventSink {
           `turn.started turn=${event.turnNumber} turnId=${event.turnId}\n`,
         );
         break;
+      case "turn.steering.applied":
+        this.stdout.write(
+          `turn.steering.applied turn=${event.turnNumber} ordinal=${event.data.ordinal}\n`,
+        );
+        break;
       case "agent.iteration.started":
         this.stdout.write(
           `agent.iteration.started iteration=${event.iterationNumber} iterationId=${event.iterationId}\n`,

package/src/events/types.ts

@@ -307,6 +307,10 @@ export type AgentEventDataMap = {
   "session.interrupted_frame_recovered": InterruptedFrameRecoveredData;
   "session.finished": SessionFinishedData;
   "turn.started": { userPrompt: UserPromptProjection };
+  "turn.steering.applied": {
+    userPrompt: UserPromptProjection;
+    ordinal: number;
+  };
   "turn.finished": TurnFinishedData;
   "turn.failed": { error: string };
   "turn.cancelled": { cancellation: TurnCancellation };
@@ -411,7 +415,7 @@ export type AgentEventInput =
     >
   | SessionEventInput<"mcp.server.connected" | "mcp.server.failed">
   | SessionEventInput<"diagnostic.sink_failed">
-  | TurnEventInput<"turn.started" | "turn.finished">
+  | TurnEventInput<"turn.started" | "turn.steering.applied" | "turn.finished">
   | (
       | TurnEventInput<"turn.failed" | "turn.cancelled">
       | IterationEventInput<"turn.failed" | "turn.cancelled">

package/src/image/image-input-policy.ts

@@ -4,11 +4,62 @@ export const IMAGE_INPUT_POLICY = Object.freeze({
   maxBytesPerImage: 20 * 1024 * 1024,
   maxImagesPerMessage: 8,
   maxImagesPerRequest: 8,
+  maxProviderLongEdge: 2048,
   maxLongEdge: 4096,
   maxPixels: 8_847_360,
   maxRequestBodyBytes: 90_000_000,
-  planningTokensPerImage: 2048,
+  allowUpscale: false,
+  resizePolicy: "sharp-auto-orient-lanczos3-round-v1",
+  outputEncodingPolicy: "preserve-input-format-fixed-encoding-v1",
+  imageTokenBuckets: Object.freeze([
+    Object.freeze({ maxLongEdge: 512, planningTokens: 384 }),
+    Object.freeze({ maxLongEdge: 1024, planningTokens: 1408 }),
+    Object.freeze({ maxLongEdge: 1536, planningTokens: 3072 }),
+    Object.freeze({ maxLongEdge: 2048, planningTokens: 5504 }),
+  ] as const),
+  imageTokensUseTextCorrectionFactor: false,
   retryPolicy: "none",
 } as const);
 
-export const IMAGE_INPUT_POLICY_VERSION = "image-input-policy-v1" as const;
+export const IMAGE_INPUT_POLICY_VERSION = "image-input-policy-v2" as const;
+
+export function providerImageDimensions(
+  width: number,
+  height: number,
+): { readonly width: number; readonly height: number } {
+  requireDimension(width, "width");
+  requireDimension(height, "height");
+  const longEdge = Math.max(width, height);
+  if (longEdge <= IMAGE_INPUT_POLICY.maxProviderLongEdge) {
+    return Object.freeze({ width, height });
+  }
+  const scale = IMAGE_INPUT_POLICY.maxProviderLongEdge / longEdge;
+  let targetWidth = Math.max(1, Math.round(width * scale));
+  let targetHeight = Math.max(1, Math.round(height * scale));
+  if (targetWidth > IMAGE_INPUT_POLICY.maxProviderLongEdge) {
+    targetWidth = IMAGE_INPUT_POLICY.maxProviderLongEdge;
+  }
+  if (targetHeight > IMAGE_INPUT_POLICY.maxProviderLongEdge) {
+    targetHeight = IMAGE_INPUT_POLICY.maxProviderLongEdge;
+  }
+  return Object.freeze({ width: targetWidth, height: targetHeight });
+}
+
+export function imagePlanningTokens(width: number, height: number): number {
+  requireDimension(width, "width");
+  requireDimension(height, "height");
+  const longEdge = Math.max(width, height);
+  const bucket = IMAGE_INPUT_POLICY.imageTokenBuckets.find(
+    (candidate) => longEdge <= candidate.maxLongEdge,
+  );
+  if (bucket === undefined) {
+    throw new Error("Materialized image exceeds the provider image size policy.");
+  }
+  return bucket.planningTokens;
+}
+
+function requireDimension(value: number, name: string): void {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new Error(`Image ${name} must be a positive safe integer.`);
+  }
+}

package/src/image/image-probe.ts

@@ -1,5 +1,6 @@
 import sharp from "sharp";
 import { IMAGE_INPUT_POLICY } from "./image-input-policy";
+import { orientedDimensions } from "./provider-image";
 import {
   imageAssetIdForBytes,
   type ImageAssetRef,
@@ -59,8 +60,13 @@ export async function probeImageBytes(
       `Image container and decoder disagree on format (${container.mimeType} vs ${mimeType}).`,
     );
   }
-  const width = requireDimension(metadata.width, "width");
-  const height = requireDimension(metadata.height, "height");
+  const decodedWidth = requireDimension(metadata.width, "width");
+  const decodedHeight = requireDimension(metadata.height, "height");
+  const { width, height } = orientedDimensions(
+    decodedWidth,
+    decodedHeight,
+    metadata.orientation,
+  );
   const decoderAnimated =
     (metadata.pages ?? 1) > 1 || metadata.pageHeight !== undefined;
   if (container.animated || decoderAnimated) {

package/src/image/provider-image.ts

@@ -0,0 +1,99 @@
+import sharp from "sharp";
+import {
+  IMAGE_INPUT_POLICY,
+  imagePlanningTokens,
+  providerImageDimensions,
+} from "./image-input-policy";
+import type { ImageMimeType } from "./image-types";
+
+export type ProviderImage = {
+  readonly bytes: Buffer;
+  readonly mimeType: ImageMimeType;
+  readonly width: number;
+  readonly height: number;
+  readonly planningTokens: number;
+};
+
+export async function materializeProviderImage(
+  bytes: Buffer,
+  mimeType: ImageMimeType,
+): Promise<ProviderImage> {
+  const input = sharp(bytes, {
+    failOn: "warning",
+    limitInputPixels: IMAGE_INPUT_POLICY.maxPixels,
+    unlimited: false,
+    sequentialRead: true,
+  });
+  const metadata = await input.metadata();
+  const sourceWidth = requireDimension(metadata.width, "width");
+  const sourceHeight = requireDimension(metadata.height, "height");
+  const oriented = orientedDimensions(sourceWidth, sourceHeight, metadata.orientation);
+  const target = providerImageDimensions(oriented.width, oriented.height);
+  const requiresOrientation =
+    metadata.orientation !== undefined && metadata.orientation !== 1;
+  const requiresResize =
+    target.width !== oriented.width || target.height !== oriented.height;
+
+  let outputBytes = bytes;
+  if (requiresOrientation || requiresResize) {
+    let pipeline = sharp(bytes, {
+      failOn: "warning",
+      limitInputPixels: IMAGE_INPUT_POLICY.maxPixels,
+      unlimited: false,
+      sequentialRead: true,
+    }).rotate();
+    if (requiresResize) {
+      pipeline = pipeline.resize(target.width, target.height, {
+        fit: "fill",
+        kernel: sharp.kernel.lanczos3,
+        withoutEnlargement: true,
+      });
+    }
+    outputBytes = await encodeInOriginalFormat(pipeline, mimeType);
+  }
+
+  const outputMetadata = await sharp(outputBytes).metadata();
+  const width = requireDimension(outputMetadata.width, "width");
+  const height = requireDimension(outputMetadata.height, "height");
+  if (Math.max(width, height) > IMAGE_INPUT_POLICY.maxProviderLongEdge) {
+    throw new Error("Materialized image exceeds the provider image size policy.");
+  }
+  return Object.freeze({
+    bytes: outputBytes,
+    mimeType,
+    width,
+    height,
+    planningTokens: imagePlanningTokens(width, height),
+  });
+}
+
+export function orientedDimensions(
+  width: number,
+  height: number,
+  orientation: number | undefined,
+): { readonly width: number; readonly height: number } {
+  return orientation !== undefined && orientation >= 5 && orientation <= 8
+    ? Object.freeze({ width: height, height: width })
+    : Object.freeze({ width, height });
+}
+
+async function encodeInOriginalFormat(
+  pipeline: ReturnType<typeof sharp>,
+  mimeType: ImageMimeType,
+): Promise<Buffer> {
+  switch (mimeType) {
+    case "image/png":
+      return pipeline.png({ compressionLevel: 6, adaptiveFiltering: false }).toBuffer();
+    case "image/jpeg":
+      return pipeline.jpeg({ quality: 80, chromaSubsampling: "4:2:0" }).toBuffer();
+    case "image/webp":
+      return pipeline.webp({ quality: 80, effort: 4 }).toBuffer();
+  }
+}
+
+function requireDimension(value: number | undefined, name: string): number {
+  if (!Number.isSafeInteger(value) || value === undefined || value < 1) {
+    throw new Error(`Decoded image ${name} is invalid.`);
+  }
+  return value;
+}