tinker-agent 1.8.0 → 1.10.1

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

@@ -6,6 +6,7 @@ import { IMAGE_INPUT_POLICY } from "../image/image-input-policy";
 import type { ImageAssetId, ImageAssetRef } from "../image/image-types";
 import type { InputTokenEstimator } from "./input-token-estimator";
 import type { ModelContextBudget } from "./model-context-profile";
+import type { ReasoningEffortController } from "./reasoning-effort";
 import type {
   MaterializedModelRequest,
   ModelClient,
@@ -24,6 +25,7 @@ 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",
     serializationVersion: "fake-v1",
@@ -38,6 +40,7 @@ export class FakeModelClient implements ModelClient {
       model: string;
       contextBudget: ModelContextBudget;
       inputModalities?: readonly ("text" | "image")[];
+      reasoningEffort?: ReasoningEffortController;
       requestLogPath?: string;
       tokenEstimator?: {
         kind: "moonshot-estimate-token-count-v1";
@@ -48,6 +51,7 @@ export class FakeModelClient implements ModelClient {
       };
     },
   ) {
+    this.reasoningEffort = options.reasoningEffort;
     this.inputModalities = Object.freeze([
       ...(options.inputModalities ?? (["text"] as const)),
     ]);
@@ -100,6 +104,7 @@ export class FakeModelClient implements ModelClient {
       (total, segment) => total + (segment.media?.length ?? 0),
       0,
     );
+    const reasoningEffort = this.reasoningEffort?.snapshot().effort;
     const requestConfigHash = sha256(
       stableJsonStringify({
         adapter: this.messageProtocol.adapter,
@@ -120,6 +125,7 @@ export class FakeModelClient implements ModelClient {
         messages: Object.freeze([...input.messages]),
         tools: Object.freeze([...input.tools]),
         maxTokens: this.options.contextBudget.requestMaxOutputTokens,
+        ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
       }),
       promptSegments: Object.freeze([...toolSegments, ...messageSegments]),
       requestConfigHash,
@@ -208,6 +214,9 @@ export class FakeModelClient implements ModelClient {
           mode: this.mode,
           model: this.options.model,
           prompt: lastUserMessage(input.messages),
+          ...(this.reasoningEffort === undefined
+            ? {}
+            : { reasoningEffort: this.reasoningEffort.snapshot().effort }),
           requestNumber: this.steps,
         })}\n`,
         "utf8",
@@ -956,7 +965,7 @@ export class FakeModelClient implements ModelClient {
     prepared: PreparedModelRequest,
     options: ModelRequestOptions,
   ): ModelRequestOutput {
-    requireTools(input, ["Read", "Recall"]);
+    requireTools(input, ["Read", "RecallSearch", "RecallGet"]);
     const prompt = lastUserMessage(input.messages);
     if (prompt === "PTY_CONTEXT_HEAVY") {
       const read = toolMessagesAfterLastUser(input.messages).find(
@@ -1156,7 +1165,8 @@ export class FakeModelClient implements ModelClient {
       .reverse()
       .find(
         (message): message is Extract<AgentMessage, { role: "tool" }> =>
-          message.role === "tool" && message.name === "Recall",
+          message.role === "tool" &&
+          (message.name === "RecallSearch" || message.name === "RecallGet"),
       );
     if (latestRecallResult === undefined) {
       return outputWithUsage(
@@ -1170,8 +1180,8 @@ export class FakeModelClient implements ModelClient {
                 1,
               ),
               providerToolCallId: "fake-recall-search-1",
-              name: "Recall",
-              args: { mode: "search", query: "recall-smoke-marker" },
+              name: "RecallSearch",
+              args: { query: "recall-smoke-marker" },
             },
           ],
         },
@@ -1183,7 +1193,7 @@ export class FakeModelClient implements ModelClient {
         /^source=(ctx:\/\/message\/[0-9a-f-]+)$/m,
       )?.[1];
       if (source === undefined) {
-        throw new Error("Fake Recall search did not return a source.");
+        throw new Error("Fake RecallSearch did not return a source.");
       }
       return outputWithUsage(
         prepared,
@@ -1196,8 +1206,8 @@ export class FakeModelClient implements ModelClient {
                 1,
               ),
               providerToolCallId: "fake-recall-get-1",
-              name: "Recall",
-              args: { mode: "get", source },
+              name: "RecallGet",
+              args: { source },
             },
           ],
         },
@@ -1205,13 +1215,13 @@ export class FakeModelClient implements ModelClient {
       );
     }
     if (!latestRecallResult.content.includes("recall-smoke-marker")) {
-      throw new Error("Fake Recall get did not recover the expected marker.");
+      throw new Error("Fake RecallGet did not recover the expected marker.");
     }
     return outputWithUsage(
       prepared,
       {
         role: "assistant",
-        content: "Recall search and get completed.",
+        content: "RecallSearch and RecallGet completed.",
       },
       "stop",
     );
@@ -1489,11 +1499,12 @@ function recallMarker(
   finalText: string,
 ): ModelRequestOutput {
   const latestRecallResult = toolMessagesAfterLastUser(input.messages)
-    .filter((message) => message.name === "Recall")
+    .filter(
+      (message) => message.name === "RecallSearch" || message.name === "RecallGet",
+    )
     .at(-1);
   if (latestRecallResult === undefined) {
-    return toolCallOutput(prepared, options, "Recall", {
-      mode: "search",
+    return toolCallOutput(prepared, options, "RecallSearch", {
       query: marker,
     });
   }
@@ -1502,15 +1513,14 @@ function recallMarker(
       /^source=(ctx:\/\/message\/[0-9a-f-]+)$/m,
     )?.[1];
     if (source === undefined) {
-      throw new Error("Fake PTY Recall search did not return a source.");
+      throw new Error("Fake PTY RecallSearch did not return a source.");
     }
-    return toolCallOutput(prepared, options, "Recall", {
-      mode: "get",
+    return toolCallOutput(prepared, options, "RecallGet", {
       source,
     });
   }
   if (!latestRecallResult.content.includes(marker)) {
-    throw new Error(`Fake PTY Recall get did not recover ${marker}.`);
+    throw new Error(`Fake PTY RecallGet did not recover ${marker}.`);
   }
   return textOutput(prepared, finalText);
 }

package/src/model/model-api.ts

@@ -0,0 +1,12 @@
+export const MODEL_APIS = ["chat-completions", "responses"] as const;
+
+export type ModelApi = (typeof MODEL_APIS)[number];
+
+export function parseModelApi(value: unknown, name: string): ModelApi {
+  if (value === "chat-completions" || value === "responses") {
+    return value;
+  }
+  throw new Error(
+    `${name} must be one of ${MODEL_APIS.map((api) => JSON.stringify(api)).join(", ")}.`,
+  );
+}

package/src/model/model-client.ts

@@ -4,11 +4,13 @@ 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;
   materialize?(
     prepared: PreparedModelRequest,
@@ -29,8 +31,14 @@ export class ModelRequestMediaAggregateError extends Error {
   }
 }
 
+export const MODEL_MESSAGE_PROTOCOL_ADAPTERS = [
+  "openai-chat",
+  "openai-responses",
+  "fake",
+] as const;
+
 export type ModelMessageProtocol = {
-  adapter: "openai-chat" | "fake";
+  adapter: (typeof MODEL_MESSAGE_PROTOCOL_ADAPTERS)[number];
   serializationVersion: string;
 };
 

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

@@ -14,6 +14,7 @@ export class MoonshotInputTokenEstimator implements InputTokenEstimator {
       model: string;
       timeoutMs: number;
       fetch?: typeof fetch;
+      payloadMapper?: (payload: unknown) => unknown;
     },
   ) {
     const base = new URL(
@@ -39,7 +40,10 @@ export class MoonshotInputTokenEstimator implements InputTokenEstimator {
     request: MaterializedModelRequest,
     options: { signal: AbortSignal },
   ): Promise<InputTokenEstimate> {
-    const chatPayload = requireRecord(request.payload, "materialized chat payload");
+    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.");
     }

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

@@ -19,17 +19,8 @@ import type {
   ChatCompletionContentPart,
   ChatCompletionTool,
 } from "openai/resources/chat/completions";
-import {
-  parseImageAssetId,
-  validateUserMessage,
-  type ImageAssetId,
-} from "../image/image-types";
-
-const IMAGE_ASSET_URL_MARKER = Symbol("tinker.image-asset-url-marker");
-
-export type ImageAssetUrlMarker = {
-  readonly [IMAGE_ASSET_URL_MARKER]: ImageAssetId;
-};
+import { validateUserMessage, type ImageAssetId } from "../image/image-types";
+import { imageAssetUrlMarker } from "./openai-image-mapping";
 
 type DeepSeekAssistantMessageParam = ChatCompletionAssistantMessageParam & {
   reasoning_content?: string | null;
@@ -108,19 +99,6 @@ export function toOpenAIUserContent(
   ];
 }
 
-export function imageAssetUrlMarker(assetId: ImageAssetId): ImageAssetUrlMarker {
-  parseImageAssetId(assetId);
-  return Object.freeze({ [IMAGE_ASSET_URL_MARKER]: assetId });
-}
-
-export function parseImageAssetUrlMarker(value: unknown): ImageAssetId | undefined {
-  if (typeof value !== "object" || value === null) {
-    return undefined;
-  }
-  const assetId = (value as Partial<ImageAssetUrlMarker>)[IMAGE_ASSET_URL_MARKER];
-  return typeof assetId === "string" ? parseImageAssetId(assetId) : undefined;
-}
-
 function requireMaterializedImage(
   materializedImages: ReadonlyMap<ImageAssetId, string>,
   assetId: ImageAssetId,

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

@@ -3,19 +3,14 @@ import type {
   ChatCompletionCreateParamsNonStreaming,
   ChatCompletionCreateParamsStreaming,
 } from "openai/resources/chat/completions";
-import type { AssistantMessage, UserMessage } from "../agent/types";
+import type { AssistantMessage } from "../agent/types";
 import {
   IMAGE_INPUT_POLICY,
   IMAGE_INPUT_POLICY_VERSION,
 } from "../image/image-input-policy";
-import type { ImageAssetId, ImageAssetRef } from "../image/image-types";
 import type { ModelContextBudget } from "./model-context-profile";
 import type { InputTokenEstimator } from "./input-token-estimator";
-import {
-  ModelRequestMediaAggregateError,
-  ProviderResponseError,
-  type ProviderResponseErrorCode,
-} from "./model-client";
+import { ProviderResponseError } from "./model-client";
 import type {
   MaterializedModelRequest,
   ModelClient,
@@ -24,18 +19,25 @@ import type {
   ModelRequestInput,
   ModelRequestOptions,
   ModelRequestOutput,
-  PreparedMediaDescriptor,
   PreparedModelRequest,
   PreparedPromptSegment,
 } from "./model-client";
 import {
   fromOpenAIChatCompletion,
-  parseImageAssetUrlMarker,
   toOpenAIChatMessages,
   toOpenAIChatTools,
 } from "./openai-chat-mapping";
 import { OpenAIChatCompletionStreamAccumulator } from "./openai-chat-stream";
+import {
+  deepFreeze,
+  imageUserSegment,
+  materializeOpenAIRequest,
+  normalizedEndpointPolicy,
+  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";
 
 const OPENAI_CHAT_SERIALIZATION_VERSION = "openai-chat-v2";
@@ -47,6 +49,7 @@ export class OpenAIChatModelClient implements ModelClient {
     serializationVersion: OPENAI_CHAT_SERIALIZATION_VERSION,
   });
   readonly inputTokenEstimator?: InputTokenEstimator;
+  readonly reasoningEffort?: ReasoningEffortController;
   private readonly client: OpenAI;
   private readonly preparedRequests = new WeakSet<object>();
   private readonly materializedRequests = new WeakSet<object>();
@@ -71,6 +74,7 @@ export class OpenAIChatModelClient implements ModelClient {
       };
       model: string;
       providerName?: string;
+      reasoningEffort?: ReasoningEffortController;
       stream?: boolean;
       timeoutMs?: number;
       fetch?: typeof fetch;
@@ -78,6 +82,7 @@ export class OpenAIChatModelClient implements ModelClient {
   ) {
     this.provider = options.providerName ?? "openai-compatible";
     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")) {
@@ -111,10 +116,12 @@ export class OpenAIChatModelClient implements ModelClient {
       includeReasoningContent: this.options.includeReasoningContent,
     });
     const tools = input.tools.length > 0 ? toOpenAIChatTools(input.tools) : undefined;
+    const reasoningEffort = this.reasoningEffort?.snapshot().effort;
     const payload = deepFreeze({
       model: this.options.model,
       messages,
       ...(tools === undefined ? {} : { tools, tool_choice: "auto" as const }),
+      ...(reasoningEffort === undefined ? {} : { reasoning_effort: reasoningEffort }),
       max_completion_tokens: this.options.contextBudget.requestMaxOutputTokens,
       ...(this.stream
         ? {
@@ -185,48 +192,10 @@ export class OpenAIChatModelClient implements ModelClient {
     options: ModelMaterializeOptions,
   ): Promise<MaterializedModelRequest> {
     this.assertPrepared(prepared);
-    options.signal.throwIfAborted();
-    if (prepared.mediaOccurrenceCount > IMAGE_INPUT_POLICY.maxImagesPerRequest) {
-      throw new ModelRequestMediaAggregateError(
-        `Model request has ${prepared.mediaOccurrenceCount} images; maximum is ${IMAGE_INPUT_POLICY.maxImagesPerRequest}.`,
-      );
-    }
     if (prepared.mediaOccurrenceCount > 0 && !this.inputModalities.includes("image")) {
       throw new Error("Current model profile does not support image input.");
     }
-
-    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>();
-    for (const asset of assets.values()) {
-      options.signal.throwIfAborted();
-      const bytes = await options.assetStore.readVerified(asset, {
-        signal: options.signal,
-      });
-      dataUrls.set(
-        asset.assetId,
-        `data:${asset.mimeType};base64,${bytes.toString("base64")}`,
-      );
-      await yieldToEventLoop();
-    }
-    options.signal.throwIfAborted();
-    const exactLengths = new Map(
-      [...dataUrls].map(([assetId, value]) => [assetId, value.length] as const),
-    );
-    const bodyBytes = exactJsonBodyBytes(prepared.payload, exactLengths);
-    assertBodyLimit(bodyBytes, prepared.mediaOccurrenceCount);
-    const payload = deepFreeze(materializePayload(prepared.payload, dataUrls));
-    const materialized = Object.freeze({ ...prepared, payload, bodyBytes });
+    const materialized = await materializeOpenAIRequest(prepared, options);
     this.materializedRequests.add(materialized);
     return materialized;
   }
@@ -330,249 +299,4 @@ export class OpenAIChatModelClient implements ModelClient {
   }
 }
 
-export function exactJsonBodyBytes(
-  value: unknown,
-  imageDataUrlLengths: ReadonlyMap<ImageAssetId, number>,
-): number {
-  const assetId = parseImageAssetUrlMarker(value);
-  if (assetId !== undefined) {
-    const length = imageDataUrlLengths.get(assetId);
-    if (!Number.isSafeInteger(length) || length === undefined || length < 1) {
-      throw new Error(
-        `Missing materialized length for image ${assetId.slice(0, 12)}….`,
-      );
-    }
-    return length + 2;
-  }
-  if (
-    value === null ||
-    typeof value === "string" ||
-    typeof value === "number" ||
-    typeof value === "boolean"
-  ) {
-    const serialized: unknown = JSON.stringify(value);
-    if (typeof serialized !== "string") {
-      throw new Error("JSON primitive did not serialize to a string.");
-    }
-    return Buffer.byteLength(serialized, "utf8");
-  }
-  if (Array.isArray(value)) {
-    const entries: readonly unknown[] = value;
-    return (
-      2 +
-      Math.max(0, entries.length - 1) +
-      entries.reduce<number>(
-        (total, entry) => total + exactJsonBodyBytes(entry, imageDataUrlLengths),
-        0,
-      )
-    );
-  }
-  if (typeof value !== "object" || value === undefined) {
-    throw new Error(`Cannot size non-JSON value of type ${typeof value}.`);
-  }
-  const entries = Object.entries(value as Record<string, unknown>).filter(
-    ([, entry]) => entry !== undefined,
-  );
-  return (
-    2 +
-    Math.max(0, entries.length - 1) +
-    entries.reduce(
-      (total, [key, entry]) =>
-        total +
-        Buffer.byteLength(JSON.stringify(key), "utf8") +
-        1 +
-        exactJsonBodyBytes(entry, imageDataUrlLengths),
-      0,
-    )
-  );
-}
-
-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,
-      }),
-  );
-  return Object.freeze({
-    kind: "user",
-    normalizedText: message.content,
-    media: Object.freeze(media),
-  });
-}
-
-function distinctPreparedAssets(
-  segments: readonly PreparedPromptSegment[],
-): Map<ImageAssetId, ImageAssetRef> {
-  const assets = new Map<ImageAssetId, ImageAssetRef>();
-  for (const segment of segments) {
-    for (const media of segment.media ?? []) {
-      const asset = Object.freeze({
-        assetId: media.assetId,
-        mimeType: media.mimeType,
-        byteLength: media.byteLength,
-        width: media.width,
-        height: media.height,
-      });
-      const existing = assets.get(media.assetId);
-      if (
-        existing !== undefined &&
-        stableJsonStringify(existing) !== stableJsonStringify(asset)
-      ) {
-        throw new Error(`Conflicting descriptors for image ${media.assetId}.`);
-      }
-      assets.set(media.assetId, asset);
-    }
-  }
-  return assets;
-}
-
-function materializePayload(
-  value: unknown,
-  dataUrls: ReadonlyMap<ImageAssetId, string>,
-): unknown {
-  const assetId = parseImageAssetUrlMarker(value);
-  if (assetId !== undefined) {
-    const dataUrl = dataUrls.get(assetId);
-    if (dataUrl === undefined) {
-      throw new Error(`Image ${assetId.slice(0, 12)}… was not materialized.`);
-    }
-    return dataUrl;
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => materializePayload(entry, dataUrls));
-  }
-  if (typeof value === "object" && value !== null) {
-    return Object.fromEntries(
-      Object.entries(value)
-        .filter(([, entry]) => entry !== undefined)
-        .map(([key, entry]) => [key, materializePayload(entry, dataUrls)]),
-    );
-  }
-  return value;
-}
-
-function countImageMarkers(value: unknown): number {
-  if (parseImageAssetUrlMarker(value) !== undefined) {
-    return 1;
-  }
-  if (Array.isArray(value)) {
-    const entries: readonly unknown[] = value;
-    return entries.reduce<number>(
-      (total, entry) => total + countImageMarkers(entry),
-      0,
-    );
-  }
-  if (typeof value === "object" && value !== null) {
-    return Object.values(value as Record<string, unknown>).reduce<number>(
-      (total, entry) => total + countImageMarkers(entry),
-      0,
-    );
-  }
-  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 {
-  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}.`,
-    );
-  }
-}
-
-function normalizedEndpointPolicy(baseURL: string | undefined): string {
-  const url = new URL(baseURL ?? "https://api.openai.com/v1");
-  url.username = "";
-  url.password = "";
-  url.search = "";
-  url.hash = "";
-  const pathname = url.pathname.replace(/\/+$/, "") || "/";
-  return `${url.protocol}//${url.host}${pathname}`;
-}
-
-function segmentKind(
-  role: ModelRequestInput["messages"][number]["role"],
-): PreparedPromptSegment["kind"] {
-  switch (role) {
-    case "system":
-      return "kernel";
-    case "user":
-      return "user";
-    case "assistant":
-      return "assistant";
-    case "tool":
-      return "tool";
-  }
-}
-
-function yieldToEventLoop(): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, 0));
-}
-
-function deepFreeze<T>(value: T): T {
-  if (typeof value !== "object" || value === null || Object.isFrozen(value)) {
-    return value;
-  }
-  for (const child of Object.values(value)) {
-    deepFreeze(child);
-  }
-  return Object.freeze(value);
-}
-
-function sanitizedProviderError(
-  error: unknown,
-  provider: string,
-  model: string,
-): ProviderResponseError {
-  const message = error instanceof Error ? error.message : String(error);
-  const sanitized = message
-    .replace(
-      /data:image\/(?:png|jpeg|webp);base64,[A-Za-z0-9+/=]+/gu,
-      "[redacted image data]",
-    )
-    .replace(/Bearer\s+[A-Za-z0-9._~+/-]+/giu, "Bearer [redacted]");
-  return new ProviderResponseError(
-    providerErrorCode(error),
-    sanitized,
-    { provider, model },
-    { cause: error },
-  );
-}
-
-function providerErrorCode(error: unknown): ProviderResponseErrorCode {
-  const status = providerErrorStatus(error);
-  if (status === 429) {
-    return "provider_rate_limited";
-  }
-  if (status === 500 || status === 502 || status === 503 || status === 504) {
-    return "provider_unavailable";
-  }
-  if (status === undefined && isProviderConnectionError(error)) {
-    return "provider_unavailable";
-  }
-  return "provider_request_error";
-}
-
-function providerErrorStatus(error: unknown): number | undefined {
-  if (typeof error !== "object" || error === null || !("status" in error)) {
-    return undefined;
-  }
-  const status = (error as { status?: unknown }).status;
-  return typeof status === "number" ? status : undefined;
-}
-
-function isProviderConnectionError(error: unknown): boolean {
-  // APIConnectionTimeoutError extends APIConnectionError in the SDK.
-  return error instanceof OpenAI.APIConnectionError;
-}
+export { exactJsonBodyBytes } from "./openai-model-utils";

package/src/model/openai-image-mapping.ts

@@ -0,0 +1,20 @@
+import { parseImageAssetId, type ImageAssetId } from "../image/image-types";
+
+const IMAGE_ASSET_URL_MARKER = Symbol("tinker.image-asset-url-marker");
+
+export type ImageAssetUrlMarker = {
+  readonly [IMAGE_ASSET_URL_MARKER]: ImageAssetId;
+};
+
+export function imageAssetUrlMarker(assetId: ImageAssetId): ImageAssetUrlMarker {
+  parseImageAssetId(assetId);
+  return Object.freeze({ [IMAGE_ASSET_URL_MARKER]: assetId });
+}
+
+export function parseImageAssetUrlMarker(value: unknown): ImageAssetId | undefined {
+  if (typeof value !== "object" || value === null) {
+    return undefined;
+  }
+  const assetId = (value as Partial<ImageAssetUrlMarker>)[IMAGE_ASSET_URL_MARKER];
+  return typeof assetId === "string" ? parseImageAssetId(assetId) : undefined;
+}