tinker-agent 1.10.1 → 2.0.0

package/src/model/fake-model-client.ts

@@ -2,9 +2,13 @@ import { createHash } from "node:crypto";
 import { appendFile } from "node:fs/promises";
 import type { AgentMessage, AssistantMessage } from "../agent/types";
 import { cancellationError } from "../agent/turn-cancellation";
-import { IMAGE_INPUT_POLICY } from "../image/image-input-policy";
+import {
+  IMAGE_INPUT_POLICY,
+  imagePlanningTokens,
+  providerImageDimensions,
+} from "../image/image-input-policy";
 import type { ImageAssetId, ImageAssetRef } from "../image/image-types";
-import type { InputTokenEstimator } from "./input-token-estimator";
+import { materializeProviderImage } from "../image/provider-image";
 import type { ModelContextBudget } from "./model-context-profile";
 import type { ReasoningEffortController } from "./reasoning-effort";
 import type {
@@ -24,7 +28,6 @@ import { estimatePromptSegments } from "./token-estimator";
 
 export class FakeModelClient implements ModelClient {
   readonly inputModalities: readonly ("text" | "image")[];
-  readonly inputTokenEstimator?: InputTokenEstimator;
   readonly reasoningEffort?: ReasoningEffortController;
   readonly messageProtocol: ModelMessageProtocol = Object.freeze({
     adapter: "fake",
@@ -42,13 +45,6 @@ export class FakeModelClient implements ModelClient {
       inputModalities?: readonly ("text" | "image")[];
       reasoningEffort?: ReasoningEffortController;
       requestLogPath?: string;
-      tokenEstimator?: {
-        kind: "moonshot-estimate-token-count-v1";
-        model: string;
-        apiBase: string;
-        timeoutMs: number;
-        maxRetries: 0;
-      };
     },
   ) {
     this.reasoningEffort = options.reasoningEffort;
@@ -58,38 +54,6 @@ export class FakeModelClient implements ModelClient {
     if (!this.inputModalities.includes("text")) {
       throw new Error('Fake model input modalities must include "text".');
     }
-    if (
-      this.inputModalities.includes("image") &&
-      options.tokenEstimator === undefined
-    ) {
-      throw new Error("Image-capable fake model requires a token estimator.");
-    }
-    if (options.tokenEstimator !== undefined) {
-      const estimator = options.tokenEstimator;
-      const endpoint = tokenEstimatorEndpoint(estimator.apiBase);
-      this.inputTokenEstimator = Object.freeze({
-        kind: estimator.kind,
-        compatibility: Object.freeze({
-          kind: estimator.kind,
-          coverageVersion: "full-request-v1",
-          model: estimator.model,
-          endpoint,
-          timeoutMs: estimator.timeoutMs,
-          maxRetries: estimator.maxRetries,
-        }),
-        async estimate(
-          request: MaterializedModelRequest,
-          estimateOptions: { signal: AbortSignal },
-        ) {
-          estimateOptions.signal.throwIfAborted();
-          return Object.freeze({
-            inputTokens: estimatePromptSegments(request.promptSegments).totalTokens,
-            source: "provider_estimated" as const,
-            coverage: "full_request" as const,
-          });
-        },
-      });
-    }
   }
 
   prepare(input: ModelRequestInput): PreparedModelRequest {
@@ -113,9 +77,6 @@ export class FakeModelClient implements ModelClient {
         model: this.options.model,
         requestMaxOutputTokens: this.options.contextBudget.requestMaxOutputTokens,
         inputModalities: this.inputModalities,
-        ...(this.inputTokenEstimator === undefined
-          ? {}
-          : { tokenEstimator: this.inputTokenEstimator.compatibility }),
       }),
     );
     const prepared: PreparedModelRequest = Object.freeze({
@@ -167,6 +128,9 @@ export class FakeModelClient implements ModelClient {
     const materializedAssets: Array<{
       readonly assetId: ImageAssetId;
       readonly byteLength: number;
+      readonly width: number;
+      readonly height: number;
+      readonly planningTokens: number;
       readonly bytesSha256: string;
     }> = [];
     for (const asset of assets.values()) {
@@ -174,11 +138,15 @@ export class FakeModelClient implements ModelClient {
       const bytes = await options.assetStore.readVerified(asset, {
         signal: options.signal,
       });
+      const image = await materializeProviderImage(bytes, asset.mimeType);
       materializedAssets.push(
         Object.freeze({
           assetId: asset.assetId,
-          byteLength: bytes.byteLength,
-          bytesSha256: createHash("sha256").update(bytes).digest("hex"),
+          byteLength: image.bytes.byteLength,
+          width: image.width,
+          height: image.height,
+          planningTokens: image.planningTokens,
+          bytesSha256: createHash("sha256").update(image.bytes).digest("hex"),
         }),
       );
     }
@@ -191,6 +159,10 @@ export class FakeModelClient implements ModelClient {
     const materialized = Object.freeze({
       ...prepared,
       payload,
+      promptSegments: materializedFakePromptSegments(
+        prepared.promptSegments,
+        materializedAssets,
+      ),
       bodyBytes: Buffer.byteLength(stableJsonStringify(payload), "utf8"),
     });
     this.preparedInputs.set(materialized, input);
@@ -241,6 +213,9 @@ export class FakeModelClient implements ModelClient {
     if (this.mode === "pty-incremental-output") {
       return this.ptyIncrementalOutput(input, prepared, options);
     }
+    if (this.mode === "pty-steering-notice") {
+      return this.ptySteeringNotice(input, prepared, options);
+    }
     if (this.mode === "pty-resume-layout") {
       return this.ptyResumeLayout(input, prepared, options);
     }
@@ -412,6 +387,32 @@ export class FakeModelClient implements ModelClient {
     return textOutput(prepared, chunks.join(""));
   }
 
+  private async ptySteeringNotice(
+    input: ModelRequestInput,
+    prepared: PreparedModelRequest,
+    options: ModelRequestOptions,
+  ): Promise<ModelRequestOutput> {
+    requireTools(input, ["Bash"]);
+    const prompt = lastUserMessage(input.messages);
+    if (prompt === "PTY_STEERING_START") {
+      await Bun.sleep(600);
+      options.signal.throwIfAborted();
+      return toolCallOutput(prepared, options, "Bash", {
+        command: "printf 'PTY_STEERING_TOOL_DONE\\n'",
+        description: "Create steering boundary",
+      });
+    }
+    if (prompt === "PTY_STEERING_FOLLOWUP") {
+      requireToolMessage(input.messages, "Bash", "PTY_STEERING_TOOL_DONE");
+      await Bun.sleep(1_500);
+      options.signal.throwIfAborted();
+      return textOutput(prepared, "PTY_STEERING_FINAL");
+    }
+    throw new Error(
+      `Unexpected pty-steering-notice prompt: ${JSON.stringify(prompt)}.`,
+    );
+  }
+
   private ptyResumeLayout(
     input: ModelRequestInput,
     prepared: PreparedModelRequest,
@@ -1426,19 +1427,21 @@ function lastMessageIndex(
 
 function toPromptSegment(message: AgentMessage): PreparedPromptSegment {
   if (message.role === "user" && message.attachments !== undefined) {
-    const media = message.attachments.map(
-      (attachment): PreparedMediaDescriptor =>
-        Object.freeze({
-          assetId: attachment.assetId,
-          label: attachment.label,
-          range: Object.freeze({ ...attachment.range }),
-          mimeType: attachment.mimeType,
-          byteLength: attachment.byteLength,
-          width: attachment.width,
-          height: attachment.height,
-          planningTokens: IMAGE_INPUT_POLICY.planningTokensPerImage,
-        }),
-    );
+    const media = message.attachments.map((attachment): PreparedMediaDescriptor => {
+      const dimensions = providerImageDimensions(attachment.width, attachment.height);
+      return Object.freeze({
+        assetId: attachment.assetId,
+        label: attachment.label,
+        range: Object.freeze({ ...attachment.range }),
+        mimeType: attachment.mimeType,
+        byteLength: attachment.byteLength,
+        sourceWidth: attachment.width,
+        sourceHeight: attachment.height,
+        width: dimensions.width,
+        height: dimensions.height,
+        planningTokens: imagePlanningTokens(dimensions.width, dimensions.height),
+      });
+    });
     return Object.freeze({
       kind: "user",
       normalizedText: message.content,
@@ -1466,8 +1469,8 @@ function distinctPreparedAssets(
         assetId: media.assetId,
         mimeType: media.mimeType,
         byteLength: media.byteLength,
-        width: media.width,
-        height: media.height,
+        width: media.sourceWidth,
+        height: media.sourceHeight,
       });
       const existing = assets.get(media.assetId);
       if (
@@ -1482,13 +1485,39 @@ function distinctPreparedAssets(
   return assets;
 }
 
-function tokenEstimatorEndpoint(apiBase: string): string {
-  const base = new URL(apiBase.endsWith("/") ? apiBase : `${apiBase}/`);
-  base.username = "";
-  base.password = "";
-  base.search = "";
-  base.hash = "";
-  return new URL("tokenizers/estimate-token-count", base).toString();
+function materializedFakePromptSegments(
+  segments: readonly PreparedPromptSegment[],
+  images: readonly {
+    assetId: ImageAssetId;
+    width: number;
+    height: number;
+    planningTokens: number;
+  }[],
+): readonly PreparedPromptSegment[] {
+  const byId = new Map(images.map((image) => [image.assetId, image] as const));
+  return Object.freeze(
+    segments.map((segment) =>
+      segment.media === undefined
+        ? segment
+        : Object.freeze({
+            ...segment,
+            media: Object.freeze(
+              segment.media.map((media) => {
+                const image = byId.get(media.assetId);
+                if (image === undefined) {
+                  throw new Error(`Fake image ${media.assetId} was not materialized.`);
+                }
+                return Object.freeze({
+                  ...media,
+                  width: image.width,
+                  height: image.height,
+                  planningTokens: image.planningTokens,
+                });
+              }),
+            ),
+          }),
+    ),
+  );
 }
 
 function recallMarker(

package/src/model/model-client.ts

@@ -3,12 +3,10 @@ import type { RuntimeSessionContext } from "../agent/runtime-session";
 import type { ToolDefinition } from "../tools/types";
 import type { ImageAssetStore } from "../image/image-asset-store";
 import type { CodePointRange, ImageAssetId, ImageMimeType } from "../image/image-types";
-import type { InputTokenEstimator } from "./input-token-estimator";
 import type { ReasoningEffortController } from "./reasoning-effort";
 
 export interface ModelClient {
   readonly messageProtocol: ModelMessageProtocol;
-  readonly inputTokenEstimator?: InputTokenEstimator;
   readonly inputModalities?: readonly ("text" | "image")[];
   readonly reasoningEffort?: ReasoningEffortController;
   prepare(input: ModelRequestInput): PreparedModelRequest;
@@ -76,6 +74,8 @@ export type PreparedMediaDescriptor = {
   range: CodePointRange;
   mimeType: ImageMimeType;
   byteLength: number;
+  sourceWidth: number;
+  sourceHeight: number;
   width: number;
   height: number;
   planningTokens: number;

package/src/model/model-request-preflight.ts

@@ -3,7 +3,6 @@ import type { ModelContextBudget } from "./model-context-profile";
 
 export type ContextUsageSource =
   | "estimated_full"
-  | "provider_estimated"
   | "provider_measured"
   | "measured_plus_estimated_delta";
 

package/src/model/openai-chat-model-client.ts

@@ -9,7 +9,6 @@ import {
   IMAGE_INPUT_POLICY_VERSION,
 } from "../image/image-input-policy";
 import type { ModelContextBudget } from "./model-context-profile";
-import type { InputTokenEstimator } from "./input-token-estimator";
 import { ProviderResponseError } from "./model-client";
 import type {
   MaterializedModelRequest,
@@ -36,7 +35,6 @@ import {
   sanitizedProviderError,
   segmentKind,
 } from "./openai-model-utils";
-import { MoonshotInputTokenEstimator } from "./moonshot-input-token-estimator";
 import type { ReasoningEffortController } from "./reasoning-effort";
 import { sha256, stableJsonStringify } from "./model-request-preflight";
 
@@ -48,7 +46,6 @@ export class OpenAIChatModelClient implements ModelClient {
     adapter: "openai-chat",
     serializationVersion: OPENAI_CHAT_SERIALIZATION_VERSION,
   });
-  readonly inputTokenEstimator?: InputTokenEstimator;
   readonly reasoningEffort?: ReasoningEffortController;
   private readonly client: OpenAI;
   private readonly preparedRequests = new WeakSet<object>();
@@ -64,14 +61,6 @@ export class OpenAIChatModelClient implements ModelClient {
       baseURL?: string;
       includeReasoningContent?: boolean;
       inputModalities?: readonly ("text" | "image")[];
-      tokenEstimator?: {
-        kind: "moonshot-estimate-token-count-v1";
-        model: string;
-        apiBase: string;
-        apiKey: string;
-        timeoutMs: number;
-        maxRetries: 0;
-      };
       model: string;
       providerName?: string;
       reasoningEffort?: ReasoningEffortController;
@@ -84,13 +73,9 @@ export class OpenAIChatModelClient implements ModelClient {
     this.stream = options.stream ?? true;
     this.reasoningEffort = options.reasoningEffort;
     this.inputModalities = Object.freeze([...(options.inputModalities ?? ["text"])]);
-    const supportsImages = this.inputModalities.includes("image");
     if (!this.inputModalities.includes("text")) {
       throw new Error('OpenAI chat input modalities must include "text".');
     }
-    if (supportsImages && options.tokenEstimator === undefined) {
-      throw new Error("Image-capable OpenAI chat requires a token estimator.");
-    }
     this.client = new OpenAI({
       apiKey: options.apiKey,
       baseURL: options.baseURL,
@@ -100,15 +85,6 @@ export class OpenAIChatModelClient implements ModelClient {
       maxRetries: 0,
       fetch: options.fetch,
     });
-    if (options.tokenEstimator !== undefined) {
-      this.inputTokenEstimator = new MoonshotInputTokenEstimator({
-        apiKey: options.tokenEstimator.apiKey,
-        baseURL: options.tokenEstimator.apiBase,
-        model: options.tokenEstimator.model,
-        timeoutMs: options.tokenEstimator.timeoutMs,
-        fetch: options.fetch,
-      });
-    }
   }
 
   prepare(input: ModelRequestInput): PreparedModelRequest {
@@ -164,9 +140,6 @@ export class OpenAIChatModelClient implements ModelClient {
           version: IMAGE_INPUT_POLICY_VERSION,
           ...IMAGE_INPUT_POLICY,
         },
-        ...(this.inputTokenEstimator === undefined
-          ? {}
-          : { tokenEstimator: this.inputTokenEstimator.compatibility }),
       }),
     );
     const prepared: PreparedModelRequest = {
@@ -299,4 +272,7 @@ export class OpenAIChatModelClient implements ModelClient {
   }
 }
 
-export { exactJsonBodyBytes } from "./openai-model-utils";
+export {
+  assertOpenAIRequestBodyLimit,
+  exactJsonBodyBytes,
+} from "./openai-model-utils";

package/src/model/openai-model-utils.ts

@@ -1,7 +1,12 @@
 import OpenAI from "openai";
 import type { UserMessage } from "../agent/types";
-import { IMAGE_INPUT_POLICY } from "../image/image-input-policy";
+import {
+  IMAGE_INPUT_POLICY,
+  imagePlanningTokens,
+  providerImageDimensions,
+} from "../image/image-input-policy";
 import type { ImageAssetId, ImageAssetRef } from "../image/image-types";
+import { materializeProviderImage, type ProviderImage } from "../image/provider-image";
 import {
   ModelRequestMediaAggregateError,
   ProviderResponseError,
@@ -28,26 +33,22 @@ export async function materializeOpenAIRequest(
   }
 
   const assets = distinctPreparedAssets(prepared.promptSegments);
-  const lowerLengths = new Map<ImageAssetId, number>();
-  for (const asset of assets.values()) {
-    lowerLengths.set(asset.assetId, dataUrlLength(asset));
-  }
   const markerCount = countImageMarkers(prepared.payload);
   if (markerCount !== prepared.mediaOccurrenceCount) {
     throw new Error("Prepared image marker count does not match media descriptors.");
   }
-  const lowerBodyBytes = exactJsonBodyBytes(prepared.payload, lowerLengths);
-  assertBodyLimit(lowerBodyBytes, prepared.mediaOccurrenceCount);
-
   const dataUrls = new Map<ImageAssetId, string>();
+  const providerImages = new Map<ImageAssetId, ProviderImage>();
   for (const asset of assets.values()) {
     options.signal.throwIfAborted();
     const bytes = await options.assetStore.readVerified(asset, {
       signal: options.signal,
     });
+    const image = await materializeProviderImage(bytes, asset.mimeType);
+    providerImages.set(asset.assetId, image);
     dataUrls.set(
       asset.assetId,
-      `data:${asset.mimeType};base64,${bytes.toString("base64")}`,
+      `data:${image.mimeType};base64,${image.bytes.toString("base64")}`,
     );
     await yieldToEventLoop();
   }
@@ -56,9 +57,14 @@ export async function materializeOpenAIRequest(
     [...dataUrls].map(([assetId, value]) => [assetId, value.length] as const),
   );
   const bodyBytes = exactJsonBodyBytes(prepared.payload, exactLengths);
-  assertBodyLimit(bodyBytes, prepared.mediaOccurrenceCount);
+  assertOpenAIRequestBodyLimit(bodyBytes, prepared.mediaOccurrenceCount);
   const payload = deepFreeze(materializePayload(prepared.payload, dataUrls));
-  return Object.freeze({ ...prepared, payload, bodyBytes });
+  return Object.freeze({
+    ...prepared,
+    payload,
+    promptSegments: materializedPromptSegments(prepared.promptSegments, providerImages),
+    bodyBytes,
+  });
 }
 
 export function exactJsonBodyBytes(
@@ -119,19 +125,21 @@ export function exactJsonBodyBytes(
 }
 
 export function imageUserSegment(message: UserMessage): PreparedPromptSegment {
-  const media = message.attachments!.map(
-    (attachment): PreparedMediaDescriptor =>
-      Object.freeze({
-        assetId: attachment.assetId,
-        label: attachment.label,
-        range: Object.freeze({ ...attachment.range }),
-        mimeType: attachment.mimeType,
-        byteLength: attachment.byteLength,
-        width: attachment.width,
-        height: attachment.height,
-        planningTokens: IMAGE_INPUT_POLICY.planningTokensPerImage,
-      }),
-  );
+  const media = message.attachments!.map((attachment): PreparedMediaDescriptor => {
+    const dimensions = providerImageDimensions(attachment.width, attachment.height);
+    return Object.freeze({
+      assetId: attachment.assetId,
+      label: attachment.label,
+      range: Object.freeze({ ...attachment.range }),
+      mimeType: attachment.mimeType,
+      byteLength: attachment.byteLength,
+      sourceWidth: attachment.width,
+      sourceHeight: attachment.height,
+      width: dimensions.width,
+      height: dimensions.height,
+      planningTokens: imagePlanningTokens(dimensions.width, dimensions.height),
+    });
+  });
   return Object.freeze({
     kind: "user",
     normalizedText: message.content,
@@ -204,8 +212,8 @@ function distinctPreparedAssets(
         assetId: media.assetId,
         mimeType: media.mimeType,
         byteLength: media.byteLength,
-        width: media.width,
-        height: media.height,
+        width: media.sourceWidth,
+        height: media.sourceHeight,
       });
       const existing = assets.get(media.assetId);
       if (
@@ -265,11 +273,10 @@ function countImageMarkers(value: unknown): number {
   return 0;
 }
 
-function dataUrlLength(asset: ImageAssetRef): number {
-  return `data:${asset.mimeType};base64,`.length + 4 * Math.ceil(asset.byteLength / 3);
-}
-
-function assertBodyLimit(bodyBytes: number, imageCount: number): void {
+export function assertOpenAIRequestBodyLimit(
+  bodyBytes: number,
+  imageCount: number,
+): void {
   if (bodyBytes > IMAGE_INPUT_POLICY.maxRequestBodyBytes) {
     throw new ModelRequestMediaAggregateError(
       `Model request is ${bodyBytes} UTF-8 bytes with ${imageCount} images; maximum is ${IMAGE_INPUT_POLICY.maxRequestBodyBytes}.`,
@@ -277,6 +284,37 @@ function assertBodyLimit(bodyBytes: number, imageCount: number): void {
   }
 }
 
+function materializedPromptSegments(
+  segments: readonly PreparedPromptSegment[],
+  images: ReadonlyMap<ImageAssetId, ProviderImage>,
+): readonly PreparedPromptSegment[] {
+  return Object.freeze(
+    segments.map((segment) =>
+      segment.media === undefined
+        ? segment
+        : Object.freeze({
+            ...segment,
+            media: Object.freeze(
+              segment.media.map((media) => {
+                const image = images.get(media.assetId);
+                if (image === undefined) {
+                  throw new Error(
+                    `Image ${media.assetId.slice(0, 12)}… was not materialized.`,
+                  );
+                }
+                return Object.freeze({
+                  ...media,
+                  width: image.width,
+                  height: image.height,
+                  planningTokens: image.planningTokens,
+                });
+              }),
+            ),
+          }),
+    ),
+  );
+}
+
 function yieldToEventLoop(): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, 0));
 }

package/src/model/openai-responses-model-client.ts

@@ -8,7 +8,6 @@ import {
   IMAGE_INPUT_POLICY,
   IMAGE_INPUT_POLICY_VERSION,
 } from "../image/image-input-policy";
-import type { InputTokenEstimator } from "./input-token-estimator";
 import type { ModelContextBudget } from "./model-context-profile";
 import { ProviderResponseError } from "./model-client";
 import type {
@@ -22,7 +21,6 @@ import type {
   PreparedModelRequest,
   PreparedPromptSegment,
 } from "./model-client";
-import { MoonshotInputTokenEstimator } from "./moonshot-input-token-estimator";
 import {
   deepFreeze,
   imageUserSegment,
@@ -38,7 +36,6 @@ import {
   toOpenAIResponsesTools,
 } from "./openai-responses-mapping";
 import { OpenAIResponsesStreamAccumulator } from "./openai-responses-stream";
-import { responsesPayloadForChatTokenEstimator } from "./openai-responses-token-estimator";
 import type { ReasoningEffortController } from "./reasoning-effort";
 import { sha256, stableJsonStringify } from "./model-request-preflight";
 
@@ -50,7 +47,6 @@ export class OpenAIResponsesModelClient implements ModelClient {
     adapter: "openai-responses",
     serializationVersion: OPENAI_RESPONSES_SERIALIZATION_VERSION,
   });
-  readonly inputTokenEstimator?: InputTokenEstimator;
   readonly inputModalities: readonly ("text" | "image")[];
   readonly reasoningEffort?: ReasoningEffortController;
   private readonly client: OpenAI;
@@ -65,14 +61,6 @@ export class OpenAIResponsesModelClient implements ModelClient {
       contextBudget: ModelContextBudget;
       baseURL?: string;
       inputModalities?: readonly ("text" | "image")[];
-      tokenEstimator?: {
-        kind: "moonshot-estimate-token-count-v1";
-        model: string;
-        apiBase: string;
-        apiKey: string;
-        timeoutMs: number;
-        maxRetries: 0;
-      };
       model: string;
       providerName?: string;
       reasoningEffort?: ReasoningEffortController;
@@ -85,13 +73,9 @@ export class OpenAIResponsesModelClient implements ModelClient {
     this.stream = options.stream ?? true;
     this.reasoningEffort = options.reasoningEffort;
     this.inputModalities = Object.freeze([...(options.inputModalities ?? ["text"])]);
-    const supportsImages = this.inputModalities.includes("image");
     if (!this.inputModalities.includes("text")) {
       throw new Error('OpenAI Responses input modalities must include "text".');
     }
-    if (supportsImages && options.tokenEstimator === undefined) {
-      throw new Error("Image-capable OpenAI Responses requires a token estimator.");
-    }
     this.client = new OpenAI({
       apiKey: options.apiKey,
       baseURL: options.baseURL,
@@ -99,16 +83,6 @@ export class OpenAIResponsesModelClient implements ModelClient {
       maxRetries: 0,
       fetch: options.fetch,
     });
-    if (options.tokenEstimator !== undefined) {
-      this.inputTokenEstimator = new MoonshotInputTokenEstimator({
-        apiKey: options.tokenEstimator.apiKey,
-        baseURL: options.tokenEstimator.apiBase,
-        model: options.tokenEstimator.model,
-        timeoutMs: options.tokenEstimator.timeoutMs,
-        fetch: options.fetch,
-        payloadMapper: responsesPayloadForChatTokenEstimator,
-      });
-    }
   }
 
   prepare(input: ModelRequestInput): PreparedModelRequest {
@@ -163,9 +137,6 @@ export class OpenAIResponsesModelClient implements ModelClient {
           version: IMAGE_INPUT_POLICY_VERSION,
           ...IMAGE_INPUT_POLICY,
         },
-        ...(this.inputTokenEstimator === undefined
-          ? {}
-          : { tokenEstimator: this.inputTokenEstimator.compatibility }),
       }),
     );
     const prepared: PreparedModelRequest = {

package/src/model/token-estimator.ts

@@ -12,10 +12,15 @@ export type RawContextBreakdown = {
   toolTokens: number;
   toolSchemaTokens: number;
   protocolTokens: number;
+  textAndProtocolTokens: number;
+  imageTokens: number;
   totalTokens: number;
 };
 
-type BreakdownKey = Exclude<keyof RawContextBreakdown, "totalTokens">;
+type BreakdownKey = Exclude<
+  keyof RawContextBreakdown,
+  "totalTokens" | "textAndProtocolTokens" | "imageTokens"
+>;
 
 const breakdownKeys: BreakdownKey[] = [
   "kernelTokens",
@@ -37,13 +42,16 @@ export function estimatePromptSegments(
     toolSchemaTokens: 0,
     protocolTokens: segments.length * 8,
   };
+  let imageTokens = 0;
 
   for (const segment of segments) {
     exact[breakdownKey(segment.kind)] += estimateText(segment.normalizedText);
-    exact[breakdownKey(segment.kind)] += (segment.media ?? []).reduce(
+    const segmentImageTokens = (segment.media ?? []).reduce(
       (total, media) => total + media.planningTokens,
       0,
     );
+    exact[breakdownKey(segment.kind)] += segmentImageTokens;
+    imageTokens += segmentImageTokens;
   }
 
   const totalTokens = Math.ceil(
@@ -69,7 +77,12 @@ export function estimatePromptSegments(
     remaining -= 1;
   }
 
-  return { ...rounded, totalTokens };
+  return {
+    ...rounded,
+    textAndProtocolTokens: totalTokens - imageTokens,
+    imageTokens,
+    totalTokens,
+  };
 }
 
 export class RollingTokenCalibration {