tinker-agent 1.11.0 → 2.0.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 {

package/src/session/session-store.ts

@@ -32,7 +32,6 @@ import {
   MODEL_MESSAGE_PROTOCOL_ADAPTERS,
   type ModelMessageProtocol,
 } from "../model/model-client";
-import type { InputTokenEstimatorCompatibility } from "../model/input-token-estimator";
 import type { ToolDefinition, ToolRawResult } from "../tools/types";
 import { sha256, stableJsonStringify } from "../model/model-request-preflight";
 import {
@@ -149,7 +148,16 @@ export type SessionImageInputCompatibility = {
   readonly policyVersion: string;
   readonly policySha256: string;
   readonly inputModalities: readonly ("text" | "image")[];
-  readonly tokenEstimator?: InputTokenEstimatorCompatibility;
+  readonly tokenEstimator?: LegacyInputTokenEstimatorCompatibility;
+};
+
+type LegacyInputTokenEstimatorCompatibility = {
+  readonly kind: "moonshot-estimate-token-count-v1";
+  readonly coverageVersion: "full-request-v1";
+  readonly model: string;
+  readonly endpoint: string;
+  readonly timeoutMs: number;
+  readonly maxRetries: 0;
 };
 
 export type CompletedTurnMessageSnapshot =
@@ -3704,7 +3712,6 @@ export function createSessionCompatibilityContract(input: {
   contextProfile: ModelContextProfile;
   messageProtocol: ModelMessageProtocol;
   inputModalities?: readonly ("text" | "image")[];
-  tokenEstimator?: InputTokenEstimatorCompatibility;
 }): SessionCompatibilityContract {
   if (input.modelName.trim() === "") {
     throw new Error("Session compatibility model name must not be empty.");
@@ -3722,14 +3729,6 @@ export function createSessionCompatibilityContract(input: {
     throw new Error("Session compatibility message protocol is invalid.");
   }
   const inputModalities = normalizeInputModalities(input.inputModalities ?? ["text"]);
-  if (inputModalities.includes("image") && input.tokenEstimator === undefined) {
-    throw new Error(
-      "Session compatibility image input requires a token estimator identity.",
-    );
-  }
-  if (input.tokenEstimator !== undefined) {
-    validateTokenEstimatorCompatibility(input.tokenEstimator);
-  }
   return Object.freeze({
     modelName: input.modelName,
     ...(input.profileName === undefined ? {} : { profileName: input.profileName }),
@@ -3745,9 +3744,6 @@ export function createSessionCompatibilityContract(input: {
         }),
       ),
       inputModalities,
-      ...(input.tokenEstimator === undefined
-        ? {}
-        : { tokenEstimator: immutableCanonicalClone(input.tokenEstimator) }),
     }),
   });
 }
@@ -3764,9 +3760,6 @@ function normalizeSessionCompatibilityContract(
     contextProfile: contract.contextProfile,
     messageProtocol: contract.messageProtocol,
     inputModalities: contract.imageInput.inputModalities,
-    ...(contract.imageInput.tokenEstimator === undefined
-      ? {}
-      : { tokenEstimator: contract.imageInput.tokenEstimator }),
   });
 }
 
