@ljoukov/llm 4.0.12 → 4.1.1

package/dist/index.cjs

@@ -34,6 +34,7 @@ __export(index_exports, {
   CODEX_APPLY_PATCH_FREEFORM_TOOL_DESCRIPTION: () => CODEX_APPLY_PATCH_FREEFORM_TOOL_DESCRIPTION,
   CODEX_APPLY_PATCH_JSON_TOOL_DESCRIPTION: () => CODEX_APPLY_PATCH_JSON_TOOL_DESCRIPTION,
   CODEX_APPLY_PATCH_LARK_GRAMMAR: () => CODEX_APPLY_PATCH_LARK_GRAMMAR,
+  DEFAULT_FILE_TTL_SECONDS: () => DEFAULT_FILE_TTL_SECONDS,
   FIREWORKS_DEFAULT_GLM_MODEL: () => FIREWORKS_DEFAULT_GLM_MODEL,
   FIREWORKS_DEFAULT_GPT_OSS_120B_MODEL: () => FIREWORKS_DEFAULT_GPT_OSS_120B_MODEL,
   FIREWORKS_DEFAULT_KIMI_MODEL: () => FIREWORKS_DEFAULT_KIMI_MODEL,
@@ -74,10 +75,12 @@ __export(index_exports, {
   createViewImageTool: () => createViewImageTool,
   createWriteFileTool: () => createWriteFileTool,
   customTool: () => customTool,
+  emptyFileUploadMetrics: () => emptyFileUploadMetrics,
   encodeChatGptAuthJson: () => encodeChatGptAuthJson,
   encodeChatGptAuthJsonB64: () => encodeChatGptAuthJsonB64,
   estimateCallCostUsd: () => estimateCallCostUsd,
   exchangeChatGptOauthCode: () => exchangeChatGptOauthCode,
+  files: () => files,
   generateImageInBatches: () => generateImageInBatches,
   generateImages: () => generateImages,
   generateJson: () => generateJson,
@@ -115,9 +118,10 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/llm.ts
-var import_node_buffer3 = require("buffer");
-var import_node_async_hooks2 = require("async_hooks");
-var import_node_crypto = require("crypto");
+var import_node_buffer4 = require("buffer");
+var import_node_async_hooks3 = require("async_hooks");
+var import_node_crypto2 = require("crypto");
+var import_node_path5 = __toESM(require("path"), 1);
 var import_genai2 = require("@google/genai");
 var import_zod_to_json_schema = require("@alcyone-labs/zod-to-json-schema");
 var import_zod3 = require("zod");
@@ -2357,6 +2361,14 @@ function normaliseConfigValue(value) {
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 }
+function resolveGeminiApiKey() {
+  loadLocalEnv();
+  const raw = process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
+  return normaliseConfigValue(raw);
+}
+function getGeminiBackend() {
+  return resolveGeminiApiKey() ? "api" : "vertex";
+}
 function configureGemini(options = {}) {
   const nextProjectId = normaliseConfigValue(options.projectId);
   const nextLocation = normaliseConfigValue(options.location);
@@ -2384,6 +2396,10 @@ function resolveLocation() {
 async function getGeminiClient() {
   if (!geminiClientState.clientPromise) {
     geminiClientState.clientPromise = Promise.resolve().then(() => {
+      const apiKey = resolveGeminiApiKey();
+      if (apiKey) {
+        return new import_genai.GoogleGenAI({ apiKey });
+      }
       const projectId = resolveProjectId();
       const location = resolveLocation();
       const googleAuthOptions = getGoogleAuthOptions(CLOUD_PLATFORM_SCOPE);
@@ -2658,7 +2674,7 @@ function getOpenAiFetch() {
     headersTimeout: timeoutMs
   });
   openAiClientState.cachedFetch = ((input, init) => {
-    return (0, import_undici2.fetch)(input, {
+    return fetch(input, {
       ...init ?? {},
       dispatcher
     });
@@ -3350,14 +3366,816 @@ function getCurrentAgentLoggingSession() {
   return loggingSessionStorage.getStore();
 }
 
+// src/files.ts
+var import_node_async_hooks2 = require("async_hooks");
+var import_node_buffer3 = require("buffer");
+var import_node_crypto = require("crypto");
+var import_node_fs3 = require("fs");
+var import_promises2 = require("fs/promises");
+var import_node_os3 = __toESM(require("os"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_node_stream = require("stream");
+var import_promises3 = require("stream/promises");
+var import_storage = require("@google-cloud/storage");
+var import_mime = __toESM(require("mime"), 1);
+var DEFAULT_FILE_TTL_SECONDS = 48 * 60 * 60;
+var OPENAI_FILE_CREATE_MAX_BYTES = 512 * 1024 * 1024;
+var OPENAI_UPLOAD_PART_MAX_BYTES = 64 * 1024 * 1024;
+var GEMINI_FILE_POLL_INTERVAL_MS = 1e3;
+var GEMINI_FILE_POLL_TIMEOUT_MS = 6e4;
+var FILES_TEMP_ROOT = import_node_path4.default.join(import_node_os3.default.tmpdir(), "ljoukov-llm-files");
+var FILES_CACHE_ROOT = import_node_path4.default.join(FILES_TEMP_ROOT, "cache");
+var FILES_CACHE_CONTENT_ROOT = import_node_path4.default.join(FILES_CACHE_ROOT, "content");
+var FILES_CACHE_METADATA_ROOT = import_node_path4.default.join(FILES_CACHE_ROOT, "metadata");
+var filesState = getRuntimeSingleton(/* @__PURE__ */ Symbol.for("@ljoukov/llm.filesState"), () => ({
+  metadataById: /* @__PURE__ */ new Map(),
+  openAiUploadCacheByKey: /* @__PURE__ */ new Map(),
+  materializedById: /* @__PURE__ */ new Map(),
+  geminiMirrorById: /* @__PURE__ */ new Map(),
+  vertexMirrorById: /* @__PURE__ */ new Map(),
+  storageClient: void 0,
+  geminiClientPromise: void 0
+}));
+var fileUploadScopeStorage = getRuntimeSingleton(
+  /* @__PURE__ */ Symbol.for("@ljoukov/llm.fileUploadScopeStorage"),
+  () => new import_node_async_hooks2.AsyncLocalStorage()
+);
+function summarizeUploadEvents(events) {
+  let totalBytes = 0;
+  let totalLatencyMs = 0;
+  for (const event of events) {
+    totalBytes += Math.max(0, event.bytes);
+    totalLatencyMs += Math.max(0, event.durationMs);
+  }
+  return {
+    count: events.length,
+    totalBytes,
+    totalLatencyMs,
+    events: Array.from(events)
+  };
+}
+function emptyFileUploadMetrics() {
+  return summarizeUploadEvents([]);
+}
+function getCurrentFileUploadMetrics() {
+  const collector = fileUploadScopeStorage.getStore()?.collectors.at(-1);
+  return summarizeUploadEvents(collector?.events ?? []);
+}
+async function collectFileUploadMetrics(fn) {
+  const parent = fileUploadScopeStorage.getStore();
+  const collector = { events: [] };
+  const scope = {
+    collectors: [...parent?.collectors ?? [], collector],
+    source: parent?.source
+  };
+  return await fileUploadScopeStorage.run(scope, async () => {
+    const result = await fn();
+    return {
+      result,
+      uploads: summarizeUploadEvents(collector.events)
+    };
+  });
+}
+async function runWithFileUploadSource(source, fn) {
+  const parent = fileUploadScopeStorage.getStore();
+  const scope = {
+    collectors: parent?.collectors ?? [],
+    source
+  };
+  return await fileUploadScopeStorage.run(scope, fn);
+}
+function formatUploadLogLine(event) {
+  const parts = [
+    "[upload]",
+    `source=${event.source}`,
+    `backend=${event.backend}`,
+    `mode=${event.mode}`,
+    `filename=${JSON.stringify(event.filename)}`,
+    `bytes=${event.bytes.toString()}`,
+    `durationMs=${event.durationMs.toString()}`
+  ];
+  if (event.mimeType) {
+    parts.push(`mimeType=${event.mimeType}`);
+  }
+  if (event.fileId) {
+    parts.push(`fileId=${event.fileId}`);
+  }
+  if (event.mirrorId) {
+    parts.push(`mirrorId=${event.mirrorId}`);
+  }
+  if (event.fileUri) {
+    parts.push(`fileUri=${JSON.stringify(event.fileUri)}`);
+  }
+  return parts.join(" ");
+}
+function recordUploadEvent(event) {
+  const scope = fileUploadScopeStorage.getStore();
+  const resolvedSource = event.source ?? scope?.source ?? (event.backend === "openai" ? "files_api" : "provider_mirror");
+  const timestampedEvent = {
+    ...event,
+    source: resolvedSource,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  for (const collector of scope?.collectors ?? []) {
+    collector.events.push(timestampedEvent);
+  }
+  getCurrentAgentLoggingSession()?.logLine(formatUploadLogLine(timestampedEvent));
+}
+function normaliseFilename(filename, fallback = "attachment.bin") {
+  const trimmed = filename?.trim();
+  if (!trimmed) {
+    return fallback;
+  }
+  const basename = import_node_path4.default.basename(trimmed);
+  return basename.length > 0 ? basename : fallback;
+}
+function resolveMimeType(filename, explicitMimeType, fallback = "application/octet-stream") {
+  const trimmed = explicitMimeType?.trim();
+  if (trimmed) {
+    return trimmed;
+  }
+  const inferred = import_mime.default.getType(filename);
+  return typeof inferred === "string" && inferred.length > 0 ? inferred : fallback;
+}
+function toBuffer(data) {
+  if (typeof data === "string") {
+    return import_node_buffer3.Buffer.from(data, "utf8");
+  }
+  if (ArrayBuffer.isView(data)) {
+    return import_node_buffer3.Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+  }
+  return import_node_buffer3.Buffer.from(data);
+}
+function computeSha256Hex(buffer) {
+  return (0, import_node_crypto.createHash)("sha256").update(buffer).digest("hex");
+}
+async function computeFileSha256Hex(filePath) {
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  const stream = (0, import_node_fs3.createReadStream)(filePath);
+  for await (const chunk of stream) {
+    hash.update(chunk);
+  }
+  return hash.digest("hex");
+}
+function toStoredFile(file) {
+  return {
+    id: file.id,
+    bytes: file.bytes,
+    created_at: file.created_at,
+    filename: file.filename,
+    object: "file",
+    purpose: file.purpose,
+    status: file.status,
+    expires_at: file.expires_at
+  };
+}
+function buildCacheKey(filename, mimeType, sha256Hex) {
+  return `${sha256Hex}\0${filename}\0${mimeType}`;
+}
+function buildCachedContentPath(sha256Hex) {
+  return import_node_path4.default.join(FILES_CACHE_CONTENT_ROOT, sha256Hex);
+}
+function buildCachedMetadataPath(fileId) {
+  return import_node_path4.default.join(FILES_CACHE_METADATA_ROOT, `${fileId}.json`);
+}
+function isFresh(file) {
+  if (!file.expires_at) {
+    return true;
+  }
+  return file.expires_at * 1e3 > Date.now() + 3e4;
+}
+function recordMetadata(metadata) {
+  filesState.metadataById.set(metadata.file.id, metadata);
+  if (metadata.sha256Hex) {
+    filesState.openAiUploadCacheByKey.set(
+      buildCacheKey(
+        metadata.filename,
+        metadata.mimeType ?? "application/octet-stream",
+        metadata.sha256Hex
+      ),
+      metadata
+    );
+  }
+  return metadata;
+}
+async function ensureFilesCacheReady() {
+  await (0, import_promises2.mkdir)(FILES_CACHE_CONTENT_ROOT, { recursive: true });
+  await (0, import_promises2.mkdir)(FILES_CACHE_METADATA_ROOT, { recursive: true });
+}
+async function cacheBufferLocally(bytes, sha256Hex) {
+  await ensureFilesCacheReady();
+  const localPath = buildCachedContentPath(sha256Hex);
+  try {
+    await (0, import_promises2.writeFile)(localPath, bytes, { flag: "wx" });
+  } catch (error) {
+    const code = error.code;
+    if (code !== "EEXIST") {
+      throw error;
+    }
+  }
+  return localPath;
+}
+async function cacheFileLocally(filePath, sha256Hex) {
+  await ensureFilesCacheReady();
+  const localPath = buildCachedContentPath(sha256Hex);
+  try {
+    await (0, import_promises2.copyFile)(filePath, localPath);
+  } catch (error) {
+    const code = error.code;
+    if (code !== "EEXIST") {
+      throw error;
+    }
+  }
+  return localPath;
+}
+async function persistMetadataToDisk(metadata) {
+  await ensureFilesCacheReady();
+  const payload = {
+    file: metadata.file,
+    filename: metadata.filename,
+    bytes: metadata.bytes,
+    mimeType: metadata.mimeType,
+    sha256Hex: metadata.sha256Hex,
+    localPath: metadata.localPath
+  };
+  await (0, import_promises2.writeFile)(
+    buildCachedMetadataPath(metadata.file.id),
+    `${JSON.stringify(payload, null, 2)}
+`
+  );
+}
+async function loadPersistedMetadata(fileId) {
+  try {
+    const payload = JSON.parse(
+      await (0, import_promises2.readFile)(buildCachedMetadataPath(fileId), "utf8")
+    );
+    if (!payload || typeof payload !== "object" || !payload.file) {
+      return void 0;
+    }
+    if (payload.localPath) {
+      try {
+        const localStats = await (0, import_promises2.stat)(payload.localPath);
+        if (!localStats.isFile()) {
+          return void 0;
+        }
+      } catch {
+        return void 0;
+      }
+    }
+    return recordMetadata({
+      file: payload.file,
+      filename: payload.filename,
+      bytes: payload.bytes,
+      mimeType: payload.mimeType,
+      sha256Hex: payload.sha256Hex,
+      localPath: payload.localPath
+    });
+  } catch {
+    return void 0;
+  }
+}
+async function uploadOpenAiFileFromBytes(params) {
+  const cacheKey = buildCacheKey(params.filename, params.mimeType, params.sha256Hex);
+  const cached = filesState.openAiUploadCacheByKey.get(cacheKey);
+  if (cached && isFresh(cached.file)) {
+    return cached;
+  }
+  const client = getOpenAiClient();
+  const startedAtMs = Date.now();
+  let uploaded;
+  let mode;
+  if (params.bytes.byteLength <= OPENAI_FILE_CREATE_MAX_BYTES) {
+    mode = "files.create";
+    uploaded = await client.files.create({
+      file: new import_node_buffer3.File([new Uint8Array(params.bytes)], params.filename, {
+        type: params.mimeType
+      }),
+      purpose: params.purpose,
+      expires_after: {
+        anchor: "created_at",
+        seconds: params.expiresAfterSeconds
+      }
+    });
+  } else {
+    mode = "uploads";
+    const upload = await client.uploads.create({
+      bytes: params.bytes.byteLength,
+      filename: params.filename,
+      mime_type: params.mimeType,
+      purpose: params.purpose
+    });
+    const partIds = [];
+    for (let offset = 0; offset < params.bytes.byteLength; offset += OPENAI_UPLOAD_PART_MAX_BYTES) {
+      const chunk = params.bytes.subarray(
+        offset,
+        Math.min(offset + OPENAI_UPLOAD_PART_MAX_BYTES, params.bytes.byteLength)
+      );
+      const uploadPart = await client.uploads.parts.create(upload.id, {
+        data: new import_node_buffer3.File([new Uint8Array(chunk)], `${params.sha256Hex}.part`, {
+          type: params.mimeType
+        })
+      });
+      partIds.push(uploadPart.id);
+    }
+    const completed = await client.uploads.complete(upload.id, { part_ids: partIds });
+    const fileId = completed.file?.id;
+    if (!fileId) {
+      throw new Error("OpenAI upload completed without a file id.");
+    }
+    uploaded = await client.files.retrieve(fileId);
+  }
+  const file = toStoredFile(uploaded);
+  const metadata = recordMetadata({
+    file,
+    filename: file.filename,
+    bytes: file.bytes,
+    mimeType: params.mimeType,
+    sha256Hex: params.sha256Hex
+  });
+  recordUploadEvent({
+    backend: "openai",
+    mode,
+    filename: metadata.filename,
+    bytes: metadata.bytes,
+    durationMs: Math.max(0, Date.now() - startedAtMs),
+    mimeType: params.mimeType,
+    fileId: metadata.file.id
+  });
+  return metadata;
+}
+async function uploadOpenAiFileFromPath(params) {
+  const cacheKey = buildCacheKey(params.filename, params.mimeType, params.sha256Hex);
+  const cached = filesState.openAiUploadCacheByKey.get(cacheKey);
+  if (cached && isFresh(cached.file)) {
+    return cached;
+  }
+  const client = getOpenAiClient();
+  const startedAtMs = Date.now();
+  let uploaded;
+  let mode;
+  if (params.bytes <= OPENAI_FILE_CREATE_MAX_BYTES) {
+    mode = "files.create";
+    const blob = await (0, import_node_fs3.openAsBlob)(params.filePath, { type: params.mimeType });
+    uploaded = await client.files.create({
+      file: new import_node_buffer3.File([blob], params.filename, { type: params.mimeType }),
+      purpose: params.purpose,
+      expires_after: {
+        anchor: "created_at",
+        seconds: params.expiresAfterSeconds
+      }
+    });
+  } else {
+    mode = "uploads";
+    const upload = await client.uploads.create({
+      bytes: params.bytes,
+      filename: params.filename,
+      mime_type: params.mimeType,
+      purpose: params.purpose
+    });
+    const partIds = [];
+    const stream = (0, import_node_fs3.createReadStream)(params.filePath, {
+      highWaterMark: OPENAI_UPLOAD_PART_MAX_BYTES
+    });
+    let partIndex = 0;
+    for await (const chunk of stream) {
+      const buffer = import_node_buffer3.Buffer.isBuffer(chunk) ? chunk : import_node_buffer3.Buffer.from(chunk);
+      const uploadPart = await client.uploads.parts.create(upload.id, {
+        data: new import_node_buffer3.File(
+          [new Uint8Array(buffer)],
+          `${params.sha256Hex}.${partIndex.toString()}.part`,
+          {
+            type: params.mimeType
+          }
+        )
+      });
+      partIds.push(uploadPart.id);
+      partIndex += 1;
+    }
+    const completed = await client.uploads.complete(upload.id, { part_ids: partIds });
+    const fileId = completed.file?.id;
+    if (!fileId) {
+      throw new Error("OpenAI upload completed without a file id.");
+    }
+    uploaded = await client.files.retrieve(fileId);
+  }
+  const file = toStoredFile(uploaded);
+  const metadata = recordMetadata({
+    file,
+    filename: file.filename,
+    bytes: file.bytes,
+    mimeType: params.mimeType,
+    sha256Hex: params.sha256Hex
+  });
+  recordUploadEvent({
+    backend: "openai",
+    mode,
+    filename: metadata.filename,
+    bytes: metadata.bytes,
+    durationMs: Math.max(0, Date.now() - startedAtMs),
+    mimeType: params.mimeType,
+    fileId: metadata.file.id
+  });
+  return metadata;
+}
+async function retrieveOpenAiFile(fileId) {
+  const cached = filesState.metadataById.get(fileId);
+  if (cached && isFresh(cached.file)) {
+    return cached;
+  }
+  const persisted = await loadPersistedMetadata(fileId);
+  if (persisted && isFresh(persisted.file)) {
+    return persisted;
+  }
+  const client = getOpenAiClient();
+  const retrieved = await client.files.retrieve(fileId);
+  const file = toStoredFile(retrieved);
+  const metadata = recordMetadata({
+    file,
+    filename: file.filename,
+    bytes: file.bytes,
+    mimeType: cached?.mimeType ?? persisted?.mimeType ?? resolveMimeType(file.filename, void 0),
+    sha256Hex: cached?.sha256Hex ?? persisted?.sha256Hex,
+    localPath: cached?.localPath ?? persisted?.localPath
+  });
+  await persistMetadataToDisk(metadata);
+  return metadata;
+}
+function buildGeminiMirrorName(sha256Hex) {
+  return `files/${sha256Hex.slice(0, 40)}`;
+}
+async function waitForGeminiFileActive(client, name) {
+  const startedAt = Date.now();
+  while (true) {
+    const file = await client.files.get({ name });
+    if (!file.state || file.state === "ACTIVE") {
+      return;
+    }
+    if (file.state === "FAILED") {
+      throw new Error(file.error?.message ?? `Gemini file ${name} failed processing.`);
+    }
+    if (Date.now() - startedAt >= GEMINI_FILE_POLL_TIMEOUT_MS) {
+      throw new Error(`Timed out waiting for Gemini file ${name} to become active.`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, GEMINI_FILE_POLL_INTERVAL_MS));
+  }
+}
+function resolveVertexMirrorBucket() {
+  const raw = process.env.VERTEX_GCS_BUCKET ?? process.env.LLM_VERTEX_GCS_BUCKET;
+  const trimmed = raw?.trim();
+  if (!trimmed) {
+    throw new Error(
+      "VERTEX_GCS_BUCKET must be set to use OpenAI-backed file ids with Vertex Gemini models."
+    );
+  }
+  return trimmed.replace(/^gs:\/\//u, "").replace(/\/+$/u, "");
+}
+function resolveVertexMirrorPrefix() {
+  const raw = process.env.VERTEX_GCS_PREFIX ?? process.env.LLM_VERTEX_GCS_PREFIX;
+  const trimmed = raw?.trim().replace(/^\/+/u, "").replace(/\/+$/u, "");
+  return trimmed ? `${trimmed}/` : "";
+}
+function getStorageClient() {
+  if (filesState.storageClient) {
+    return filesState.storageClient;
+  }
+  const serviceAccount = getGoogleServiceAccount();
+  filesState.storageClient = new import_storage.Storage({
+    projectId: serviceAccount.projectId,
+    credentials: {
+      client_email: serviceAccount.clientEmail,
+      private_key: serviceAccount.privateKey
+    }
+  });
+  return filesState.storageClient;
+}
+function getGeminiMirrorClient() {
+  if (!filesState.geminiClientPromise) {
+    filesState.geminiClientPromise = getGeminiClient();
+  }
+  return filesState.geminiClientPromise;
+}
+async function materializeOpenAiFile(fileId) {
+  const cachedPromise = filesState.materializedById.get(fileId);
+  if (cachedPromise) {
+    return await cachedPromise;
+  }
+  const promise = (async () => {
+    const metadata = await retrieveOpenAiFile(fileId);
+    if (metadata.localPath && metadata.sha256Hex && metadata.mimeType) {
+      return {
+        file: metadata.file,
+        filename: metadata.filename,
+        bytes: metadata.bytes,
+        mimeType: metadata.mimeType,
+        sha256Hex: metadata.sha256Hex,
+        localPath: metadata.localPath
+      };
+    }
+    await (0, import_promises2.mkdir)(FILES_TEMP_ROOT, { recursive: true });
+    const tempDir = await (0, import_promises2.mkdtemp)(
+      import_node_path4.default.join(FILES_TEMP_ROOT, `${fileId.replace(/[^a-z0-9_-]/giu, "")}-`)
+    );
+    const localPath = import_node_path4.default.join(tempDir, normaliseFilename(metadata.filename, `${fileId}.bin`));
+    const response = await getOpenAiClient().files.content(fileId);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to download OpenAI file ${fileId}: ${response.status} ${response.statusText}`
+      );
+    }
+    const responseMimeType = response.headers.get("content-type")?.trim() || void 0;
+    const mimeType = resolveMimeType(metadata.filename, responseMimeType);
+    const hash = (0, import_node_crypto.createHash)("sha256");
+    let bytes = 0;
+    if (response.body) {
+      const source = import_node_stream.Readable.fromWeb(response.body);
+      const writable = (0, import_node_fs3.createWriteStream)(localPath, { flags: "wx" });
+      source.on("data", (chunk) => {
+        const buffer = import_node_buffer3.Buffer.isBuffer(chunk) ? chunk : import_node_buffer3.Buffer.from(chunk);
+        hash.update(buffer);
+        bytes += buffer.byteLength;
+      });
+      await (0, import_promises3.pipeline)(source, writable);
+    } else {
+      const buffer = import_node_buffer3.Buffer.from(await response.arrayBuffer());
+      hash.update(buffer);
+      bytes = buffer.byteLength;
+      await (0, import_promises2.writeFile)(localPath, buffer);
+    }
+    const sha256Hex = hash.digest("hex");
+    const updated = recordMetadata({
+      file: metadata.file,
+      filename: metadata.filename,
+      bytes: bytes || metadata.bytes,
+      mimeType,
+      sha256Hex,
+      localPath
+    });
+    await persistMetadataToDisk(updated);
+    return {
+      file: updated.file,
+      filename: updated.filename,
+      bytes: updated.bytes,
+      mimeType: updated.mimeType ?? mimeType,
+      sha256Hex,
+      localPath
+    };
+  })();
+  filesState.materializedById.set(fileId, promise);
+  try {
+    return await promise;
+  } catch (error) {
+    filesState.materializedById.delete(fileId);
+    throw error;
+  }
+}
+async function ensureGeminiFileMirror(fileId) {
+  const cached = filesState.geminiMirrorById.get(fileId);
+  if (cached) {
+    return cached;
+  }
+  const materialized = await materializeOpenAiFile(fileId);
+  const client = await getGeminiMirrorClient();
+  const name = buildGeminiMirrorName(materialized.sha256Hex);
+  try {
+    const existing = await client.files.get({ name });
+    if (existing.name && existing.uri && existing.mimeType) {
+      const mirror2 = {
+        openAiFileId: fileId,
+        name: existing.name,
+        uri: existing.uri,
+        mimeType: existing.mimeType,
+        displayName: existing.displayName ?? materialized.filename
+      };
+      filesState.geminiMirrorById.set(fileId, mirror2);
+      return mirror2;
+    }
+  } catch {
+  }
+  const startedAtMs = Date.now();
+  const uploaded = await client.files.upload({
+    file: materialized.localPath,
+    config: {
+      name,
+      mimeType: materialized.mimeType,
+      displayName: materialized.filename
+    }
+  });
+  if (uploaded.name && uploaded.state && uploaded.state !== "ACTIVE") {
+    await waitForGeminiFileActive(client, uploaded.name);
+  }
+  const resolved = await client.files.get({ name: uploaded.name ?? name });
+  if (!resolved.name || !resolved.uri || !resolved.mimeType) {
+    throw new Error("Gemini file upload completed without a usable URI.");
+  }
+  const mirror = {
+    openAiFileId: fileId,
+    name: resolved.name,
+    uri: resolved.uri,
+    mimeType: resolved.mimeType,
+    displayName: resolved.displayName ?? materialized.filename
+  };
+  filesState.geminiMirrorById.set(fileId, mirror);
+  recordUploadEvent({
+    backend: "gemini",
+    mode: "mirror",
+    filename: materialized.filename,
+    bytes: materialized.bytes,
+    durationMs: Math.max(0, Date.now() - startedAtMs),
+    mimeType: materialized.mimeType,
+    fileId,
+    mirrorId: mirror.name,
+    fileUri: mirror.uri
+  });
+  return mirror;
+}
+async function ensureVertexFileMirror(fileId) {
+  const cached = filesState.vertexMirrorById.get(fileId);
+  if (cached) {
+    return cached;
+  }
+  const materialized = await materializeOpenAiFile(fileId);
+  const bucketName = resolveVertexMirrorBucket();
+  const prefix = resolveVertexMirrorPrefix();
+  const extension = import_mime.default.getExtension(materialized.mimeType) ?? import_node_path4.default.extname(materialized.filename).replace(/^\./u, "") ?? "bin";
+  const objectName = `${prefix}${materialized.sha256Hex}.${extension}`;
+  const file = getStorageClient().bucket(bucketName).file(objectName);
+  let uploaded = false;
+  const startedAtMs = Date.now();
+  try {
+    await file.getMetadata();
+  } catch (error) {
+    const code = error.code;
+    if (code !== 404 && code !== "404") {
+      throw error;
+    }
+    try {
+      await (0, import_promises3.pipeline)(
+        (0, import_node_fs3.createReadStream)(materialized.localPath),
+        file.createWriteStream({
+          resumable: materialized.bytes >= 10 * 1024 * 1024,
+          preconditionOpts: { ifGenerationMatch: 0 },
+          metadata: {
+            contentType: materialized.mimeType,
+            customTime: (/* @__PURE__ */ new Date()).toISOString(),
+            metadata: {
+              filename: materialized.filename,
+              sha256: materialized.sha256Hex,
+              expiresAt: new Date(Date.now() + DEFAULT_FILE_TTL_SECONDS * 1e3).toISOString()
+            }
+          }
+        })
+      );
+      uploaded = true;
+    } catch (uploadError) {
+      const uploadCode = uploadError.code;
+      if (uploadCode !== 412 && uploadCode !== "412") {
+        throw uploadError;
+      }
+    }
+  }
+  const mirror = {
+    openAiFileId: fileId,
+    bucket: bucketName,
+    objectName,
+    fileUri: `gs://${bucketName}/${objectName}`,
+    mimeType: materialized.mimeType
+  };
+  filesState.vertexMirrorById.set(fileId, mirror);
+  if (uploaded) {
+    recordUploadEvent({
+      backend: "vertex",
+      mode: "mirror",
+      filename: materialized.filename,
+      bytes: materialized.bytes,
+      durationMs: Math.max(0, Date.now() - startedAtMs),
+      mimeType: materialized.mimeType,
+      fileId,
+      mirrorId: mirror.objectName,
+      fileUri: mirror.fileUri
+    });
+  }
+  return mirror;
+}
+async function filesCreate(params) {
+  const purpose = params.purpose ?? "user_data";
+  const expiresAfterSeconds = params.expiresAfterSeconds ?? DEFAULT_FILE_TTL_SECONDS;
+  if ("path" in params) {
+    const filePath = import_node_path4.default.resolve(params.path);
+    const info = await (0, import_promises2.stat)(filePath);
+    const filename2 = normaliseFilename(params.filename, import_node_path4.default.basename(filePath));
+    const mimeType2 = resolveMimeType(filename2, params.mimeType);
+    const sha256Hex2 = await computeFileSha256Hex(filePath);
+    const uploaded2 = await uploadOpenAiFileFromPath({
+      filePath,
+      filename: filename2,
+      mimeType: mimeType2,
+      purpose,
+      expiresAfterSeconds,
+      sha256Hex: sha256Hex2,
+      bytes: info.size
+    });
+    const localPath2 = await cacheFileLocally(filePath, sha256Hex2);
+    const cached2 = recordMetadata({
+      ...uploaded2,
+      localPath: localPath2
+    });
+    await persistMetadataToDisk(cached2);
+    return cached2.file;
+  }
+  const filename = normaliseFilename(params.filename);
+  const bytes = toBuffer(params.data);
+  const mimeType = resolveMimeType(filename, params.mimeType, "text/plain");
+  const sha256Hex = computeSha256Hex(bytes);
+  const uploaded = await uploadOpenAiFileFromBytes({
+    bytes,
+    filename,
+    mimeType,
+    purpose,
+    expiresAfterSeconds,
+    sha256Hex
+  });
+  const localPath = await cacheBufferLocally(bytes, sha256Hex);
+  const cached = recordMetadata({
+    ...uploaded,
+    localPath
+  });
+  await persistMetadataToDisk(cached);
+  return cached.file;
+}
+async function filesRetrieve(fileId) {
+  return (await retrieveOpenAiFile(fileId)).file;
+}
+async function filesDelete(fileId) {
+  const cachedGemini = filesState.geminiMirrorById.get(fileId);
+  if (cachedGemini) {
+    try {
+      const client = await getGeminiMirrorClient();
+      await client.files.delete({ name: cachedGemini.name });
+    } catch {
+    }
+    filesState.geminiMirrorById.delete(fileId);
+  }
+  const cachedVertex = filesState.vertexMirrorById.get(fileId);
+  if (cachedVertex) {
+    try {
+      await getStorageClient().bucket(cachedVertex.bucket).file(cachedVertex.objectName).delete({ ignoreNotFound: true });
+    } catch {
+    }
+    filesState.vertexMirrorById.delete(fileId);
+  }
+  const cachedMaterialized = filesState.metadataById.get(fileId)?.localPath;
+  if (cachedMaterialized) {
+    try {
+      await (0, import_promises2.unlink)(cachedMaterialized);
+    } catch {
+    }
+  }
+  const response = await getOpenAiClient().files.delete(fileId);
+  filesState.metadataById.delete(fileId);
+  filesState.materializedById.delete(fileId);
+  try {
+    await (0, import_promises2.unlink)(buildCachedMetadataPath(fileId));
+  } catch {
+  }
+  return {
+    id: response.id,
+    deleted: response.deleted,
+    object: "file"
+  };
+}
+async function filesContent(fileId) {
+  return await getOpenAiClient().files.content(fileId);
+}
+async function getCanonicalFileMetadata(fileId) {
+  const metadata = await retrieveOpenAiFile(fileId);
+  const mimeType = metadata.mimeType ?? resolveMimeType(metadata.filename, void 0);
+  const updated = metadata.mimeType === mimeType ? metadata : recordMetadata({
+    ...metadata,
+    mimeType
+  });
+  return {
+    ...updated,
+    mimeType
+  };
+}
+var files = {
+  create: filesCreate,
+  retrieve: filesRetrieve,
+  delete: filesDelete,
+  content: filesContent
+};
+
 // src/llm.ts
 var toolCallContextStorage = getRuntimeSingleton(
   /* @__PURE__ */ Symbol.for("@ljoukov/llm.toolCallContextStorage"),
-  () => new import_node_async_hooks2.AsyncLocalStorage()
+  () => new import_node_async_hooks3.AsyncLocalStorage()
 );
 function getCurrentToolCallContext() {
   return toolCallContextStorage.getStore() ?? null;
 }
+var INLINE_ATTACHMENT_FILENAME_SYMBOL = /* @__PURE__ */ Symbol.for("@ljoukov/llm.inlineAttachmentFilename");
+var INLINE_ATTACHMENT_PROMPT_THRESHOLD_BYTES = 20 * 1024 * 1024;
+var TOOL_OUTPUT_SPILL_THRESHOLD_BYTES = 1 * 1024 * 1024;
 var LLM_TEXT_MODEL_IDS = [
   ...OPENAI_MODEL_IDS,
   ...CHATGPT_MODEL_IDS,
@@ -3635,27 +4453,90 @@ function isJsonSchemaObject(schema) {
   }
   return false;
 }
-function sanitisePartForLogging(part) {
+var CANONICAL_GEMINI_FILE_URI_PREFIX = "openai://file/";
+function buildCanonicalGeminiFileUri(fileId) {
+  return `${CANONICAL_GEMINI_FILE_URI_PREFIX}${fileId}`;
+}
+function parseCanonicalGeminiFileId(fileUri) {
+  if (!fileUri?.startsWith(CANONICAL_GEMINI_FILE_URI_PREFIX)) {
+    return void 0;
+  }
+  const fileId = fileUri.slice(CANONICAL_GEMINI_FILE_URI_PREFIX.length).trim();
+  return fileId.length > 0 ? fileId : void 0;
+}
+function cloneContentPart(part) {
   switch (part.type) {
     case "text":
       return {
         type: "text",
-        thought: part.thought === true ? true : void 0,
-        preview: part.text.slice(0, 200)
+        text: part.text,
+        thought: part.thought === true ? true : void 0
       };
-    case "inlineData": {
-      let omittedBytes;
-      try {
-        omittedBytes = import_node_buffer3.Buffer.from(part.data, "base64").byteLength;
-      } catch {
-        omittedBytes = import_node_buffer3.Buffer.byteLength(part.data, "utf8");
-      }
+    case "inlineData":
       return {
         type: "inlineData",
+        data: part.data,
         mimeType: part.mimeType,
-        data: `[omitted:${omittedBytes}b]`
+        filename: part.filename
+      };
+    case "input_image":
+      return {
+        type: "input_image",
+        image_url: part.image_url ?? void 0,
+        file_id: part.file_id ?? void 0,
+        detail: part.detail,
+        filename: part.filename ?? void 0
+      };
+    case "input_file":
+      return {
+        type: "input_file",
+        file_data: part.file_data ?? void 0,
+        file_id: part.file_id ?? void 0,
+        file_url: part.file_url ?? void 0,
+        filename: part.filename ?? void 0
+      };
+    default:
+      return part;
+  }
+}
+function sanitisePartForLogging(part) {
+  switch (part.type) {
+    case "text":
+      return {
+        type: "text",
+        thought: part.thought === true ? true : void 0,
+        preview: part.text.slice(0, 200)
+      };
+    case "inlineData": {
+      let omittedBytes;
+      try {
+        omittedBytes = import_node_buffer4.Buffer.from(part.data, "base64").byteLength;
+      } catch {
+        omittedBytes = import_node_buffer4.Buffer.byteLength(part.data, "utf8");
+      }
+      return {
+        type: "inlineData",
+        mimeType: part.mimeType,
+        filename: part.filename,
+        data: `[omitted:${omittedBytes}b]`
+      };
+    }
+    case "input_image":
+      return {
+        type: "input_image",
+        file_id: part.file_id ?? void 0,
+        filename: part.filename ?? void 0,
+        detail: part.detail ?? void 0,
+        image_url: typeof part.image_url === "string" ? part.image_url.startsWith("data:") ? "[omitted:data-url]" : part.image_url : void 0
+      };
+    case "input_file":
+      return {
+        type: "input_file",
+        file_id: part.file_id ?? void 0,
+        filename: part.filename ?? void 0,
+        file_url: typeof part.file_url === "string" ? part.file_url.startsWith("data:") ? "[omitted:data-url]" : part.file_url : void 0,
+        file_data: typeof part.file_data === "string" ? `[omitted:${import_node_buffer4.Buffer.byteLength(part.file_data, "utf8")}b]` : void 0
       };
-    }
     default:
       return "[unknown part]";
   }
@@ -3676,12 +4557,17 @@ function convertGooglePartsToLlmParts(parts) {
       result.push({
         type: "inlineData",
         data: inline.data,
-        mimeType: inline.mimeType
+        mimeType: inline.mimeType,
+        filename: inline.displayName
       });
       continue;
     }
     if (part.fileData?.fileUri) {
-      throw new Error("fileData parts are not supported");
+      result.push({
+        type: "input_file",
+        file_url: part.fileData.fileUri,
+        filename: part.fileData.displayName
+      });
     }
   }
   return result;
@@ -3713,13 +4599,82 @@ function toGeminiPart(part) {
         text: part.text,
         thought: part.thought === true ? true : void 0
       };
-    case "inlineData":
+    case "inlineData": {
+      const inlineData = {
+        data: part.data,
+        mimeType: part.mimeType
+      };
+      setInlineAttachmentFilename(inlineData, part.filename);
       return {
         inlineData: {
-          data: part.data,
-          mimeType: part.mimeType
+          ...inlineData
+        }
+      };
+    }
+    case "input_image": {
+      if (part.file_id) {
+        return {
+          fileData: {
+            fileUri: buildCanonicalGeminiFileUri(part.file_id),
+            mimeType: inferToolOutputMimeTypeFromFilename(part.filename) ?? "application/octet-stream"
+          }
+        };
+      }
+      if (typeof part.image_url !== "string" || part.image_url.trim().length === 0) {
+        throw new Error("input_image requires image_url or file_id.");
+      }
+      const parsed = parseDataUrlPayload(part.image_url);
+      if (parsed) {
+        const geminiPart = (0, import_genai2.createPartFromBase64)(parsed.dataBase64, parsed.mimeType);
+        if (part.filename && geminiPart.inlineData) {
+          geminiPart.inlineData.displayName = part.filename;
+        }
+        return geminiPart;
+      }
+      return {
+        fileData: {
+          fileUri: part.image_url,
+          mimeType: inferToolOutputMimeTypeFromFilename(part.filename) ?? "application/octet-stream"
         }
       };
+    }
+    case "input_file": {
+      if (part.file_id) {
+        return {
+          fileData: {
+            fileUri: buildCanonicalGeminiFileUri(part.file_id),
+            mimeType: inferToolOutputMimeTypeFromFilename(part.filename) ?? "application/octet-stream"
+          }
+        };
+      }
+      if (typeof part.file_data === "string" && part.file_data.trim().length > 0) {
+        const geminiPart = (0, import_genai2.createPartFromBase64)(
+          part.file_data,
+          inferToolOutputMimeTypeFromFilename(part.filename) ?? "application/octet-stream"
+        );
+        if (part.filename && geminiPart.inlineData) {
+          geminiPart.inlineData.displayName = part.filename;
+        }
+        return geminiPart;
+      }
+      if (typeof part.file_url === "string" && part.file_url.trim().length > 0) {
+        const parsed = parseDataUrlPayload(part.file_url);
+        if (parsed) {
+          const geminiPart = (0, import_genai2.createPartFromBase64)(parsed.dataBase64, parsed.mimeType);
+          if (part.filename && geminiPart.inlineData) {
+            geminiPart.inlineData.displayName = part.filename;
+          }
+          return geminiPart;
+        }
+        return {
+          fileData: {
+            fileUri: part.file_url,
+            mimeType: inferToolOutputMimeTypeFromFilename(part.filename) ?? "application/octet-stream"
+          }
+        };
+      }
+      throw new Error("input_file requires file_id, file_data, or file_url.");
+    }
     default:
       throw new Error("Unsupported LLM content part");
   }
@@ -3816,6 +4771,14 @@ function isInlineImageMime(mimeType) {
 }
 function guessInlineDataFilename(mimeType) {
   switch (mimeType) {
+    case "image/jpeg":
+      return "image.jpg";
+    case "image/png":
+      return "image.png";
+    case "image/webp":
+      return "image.webp";
+    case "image/gif":
+      return "image.gif";
     case "application/pdf":
       return "document.pdf";
     case "application/json":
@@ -3828,6 +4791,251 @@ function guessInlineDataFilename(mimeType) {
       return "attachment.bin";
   }
 }
+function normaliseAttachmentFilename(value, fallback) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return fallback;
+  }
+  const basename = import_node_path5.default.basename(trimmed).replace(/[^\w.-]+/g, "-");
+  return basename.length > 0 ? basename : fallback;
+}
+function setInlineAttachmentFilename(target, filename) {
+  const normalized = filename?.trim();
+  if (!normalized) {
+    return;
+  }
+  target[INLINE_ATTACHMENT_FILENAME_SYMBOL] = normalized;
+}
+function getInlineAttachmentFilename(target) {
+  if (!target || typeof target !== "object") {
+    return void 0;
+  }
+  const value = target[INLINE_ATTACHMENT_FILENAME_SYMBOL];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function estimateInlinePayloadBytes(value) {
+  return import_node_buffer4.Buffer.byteLength(value, "utf8");
+}
+function isOpenAiNativeContentItem(value) {
+  return !!value && typeof value === "object" && typeof value.type === "string";
+}
+function estimateOpenAiInlinePromptBytes(input) {
+  let total = 0;
+  const visitItems = (items) => {
+    for (const item of items) {
+      if (!item || typeof item !== "object") {
+        continue;
+      }
+      if (Array.isArray(item.content)) {
+        visitItems(item.content);
+      }
+      if (Array.isArray(item.output)) {
+        visitItems(item.output);
+      }
+      if (!isOpenAiNativeContentItem(item)) {
+        continue;
+      }
+      if (item.type === "input_image" && typeof item.image_url === "string" && item.image_url.trim().toLowerCase().startsWith("data:")) {
+        total += estimateInlinePayloadBytes(item.image_url);
+      }
+      if (item.type === "input_file" && typeof item.file_data === "string" && item.file_data.trim().length > 0) {
+        total += estimateInlinePayloadBytes(item.file_data);
+      }
+      if (item.type === "input_file" && typeof item.file_url === "string" && item.file_url.trim().toLowerCase().startsWith("data:")) {
+        total += estimateInlinePayloadBytes(item.file_url);
+      }
+    }
+  };
+  visitItems(input);
+  return total;
+}
+async function storeCanonicalPromptFile(options) {
+  const file = await runWithFileUploadSource("prompt_inline_offload", async () => {
+    return await filesCreate({
+      data: options.bytes,
+      filename: options.filename,
+      mimeType: options.mimeType,
+      expiresAfterSeconds: DEFAULT_FILE_TTL_SECONDS
+    });
+  });
+  return {
+    fileId: file.id,
+    filename: file.filename,
+    mimeType: options.mimeType
+  };
+}
+async function prepareOpenAiPromptContentItem(item) {
+  if (!isOpenAiNativeContentItem(item)) {
+    return item;
+  }
+  if (item.type === "input_image" && typeof item.image_url === "string" && item.image_url.trim().toLowerCase().startsWith("data:")) {
+    const parsed = parseDataUrlPayload(item.image_url);
+    if (!parsed) {
+      return item;
+    }
+    const uploaded = await storeCanonicalPromptFile({
+      bytes: parsed.bytes,
+      mimeType: parsed.mimeType ?? "application/octet-stream",
+      filename: normaliseAttachmentFilename(
+        getInlineAttachmentFilename(item),
+        guessInlineDataFilename(parsed.mimeType)
+      )
+    });
+    return {
+      type: "input_image",
+      detail: item.detail === "high" || item.detail === "low" ? item.detail : "auto",
+      file_id: uploaded.fileId
+    };
+  }
+  if (item.type !== "input_file" || item.file_id) {
+    return item;
+  }
+  if (typeof item.file_data === "string" && item.file_data.trim().length > 0) {
+    const filename = normaliseAttachmentFilename(
+      typeof item.filename === "string" ? item.filename : void 0,
+      guessInlineDataFilename(void 0)
+    );
+    const mimeType = inferToolOutputMimeTypeFromFilename(filename) ?? "application/octet-stream";
+    const uploaded = await storeCanonicalPromptFile({
+      bytes: decodeInlineDataBuffer(item.file_data),
+      mimeType,
+      filename
+    });
+    return { type: "input_file", file_id: uploaded.fileId };
+  }
+  if (typeof item.file_url === "string" && item.file_url.trim().toLowerCase().startsWith("data:")) {
+    const parsed = parseDataUrlPayload(item.file_url);
+    if (!parsed) {
+      return item;
+    }
+    const uploaded = await storeCanonicalPromptFile({
+      bytes: parsed.bytes,
+      mimeType: parsed.mimeType ?? "application/octet-stream",
+      filename: normaliseAttachmentFilename(
+        typeof item.filename === "string" ? item.filename : void 0,
+        guessInlineDataFilename(parsed.mimeType)
+      )
+    });
+    return { type: "input_file", file_id: uploaded.fileId };
+  }
+  return item;
+}
+async function prepareOpenAiPromptInput(input) {
+  const prepareItem = async (item) => {
+    if (!item || typeof item !== "object") {
+      return item;
+    }
+    const record = item;
+    if (Array.isArray(record.content)) {
+      return {
+        ...record,
+        content: await Promise.all(
+          record.content.map((part) => prepareOpenAiPromptContentItem(part))
+        )
+      };
+    }
+    if (Array.isArray(record.output)) {
+      return {
+        ...record,
+        output: await Promise.all(
+          record.output.map((part) => prepareOpenAiPromptContentItem(part))
+        )
+      };
+    }
+    return await prepareOpenAiPromptContentItem(item);
+  };
+  return await Promise.all(input.map((item) => prepareItem(item)));
+}
+async function maybePrepareOpenAiPromptInput(input) {
+  if (estimateOpenAiInlinePromptBytes(input) <= INLINE_ATTACHMENT_PROMPT_THRESHOLD_BYTES) {
+    return Array.from(input);
+  }
+  return await prepareOpenAiPromptInput(input);
+}
+function estimateGeminiInlinePromptBytes(contents) {
+  let total = 0;
+  for (const content of contents) {
+    for (const part of content.parts ?? []) {
+      if (part.inlineData?.data) {
+        total += estimateInlinePayloadBytes(part.inlineData.data);
+      }
+    }
+  }
+  return total;
+}
+function hasCanonicalGeminiFileReferences(contents) {
+  for (const content of contents) {
+    for (const part of content.parts ?? []) {
+      if (parseCanonicalGeminiFileId(part.fileData?.fileUri)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+async function prepareGeminiPromptContents(contents) {
+  const backend = getGeminiBackend();
+  const preparedContents = [];
+  for (const content of contents) {
+    const parts = [];
+    for (const part of content.parts ?? []) {
+      const canonicalFileId = parseCanonicalGeminiFileId(part.fileData?.fileUri);
+      if (canonicalFileId) {
+        await getCanonicalFileMetadata(canonicalFileId);
+        if (backend === "api") {
+          const mirrored = await ensureGeminiFileMirror(canonicalFileId);
+          parts.push((0, import_genai2.createPartFromUri)(mirrored.uri, mirrored.mimeType));
+        } else {
+          const mirrored = await ensureVertexFileMirror(canonicalFileId);
+          parts.push({
+            fileData: {
+              fileUri: mirrored.fileUri,
+              mimeType: mirrored.mimeType
+            }
+          });
+        }
+        continue;
+      }
+      if (part.inlineData?.data) {
+        const mimeType = part.inlineData.mimeType ?? "application/octet-stream";
+        const filename = normaliseAttachmentFilename(
+          getInlineAttachmentFilename(part.inlineData) ?? part.inlineData.displayName ?? guessInlineDataFilename(mimeType),
+          guessInlineDataFilename(mimeType)
+        );
+        const stored = await storeCanonicalPromptFile({
+          bytes: decodeInlineDataBuffer(part.inlineData.data),
+          mimeType,
+          filename
+        });
+        if (backend === "api") {
+          const mirrored = await ensureGeminiFileMirror(stored.fileId);
+          parts.push((0, import_genai2.createPartFromUri)(mirrored.uri, mirrored.mimeType));
+        } else {
+          const mirrored = await ensureVertexFileMirror(stored.fileId);
+          parts.push({
+            fileData: {
+              fileUri: mirrored.fileUri,
+              mimeType: mirrored.mimeType
+            }
+          });
+        }
+        continue;
+      }
+      parts.push(part);
+    }
+    preparedContents.push({
+      ...content,
+      parts
+    });
+  }
+  return preparedContents;
+}
+async function maybePrepareGeminiPromptContents(contents) {
+  if (!hasCanonicalGeminiFileReferences(contents) && estimateGeminiInlinePromptBytes(contents) <= INLINE_ATTACHMENT_PROMPT_THRESHOLD_BYTES) {
+    return Array.from(contents);
+  }
+  return await prepareGeminiPromptContents(contents);
+}
 function mergeConsecutiveTextParts(parts) {
   if (parts.length === 0) {
     return [];
@@ -3835,7 +5043,7 @@ function mergeConsecutiveTextParts(parts) {
   const merged = [];
   for (const part of parts) {
     if (part.type !== "text") {
-      merged.push({ type: "inlineData", data: part.data, mimeType: part.mimeType });
+      merged.push(cloneContentPart(part));
       continue;
     }
     const isThought = part.thought === true;
@@ -4266,13 +5474,7 @@ function resolveTextContents(input) {
     const parts = typeof message.content === "string" ? [{ type: "text", text: message.content }] : message.content;
     contents.push({
       role: message.role,
-      parts: parts.map(
-        (part) => part.type === "text" ? {
-          type: "text",
-          text: part.text,
-          thought: "thought" in part && part.thought === true ? true : void 0
-        } : { type: "inlineData", data: part.data, mimeType: part.mimeType }
-      )
+      parts: parts.map((part) => cloneContentPart(part))
     });
   }
   return contents;
@@ -4288,22 +5490,58 @@ function toOpenAiInput(contents) {
   return contents.map((content) => {
     const parts = [];
     for (const part of content.parts) {
-      if (part.type === "text") {
-        parts.push({ type: "input_text", text: part.text });
-        continue;
-      }
-      const mimeType = part.mimeType;
-      if (isInlineImageMime(mimeType)) {
-        const dataUrl = `data:${mimeType};base64,${part.data}`;
-        parts.push({ type: "input_image", image_url: dataUrl, detail: "auto" });
-        continue;
+      switch (part.type) {
+        case "text":
+          parts.push({ type: "input_text", text: part.text });
+          break;
+        case "inlineData": {
+          const mimeType = part.mimeType;
+          if (isInlineImageMime(mimeType)) {
+            const dataUrl = `data:${mimeType};base64,${part.data}`;
+            const imagePart = {
+              type: "input_image",
+              image_url: dataUrl,
+              detail: "auto"
+            };
+            setInlineAttachmentFilename(
+              imagePart,
+              normaliseAttachmentFilename(part.filename, guessInlineDataFilename(mimeType))
+            );
+            parts.push(imagePart);
+            break;
+          }
+          parts.push({
+            type: "input_file",
+            filename: normaliseAttachmentFilename(part.filename, guessInlineDataFilename(mimeType)),
+            file_data: part.data
+          });
+          break;
+        }
+        case "input_image": {
+          const imagePart = {
+            type: "input_image",
+            ...part.file_id ? { file_id: part.file_id } : {},
+            ...part.image_url ? { image_url: part.image_url } : {},
+            detail: part.detail === "high" || part.detail === "low" ? part.detail : "auto"
+          };
+          if (part.filename) {
+            setInlineAttachmentFilename(imagePart, part.filename);
+          }
+          parts.push(imagePart);
+          break;
+        }
+        case "input_file":
+          parts.push({
+            type: "input_file",
+            ...part.file_id ? { file_id: part.file_id } : {},
+            ...part.file_data ? { file_data: part.file_data } : {},
+            ...part.file_url ? { file_url: part.file_url } : {},
+            ...!part.file_id && part.filename ? { filename: part.filename } : {}
+          });
+          break;
+        default:
+          throw new Error("Unsupported LLM content part");
       }
-      const fileData = decodeInlineDataBuffer(part.data).toString("base64");
-      parts.push({
-        type: "input_file",
-        filename: guessInlineDataFilename(mimeType),
-        file_data: fileData
-      });
     }
     if (parts.length === 1 && parts[0]?.type === "input_text" && typeof parts[0].text === "string") {
       return {
@@ -4340,28 +5578,54 @@ function toChatGptInput(contents) {
         continue;
       }
       if (isAssistant) {
-        const mimeType = part.mimeType ?? "application/octet-stream";
+        const mimeType = part.type === "inlineData" ? part.mimeType ?? "application/octet-stream" : inferToolOutputMimeTypeFromFilename(part.filename) ?? "application/octet-stream";
         parts.push({
           type: "output_text",
-          text: isInlineImageMime(part.mimeType) ? `[image:${mimeType}]` : `[file:${mimeType}]`
+          text: part.type === "input_image" || isInlineImageMime(part.mimeType) ? `[image:${mimeType}]` : `[file:${mimeType}]`
         });
-      } else {
-        if (isInlineImageMime(part.mimeType)) {
-          const mimeType = part.mimeType ?? "application/octet-stream";
-          const dataUrl = `data:${mimeType};base64,${part.data}`;
+        continue;
+      }
+      switch (part.type) {
+        case "inlineData": {
+          if (isInlineImageMime(part.mimeType)) {
+            const mimeType = part.mimeType ?? "application/octet-stream";
+            const dataUrl = `data:${mimeType};base64,${part.data}`;
+            parts.push({
+              type: "input_image",
+              image_url: dataUrl,
+              detail: "auto"
+            });
+          } else {
+            parts.push({
+              type: "input_file",
+              filename: normaliseAttachmentFilename(
+                part.filename,
+                guessInlineDataFilename(part.mimeType)
+              ),
+              file_data: part.data
+            });
+          }
+          break;
+        }
+        case "input_image":
           parts.push({
             type: "input_image",
-            image_url: dataUrl,
-            detail: "auto"
+            ...part.file_id ? { file_id: part.file_id } : {},
+            ...part.image_url ? { image_url: part.image_url } : {},
+            detail: part.detail === "high" || part.detail === "low" ? part.detail : "auto"
           });
-        } else {
-          const fileData = decodeInlineDataBuffer(part.data).toString("base64");
+          break;
+        case "input_file":
           parts.push({
             type: "input_file",
-            filename: guessInlineDataFilename(part.mimeType),
-            file_data: fileData
+            ...part.file_id ? { file_id: part.file_id } : {},
+            ...part.file_data ? { file_data: part.file_data } : {},
+            ...part.file_url ? { file_url: part.file_url } : {},
+            ...!part.file_id && part.filename ? { filename: part.filename } : {}
           });
-        }
+          break;
+        default:
+          throw new Error("Unsupported LLM content part");
       }
     }
     if (parts.length === 0) {
@@ -4405,8 +5669,8 @@ ${JSON.stringify(options.responseJsonSchema)}`);
       if (part.type === "text") {
         return part.text;
       }
-      const mimeType = part.mimeType ?? "application/octet-stream";
-      if (isInlineImageMime(mimeType)) {
+      const mimeType = part.type === "inlineData" ? part.mimeType ?? "application/octet-stream" : inferToolOutputMimeTypeFromFilename(part.filename) ?? "application/octet-stream";
+      if (part.type === "input_image" || isInlineImageMime(mimeType)) {
         return `[image:${mimeType}]`;
       }
       return `[file:${mimeType}]`;
@@ -4677,7 +5941,14 @@ function isLlmToolOutputContentItem(value) {
     return typeof value.text === "string";
   }
   if (itemType === "input_image") {
-    return typeof value.image_url === "string";
+    const keys = ["image_url", "file_id", "filename"];
+    for (const key of keys) {
+      const part = value[key];
+      if (part !== void 0 && part !== null && typeof part !== "string") {
+        return false;
+      }
+    }
+    return value.image_url !== void 0 || value.file_id !== void 0;
   }
   if (itemType === "input_file") {
     const keys = ["file_data", "file_id", "file_url", "filename"];
@@ -4746,15 +6017,249 @@ function inferToolOutputMimeTypeFromFilename(filename) {
   }
   return void 0;
 }
-function buildGeminiToolOutputMediaPart(item) {
+function estimateToolOutputItemBytes(item) {
+  if (item.type === "input_text") {
+    return import_node_buffer4.Buffer.byteLength(item.text, "utf8");
+  }
+  if (item.type === "input_image") {
+    return typeof item.image_url === "string" ? estimateInlinePayloadBytes(item.image_url) : 0;
+  }
+  if (typeof item.file_data === "string" && item.file_data.trim().length > 0) {
+    return estimateInlinePayloadBytes(item.file_data);
+  }
+  if (typeof item.file_url === "string" && item.file_url.trim().length > 0) {
+    return estimateInlinePayloadBytes(item.file_url);
+  }
+  return 0;
+}
+async function spillTextToolOutputToFile(options) {
+  const stored = await runWithFileUploadSource("tool_output_spill", async () => {
+    return await filesCreate({
+      data: options.text,
+      filename: options.filename,
+      mimeType: options.mimeType,
+      expiresAfterSeconds: DEFAULT_FILE_TTL_SECONDS
+    });
+  });
+  return [
+    {
+      type: "input_text",
+      text: `Tool output was attached as ${stored.filename} (${stored.id}) because it exceeded the inline payload threshold.`
+    },
+    {
+      type: "input_file",
+      file_id: stored.id,
+      filename: stored.filename
+    }
+  ];
+}
+async function maybeSpillToolOutputItem(item, toolName, options) {
+  if (options?.force !== true && estimateToolOutputItemBytes(item) <= TOOL_OUTPUT_SPILL_THRESHOLD_BYTES) {
+    return item;
+  }
+  if (item.type === "input_text") {
+    return await spillTextToolOutputToFile({
+      text: item.text,
+      filename: normaliseAttachmentFilename(`${toolName}.txt`, "tool-output.txt"),
+      mimeType: "text/plain"
+    });
+  }
   if (item.type === "input_image") {
+    if (item.file_id || !item.image_url) {
+      return item;
+    }
     const parsed = parseDataUrlPayload(item.image_url);
     if (!parsed) {
+      return item;
+    }
+    const stored = await runWithFileUploadSource("tool_output_spill", async () => {
+      return await filesCreate({
+        data: parsed.bytes,
+        filename: normaliseAttachmentFilename(
+          item.filename ?? guessInlineDataFilename(parsed.mimeType),
+          guessInlineDataFilename(parsed.mimeType)
+        ),
+        mimeType: parsed.mimeType,
+        expiresAfterSeconds: DEFAULT_FILE_TTL_SECONDS
+      });
+    });
+    return {
+      type: "input_image",
+      file_id: stored.id,
+      detail: item.detail ?? "auto",
+      filename: stored.filename
+    };
+  }
+  if (item.file_id) {
+    return item;
+  }
+  if (typeof item.file_data === "string" && item.file_data.trim().length > 0) {
+    const fileData = item.file_data;
+    const filename = normaliseAttachmentFilename(
+      item.filename ?? `${toolName}.bin`,
+      `${toolName}.bin`
+    );
+    const stored = await runWithFileUploadSource("tool_output_spill", async () => {
+      return await filesCreate({
+        data: decodeInlineDataBuffer(fileData),
+        filename,
+        mimeType: inferToolOutputMimeTypeFromFilename(filename) ?? "application/octet-stream",
+        expiresAfterSeconds: DEFAULT_FILE_TTL_SECONDS
+      });
+    });
+    return {
+      type: "input_file",
+      file_id: stored.id,
+      filename: stored.filename
+    };
+  }
+  if (typeof item.file_url === "string" && item.file_url.trim().length > 0) {
+    const parsed = parseDataUrlPayload(item.file_url);
+    if (!parsed) {
+      return item;
+    }
+    const stored = await runWithFileUploadSource("tool_output_spill", async () => {
+      return await filesCreate({
+        data: parsed.bytes,
+        filename: normaliseAttachmentFilename(
+          item.filename ?? guessInlineDataFilename(parsed.mimeType),
+          guessInlineDataFilename(parsed.mimeType)
+        ),
+        mimeType: parsed.mimeType,
+        expiresAfterSeconds: DEFAULT_FILE_TTL_SECONDS
+      });
+    });
+    return {
+      type: "input_file",
+      file_id: stored.id,
+      filename: stored.filename
+    };
+  }
+  return item;
+}
+async function maybeSpillToolOutput(value, toolName, options) {
+  if (typeof value === "string") {
+    if (options?.force !== true && import_node_buffer4.Buffer.byteLength(value, "utf8") <= TOOL_OUTPUT_SPILL_THRESHOLD_BYTES) {
+      return value;
+    }
+    return await spillTextToolOutputToFile({
+      text: value,
+      filename: normaliseAttachmentFilename(`${toolName}.txt`, "tool-output.txt"),
+      mimeType: "text/plain"
+    });
+  }
+  if (isLlmToolOutputContentItem(value)) {
+    return await maybeSpillToolOutputItem(value, toolName, options);
+  }
+  if (Array.isArray(value) && value.every((item) => isLlmToolOutputContentItem(item))) {
+    const spilledItems = [];
+    for (const item of value) {
+      const maybeSpilled = await maybeSpillToolOutputItem(item, toolName, options);
+      if (Array.isArray(maybeSpilled)) {
+        spilledItems.push(...maybeSpilled);
+      } else {
+        spilledItems.push(maybeSpilled);
+      }
+    }
+    return spilledItems;
+  }
+  try {
+    const serialized = JSON.stringify(value, null, 2);
+    if (options?.force !== true && import_node_buffer4.Buffer.byteLength(serialized, "utf8") <= TOOL_OUTPUT_SPILL_THRESHOLD_BYTES) {
+      return value;
+    }
+    return await spillTextToolOutputToFile({
+      text: serialized,
+      filename: normaliseAttachmentFilename(`${toolName}.json`, "tool-output.json"),
+      mimeType: "application/json"
+    });
+  } catch {
+    return value;
+  }
+}
+function estimateToolOutputPayloadBytes(value) {
+  if (typeof value === "string") {
+    return import_node_buffer4.Buffer.byteLength(value, "utf8");
+  }
+  if (isLlmToolOutputContentItem(value)) {
+    return value.type === "input_text" ? 0 : estimateToolOutputItemBytes(value);
+  }
+  if (Array.isArray(value) && value.every((item) => isLlmToolOutputContentItem(item))) {
+    return value.reduce((total, item) => {
+      return total + (item.type === "input_text" ? 0 : estimateToolOutputItemBytes(item));
+    }, 0);
+  }
+  return 0;
+}
+async function maybeSpillCombinedToolCallOutputs(callResults) {
+  const totalBytes = callResults.reduce(
+    (sum, callResult) => sum + estimateToolOutputPayloadBytes(callResult.outputPayload),
+    0
+  );
+  if (totalBytes <= INLINE_ATTACHMENT_PROMPT_THRESHOLD_BYTES) {
+    return Array.from(callResults);
+  }
+  return await Promise.all(
+    callResults.map(async (callResult) => {
+      if (estimateToolOutputPayloadBytes(callResult.outputPayload) === 0) {
+        return callResult;
+      }
+      const outputPayload = await maybeSpillToolOutput(
+        callResult.outputPayload,
+        callResult.entry.toolName,
+        {
+          force: true
+        }
+      );
+      return {
+        ...callResult,
+        outputPayload,
+        result: {
+          ...callResult.result,
+          output: outputPayload
+        }
+      };
+    })
+  );
+}
+function buildGeminiToolOutputMediaPart(item) {
+  if (item.type === "input_image") {
+    if (typeof item.file_id === "string" && item.file_id.trim().length > 0) {
+      return {
+        fileData: {
+          fileUri: buildCanonicalGeminiFileUri(item.file_id),
+          mimeType: inferToolOutputMimeTypeFromFilename(item.filename) ?? "application/octet-stream"
+        }
+      };
+    }
+    if (typeof item.image_url !== "string" || item.image_url.trim().length === 0) {
       return null;
     }
-    return (0, import_genai2.createPartFromBase64)(parsed.dataBase64, parsed.mimeType);
+    const parsed = parseDataUrlPayload(item.image_url);
+    if (parsed) {
+      const part = (0, import_genai2.createPartFromBase64)(parsed.dataBase64, parsed.mimeType);
+      const displayName = item.filename?.trim();
+      if (displayName && part.inlineData) {
+        part.inlineData.displayName = displayName;
+      }
+      return part;
+    }
+    return {
+      fileData: {
+        fileUri: item.image_url,
+        mimeType: inferToolOutputMimeTypeFromFilename(item.filename) ?? "application/octet-stream"
+      }
+    };
   }
   if (item.type === "input_file") {
+    if (typeof item.file_id === "string" && item.file_id.trim().length > 0) {
+      return {
+        fileData: {
+          fileUri: buildCanonicalGeminiFileUri(item.file_id),
+          mimeType: inferToolOutputMimeTypeFromFilename(item.filename) ?? "application/octet-stream"
+        }
+      };
+    }
     const dataUrl = typeof item.file_url === "string" ? parseDataUrlPayload(item.file_url) : null;
     if (dataUrl) {
       const part = (0, import_genai2.createPartFromBase64)(dataUrl.dataBase64, dataUrl.mimeType);
@@ -4774,12 +6279,7 @@ function buildGeminiToolOutputMediaPart(item) {
       return part;
     }
     if (typeof item.file_url === "string" && item.file_url.trim().length > 0 && inferredMimeType) {
-      const part = (0, import_genai2.createPartFromUri)(item.file_url, inferredMimeType);
-      const displayName = item.filename?.trim();
-      if (displayName && part.fileData) {
-        part.fileData.displayName = displayName;
-      }
-      return part;
+      return (0, import_genai2.createPartFromUri)(item.file_url, inferredMimeType);
     }
   }
   return null;
@@ -4792,11 +6292,12 @@ function toGeminiToolOutputPlaceholder(item) {
     };
   }
   if (item.type === "input_image") {
-    const parsed = parseDataUrlPayload(item.image_url);
+    const parsed = typeof item.image_url === "string" ? parseDataUrlPayload(item.image_url) : null;
     return {
       type: item.type,
+      fileId: item.file_id ?? void 0,
       mimeType: parsed?.mimeType ?? void 0,
-      media: "attached-inline-data"
+      media: item.file_id ? "attached-file-id" : parsed ? "attached-inline-data" : item.image_url ? "attached-file-data" : void 0
     };
   }
   const dataUrl = typeof item.file_url === "string" ? parseDataUrlPayload(item.file_url) : null;
@@ -4805,7 +6306,7 @@ function toGeminiToolOutputPlaceholder(item) {
     filename: item.filename ?? void 0,
     fileId: item.file_id ?? void 0,
     mimeType: dataUrl?.mimeType ?? inferToolOutputMimeTypeFromFilename(item.filename) ?? void 0,
-    media: dataUrl || typeof item.file_data === "string" && item.file_data.trim().length > 0 ? "attached-inline-data" : typeof item.file_url === "string" && item.file_url.trim().length > 0 ? "attached-file-data" : void 0
+    media: item.file_id ? "attached-file-id" : dataUrl || typeof item.file_data === "string" && item.file_data.trim().length > 0 ? "attached-inline-data" : typeof item.file_url === "string" && item.file_url.trim().length > 0 ? "attached-file-data" : void 0
   };
 }
 function buildGeminiFunctionResponseParts(options) {
@@ -4853,8 +6354,8 @@ function parseOpenAiToolArguments(raw) {
 function formatZodIssues(issues) {
   const messages = [];
   for (const issue of issues) {
-    const path8 = issue.path.length > 0 ? issue.path.map(String).join(".") : "input";
-    messages.push(`${path8}: ${issue.message}`);
+    const path10 = issue.path.length > 0 ? issue.path.map(String).join(".") : "input";
+    messages.push(`${path10}: ${issue.message}`);
   }
   return messages.join("; ");
 }
@@ -4972,8 +6473,9 @@ async function executeToolCall(params) {
     const input = typeof rawInput === "string" ? rawInput : String(rawInput ?? "");
     try {
       const output = await tool2.execute(input);
-      const metrics = toolName === "spawn_agent" ? extractSpawnStartupMetrics(output) : void 0;
-      return finalize({ toolName, input, output }, output, metrics);
+      const outputPayload = await maybeSpillToolOutput(output, toolName);
+      const metrics = toolName === "spawn_agent" ? extractSpawnStartupMetrics(outputPayload) : void 0;
+      return finalize({ toolName, input, output: outputPayload }, outputPayload, metrics);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       const outputPayload = buildToolErrorOutput(`Tool ${toolName} failed: ${message}`);
@@ -5007,8 +6509,13 @@ async function executeToolCall(params) {
   }
   try {
     const output = await tool2.execute(parsed.data);
-    const metrics = toolName === "spawn_agent" ? extractSpawnStartupMetrics(output) : void 0;
-    return finalize({ toolName, input: parsed.data, output }, output, metrics);
+    const outputPayload = await maybeSpillToolOutput(output, toolName);
+    const metrics = toolName === "spawn_agent" ? extractSpawnStartupMetrics(outputPayload) : void 0;
+    return finalize(
+      { toolName, input: parsed.data, output: outputPayload },
+      outputPayload,
+      metrics
+    );
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     const outputPayload = buildToolErrorOutput(`Tool ${toolName} failed: ${message}`);
@@ -5024,7 +6531,7 @@ function buildToolLogId(turn, toolIndex) {
 function sanitizeChatGptToolId(value) {
   const cleaned = value.replace(/[^A-Za-z0-9_-]/gu, "");
   if (cleaned.length === 0) {
-    return (0, import_node_crypto.randomBytes)(8).toString("hex");
+    return (0, import_node_crypto2.randomBytes)(8).toString("hex");
   }
   return cleaned.slice(0, 64);
 }
@@ -5042,7 +6549,7 @@ function normalizeChatGptToolIds(params) {
     rawCallId = nextCallId ?? rawCallId;
     rawItemId = nextItemId ?? rawItemId;
   }
-  const callValue = sanitizeChatGptToolId(rawCallId || rawItemId || (0, import_node_crypto.randomBytes)(8).toString("hex"));
+  const callValue = sanitizeChatGptToolId(rawCallId || rawItemId || (0, import_node_crypto2.randomBytes)(8).toString("hex"));
   let itemValue = sanitizeChatGptToolId(rawItemId || callValue);
   if (params.callKind === "custom") {
     if (!itemValue.startsWith("ctc")) {
@@ -5209,7 +6716,7 @@ function toGemini25ProThinkingBudget(thinkingLevel) {
   }
 }
 function resolveGeminiThinkingConfig(modelId, thinkingLevel) {
-  if (isGeminiImageModelId(modelId)) {
+  if (isGeminiImageModelId(modelId) || modelId === "gemini-flash-lite-latest") {
     return void 0;
   }
   if (thinkingLevel) {
@@ -5240,9 +6747,9 @@ function resolveGeminiThinkingConfig(modelId, thinkingLevel) {
 }
 function decodeInlineDataBuffer(base64) {
   try {
-    return import_node_buffer3.Buffer.from(base64, "base64");
+    return import_node_buffer4.Buffer.from(base64, "base64");
   } catch {
-    return import_node_buffer3.Buffer.from(base64, "base64url");
+    return import_node_buffer4.Buffer.from(base64, "base64url");
   }
 }
 function extractImages(content) {
@@ -5312,7 +6819,7 @@ function parseDataUrlPayload(value) {
   const isBase64 = /;base64(?:;|$)/iu.test(header);
   const mimeType = (header.split(";")[0] ?? "application/octet-stream").trim().toLowerCase();
   try {
-    const bytes = isBase64 ? import_node_buffer3.Buffer.from(payload, "base64") : import_node_buffer3.Buffer.from(decodeURIComponent(payload), "utf8");
+    const bytes = isBase64 ? import_node_buffer4.Buffer.from(payload, "base64") : import_node_buffer4.Buffer.from(decodeURIComponent(payload), "utf8");
     return {
       mimeType,
       dataBase64: bytes.toString("base64"),
@@ -5415,7 +6922,10 @@ function collectLoggedAttachmentsFromLlmParts(parts, prefix) {
       continue;
     }
     attachments.push({
-      filename: buildLoggedAttachmentFilename(prefix, index, part.mimeType),
+      filename: normaliseAttachmentFilename(
+        part.filename,
+        buildLoggedAttachmentFilename(prefix, index, part.mimeType)
+      ),
       bytes: decodeInlineDataBuffer(part.data)
     });
     index += 1;
@@ -5544,15 +7054,19 @@ function startLlmCallLoggerFromContents(options) {
         sections.push(part.text);
         continue;
       }
-      const filename = buildLoggedAttachmentFilename("input", attachmentIndex, part.mimeType);
-      attachments.push({
-        filename,
-        bytes: decodeInlineDataBuffer(part.data)
-      });
-      attachmentIndex += 1;
-      sections.push(
-        `[inlineData] file=${filename} mime=${part.mimeType ?? "application/octet-stream"} bytes=${attachments[attachments.length - 1]?.bytes.byteLength ?? 0}`
-      );
+      if (part.type === "inlineData") {
+        const filename = buildLoggedAttachmentFilename("input", attachmentIndex, part.mimeType);
+        attachments.push({
+          filename,
+          bytes: decodeInlineDataBuffer(part.data)
+        });
+        attachmentIndex += 1;
+        sections.push(
+          `[inlineData] file=${filename} mime=${part.mimeType ?? "application/octet-stream"} bytes=${attachments[attachments.length - 1]?.bytes.byteLength ?? 0}`
+        );
+        continue;
+      }
+      sections.push(`[${part.type}] file_id=${"file_id" in part ? part.file_id ?? "" : ""}`);
     }
     sections.push("");
   }
@@ -5683,307 +7197,317 @@ async function runTextCall(params) {
     return abortController.signal;
   };
   const signal = resolveAbortSignal();
-  try {
-    if (provider === "openai") {
-      const openAiInput = toOpenAiInput(contents);
-      const openAiTools = toOpenAiTools(request.tools);
-      const reasoningEffort = resolveOpenAiReasoningEffort(modelForProvider, request.thinkingLevel);
-      const openAiTextConfig = {
-        format: request.openAiTextFormat ?? { type: "text" },
-        verbosity: resolveOpenAiVerbosity(modelForProvider)
-      };
-      const reasoning = {
-        effort: toOpenAiReasoningEffort(reasoningEffort),
-        summary: "detailed"
-      };
-      await runOpenAiCall(async (client) => {
-        const stream = client.responses.stream(
-          {
-            model: modelForProvider,
-            input: openAiInput,
-            reasoning,
-            text: openAiTextConfig,
-            ...openAiTools ? { tools: openAiTools } : {},
-            include: ["code_interpreter_call.outputs", "reasoning.encrypted_content"]
-          },
-          { signal }
+  const { result } = await collectFileUploadMetrics(async () => {
+    try {
+      if (provider === "openai") {
+        const openAiInput = await maybePrepareOpenAiPromptInput(toOpenAiInput(contents));
+        const openAiTools = toOpenAiTools(request.tools);
+        const reasoningEffort = resolveOpenAiReasoningEffort(
+          modelForProvider,
+          request.thinkingLevel
         );
-        for await (const event of stream) {
-          switch (event.type) {
-            case "response.output_text.delta": {
-              const delta = event.delta ?? "";
-              pushDelta("response", typeof delta === "string" ? delta : "");
-              break;
-            }
-            case "response.reasoning_summary_text.delta": {
-              const delta = event.delta ?? "";
-              pushDelta("thought", typeof delta === "string" ? delta : "");
-              break;
-            }
-            case "response.refusal.delta": {
-              blocked = true;
-              queue.push({ type: "blocked" });
-              break;
-            }
-            default:
-              break;
-          }
-        }
-        const finalResponse = await stream.finalResponse();
-        modelVersion = typeof finalResponse.model === "string" ? finalResponse.model : request.model;
-        queue.push({ type: "model", modelVersion });
-        if (finalResponse.error) {
-          const message = typeof finalResponse.error.message === "string" ? finalResponse.error.message : "OpenAI response failed";
-          throw new Error(message);
-        }
-        if (finalResponse.status && finalResponse.status !== "completed" && finalResponse.status !== "in_progress") {
-          const detail = finalResponse.incomplete_details?.reason;
-          throw new Error(
-            `OpenAI response status ${finalResponse.status}${detail ? ` (${detail})` : ""}`
+        const openAiTextConfig = {
+          format: request.openAiTextFormat ?? { type: "text" },
+          verbosity: resolveOpenAiVerbosity(modelForProvider)
+        };
+        const reasoning = {
+          effort: toOpenAiReasoningEffort(reasoningEffort),
+          summary: "detailed"
+        };
+        await runOpenAiCall(async (client) => {
+          const stream = client.responses.stream(
+            {
+              model: modelForProvider,
+              input: openAiInput,
+              reasoning,
+              text: openAiTextConfig,
+              ...openAiTools ? { tools: openAiTools } : {},
+              include: ["code_interpreter_call.outputs", "reasoning.encrypted_content"]
+            },
+            { signal }
           );
-        }
-        latestUsage = extractOpenAiUsageTokens(finalResponse.usage);
-        if (responseParts.length === 0) {
-          const fallback = extractOpenAiResponseParts(finalResponse);
-          blocked = blocked || fallback.blocked;
-          for (const part of fallback.parts) {
-            if (part.type === "text") {
-              pushDelta(part.thought === true ? "thought" : "response", part.text);
-            } else {
-              pushInline(part.data, part.mimeType);
+          for await (const event of stream) {
+            switch (event.type) {
+              case "response.output_text.delta": {
+                const delta = event.delta ?? "";
+                pushDelta("response", typeof delta === "string" ? delta : "");
+                break;
+              }
+              case "response.reasoning_summary_text.delta": {
+                const delta = event.delta ?? "";
+                pushDelta("thought", typeof delta === "string" ? delta : "");
+                break;
+              }
+              case "response.refusal.delta": {
+                blocked = true;
+                queue.push({ type: "blocked" });
+                break;
+              }
+              default:
+                break;
             }
           }
-        }
-      }, modelForProvider);
-    } else if (provider === "chatgpt") {
-      const chatGptInput = toChatGptInput(contents);
-      const reasoningEffort = resolveOpenAiReasoningEffort(request.model, request.thinkingLevel);
-      const openAiTools = toOpenAiTools(request.tools);
-      const requestPayload = {
-        model: modelForProvider,
-        store: false,
-        stream: true,
-        ...providerInfo.serviceTier ? { service_tier: providerInfo.serviceTier } : {},
-        instructions: chatGptInput.instructions ?? "You are a helpful assistant.",
-        input: chatGptInput.input,
-        include: ["reasoning.encrypted_content"],
-        reasoning: {
-          effort: toOpenAiReasoningEffort(reasoningEffort),
-          summary: "detailed"
-        },
-        text: {
-          format: request.openAiTextFormat ?? { type: "text" },
-          verbosity: resolveOpenAiVerbosity(request.model)
-        },
-        ...openAiTools ? { tools: openAiTools } : {}
-      };
-      let sawResponseDelta = false;
-      let sawThoughtDelta = false;
-      const result = await collectChatGptCodexResponseWithRetry({
-        request: requestPayload,
-        signal,
-        onDelta: (delta) => {
-          if (delta.thoughtDelta) {
-            sawThoughtDelta = true;
-            pushDelta("thought", delta.thoughtDelta);
+          const finalResponse = await stream.finalResponse();
+          modelVersion = typeof finalResponse.model === "string" ? finalResponse.model : request.model;
+          queue.push({ type: "model", modelVersion });
+          if (finalResponse.error) {
+            const message = typeof finalResponse.error.message === "string" ? finalResponse.error.message : "OpenAI response failed";
+            throw new Error(message);
           }
-          if (delta.textDelta) {
-            sawResponseDelta = true;
-            pushDelta("response", delta.textDelta);
+          if (finalResponse.status && finalResponse.status !== "completed" && finalResponse.status !== "in_progress") {
+            const detail = finalResponse.incomplete_details?.reason;
+            throw new Error(
+              `OpenAI response status ${finalResponse.status}${detail ? ` (${detail})` : ""}`
+            );
           }
-        }
-      });
-      blocked = blocked || result.blocked;
-      if (blocked) {
-        queue.push({ type: "blocked" });
-      }
-      if (result.model) {
-        modelVersion = providerInfo.serviceTier ? request.model : `chatgpt-${result.model}`;
-        queue.push({ type: "model", modelVersion });
-      }
-      latestUsage = extractChatGptUsageTokens(result.usage);
-      const fallbackText = typeof result.text === "string" ? result.text : "";
-      const fallbackThoughts = typeof result.reasoningSummaryText === "string" && result.reasoningSummaryText.length > 0 ? result.reasoningSummaryText : typeof result.reasoningText === "string" ? result.reasoningText : "";
-      if (!sawThoughtDelta && fallbackThoughts.length > 0) {
-        pushDelta("thought", fallbackThoughts);
-      }
-      if (!sawResponseDelta && fallbackText.length > 0) {
-        pushDelta("response", fallbackText);
-      }
-    } else if (provider === "fireworks") {
-      if (request.tools && request.tools.length > 0) {
-        throw new Error(
-          "Fireworks provider does not support provider-native tools in generateText; use runToolLoop for function tools."
-        );
-      }
-      const fireworksMessages = toFireworksMessages(contents, {
-        responseMimeType: request.responseMimeType,
-        responseJsonSchema: request.responseJsonSchema
-      });
-      await runFireworksCall(async (client) => {
-        const responseFormat = request.responseJsonSchema ? {
-          type: "json_schema",
-          json_schema: {
-            name: "llm-response",
-            schema: request.responseJsonSchema
+          latestUsage = extractOpenAiUsageTokens(finalResponse.usage);
+          if (responseParts.length === 0) {
+            const fallback = extractOpenAiResponseParts(finalResponse);
+            blocked = blocked || fallback.blocked;
+            for (const part of fallback.parts) {
+              if (part.type === "text") {
+                pushDelta(part.thought === true ? "thought" : "response", part.text);
+              } else if (part.type === "inlineData") {
+                pushInline(part.data, part.mimeType);
+              }
+            }
           }
-        } : request.responseMimeType === "application/json" ? { type: "json_object" } : void 0;
-        const response = await client.chat.completions.create(
-          {
-            model: modelForProvider,
-            messages: fireworksMessages,
-            ...responseFormat ? { response_format: responseFormat } : {}
+        }, modelForProvider);
+      } else if (provider === "chatgpt") {
+        const chatGptInput = toChatGptInput(contents);
+        const reasoningEffort = resolveOpenAiReasoningEffort(request.model, request.thinkingLevel);
+        const openAiTools = toOpenAiTools(request.tools);
+        const requestPayload = {
+          model: modelForProvider,
+          store: false,
+          stream: true,
+          ...providerInfo.serviceTier ? { service_tier: providerInfo.serviceTier } : {},
+          instructions: chatGptInput.instructions ?? "You are a helpful assistant.",
+          input: chatGptInput.input,
+          include: ["reasoning.encrypted_content"],
+          reasoning: {
+            effort: toOpenAiReasoningEffort(reasoningEffort),
+            summary: "detailed"
           },
-          { signal }
-        );
-        modelVersion = typeof response.model === "string" ? response.model : request.model;
-        queue.push({ type: "model", modelVersion });
-        const choice = Array.isArray(response.choices) ? response.choices[0] : void 0;
-        if (choice?.finish_reason === "content_filter") {
-          blocked = true;
+          text: {
+            format: request.openAiTextFormat ?? { type: "text" },
+            verbosity: resolveOpenAiVerbosity(request.model)
+          },
+          ...openAiTools ? { tools: openAiTools } : {}
+        };
+        let sawResponseDelta = false;
+        let sawThoughtDelta = false;
+        const result2 = await collectChatGptCodexResponseWithRetry({
+          request: requestPayload,
+          signal,
+          onDelta: (delta) => {
+            if (delta.thoughtDelta) {
+              sawThoughtDelta = true;
+              pushDelta("thought", delta.thoughtDelta);
+            }
+            if (delta.textDelta) {
+              sawResponseDelta = true;
+              pushDelta("response", delta.textDelta);
+            }
+          }
+        });
+        blocked = blocked || result2.blocked;
+        if (blocked) {
           queue.push({ type: "blocked" });
         }
-        const textOutput = extractFireworksMessageText(
-          choice?.message
-        );
-        if (textOutput.length > 0) {
-          pushDelta("response", textOutput);
+        if (result2.model) {
+          modelVersion = providerInfo.serviceTier ? request.model : `chatgpt-${result2.model}`;
+          queue.push({ type: "model", modelVersion });
         }
-        latestUsage = extractFireworksUsageTokens(response.usage);
-      }, modelForProvider);
-    } else {
-      const geminiContents = contents.map(convertLlmContentToGeminiContent);
-      const thinkingConfig = resolveGeminiThinkingConfig(modelForProvider, request.thinkingLevel);
-      const config = {
-        maxOutputTokens: 32e3,
-        ...thinkingConfig ? { thinkingConfig } : {},
-        ...request.responseMimeType ? { responseMimeType: request.responseMimeType } : {},
-        ...request.responseJsonSchema ? { responseJsonSchema: request.responseJsonSchema } : {},
-        ...request.responseModalities ? { responseModalities: Array.from(request.responseModalities) } : {},
-        ...request.imageAspectRatio || request.imageSize ? {
-          imageConfig: {
-            ...request.imageAspectRatio ? { aspectRatio: request.imageAspectRatio } : {},
-            ...request.imageSize ? { imageSize: request.imageSize } : {}
-          }
-        } : {}
-      };
-      const geminiTools = toGeminiTools(request.tools);
-      if (geminiTools) {
-        config.tools = geminiTools;
-      }
-      await runGeminiCall(async (client) => {
-        const stream = await client.models.generateContentStream({
-          model: modelForProvider,
-          contents: geminiContents,
-          config
+        latestUsage = extractChatGptUsageTokens(result2.usage);
+        const fallbackText = typeof result2.text === "string" ? result2.text : "";
+        const fallbackThoughts = typeof result2.reasoningSummaryText === "string" && result2.reasoningSummaryText.length > 0 ? result2.reasoningSummaryText : typeof result2.reasoningText === "string" ? result2.reasoningText : "";
+        if (!sawThoughtDelta && fallbackThoughts.length > 0) {
+          pushDelta("thought", fallbackThoughts);
+        }
+        if (!sawResponseDelta && fallbackText.length > 0) {
+          pushDelta("response", fallbackText);
+        }
+      } else if (provider === "fireworks") {
+        if (request.tools && request.tools.length > 0) {
+          throw new Error(
+            "Fireworks provider does not support provider-native tools in generateText; use runToolLoop for function tools."
+          );
+        }
+        const fireworksMessages = toFireworksMessages(contents, {
+          responseMimeType: request.responseMimeType,
+          responseJsonSchema: request.responseJsonSchema
         });
-        let latestGrounding;
-        for await (const chunk of stream) {
-          if (chunk.modelVersion) {
-            modelVersion = chunk.modelVersion;
-            queue.push({ type: "model", modelVersion });
-          }
-          if (chunk.promptFeedback?.blockReason) {
+        await runFireworksCall(async (client) => {
+          const responseFormat = request.responseJsonSchema ? {
+            type: "json_schema",
+            json_schema: {
+              name: "llm-response",
+              schema: request.responseJsonSchema
+            }
+          } : request.responseMimeType === "application/json" ? { type: "json_object" } : void 0;
+          const response = await client.chat.completions.create(
+            {
+              model: modelForProvider,
+              messages: fireworksMessages,
+              ...responseFormat ? { response_format: responseFormat } : {}
+            },
+            { signal }
+          );
+          modelVersion = typeof response.model === "string" ? response.model : request.model;
+          queue.push({ type: "model", modelVersion });
+          const choice = Array.isArray(response.choices) ? response.choices[0] : void 0;
+          if (choice?.finish_reason === "content_filter") {
             blocked = true;
             queue.push({ type: "blocked" });
           }
-          latestUsage = mergeTokenUpdates(
-            latestUsage,
-            extractGeminiUsageTokens(chunk.usageMetadata)
+          const textOutput = extractFireworksMessageText(
+            choice?.message
           );
-          const candidates = chunk.candidates;
-          if (!candidates || candidates.length === 0) {
-            continue;
-          }
-          const primary = candidates[0];
-          if (primary && isModerationFinish(primary.finishReason)) {
-            blocked = true;
-            queue.push({ type: "blocked" });
+          if (textOutput.length > 0) {
+            pushDelta("response", textOutput);
           }
-          for (const candidate of candidates) {
-            const candidateContent = candidate.content;
-            if (!candidateContent) {
-              continue;
+          latestUsage = extractFireworksUsageTokens(response.usage);
+        }, modelForProvider);
+      } else {
+        const geminiContents = await maybePrepareGeminiPromptContents(
+          contents.map(convertLlmContentToGeminiContent)
+        );
+        const thinkingConfig = resolveGeminiThinkingConfig(modelForProvider, request.thinkingLevel);
+        const config = {
+          maxOutputTokens: 32e3,
+          ...thinkingConfig ? { thinkingConfig } : {},
+          ...request.responseMimeType ? { responseMimeType: request.responseMimeType } : {},
+          ...request.responseJsonSchema ? { responseJsonSchema: request.responseJsonSchema } : {},
+          ...request.responseModalities ? { responseModalities: Array.from(request.responseModalities) } : {},
+          ...request.imageAspectRatio || request.imageSize ? {
+            imageConfig: {
+              ...request.imageAspectRatio ? { aspectRatio: request.imageAspectRatio } : {},
+              ...request.imageSize ? { imageSize: request.imageSize } : {}
+            }
+          } : {}
+        };
+        const geminiTools = toGeminiTools(request.tools);
+        if (geminiTools) {
+          config.tools = geminiTools;
+        }
+        await runGeminiCall(async (client) => {
+          const stream = await client.models.generateContentStream({
+            model: modelForProvider,
+            contents: geminiContents,
+            config
+          });
+          let latestGrounding;
+          for await (const chunk of stream) {
+            if (chunk.modelVersion) {
+              modelVersion = chunk.modelVersion;
+              queue.push({ type: "model", modelVersion });
             }
-            if (candidate.groundingMetadata) {
-              latestGrounding = candidate.groundingMetadata;
+            if (chunk.promptFeedback?.blockReason) {
+              blocked = true;
+              queue.push({ type: "blocked" });
             }
-            const content2 = convertGeminiContentToLlmContent(candidateContent);
-            if (!responseRole) {
-              responseRole = content2.role;
+            latestUsage = mergeTokenUpdates(
+              latestUsage,
+              extractGeminiUsageTokens(chunk.usageMetadata)
+            );
+            const candidates = chunk.candidates;
+            if (!candidates || candidates.length === 0) {
+              continue;
             }
-            for (const part of content2.parts) {
-              if (part.type === "text") {
-                pushDelta(part.thought === true ? "thought" : "response", part.text);
-              } else {
-                pushInline(part.data, part.mimeType);
+            const primary = candidates[0];
+            if (primary && isModerationFinish(primary.finishReason)) {
+              blocked = true;
+              queue.push({ type: "blocked" });
+            }
+            for (const candidate of candidates) {
+              const candidateContent = candidate.content;
+              if (!candidateContent) {
+                continue;
+              }
+              if (candidate.groundingMetadata) {
+                latestGrounding = candidate.groundingMetadata;
+              }
+              const content2 = convertGeminiContentToLlmContent(candidateContent);
+              if (!responseRole) {
+                responseRole = content2.role;
+              }
+              for (const part of content2.parts) {
+                if (part.type === "text") {
+                  pushDelta(part.thought === true ? "thought" : "response", part.text);
+                } else if (part.type === "inlineData") {
+                  pushInline(part.data, part.mimeType);
+                }
               }
             }
           }
+          grounding = latestGrounding;
+        }, modelForProvider);
+      }
+      const mergedParts = mergeConsecutiveTextParts(responseParts);
+      const content = mergedParts.length > 0 ? { role: responseRole ?? "assistant", parts: mergedParts } : void 0;
+      const { text, thoughts } = extractTextByChannel(content);
+      const outputAttachments = collectLoggedAttachmentsFromLlmParts(mergedParts, "output");
+      const costUsd = estimateCallCostUsd({
+        modelId: modelVersion,
+        tokens: latestUsage,
+        responseImages,
+        imageSize: request.imageSize
+      });
+      if (latestUsage) {
+        queue.push({ type: "usage", usage: latestUsage, costUsd, modelVersion });
+      }
+      callLogger?.complete({
+        responseText: text,
+        attachments: outputAttachments,
+        metadata: {
+          provider,
+          model: request.model,
+          modelVersion,
+          blocked,
+          costUsd,
+          usage: latestUsage,
+          grounding: grounding ? sanitiseLogValue(grounding) : void 0,
+          responseChars: text.length,
+          thoughtChars: thoughts.length,
+          responseImages,
+          uploads: getCurrentFileUploadMetrics()
         }
-        grounding = latestGrounding;
-      }, modelForProvider);
-    }
-    const mergedParts = mergeConsecutiveTextParts(responseParts);
-    const content = mergedParts.length > 0 ? { role: responseRole ?? "assistant", parts: mergedParts } : void 0;
-    const { text, thoughts } = extractTextByChannel(content);
-    const outputAttachments = collectLoggedAttachmentsFromLlmParts(mergedParts, "output");
-    const costUsd = estimateCallCostUsd({
-      modelId: modelVersion,
-      tokens: latestUsage,
-      responseImages,
-      imageSize: request.imageSize
-    });
-    if (latestUsage) {
-      queue.push({ type: "usage", usage: latestUsage, costUsd, modelVersion });
-    }
-    callLogger?.complete({
-      responseText: text,
-      attachments: outputAttachments,
-      metadata: {
-        provider,
-        model: request.model,
-        modelVersion,
-        blocked,
-        costUsd,
-        usage: latestUsage,
-        grounding: grounding ? sanitiseLogValue(grounding) : void 0,
-        responseChars: text.length,
-        thoughtChars: thoughts.length,
-        responseImages
-      }
-    });
-    return {
-      provider,
-      model: request.model,
-      modelVersion,
-      content,
-      text,
-      thoughts,
-      blocked,
-      usage: latestUsage,
-      costUsd,
-      grounding
-    };
-  } catch (error) {
-    const partialParts = mergeConsecutiveTextParts(responseParts);
-    const partialContent = partialParts.length > 0 ? { role: responseRole ?? "assistant", parts: partialParts } : void 0;
-    const { text: partialText } = extractTextByChannel(partialContent);
-    callLogger?.fail(error, {
-      responseText: partialText,
-      attachments: collectLoggedAttachmentsFromLlmParts(partialParts, "output"),
-      metadata: {
+      });
+      return {
         provider,
         model: request.model,
         modelVersion,
+        content,
+        text,
+        thoughts,
         blocked,
         usage: latestUsage,
-        partialResponseParts: responseParts.length,
-        responseImages
-      }
-    });
-    throw error;
-  }
+        costUsd,
+        grounding
+      };
+    } catch (error) {
+      const partialParts = mergeConsecutiveTextParts(responseParts);
+      const partialContent = partialParts.length > 0 ? { role: responseRole ?? "assistant", parts: partialParts } : void 0;
+      const { text: partialText } = extractTextByChannel(partialContent);
+      callLogger?.fail(error, {
+        responseText: partialText,
+        attachments: collectLoggedAttachmentsFromLlmParts(partialParts, "output"),
+        metadata: {
+          provider,
+          model: request.model,
+          modelVersion,
+          blocked,
+          usage: latestUsage,
+          partialResponseParts: responseParts.length,
+          responseImages,
+          uploads: getCurrentFileUploadMetrics()
+        }
+      });
+      throw error;
+    }
+  });
+  return result;
 }
 function streamText(request) {
   const queue = createAsyncQueue();
@@ -6266,7 +7790,12 @@ function normalizeToolLoopSteeringInput(input) {
       if (part.type === "text") {
         parts.push({ type: "text", text: part.text });
       } else {
-        parts.push({ type: "inlineData", data: part.data, mimeType: part.mimeType });
+        parts.push({
+          type: "inlineData",
+          data: part.data,
+          mimeType: part.mimeType,
+          filename: part.filename
+        });
       }
     }
     if (parts.length > 0) {
@@ -6454,9 +7983,10 @@ async function runToolLoop(request) {
         let reasoningSummary = "";
         let stepToolCallText;
         let stepToolCallPayload;
+        const preparedInput = await maybePrepareOpenAiPromptInput(input);
         const stepRequestPayload = {
           model: providerInfo.model,
-          input,
+          input: preparedInput,
           ...previousResponseId ? { previous_response_id: previousResponseId } : {},
           ...openAiTools.length > 0 ? { tools: openAiTools } : {},
           ...openAiTools.length > 0 ? { parallel_tool_calls: true } : {},
@@ -6484,7 +8014,7 @@ async function runToolLoop(request) {
               const stream = client.responses.stream(
                 {
                   model: providerInfo.model,
-                  input,
+                  input: preparedInput,
                   ...previousResponseId ? { previous_response_id: previousResponseId } : {},
                   ...openAiTools.length > 0 ? { tools: openAiTools } : {},
                   ...openAiTools.length > 0 ? { parallel_tool_calls: true } : {},
@@ -6661,27 +8191,29 @@ async function runToolLoop(request) {
               input: entry.value
             });
           }
-          const callResults = await Promise.all(
-            callInputs.map(async (entry) => {
-              return await toolCallContextStorage.run(
-                {
-                  toolName: entry.toolName,
-                  toolId: entry.toolId,
-                  turn: entry.turn,
-                  toolIndex: entry.toolIndex
-                },
-                async () => {
-                  const { result, outputPayload } = await executeToolCall({
-                    callKind: entry.call.kind,
+          const callResults = await maybeSpillCombinedToolCallOutputs(
+            await Promise.all(
+              callInputs.map(async (entry) => {
+                return await toolCallContextStorage.run(
+                  {
                     toolName: entry.toolName,
-                    tool: request.tools[entry.toolName],
-                    rawInput: entry.value,
-                    parseError: entry.parseError
-                  });
-                  return { entry, result, outputPayload };
-                }
-              );
-            })
+                    toolId: entry.toolId,
+                    turn: entry.turn,
+                    toolIndex: entry.toolIndex
+                  },
+                  async () => {
+                    const { result, outputPayload } = await executeToolCall({
+                      callKind: entry.call.kind,
+                      toolName: entry.toolName,
+                      tool: request.tools[entry.toolName],
+                      rawInput: entry.value,
+                      parseError: entry.parseError
+                    });
+                    return { entry, result, outputPayload };
+                  }
+                );
+              })
+            )
           );
           const toolOutputs = [];
           let toolExecutionMs = 0;
@@ -6788,7 +8320,7 @@ async function runToolLoop(request) {
       const openAiTools = openAiNativeTools ? [...openAiNativeTools, ...openAiAgentTools] : [...openAiAgentTools];
       const reasoningEffort = resolveOpenAiReasoningEffort(request.model, request.thinkingLevel);
       const toolLoopInput = toChatGptInput(contents);
-      const conversationId = `tool-loop-${(0, import_node_crypto.randomBytes)(8).toString("hex")}`;
+      const conversationId = `tool-loop-${(0, import_node_crypto2.randomBytes)(8).toString("hex")}`;
       const promptCacheKey = conversationId;
       let input = [...toolLoopInput.input];
       for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
@@ -6962,27 +8494,29 @@ async function runToolLoop(request) {
               input: entry.value
             });
           }
-          const callResults = await Promise.all(
-            callInputs.map(async (entry) => {
-              return await toolCallContextStorage.run(
-                {
-                  toolName: entry.toolName,
-                  toolId: entry.toolId,
-                  turn: entry.turn,
-                  toolIndex: entry.toolIndex
-                },
-                async () => {
-                  const { result, outputPayload } = await executeToolCall({
-                    callKind: entry.call.kind,
+          const callResults = await maybeSpillCombinedToolCallOutputs(
+            await Promise.all(
+              callInputs.map(async (entry) => {
+                return await toolCallContextStorage.run(
+                  {
                     toolName: entry.toolName,
-                    tool: request.tools[entry.toolName],
-                    rawInput: entry.value,
-                    parseError: entry.parseError
-                  });
-                  return { entry, result, outputPayload };
-                }
-              );
-            })
+                    toolId: entry.toolId,
+                    turn: entry.turn,
+                    toolIndex: entry.toolIndex
+                  },
+                  async () => {
+                    const { result, outputPayload } = await executeToolCall({
+                      callKind: entry.call.kind,
+                      toolName: entry.toolName,
+                      tool: request.tools[entry.toolName],
+                      rawInput: entry.value,
+                      parseError: entry.parseError
+                    });
+                    return { entry, result, outputPayload };
+                  }
+                );
+              })
+            )
           );
           let toolExecutionMs = 0;
           let waitToolMs = 0;
@@ -7254,27 +8788,29 @@ async function runToolLoop(request) {
               input: entry.value
             });
           }
-          const callResults = await Promise.all(
-            callInputs.map(async (entry) => {
-              return await toolCallContextStorage.run(
-                {
-                  toolName: entry.toolName,
-                  toolId: entry.toolId,
-                  turn: entry.turn,
-                  toolIndex: entry.toolIndex
-                },
-                async () => {
-                  const { result, outputPayload } = await executeToolCall({
-                    callKind: "function",
+          const callResults = await maybeSpillCombinedToolCallOutputs(
+            await Promise.all(
+              callInputs.map(async (entry) => {
+                return await toolCallContextStorage.run(
+                  {
                     toolName: entry.toolName,
-                    tool: request.tools[entry.toolName],
-                    rawInput: entry.value,
-                    parseError: entry.parseError
-                  });
-                  return { entry, result, outputPayload };
-                }
-              );
-            })
+                    toolId: entry.toolId,
+                    turn: entry.turn,
+                    toolIndex: entry.toolIndex
+                  },
+                  async () => {
+                    const { result, outputPayload } = await executeToolCall({
+                      callKind: "function",
+                      toolName: entry.toolName,
+                      tool: request.tools[entry.toolName],
+                      rawInput: entry.value,
+                      parseError: entry.parseError
+                    });
+                    return { entry, result, outputPayload };
+                  }
+                );
+              })
+            )
           );
           const assistantToolCalls = [];
           const toolMessages = [];
@@ -7413,9 +8949,10 @@ async function runToolLoop(request) {
         ...thinkingConfig ? { thinkingConfig } : {}
       };
       const onEvent = request.onEvent;
+      const preparedGeminiContents = await maybePrepareGeminiPromptContents(geminiContents);
       const stepRequestPayload = {
         model: request.model,
-        contents: geminiContents,
+        contents: preparedGeminiContents,
         config
       };
       const stepCallLogger = startLlmCallLoggerFromPayload({
@@ -7429,7 +8966,7 @@ async function runToolLoop(request) {
           async (client) => {
             const stream = await client.models.generateContentStream({
               model: request.model,
-              contents: geminiContents,
+              contents: preparedGeminiContents,
               config
             });
             let responseText2 = "";
@@ -7605,26 +9142,28 @@ async function runToolLoop(request) {
             input: entry.rawInput
           });
         }
-        const callResults = await Promise.all(
-          callInputs.map(async (entry) => {
-            return await toolCallContextStorage.run(
-              {
-                toolName: entry.toolName,
-                toolId: entry.toolId,
-                turn: entry.turn,
-                toolIndex: entry.toolIndex
-              },
-              async () => {
-                const { result, outputPayload } = await executeToolCall({
-                  callKind: "function",
+        const callResults = await maybeSpillCombinedToolCallOutputs(
+          await Promise.all(
+            callInputs.map(async (entry) => {
+              return await toolCallContextStorage.run(
+                {
                   toolName: entry.toolName,
-                  tool: request.tools[entry.toolName],
-                  rawInput: entry.rawInput
-                });
-                return { entry, result, outputPayload };
-              }
-            );
-          })
+                  toolId: entry.toolId,
+                  turn: entry.turn,
+                  toolIndex: entry.toolIndex
+                },
+                async () => {
+                  const { result, outputPayload } = await executeToolCall({
+                    callKind: "function",
+                    toolName: entry.toolName,
+                    tool: request.tools[entry.toolName],
+                    rawInput: entry.rawInput
+                  });
+                  return { entry, result, outputPayload };
+                }
+              );
+            })
+          )
         );
         let toolExecutionMs = 0;
         let waitToolMs = 0;
@@ -8028,11 +9567,11 @@ ${lines}`;
 }
 
 // src/agent.ts
-var import_node_crypto3 = require("crypto");
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_crypto4 = require("crypto");
+var import_node_path9 = __toESM(require("path"), 1);
 
 // src/agent/subagents.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto3 = require("crypto");
 var import_zod4 = require("zod");
 var DEFAULT_SUBAGENT_MAX_AGENTS = 6;
 var DEFAULT_SUBAGENT_MAX_DEPTH = 1;
@@ -8252,7 +9791,7 @@ function createSubagentToolController(options) {
           }
           model = input.model;
         }
-        const id = `agent_${(0, import_node_crypto2.randomBytes)(6).toString("hex")}`;
+        const id = `agent_${(0, import_node_crypto3.randomBytes)(6).toString("hex")}`;
         const now = Date.now();
         const { roleName, roleInstructions } = resolveAgentType(input.agent_type);
         const nickname = reserveAgentNickname(roleName, roleNicknameCounts);
@@ -8504,26 +10043,26 @@ function resolveInputItemsText(items) {
     }
     const itemType = typeof item.type === "string" ? item.type.trim() : "";
     const name = typeof item.name === "string" ? item.name.trim() : "";
-    const path8 = typeof item.path === "string" ? item.path.trim() : "";
+    const path10 = typeof item.path === "string" ? item.path.trim() : "";
     const imageUrl = typeof item.image_url === "string" ? item.image_url.trim() : "";
     if (itemType === "image") {
       lines.push("[image]");
       continue;
     }
-    if (itemType === "local_image" && path8) {
-      lines.push(`[local_image:${path8}]`);
+    if (itemType === "local_image" && path10) {
+      lines.push(`[local_image:${path10}]`);
       continue;
     }
-    if (itemType === "skill" && name && path8) {
-      lines.push(`[skill:$${name}](${path8})`);
+    if (itemType === "skill" && name && path10) {
+      lines.push(`[skill:$${name}](${path10})`);
       continue;
     }
-    if (itemType === "mention" && name && path8) {
-      lines.push(`[mention:$${name}](${path8})`);
+    if (itemType === "mention" && name && path10) {
+      lines.push(`[mention:$${name}](${path10})`);
       continue;
     }
-    if (path8 || imageUrl) {
-      lines.push(`[${itemType || "input"}:${path8 || imageUrl}]`);
+    if (path10 || imageUrl) {
+      lines.push(`[${itemType || "input"}:${path10 || imageUrl}]`);
       continue;
     }
     if (name) {
@@ -8812,7 +10351,7 @@ function joinInstructionBlocks(...blocks) {
   return parts.join("\n\n");
 }
 function randomSubmissionId() {
-  return `sub_${(0, import_node_crypto2.randomBytes)(6).toString("hex")}`;
+  return `sub_${(0, import_node_crypto3.randomBytes)(6).toString("hex")}`;
 }
 function normalizeInteger(value, fallback, min, max) {
   const parsed = Number.isFinite(value) ? Math.floor(value) : fallback;
@@ -8841,27 +10380,27 @@ function sleep2(ms) {
 }
 
 // src/tools/filesystemTools.ts
-var import_node_path6 = __toESM(require("path"), 1);
-var import_node_buffer4 = require("buffer");
+var import_node_path8 = __toESM(require("path"), 1);
+var import_node_buffer5 = require("buffer");
 var import_zod6 = require("zod");
 
 // src/tools/applyPatch.ts
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 var import_zod5 = require("zod");
 
 // src/tools/filesystem.ts
-var import_node_fs3 = require("fs");
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_fs4 = require("fs");
+var import_node_path6 = __toESM(require("path"), 1);
 var InMemoryAgentFilesystem = class {
   #files = /* @__PURE__ */ new Map();
   #dirs = /* @__PURE__ */ new Map();
   #clock = 0;
   constructor(initialFiles = {}) {
-    const root = import_node_path4.default.resolve("/");
+    const root = import_node_path6.default.resolve("/");
     this.#dirs.set(root, { mtimeMs: this.#nextMtime() });
     for (const [filePath, content] of Object.entries(initialFiles)) {
-      const absolutePath = import_node_path4.default.resolve(filePath);
-      this.#ensureDirSync(import_node_path4.default.dirname(absolutePath));
+      const absolutePath = import_node_path6.default.resolve(filePath);
+      this.#ensureDirSync(import_node_path6.default.dirname(absolutePath));
       this.#files.set(absolutePath, {
         content,
         mtimeMs: this.#nextMtime()
@@ -8869,7 +10408,7 @@ var InMemoryAgentFilesystem = class {
     }
   }
   async readTextFile(filePath) {
-    const absolutePath = import_node_path4.default.resolve(filePath);
+    const absolutePath = import_node_path6.default.resolve(filePath);
     const file = this.#files.get(absolutePath);
     if (!file) {
       throw createNoSuchFileError("open", absolutePath);
@@ -8881,24 +10420,24 @@ var InMemoryAgentFilesystem = class {
     return Buffer.from(content, "utf8");
   }
   async writeTextFile(filePath, content) {
-    const absolutePath = import_node_path4.default.resolve(filePath);
-    const parentPath = import_node_path4.default.dirname(absolutePath);
+    const absolutePath = import_node_path6.default.resolve(filePath);
+    const parentPath = import_node_path6.default.dirname(absolutePath);
     if (!this.#dirs.has(parentPath)) {
       throw createNoSuchFileError("open", parentPath);
     }
     this.#files.set(absolutePath, { content, mtimeMs: this.#nextMtime() });
   }
   async deleteFile(filePath) {
-    const absolutePath = import_node_path4.default.resolve(filePath);
+    const absolutePath = import_node_path6.default.resolve(filePath);
     if (!this.#files.delete(absolutePath)) {
       throw createNoSuchFileError("unlink", absolutePath);
     }
   }
   async ensureDir(directoryPath) {
-    this.#ensureDirSync(import_node_path4.default.resolve(directoryPath));
+    this.#ensureDirSync(import_node_path6.default.resolve(directoryPath));
   }
   async readDir(directoryPath) {
-    const absolutePath = import_node_path4.default.resolve(directoryPath);
+    const absolutePath = import_node_path6.default.resolve(directoryPath);
     const directory = this.#dirs.get(absolutePath);
     if (!directory) {
       throw createNoSuchFileError("scandir", absolutePath);
@@ -8909,10 +10448,10 @@ var InMemoryAgentFilesystem = class {
       if (dirPath === absolutePath) {
         continue;
       }
-      if (import_node_path4.default.dirname(dirPath) !== absolutePath) {
+      if (import_node_path6.default.dirname(dirPath) !== absolutePath) {
         continue;
       }
-      const name = import_node_path4.default.basename(dirPath);
+      const name = import_node_path6.default.basename(dirPath);
       if (seenNames.has(name)) {
         continue;
       }
@@ -8925,10 +10464,10 @@ var InMemoryAgentFilesystem = class {
       });
     }
     for (const [filePath, fileRecord] of this.#files.entries()) {
-      if (import_node_path4.default.dirname(filePath) !== absolutePath) {
+      if (import_node_path6.default.dirname(filePath) !== absolutePath) {
         continue;
       }
-      const name = import_node_path4.default.basename(filePath);
+      const name = import_node_path6.default.basename(filePath);
       if (seenNames.has(name)) {
         continue;
       }
@@ -8944,7 +10483,7 @@ var InMemoryAgentFilesystem = class {
     return entries;
   }
   async stat(entryPath) {
-    const absolutePath = import_node_path4.default.resolve(entryPath);
+    const absolutePath = import_node_path6.default.resolve(entryPath);
     const file = this.#files.get(absolutePath);
     if (file) {
       return { kind: "file", mtimeMs: file.mtimeMs };
@@ -8960,7 +10499,7 @@ var InMemoryAgentFilesystem = class {
     return Object.fromEntries(entries.map(([filePath, record]) => [filePath, record.content]));
   }
   #ensureDirSync(directoryPath) {
-    const absolutePath = import_node_path4.default.resolve(directoryPath);
+    const absolutePath = import_node_path6.default.resolve(directoryPath);
     const parts = [];
     let cursor = absolutePath;
     for (; ; ) {
@@ -8968,7 +10507,7 @@ var InMemoryAgentFilesystem = class {
         break;
       }
       parts.push(cursor);
-      const parent = import_node_path4.default.dirname(cursor);
+      const parent = import_node_path6.default.dirname(cursor);
       if (parent === cursor) {
         break;
       }
@@ -8991,19 +10530,19 @@ var InMemoryAgentFilesystem = class {
 };
 function createNodeAgentFilesystem() {
   return {
-    readTextFile: async (filePath) => import_node_fs3.promises.readFile(filePath, "utf8"),
-    readBinaryFile: async (filePath) => import_node_fs3.promises.readFile(filePath),
-    writeTextFile: async (filePath, content) => import_node_fs3.promises.writeFile(filePath, content, "utf8"),
-    deleteFile: async (filePath) => import_node_fs3.promises.unlink(filePath),
+    readTextFile: async (filePath) => import_node_fs4.promises.readFile(filePath, "utf8"),
+    readBinaryFile: async (filePath) => import_node_fs4.promises.readFile(filePath),
+    writeTextFile: async (filePath, content) => import_node_fs4.promises.writeFile(filePath, content, "utf8"),
+    deleteFile: async (filePath) => import_node_fs4.promises.unlink(filePath),
     ensureDir: async (directoryPath) => {
-      await import_node_fs3.promises.mkdir(directoryPath, { recursive: true });
+      await import_node_fs4.promises.mkdir(directoryPath, { recursive: true });
     },
     readDir: async (directoryPath) => {
-      const entries = await import_node_fs3.promises.readdir(directoryPath, { withFileTypes: true });
+      const entries = await import_node_fs4.promises.readdir(directoryPath, { withFileTypes: true });
       const result = [];
       for (const entry of entries) {
-        const entryPath = import_node_path4.default.resolve(directoryPath, entry.name);
-        const stats = await import_node_fs3.promises.lstat(entryPath);
+        const entryPath = import_node_path6.default.resolve(directoryPath, entry.name);
+        const stats = await import_node_fs4.promises.lstat(entryPath);
         result.push({
           name: entry.name,
           path: entryPath,
@@ -9014,7 +10553,7 @@ function createNodeAgentFilesystem() {
       return result;
     },
     stat: async (entryPath) => {
-      const stats = await import_node_fs3.promises.lstat(entryPath);
+      const stats = await import_node_fs4.promises.lstat(entryPath);
       return {
         kind: statsToKind(stats),
         mtimeMs: stats.mtimeMs
@@ -9166,7 +10705,7 @@ function createApplyPatchTool(options = {}) {
   });
 }
 async function applyPatch(request) {
-  const cwd = import_node_path5.default.resolve(request.cwd ?? process.cwd());
+  const cwd = import_node_path7.default.resolve(request.cwd ?? process.cwd());
   const adapter = request.fs ?? createNodeAgentFilesystem();
   const allowOutsideCwd = request.allowOutsideCwd === true;
   const patchBytes = Buffer.byteLength(request.patch, "utf8");
@@ -9188,7 +10727,7 @@ async function applyPatch(request) {
         kind: "add",
         path: absolutePath2
       });
-      await adapter.ensureDir(import_node_path5.default.dirname(absolutePath2));
+      await adapter.ensureDir(import_node_path7.default.dirname(absolutePath2));
       await adapter.writeTextFile(absolutePath2, operation.content);
       added.push(toDisplayPath(absolutePath2, cwd));
       continue;
@@ -9222,7 +10761,7 @@ async function applyPatch(request) {
         fromPath: absolutePath,
         toPath: destinationPath
       });
-      await adapter.ensureDir(import_node_path5.default.dirname(destinationPath));
+      await adapter.ensureDir(import_node_path7.default.dirname(destinationPath));
       await adapter.writeTextFile(destinationPath, next);
       await adapter.deleteFile(absolutePath);
       modified.push(toDisplayPath(destinationPath, cwd));
@@ -9253,22 +10792,22 @@ function resolvePatchPath(rawPath, cwd, allowOutsideCwd) {
   if (trimmed.length === 0) {
     throw new Error("apply_patch failed: empty file path");
   }
-  const absolutePath = import_node_path5.default.isAbsolute(trimmed) ? import_node_path5.default.resolve(trimmed) : import_node_path5.default.resolve(cwd, trimmed);
+  const absolutePath = import_node_path7.default.isAbsolute(trimmed) ? import_node_path7.default.resolve(trimmed) : import_node_path7.default.resolve(cwd, trimmed);
   if (!allowOutsideCwd && !isPathInsideCwd(absolutePath, cwd)) {
     throw new Error(`apply_patch failed: path "${trimmed}" resolves outside cwd "${cwd}"`);
   }
   return absolutePath;
 }
 function isPathInsideCwd(candidatePath, cwd) {
-  const relative = import_node_path5.default.relative(cwd, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !import_node_path5.default.isAbsolute(relative);
+  const relative = import_node_path7.default.relative(cwd, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !import_node_path7.default.isAbsolute(relative);
 }
 function toDisplayPath(absolutePath, cwd) {
-  const relative = import_node_path5.default.relative(cwd, absolutePath);
+  const relative = import_node_path7.default.relative(cwd, absolutePath);
   if (relative === "") {
     return ".";
   }
-  if (!relative.startsWith("..") && !import_node_path5.default.isAbsolute(relative)) {
+  if (!relative.startsWith("..") && !import_node_path7.default.isAbsolute(relative)) {
     return relative;
   }
   return absolutePath;
@@ -10035,7 +11574,7 @@ async function readBinaryFile(filesystem, filePath) {
     return await filesystem.readBinaryFile(filePath);
   }
   const text = await filesystem.readTextFile(filePath);
-  return import_node_buffer4.Buffer.from(text, "utf8");
+  return import_node_buffer5.Buffer.from(text, "utf8");
 }
 function detectImageMimeType(buffer, filePath) {
   if (buffer.length >= 8 && buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71 && buffer[4] === 13 && buffer[5] === 10 && buffer[6] === 26 && buffer[7] === 10) {
@@ -10053,7 +11592,7 @@ function detectImageMimeType(buffer, filePath) {
   if (buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP") {
     return "image/webp";
   }
-  const fromExtension = IMAGE_MIME_BY_EXTENSION[import_node_path6.default.extname(filePath).toLowerCase()];
+  const fromExtension = IMAGE_MIME_BY_EXTENSION[import_node_path8.default.extname(filePath).toLowerCase()];
   if (fromExtension && SUPPORTED_IMAGE_MIME_TYPES.has(fromExtension)) {
     return fromExtension;
   }
@@ -10063,13 +11602,13 @@ function isPdfFile(buffer, filePath) {
   if (buffer.length >= 5 && buffer.subarray(0, 5).toString("ascii") === "%PDF-") {
     return true;
   }
-  return import_node_path6.default.extname(filePath).toLowerCase() === ".pdf";
+  return import_node_path8.default.extname(filePath).toLowerCase() === ".pdf";
 }
 function isValidUtf8(buffer) {
   if (buffer.length === 0) {
     return true;
   }
-  return import_node_buffer4.Buffer.from(buffer.toString("utf8"), "utf8").equals(buffer);
+  return import_node_buffer5.Buffer.from(buffer.toString("utf8"), "utf8").equals(buffer);
 }
 async function readFileGemini(input, options) {
   const runtime = resolveRuntime(options);
@@ -10101,7 +11640,7 @@ async function writeFileGemini(input, options) {
     action: "write",
     path: filePath
   });
-  await runtime.filesystem.ensureDir(import_node_path6.default.dirname(filePath));
+  await runtime.filesystem.ensureDir(import_node_path8.default.dirname(filePath));
   await runtime.filesystem.writeTextFile(filePath, input.content);
   return `Successfully wrote file: ${toDisplayPath2(filePath, runtime.cwd)}`;
 }
@@ -10122,7 +11661,7 @@ async function replaceFileContentGemini(input, options) {
     originalContent = await runtime.filesystem.readTextFile(filePath);
   } catch (error) {
     if (isNoEntError(error) && oldValue.length === 0) {
-      await runtime.filesystem.ensureDir(import_node_path6.default.dirname(filePath));
+      await runtime.filesystem.ensureDir(import_node_path8.default.dirname(filePath));
       await runtime.filesystem.writeTextFile(filePath, newValue);
       return `Successfully wrote new file: ${toDisplayPath2(filePath, runtime.cwd)}`;
     }
@@ -10292,15 +11831,15 @@ async function globFilesGemini(input, options) {
     throw new Error(`Path is not a directory: ${dirPath}`);
   }
   const matcher = createGlobMatcher(input.pattern, input.case_sensitive === true);
-  const files = await collectSearchFiles({
+  const files2 = await collectSearchFiles({
     filesystem: runtime.filesystem,
     searchPath: dirPath,
     rootKind: "directory",
     maxScannedFiles: runtime.grepMaxScannedFiles
   });
   const matched = [];
-  for (const filePath of files) {
-    const relativePath = normalizeSlashes(import_node_path6.default.relative(dirPath, filePath));
+  for (const filePath of files2) {
+    const relativePath = normalizeSlashes(import_node_path8.default.relative(dirPath, filePath));
     if (!matcher(relativePath)) {
       continue;
     }
@@ -10318,7 +11857,7 @@ async function globFilesGemini(input, options) {
 }
 function resolveRuntime(options) {
   return {
-    cwd: import_node_path6.default.resolve(options.cwd ?? process.cwd()),
+    cwd: import_node_path8.default.resolve(options.cwd ?? process.cwd()),
     filesystem: options.fs ?? createNodeAgentFilesystem(),
     allowOutsideCwd: options.allowOutsideCwd === true,
     checkAccess: options.checkAccess,
@@ -10349,13 +11888,13 @@ function mapApplyPatchAction(action) {
   return "move";
 }
 function resolvePathWithPolicy(inputPath, cwd, allowOutsideCwd) {
-  const absolutePath = import_node_path6.default.isAbsolute(inputPath) ? import_node_path6.default.resolve(inputPath) : import_node_path6.default.resolve(cwd, inputPath);
+  const absolutePath = import_node_path8.default.isAbsolute(inputPath) ? import_node_path8.default.resolve(inputPath) : import_node_path8.default.resolve(cwd, inputPath);
   if (allowOutsideCwd || isPathInsideCwd2(absolutePath, cwd)) {
     return absolutePath;
   }
-  if (import_node_path6.default.isAbsolute(inputPath)) {
+  if (import_node_path8.default.isAbsolute(inputPath)) {
     const sandboxRelativePath = inputPath.replace(/^[/\\]+/, "");
-    const sandboxRootedPath = import_node_path6.default.resolve(cwd, sandboxRelativePath);
+    const sandboxRootedPath = import_node_path8.default.resolve(cwd, sandboxRelativePath);
     if (isPathInsideCwd2(sandboxRootedPath, cwd)) {
       return sandboxRootedPath;
     }
@@ -10363,25 +11902,25 @@ function resolvePathWithPolicy(inputPath, cwd, allowOutsideCwd) {
   throw new Error(`path "${inputPath}" resolves outside cwd "${cwd}"`);
 }
 function isPathInsideCwd2(candidatePath, cwd) {
-  const relative = import_node_path6.default.relative(cwd, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !import_node_path6.default.isAbsolute(relative);
+  const relative = import_node_path8.default.relative(cwd, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !import_node_path8.default.isAbsolute(relative);
 }
 function toDisplayPath2(absolutePath, cwd) {
-  const relative = import_node_path6.default.relative(cwd, absolutePath);
+  const relative = import_node_path8.default.relative(cwd, absolutePath);
   if (relative === "") {
     return ".";
   }
-  if (!relative.startsWith("..") && !import_node_path6.default.isAbsolute(relative)) {
+  if (!relative.startsWith("..") && !import_node_path8.default.isAbsolute(relative)) {
     return relative;
   }
   return absolutePath;
 }
 function toSandboxDisplayPath(absolutePath, cwd) {
-  const relative = import_node_path6.default.relative(cwd, absolutePath);
+  const relative = import_node_path8.default.relative(cwd, absolutePath);
   if (relative === "") {
     return "/";
   }
-  if (!relative.startsWith("..") && !import_node_path6.default.isAbsolute(relative)) {
+  if (!relative.startsWith("..") && !import_node_path8.default.isAbsolute(relative)) {
     return `/${normalizeSlashes(relative)}`;
   }
   return normalizeSlashes(absolutePath);
@@ -10457,7 +11996,7 @@ async function collectSearchFiles(params) {
     return [searchPath];
   }
   const queue = [searchPath];
-  const files = [];
+  const files2 = [];
   while (queue.length > 0) {
     const current = queue.shift();
     if (!current) {
@@ -10472,13 +12011,13 @@ async function collectSearchFiles(params) {
       if (entry.kind !== "file") {
         continue;
       }
-      files.push(entry.path);
-      if (files.length >= maxScannedFiles) {
-        return files;
+      files2.push(entry.path);
+      if (files2.length >= maxScannedFiles) {
+        return files2;
       }
     }
   }
-  return files;
+  return files2;
 }
 function compileRegex(pattern, flags = "m") {
   try {
@@ -10497,7 +12036,7 @@ function createGlobMatcher(pattern, caseSensitive = false) {
   }));
   return (candidatePath) => {
     const normalizedPath = normalizeSlashes(candidatePath);
-    const basename = import_node_path6.default.posix.basename(normalizedPath);
+    const basename = import_node_path8.default.posix.basename(normalizedPath);
     return compiled.some(
       (entry) => entry.regex.test(entry.applyToBasename ? basename : normalizedPath)
     );
@@ -10774,13 +12313,24 @@ async function runAgentLoopInternal(request, context) {
     }
     streamEventLogger?.appendEvent(event);
   } : void 0;
+  let uploadMetrics = emptyFileUploadMetrics();
   try {
-    const result = await runToolLoop({
-      ...toolLoopRequestWithSteering,
-      ...instructions ? { instructions } : {},
-      ...wrappedOnEvent ? { onEvent: wrappedOnEvent } : {},
-      tools: mergedTools
+    let result;
+    await collectFileUploadMetrics(async () => {
+      try {
+        result = await runToolLoop({
+          ...toolLoopRequestWithSteering,
+          ...instructions ? { instructions } : {},
+          ...wrappedOnEvent ? { onEvent: wrappedOnEvent } : {},
+          tools: mergedTools
+        });
+      } finally {
+        uploadMetrics = getCurrentFileUploadMetrics();
+      }
     });
+    if (!result) {
+      throw new Error("runToolLoop returned no result.");
+    }
     streamEventLogger?.flush();
     emitTelemetry({
       type: "agent.run.completed",
@@ -10789,7 +12339,10 @@ async function runAgentLoopInternal(request, context) {
       stepCount: result.steps.length,
       toolCallCount: countToolCalls(result),
       totalCostUsd: result.totalCostUsd,
-      usage: summarizeResultUsage(result)
+      usage: summarizeResultUsage(result),
+      uploadCount: uploadMetrics.count,
+      uploadBytes: uploadMetrics.totalBytes,
+      uploadLatencyMs: uploadMetrics.totalLatencyMs
     });
     loggingSession?.logLine(
       [
@@ -10798,7 +12351,10 @@ async function runAgentLoopInternal(request, context) {
         `durationMs=${Math.max(0, Date.now() - startedAtMs).toString()}`,
         `steps=${result.steps.length.toString()}`,
         `toolCalls=${countToolCalls(result).toString()}`,
-        `totalCostUsd=${(result.totalCostUsd ?? 0).toFixed(6)}`
+        `totalCostUsd=${(result.totalCostUsd ?? 0).toFixed(6)}`,
+        `uploadCount=${uploadMetrics.count.toString()}`,
+        `uploadBytes=${uploadMetrics.totalBytes.toString()}`,
+        `uploadLatencyMs=${uploadMetrics.totalLatencyMs.toString()}`
       ].join(" ")
     );
     for (const step of result.steps) {
@@ -10819,6 +12375,9 @@ async function runAgentLoopInternal(request, context) {
       type: "agent.run.completed",
       success: false,
       durationMs: Math.max(0, Date.now() - startedAtMs),
+      uploadCount: uploadMetrics.count,
+      uploadBytes: uploadMetrics.totalBytes,
+      uploadLatencyMs: uploadMetrics.totalLatencyMs,
       error: toErrorMessage3(error)
     });
     loggingSession?.logLine(
@@ -10826,6 +12385,9 @@ async function runAgentLoopInternal(request, context) {
         `[agent:${runId}] run_completed`,
         `status=error`,
         `durationMs=${Math.max(0, Date.now() - startedAtMs).toString()}`,
+        `uploadCount=${uploadMetrics.count.toString()}`,
+        `uploadBytes=${uploadMetrics.totalBytes.toString()}`,
+        `uploadLatencyMs=${uploadMetrics.totalLatencyMs.toString()}`,
         `error=${toErrorMessage3(error)}`
       ].join(" ")
     );
@@ -10963,7 +12525,7 @@ function trimToUndefined2(value) {
   return trimmed && trimmed.length > 0 ? trimmed : void 0;
 }
 function randomRunId() {
-  return (0, import_node_crypto3.randomBytes)(8).toString("hex");
+  return (0, import_node_crypto4.randomBytes)(8).toString("hex");
 }
 function toIsoNow2() {
   return (/* @__PURE__ */ new Date()).toISOString();
@@ -11032,7 +12594,7 @@ function resolveWorkspaceDirForLogging(request) {
   if (explicitSelection && typeof explicitSelection === "object" && !Array.isArray(explicitSelection)) {
     const cwd = explicitSelection.options?.cwd;
     if (typeof cwd === "string" && cwd.trim().length > 0) {
-      return import_node_path7.default.resolve(cwd);
+      return import_node_path9.default.resolve(cwd);
     }
   }
   return process.cwd();
@@ -11042,7 +12604,7 @@ function createRootAgentLoggingSession(request) {
   if (!selected) {
     return void 0;
   }
-  const workspaceDir = typeof selected.workspaceDir === "string" && selected.workspaceDir.trim().length > 0 ? import_node_path7.default.resolve(selected.workspaceDir) : resolveWorkspaceDirForLogging(request);
+  const workspaceDir = typeof selected.workspaceDir === "string" && selected.workspaceDir.trim().length > 0 ? import_node_path9.default.resolve(selected.workspaceDir) : resolveWorkspaceDirForLogging(request);
   return createAgentLoggingSession({
     ...selected,
     workspaceDir,
@@ -11120,7 +12682,7 @@ function createAgentTelemetryEmitter(params) {
 }
 
 // src/agent/candidateEvolution.ts
-var import_node_crypto4 = require("crypto");
+var import_node_crypto5 = require("crypto");
 var DEFAULT_BATCH_SIZE = 1;
 var DEFAULT_GENERATION_CONCURRENCY = 8;
 var DEFAULT_ASSESSMENT_CONCURRENCY = 8;
@@ -11152,7 +12714,7 @@ function addStats(left, right) {
   };
 }
 function randomId(prefix) {
-  return `${prefix}_${(0, import_node_crypto4.randomBytes)(8).toString("hex")}`;
+  return `${prefix}_${(0, import_node_crypto5.randomBytes)(8).toString("hex")}`;
 }
 function toFiniteNumber(value, fallback) {
   if (!Number.isFinite(value)) {
@@ -11777,6 +13339,7 @@ async function runCandidateEvolution(options) {
   CODEX_APPLY_PATCH_FREEFORM_TOOL_DESCRIPTION,
   CODEX_APPLY_PATCH_JSON_TOOL_DESCRIPTION,
   CODEX_APPLY_PATCH_LARK_GRAMMAR,
+  DEFAULT_FILE_TTL_SECONDS,
   FIREWORKS_DEFAULT_GLM_MODEL,
   FIREWORKS_DEFAULT_GPT_OSS_120B_MODEL,
   FIREWORKS_DEFAULT_KIMI_MODEL,
@@ -11817,10 +13380,12 @@ async function runCandidateEvolution(options) {
   createViewImageTool,
   createWriteFileTool,
   customTool,
+  emptyFileUploadMetrics,
   encodeChatGptAuthJson,
   encodeChatGptAuthJsonB64,
   estimateCallCostUsd,
   exchangeChatGptOauthCode,
+  files,
   generateImageInBatches,
   generateImages,
   generateJson,