@@ -3787,7 +3780,7 @@ function normalizeInputModalities(
 }
 
 function validateTokenEstimatorCompatibility(
-  estimator: InputTokenEstimatorCompatibility,
+  estimator: LegacyInputTokenEstimatorCompatibility,
 ): void {
   if (
     estimator.kind !== "moonshot-estimate-token-count-v1" ||
@@ -5594,9 +5587,6 @@ function decodeSessionCompatibilityContract(
       enumFromSql(value, ["text", "image"] as const, "compatibility input modality"),
     ),
   );
-  if (modalities.includes("image") && tokenEstimator === undefined) {
-    throw new Error("Stored image input compatibility has no token estimator.");
-  }
   const policyVersion = stringFromSql(
     imageInput.policyVersion,
     "compatibility image policyVersion",
@@ -5625,7 +5615,7 @@ function decodeSessionCompatibilityContract(
 
 function decodeTokenEstimatorCompatibility(
   value: unknown,
-): InputTokenEstimatorCompatibility {
+): LegacyInputTokenEstimatorCompatibility {
   const record = recordFromSql(value, "session compatibility token estimator");
   assertObjectKeys(
     record,
@@ -5633,7 +5623,7 @@ function decodeTokenEstimatorCompatibility(
     ["kind", "coverageVersion", "model", "endpoint", "timeoutMs", "maxRetries"],
     "session compatibility token estimator",
   );
-  const estimator: InputTokenEstimatorCompatibility = {
+  const estimator: LegacyInputTokenEstimatorCompatibility = {
     kind: enumFromSql(
       record.kind,
       ["moonshot-estimate-token-count-v1"] as const,

package/src/model/input-token-estimator.ts

@@ -1,25 +0,0 @@
-import type { MaterializedModelRequest } from "./model-client";
-
-export type InputTokenEstimate = {
-  readonly inputTokens: number;
-  readonly source: "provider_estimated";
-  readonly coverage: "messages" | "full_request";
-};
-
-export type InputTokenEstimatorCompatibility = {
-  readonly kind: "moonshot-estimate-token-count-v1";
-  readonly coverageVersion: "full-request-v1";
-  readonly model: string;
-  readonly endpoint: string;
-  readonly timeoutMs: number;
-  readonly maxRetries: 0;
-};
-
-export interface InputTokenEstimator {
-  readonly kind: string;
-  readonly compatibility: InputTokenEstimatorCompatibility;
-  estimate(
-    request: MaterializedModelRequest,
-    options: { signal: AbortSignal },
-  ): Promise<InputTokenEstimate>;
-}

package/src/model/moonshot-input-token-estimator.ts

@@ -1,111 +0,0 @@
-import type { InputTokenEstimate, InputTokenEstimator } from "./input-token-estimator";
-import type { MaterializedModelRequest } from "./model-client";
-import { IMAGE_INPUT_POLICY } from "../image/image-input-policy";
-
-export class MoonshotInputTokenEstimator implements InputTokenEstimator {
-  readonly kind = "moonshot-estimate-token-count-v1";
-  readonly compatibility: InputTokenEstimator["compatibility"];
-  private readonly endpoint: string;
-
-  constructor(
-    private readonly options: {
-      apiKey: string;
-      baseURL: string;
-      model: string;
-      timeoutMs: number;
-      fetch?: typeof fetch;
-      payloadMapper?: (payload: unknown) => unknown;
-    },
-  ) {
-    const base = new URL(
-      options.baseURL.endsWith("/") ? options.baseURL : `${options.baseURL}/`,
-    );
-    base.username = "";
-    base.password = "";
-    base.search = "";
-    base.hash = "";
-    const endpoint = new URL("tokenizers/estimate-token-count", base);
-    this.endpoint = endpoint.toString();
-    this.compatibility = Object.freeze({
-      kind: "moonshot-estimate-token-count-v1",
-      coverageVersion: "full-request-v1",
-      model: options.model,
-      endpoint: this.endpoint,
-      timeoutMs: options.timeoutMs,
-      maxRetries: 0,
-    });
-  }
-
-  async estimate(
-    request: MaterializedModelRequest,
-    options: { signal: AbortSignal },
-  ): Promise<InputTokenEstimate> {
-    const chatPayload = requireRecord(
-      this.options.payloadMapper?.(request.payload) ?? request.payload,
-      "materialized chat payload",
-    );
-    if (!Array.isArray(chatPayload.messages)) {
-      throw new Error("Materialized request has no token estimator messages.");
-    }
-    const payload = {
-      model: this.options.model,
-      messages: chatPayload.messages,
-      ...(Array.isArray(chatPayload.tools) ? { tools: chatPayload.tools } : {}),
-    };
-    const body = JSON.stringify(payload);
-    const bodyBytes = Buffer.byteLength(body, "utf8");
-    if (bodyBytes > IMAGE_INPUT_POLICY.maxRequestBodyBytes) {
-      throw new Error(
-        `Token estimate request is ${bodyBytes} bytes; maximum is ${IMAGE_INPUT_POLICY.maxRequestBodyBytes}.`,
-      );
-    }
-
-    const controller = new AbortController();
-    const timeout = setTimeout(
-      () => controller.abort(new Error("Token estimate timed out.")),
-      this.options.timeoutMs,
-    );
-    const onAbort = () => controller.abort(options.signal.reason);
-    options.signal.addEventListener("abort", onAbort, { once: true });
-    try {
-      options.signal.throwIfAborted();
-      const response = await (this.options.fetch ?? fetch)(this.endpoint, {
-        method: "POST",
-        headers: {
-          authorization: `Bearer ${this.options.apiKey}`,
-          "content-type": "application/json",
-        },
-        body,
-        signal: controller.signal,
-      });
-      if (!response.ok) {
-        throw new Error(`Token estimate endpoint returned HTTP ${response.status}.`);
-      }
-      const decoded: unknown = await response.json();
-      const root = requireRecord(decoded, "token estimate response");
-      if (root.error !== undefined && root.error !== null) {
-        throw new Error("Token estimate endpoint returned an error response.");
-      }
-      const data = requireRecord(root.data, "token estimate response data");
-      const inputTokens = data.total_tokens;
-      if (!Number.isSafeInteger(inputTokens) || (inputTokens as number) < 0) {
-        throw new Error("Token estimate response total_tokens is invalid.");
-      }
-      return Object.freeze({
-        inputTokens: inputTokens as number,
-        source: "provider_estimated",
-        coverage: "full_request",
-      });
-    } finally {
-      clearTimeout(timeout);
-      options.signal.removeEventListener("abort", onAbort);
-    }
-  }
-}
-
-function requireRecord(value: unknown, name: string): Record<string, unknown> {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new Error(`${name} must be an object.`);
-  }
-  return value as Record<string, unknown>;
-}

package/src/model/openai-responses-token-estimator.ts

@@ -1,155 +0,0 @@
-type ChatEstimatorToolCall = {
-  id: string;
-  type: "function";
-  function: {
-    name: string;
-    arguments: string;
-  };
-};
-
-type ChatEstimatorMessage = {
-  role: "system" | "user" | "assistant" | "tool";
-  content: unknown;
-  tool_calls?: ChatEstimatorToolCall[];
-  tool_call_id?: string;
-};
-
-export function responsesPayloadForChatTokenEstimator(
-  payload: unknown,
-): Record<string, unknown> {
-  const root = requireRecord(payload, "Responses token estimator payload");
-  if (!Array.isArray(root.input)) {
-    throw new Error("Responses token estimator payload input must be an array.");
-  }
-
-  const messages: ChatEstimatorMessage[] = [];
-  for (const [index, rawItem] of root.input.entries()) {
-    const path = `Responses token estimator input[${index}]`;
-    const item = requireRecord(rawItem, path);
-    const type = requireString(item.type, `${path}.type`);
-    if (type === "message") {
-      messages.push(toChatMessage(item, path));
-      continue;
-    }
-    if (type === "function_call") {
-      appendFunctionCall(messages, item, path);
-      continue;
-    }
-    if (type === "function_call_output") {
-      messages.push({
-        role: "tool",
-        tool_call_id: requireString(item.call_id, `${path}.call_id`),
-        content: requireString(item.output, `${path}.output`),
-      });
-      continue;
-    }
-    throw new Error(`${path}.type is unsupported: ${JSON.stringify(type)}.`);
-  }
-
-  return {
-    messages,
-    ...(root.tools === undefined ? {} : { tools: toChatTools(root.tools) }),
-  };
-}
-
-function toChatMessage(
-  item: Record<string, unknown>,
-  path: string,
-): ChatEstimatorMessage {
-  const role = requireString(item.role, `${path}.role`);
-  if (role !== "system" && role !== "user" && role !== "assistant") {
-    throw new Error(`${path}.role is unsupported: ${JSON.stringify(role)}.`);
-  }
-  return {
-    role,
-    content: toChatContent(item.content, `${path}.content`),
-  };
-}
-
-function toChatContent(value: unknown, path: string): unknown {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (!Array.isArray(value)) {
-    throw new Error(`${path} must be a string or an array.`);
-  }
-  return value.map((rawPart, index) => {
-    const partPath = `${path}[${index}]`;
-    const part = requireRecord(rawPart, partPath);
-    const type = requireString(part.type, `${partPath}.type`);
-    if (type === "input_text") {
-      return {
-        type: "text",
-        text: requireString(part.text, `${partPath}.text`),
-      };
-    }
-    if (type === "input_image") {
-      return {
-        type: "image_url",
-        image_url: {
-          url: requireString(part.image_url, `${partPath}.image_url`),
-          ...(part.detail === undefined
-            ? {}
-            : { detail: requireString(part.detail, `${partPath}.detail`) }),
-        },
-      };
-    }
-    throw new Error(`${partPath}.type is unsupported: ${JSON.stringify(type)}.`);
-  });
-}
-
-function appendFunctionCall(
-  messages: ChatEstimatorMessage[],
-  item: Record<string, unknown>,
-  path: string,
-): void {
-  const call: ChatEstimatorToolCall = {
-    id: requireString(item.call_id, `${path}.call_id`),
-    type: "function",
-    function: {
-      name: requireString(item.name, `${path}.name`),
-      arguments: requireString(item.arguments, `${path}.arguments`),
-    },
-  };
-  const previous = messages[messages.length - 1];
-  if (previous?.role === "assistant") {
-    (previous.tool_calls ??= []).push(call);
-    return;
-  }
-  messages.push({ role: "assistant", content: null, tool_calls: [call] });
-}
-
-function toChatTools(value: unknown): Record<string, unknown>[] {
-  if (!Array.isArray(value)) {
-    throw new Error("Responses token estimator payload tools must be an array.");
-  }
-  return value.map((rawTool, index) => {
-    const path = `Responses token estimator tools[${index}]`;
-    const tool = requireRecord(rawTool, path);
-    if (tool.type !== "function") {
-      throw new Error(`${path}.type must be "function".`);
-    }
-    return {
-      type: "function",
-      function: {
-        name: requireString(tool.name, `${path}.name`),
-        description: requireString(tool.description, `${path}.description`),
-        parameters: requireRecord(tool.parameters, `${path}.parameters`),
-      },
-    };
-  });
-}
-
-function requireRecord(value: unknown, path: string): Record<string, unknown> {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new Error(`${path} must be an object.`);
-  }
-  return value as Record<string, unknown>;
-}
-
-function requireString(value: unknown, path: string): string {
-  if (typeof value !== "string") {
-    throw new Error(`${path} must be a string.`);
-  }
-  return value;
-}