@ljoukov/llm 4.0.0 → 4.0.2

package/dist/index.cjs

@@ -115,8 +115,8 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/llm.ts
-var import_node_buffer2 = require("buffer");
-var import_node_async_hooks = require("async_hooks");
+var import_node_buffer3 = require("buffer");
+var import_node_async_hooks2 = require("async_hooks");
 var import_node_crypto = require("crypto");
 var import_genai2 = require("@google/genai");
 var import_zod_to_json_schema = require("@alcyone-labs/zod-to-json-schema");
@@ -2755,8 +2755,375 @@ function stripChatGptPrefix(model) {
   return model.slice("chatgpt-".length);
 }
 
+// src/agentLogging.ts
+var import_node_async_hooks = require("async_hooks");
+var import_node_buffer2 = require("buffer");
+var import_promises = require("fs/promises");
+var import_node_path3 = __toESM(require("path"), 1);
+function toIsoNow() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function toErrorMessage(error) {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return String(error);
+}
+function isPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
+}
+function normalisePathSegment(value) {
+  const cleaned = value.trim().replace(/[^a-z0-9._-]+/giu, "-").replace(/-{2,}/g, "-").replace(/^-+|-+$/g, "");
+  return cleaned.length > 0 ? cleaned : "segment";
+}
+function ensureTrailingNewline(value) {
+  return value.endsWith("\n") ? value : `${value}
+`;
+}
+function redactDataUrlPayload(value) {
+  if (!value.toLowerCase().startsWith("data:")) {
+    return value;
+  }
+  const commaIndex = value.indexOf(",");
+  if (commaIndex < 0) {
+    return value;
+  }
+  return `${value.slice(0, commaIndex + 1)}...`;
+}
+function sanitiseLogValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value === "string") {
+    return redactDataUrlPayload(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean" || value === null || value === void 0) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => sanitiseLogValue(entry, seen));
+  }
+  if (typeof value !== "object") {
+    return String(value);
+  }
+  if (seen.has(value)) {
+    return "[circular]";
+  }
+  seen.add(value);
+  const record = value;
+  const output = {};
+  const hasInlineMime = typeof record.mimeType === "string" && record.mimeType.trim().length > 0 || typeof record.mime_type === "string" && record.mime_type.trim().length > 0;
+  for (const [key, entryValue] of Object.entries(record)) {
+    if (key === "image_url") {
+      if (typeof entryValue === "string") {
+        output[key] = redactDataUrlPayload(entryValue);
+        continue;
+      }
+      if (entryValue && typeof entryValue === "object") {
+        const nested = entryValue;
+        if (typeof nested.url === "string") {
+          output[key] = {
+            ...nested,
+            url: redactDataUrlPayload(nested.url)
+          };
+          continue;
+        }
+      }
+    }
+    if (key === "data" && hasInlineMime && typeof entryValue === "string") {
+      output[key] = `[omitted:${import_node_buffer2.Buffer.byteLength(entryValue, "utf8")}b]`;
+      continue;
+    }
+    output[key] = sanitiseLogValue(entryValue, seen);
+  }
+  return output;
+}
+function serialiseForSnippet(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(sanitiseLogValue(value));
+  } catch {
+    return String(value);
+  }
+}
+function formatToolLogSnippet(value) {
+  const compact = serialiseForSnippet(value).replace(/\s+/gu, " ").trim();
+  if (compact.length === 0) {
+    return "<empty>";
+  }
+  const max = 600;
+  if (compact.length <= max) {
+    return compact;
+  }
+  return `${compact.slice(0, max)}...`;
+}
+function formatUsd(value) {
+  const amount = typeof value === "number" && Number.isFinite(value) ? Math.max(0, value) : 0;
+  return amount.toFixed(6);
+}
+function appendToolCallStreamLog(options) {
+  const event = options.event;
+  if (event.type !== "tool_call") {
+    return;
+  }
+  const callIdSegment = typeof event.callId === "string" && event.callId.trim().length > 0 ? ` callId=${event.callId}` : "";
+  const prefix = [
+    `tool_call_${event.phase}:`,
+    `turn=${event.turn.toString()}`,
+    `index=${event.toolIndex.toString()}`,
+    `tool=${event.toolName}${callIdSegment}`
+  ].join(" ");
+  if (event.phase === "started") {
+    options.append(prefix);
+    options.append(`tool_call_input: ${formatToolLogSnippet(sanitiseLogValue(event.input))}`);
+    return;
+  }
+  const durationSegment = typeof event.durationMs === "number" && Number.isFinite(event.durationMs) ? ` durationMs=${Math.max(0, Math.round(event.durationMs)).toString()}` : "";
+  options.append(`${prefix} status=${event.error ? "error" : "ok"}${durationSegment}`);
+  options.append(`tool_call_output: ${formatToolLogSnippet(sanitiseLogValue(event.output))}`);
+  if (typeof event.error === "string" && event.error.trim().length > 0) {
+    options.append(`tool_call_error: ${event.error.trim()}`);
+  }
+}
+function appendAgentStreamEventLog(options) {
+  const event = options.event;
+  switch (event.type) {
+    case "delta": {
+      const channelPrefix = event.channel === "thought" ? "thought_delta" : "response_delta";
+      options.append(`${channelPrefix}: ${event.text}`);
+      return;
+    }
+    case "model": {
+      options.append(`model: ${event.modelVersion}`);
+      return;
+    }
+    case "usage": {
+      options.append(
+        [
+          "usage:",
+          `modelVersion=${event.modelVersion}`,
+          `costUsd=${formatUsd(event.costUsd)}`,
+          `tokens=${formatToolLogSnippet(sanitiseLogValue(event.usage))}`
+        ].join(" ")
+      );
+      return;
+    }
+    case "blocked": {
+      options.append("blocked");
+      return;
+    }
+    case "tool_call": {
+      appendToolCallStreamLog({
+        event,
+        append: options.append
+      });
+      return;
+    }
+  }
+}
+var AgentLoggingSessionImpl = class {
+  workspaceDir;
+  logsRootDir;
+  mirrorToConsole;
+  sink;
+  agentLogPath;
+  ensureReady;
+  pending = /* @__PURE__ */ new Set();
+  lineChain = Promise.resolve();
+  callCounter = 0;
+  constructor(config) {
+    this.workspaceDir = import_node_path3.default.resolve(config.workspaceDir ?? process.cwd());
+    this.logsRootDir = import_node_path3.default.join(import_node_path3.default.dirname(this.workspaceDir), "logs");
+    this.mirrorToConsole = config.mirrorToConsole !== false;
+    this.sink = config.sink;
+    this.agentLogPath = import_node_path3.default.join(this.workspaceDir, "agent.log");
+    this.ensureReady = this.prepare();
+    this.track(this.ensureReady);
+  }
+  async prepare() {
+    await (0, import_promises.mkdir)(this.workspaceDir, { recursive: true });
+    await (0, import_promises.mkdir)(this.logsRootDir, { recursive: true });
+  }
+  track(task) {
+    this.pending.add(task);
+    task.finally(() => {
+      this.pending.delete(task);
+    });
+  }
+  enqueueLineWrite(line) {
+    const next = this.lineChain.then(async () => {
+      await this.ensureReady;
+      await (0, import_promises.appendFile)(this.agentLogPath, `${line}
+`, "utf8");
+      const sinkResult = this.sink?.append(line);
+      if (isPromiseLike(sinkResult)) {
+        await sinkResult;
+      }
+    });
+    const tracked = next.catch(() => void 0);
+    this.lineChain = tracked;
+    this.track(tracked);
+  }
+  logLine(line) {
+    const timestamped = `${toIsoNow()} ${line}`;
+    if (this.mirrorToConsole) {
+      console.log(timestamped);
+    }
+    this.enqueueLineWrite(timestamped);
+  }
+  startLlmCall(input) {
+    const callNumber = this.callCounter + 1;
+    this.callCounter = callNumber;
+    const timestampSegment = toIsoNow().replace(/[:]/g, "-");
+    const modelSegment = normalisePathSegment(input.modelId);
+    const baseDir = import_node_path3.default.join(
+      this.logsRootDir,
+      `${timestampSegment}-${callNumber.toString().padStart(4, "0")}`,
+      modelSegment
+    );
+    const responsePath = import_node_path3.default.join(baseDir, "response.txt");
+    const thoughtsPath = import_node_path3.default.join(baseDir, "thoughts.txt");
+    const responseMetadataPath = import_node_path3.default.join(baseDir, "response.metadata.json");
+    let chain = this.ensureReady.then(async () => {
+      await (0, import_promises.mkdir)(baseDir, { recursive: true });
+      const requestText = input.requestText.trim().length > 0 ? input.requestText : "<empty request>";
+      await (0, import_promises.writeFile)(
+        import_node_path3.default.join(baseDir, "request.txt"),
+        ensureTrailingNewline(requestText),
+        "utf8"
+      );
+      const requestMetadata = {
+        capturedAt: toIsoNow(),
+        provider: input.provider,
+        modelId: input.modelId,
+        ...input.requestMetadata ? { request: sanitiseLogValue(input.requestMetadata) } : {}
+      };
+      await (0, import_promises.writeFile)(
+        import_node_path3.default.join(baseDir, "request.metadata.json"),
+        `${JSON.stringify(requestMetadata, null, 2)}
+`,
+        "utf8"
+      );
+      const usedNames = /* @__PURE__ */ new Set();
+      for (const attachment of input.attachments ?? []) {
+        let filename = normalisePathSegment(attachment.filename);
+        if (!filename.includes(".")) {
+          filename = `${filename}.bin`;
+        }
+        const ext = import_node_path3.default.extname(filename);
+        const base = ext.length > 0 ? filename.slice(0, -ext.length) : filename;
+        let candidate = filename;
+        let duplicateIndex = 2;
+        while (usedNames.has(candidate)) {
+          candidate = `${base}-${duplicateIndex.toString()}${ext}`;
+          duplicateIndex += 1;
+        }
+        usedNames.add(candidate);
+        await (0, import_promises.writeFile)(import_node_path3.default.join(baseDir, candidate), attachment.bytes);
+      }
+    }).catch(() => void 0);
+    this.track(chain);
+    let closed = false;
+    const enqueue = (operation) => {
+      const next = chain.then(operation);
+      const tracked = next.catch(() => void 0);
+      chain = tracked;
+      this.track(tracked);
+    };
+    return {
+      appendThoughtDelta: (text) => {
+        if (closed || text.length === 0) {
+          return;
+        }
+        enqueue(async () => {
+          await (0, import_promises.appendFile)(thoughtsPath, text, "utf8");
+        });
+      },
+      appendResponseDelta: (text) => {
+        if (closed || text.length === 0) {
+          return;
+        }
+        enqueue(async () => {
+          await (0, import_promises.appendFile)(responsePath, text, "utf8");
+        });
+      },
+      complete: (metadata) => {
+        if (closed) {
+          return;
+        }
+        closed = true;
+        enqueue(async () => {
+          const payload = {
+            capturedAt: toIsoNow(),
+            status: "completed"
+          };
+          if (metadata) {
+            const sanitised = sanitiseLogValue(metadata);
+            if (sanitised && typeof sanitised === "object" && !Array.isArray(sanitised)) {
+              Object.assign(payload, sanitised);
+            } else if (sanitised !== void 0) {
+              payload.metadata = sanitised;
+            }
+          }
+          await (0, import_promises.writeFile)(responseMetadataPath, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+        });
+      },
+      fail: (error, metadata) => {
+        if (closed) {
+          return;
+        }
+        closed = true;
+        enqueue(async () => {
+          const payload = {
+            capturedAt: toIsoNow(),
+            status: "failed",
+            error: toErrorMessage(error)
+          };
+          if (metadata) {
+            const sanitised = sanitiseLogValue(metadata);
+            if (sanitised && typeof sanitised === "object" && !Array.isArray(sanitised)) {
+              Object.assign(payload, sanitised);
+            } else if (sanitised !== void 0) {
+              payload.metadata = sanitised;
+            }
+          }
+          await (0, import_promises.writeFile)(responseMetadataPath, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+        });
+      }
+    };
+  }
+  async flush() {
+    while (this.pending.size > 0) {
+      await Promise.allSettled([...this.pending]);
+    }
+    if (typeof this.sink?.flush === "function") {
+      try {
+        await this.sink.flush();
+      } catch {
+      }
+    }
+  }
+};
+var loggingSessionStorage = new import_node_async_hooks.AsyncLocalStorage();
+function createAgentLoggingSession(config) {
+  return new AgentLoggingSessionImpl(config);
+}
+function runWithAgentLoggingSession(session, fn) {
+  if (!session) {
+    return fn();
+  }
+  return loggingSessionStorage.run(session, fn);
+}
+function getCurrentAgentLoggingSession() {
+  return loggingSessionStorage.getStore();
+}
+
 // src/llm.ts
-var toolCallContextStorage = new import_node_async_hooks.AsyncLocalStorage();
+var toolCallContextStorage = new import_node_async_hooks2.AsyncLocalStorage();
 function getCurrentToolCallContext() {
   return toolCallContextStorage.getStore() ?? null;
 }
@@ -3048,9 +3415,9 @@ function sanitisePartForLogging(part) {
     case "inlineData": {
       let omittedBytes;
       try {
-        omittedBytes = import_node_buffer2.Buffer.from(part.data, "base64").byteLength;
+        omittedBytes = import_node_buffer3.Buffer.from(part.data, "base64").byteLength;
       } catch {
-        omittedBytes = import_node_buffer2.Buffer.byteLength(part.data, "utf8");
+        omittedBytes = import_node_buffer3.Buffer.byteLength(part.data, "utf8");
       }
       return {
         type: "inlineData",
@@ -4113,8 +4480,8 @@ function parseOpenAiToolArguments(raw) {
 function formatZodIssues(issues) {
   const messages = [];
   for (const issue of issues) {
-    const path6 = issue.path.length > 0 ? issue.path.map(String).join(".") : "input";
-    messages.push(`${path6}: ${issue.message}`);
+    const path8 = issue.path.length > 0 ? issue.path.map(String).join(".") : "input";
+    messages.push(`${path8}: ${issue.message}`);
   }
   return messages.join("; ");
 }
@@ -4500,9 +4867,9 @@ function resolveGeminiThinkingConfig(modelId, thinkingLevel) {
 }
 function decodeInlineDataBuffer(base64) {
   try {
-    return import_node_buffer2.Buffer.from(base64, "base64");
+    return import_node_buffer3.Buffer.from(base64, "base64");
   } catch {
-    return import_node_buffer2.Buffer.from(base64, "base64url");
+    return import_node_buffer3.Buffer.from(base64, "base64url");
   }
 }
 function extractImages(content) {
@@ -4519,6 +4886,195 @@ function extractImages(content) {
   }
   return images;
 }
+function resolveAttachmentExtension(mimeType) {
+  const normalized = (mimeType ?? "").trim().toLowerCase();
+  switch (normalized) {
+    case "image/jpeg":
+      return "jpg";
+    case "image/png":
+      return "png";
+    case "image/webp":
+      return "webp";
+    case "image/gif":
+      return "gif";
+    case "image/heic":
+      return "heic";
+    case "image/heif":
+      return "heif";
+    case "application/pdf":
+      return "pdf";
+    case "application/json":
+      return "json";
+    case "text/plain":
+      return "txt";
+    case "text/markdown":
+      return "md";
+    default: {
+      const slashIndex = normalized.indexOf("/");
+      if (slashIndex >= 0) {
+        const subtype = normalized.slice(slashIndex + 1).split("+")[0] ?? "";
+        const cleaned = subtype.replace(/[^a-z0-9]+/giu, "");
+        if (cleaned.length > 0) {
+          return cleaned;
+        }
+      }
+      return "bin";
+    }
+  }
+}
+function decodeDataUrlAttachment(value, basename) {
+  const trimmed = value.trim();
+  if (!trimmed.toLowerCase().startsWith("data:")) {
+    return null;
+  }
+  const commaIndex = trimmed.indexOf(",");
+  if (commaIndex < 0) {
+    return null;
+  }
+  const header = trimmed.slice(5, commaIndex);
+  const payload = trimmed.slice(commaIndex + 1);
+  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");
+    return {
+      filename: `${basename}.${resolveAttachmentExtension(mimeType)}`,
+      bytes
+    };
+  } catch {
+    return null;
+  }
+}
+function collectPayloadAttachments(value, options) {
+  if (typeof value === "string") {
+    const attachment = decodeDataUrlAttachment(
+      value,
+      `${options.prefix}-${options.counter.toString()}`
+    );
+    if (attachment) {
+      options.attachments.push(attachment);
+      options.counter += 1;
+    }
+    return;
+  }
+  if (!value || typeof value !== "object") {
+    return;
+  }
+  if (options.seen.has(value)) {
+    return;
+  }
+  options.seen.add(value);
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      collectPayloadAttachments(entry, options);
+    }
+    return;
+  }
+  const record = value;
+  const mimeType = typeof record.mimeType === "string" ? record.mimeType : void 0;
+  if (typeof record.data === "string" && mimeType) {
+    try {
+      options.attachments.push({
+        filename: `${options.prefix}-${options.counter.toString()}.${resolveAttachmentExtension(mimeType)}`,
+        bytes: decodeInlineDataBuffer(record.data)
+      });
+      options.counter += 1;
+    } catch {
+    }
+  }
+  for (const entry of Object.values(record)) {
+    collectPayloadAttachments(entry, options);
+  }
+}
+function serialiseRequestPayloadForLogging(value) {
+  try {
+    return `${JSON.stringify(sanitiseLogValue(value), null, 2)}
+`;
+  } catch {
+    return `${String(value)}
+`;
+  }
+}
+function startLlmCallLoggerFromContents(options) {
+  const session = getCurrentAgentLoggingSession();
+  if (!session) {
+    return void 0;
+  }
+  const attachments = [];
+  const sections = [];
+  for (const [messageIndex, message] of options.contents.entries()) {
+    sections.push(`### message_${(messageIndex + 1).toString()} role=${message.role}`);
+    for (const [partIndex, part] of message.parts.entries()) {
+      if (part.type === "text") {
+        const channel = part.thought === true ? "thought" : "response";
+        sections.push(`[text:${channel}]`);
+        sections.push(part.text);
+        continue;
+      }
+      const filename = `message-${(messageIndex + 1).toString()}-part-${(partIndex + 1).toString()}.${resolveAttachmentExtension(part.mimeType)}`;
+      attachments.push({
+        filename,
+        bytes: decodeInlineDataBuffer(part.data)
+      });
+      sections.push(
+        `[inlineData] file=${filename} mime=${part.mimeType ?? "application/octet-stream"} bytes=${attachments[attachments.length - 1]?.bytes.byteLength ?? 0}`
+      );
+    }
+    sections.push("");
+  }
+  return session.startLlmCall({
+    provider: options.provider,
+    modelId: options.request.model,
+    requestText: sections.join("\n").trim(),
+    requestMetadata: {
+      model: options.request.model,
+      input: options.contents.map((content) => ({
+        role: content.role,
+        parts: content.parts.map((part) => sanitisePartForLogging(part))
+      })),
+      ...options.request.instructions ? {
+        instructions: options.request.instructions
+      } : {},
+      ...options.request.tools ? { tools: options.request.tools } : {},
+      ...options.request.responseMimeType ? {
+        responseMimeType: options.request.responseMimeType
+      } : {},
+      ...options.request.responseJsonSchema ? {
+        responseJsonSchema: sanitiseLogValue(options.request.responseJsonSchema)
+      } : {},
+      ...options.request.responseModalities ? { responseModalities: options.request.responseModalities } : {},
+      ...options.request.imageAspectRatio ? { imageAspectRatio: options.request.imageAspectRatio } : {},
+      ...options.request.imageSize ? { imageSize: options.request.imageSize } : {},
+      ...options.request.thinkingLevel ? { thinkingLevel: options.request.thinkingLevel } : {},
+      ...options.request.openAiTextFormat ? { openAiTextFormat: sanitiseLogValue(options.request.openAiTextFormat) } : {},
+      ...getCurrentToolCallContext() ? { toolContext: getCurrentToolCallContext() } : {}
+    },
+    attachments
+  });
+}
+function startLlmCallLoggerFromPayload(options) {
+  const session = getCurrentAgentLoggingSession();
+  if (!session) {
+    return void 0;
+  }
+  const attachments = [];
+  collectPayloadAttachments(options.requestPayload, {
+    prefix: `step-${options.step.toString()}`,
+    attachments,
+    seen: /* @__PURE__ */ new WeakSet(),
+    counter: 1
+  });
+  return session.startLlmCall({
+    provider: options.provider,
+    modelId: options.modelId,
+    requestText: serialiseRequestPayloadForLogging(options.requestPayload),
+    requestMetadata: {
+      step: options.step,
+      ...getCurrentToolCallContext() ? { toolContext: getCurrentToolCallContext() } : {}
+    },
+    attachments
+  });
+}
 async function runTextCall(params) {
   const { request, queue, abortController } = params;
   const providerInfo = resolveProvider(request.model);
@@ -4528,6 +5084,11 @@ async function runTextCall(params) {
   if (contents.length === 0) {
     throw new Error("LLM call received an empty prompt.");
   }
+  const callLogger = startLlmCallLoggerFromContents({
+    provider,
+    request,
+    contents
+  });
   let modelVersion = request.model;
   let blocked = false;
   let grounding;
@@ -4535,12 +5096,17 @@ async function runTextCall(params) {
   let responseRole;
   let latestUsage;
   let responseImages = 0;
-  const pushDelta = (channel, text2) => {
-    if (!text2) {
+  const pushDelta = (channel, text) => {
+    if (!text) {
       return;
     }
-    responseParts.push({ type: "text", text: text2, ...channel === "thought" ? { thought: true } : {} });
-    queue.push({ type: "delta", channel, text: text2 });
+    responseParts.push({ type: "text", text, ...channel === "thought" ? { thought: true } : {} });
+    if (channel === "thought") {
+      callLogger?.appendThoughtDelta(text);
+    } else {
+      callLogger?.appendResponseDelta(text);
+    }
+    queue.push({ type: "delta", channel, text });
   };
   const pushInline = (data, mimeType) => {
     if (!data) {
@@ -4567,263 +5133,294 @@ async function runTextCall(params) {
     return abortController.signal;
   };
   const signal = resolveAbortSignal();
-  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 }
-      );
-      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;
+  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 }
+        );
+        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;
           }
-          case "response.reasoning_summary_text.delta": {
-            const delta = event.delta ?? "";
-            pushDelta("thought", typeof delta === "string" ? delta : "");
-            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})` : ""}`
+          );
+        }
+        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);
+            }
           }
-          case "response.refusal.delta": {
-            blocked = true;
-            queue.push({ type: "blocked" });
-            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,
+        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);
+          }
+          if (delta.textDelta) {
+            sawResponseDelta = true;
+            pushDelta("response", delta.textDelta);
           }
-          default:
-            break;
         }
+      });
+      blocked = blocked || result.blocked;
+      if (blocked) {
+        queue.push({ type: "blocked" });
       }
-      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 (result.model) {
+        modelVersion = `chatgpt-${result.model}`;
+        queue.push({ type: "model", modelVersion });
       }
-      if (finalResponse.status && finalResponse.status !== "completed" && finalResponse.status !== "in_progress") {
-        const detail = finalResponse.incomplete_details?.reason;
+      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(
-          `OpenAI response status ${finalResponse.status}${detail ? ` (${detail})` : ""}`
+          "Fireworks provider does not support provider-native tools in generateText; use runToolLoop for function tools."
         );
       }
-      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);
+      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
           }
-        }
-      }
-    }, 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,
-      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);
-        }
-        if (delta.textDelta) {
-          sawResponseDelta = true;
-          pushDelta("response", delta.textDelta);
-        }
-      }
-    });
-    blocked = blocked || result.blocked;
-    if (blocked) {
-      queue.push({ type: "blocked" });
-    }
-    if (result.model) {
-      modelVersion = `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
-        }
-      } : 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" });
-      }
-      const textOutput = extractFireworksMessageText(
-        choice?.message
-      );
-      if (textOutput.length > 0) {
-        pushDelta("response", textOutput);
-      }
-      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
-      });
-      let latestGrounding;
-      for await (const chunk of stream) {
-        if (chunk.modelVersion) {
-          modelVersion = chunk.modelVersion;
-          queue.push({ type: "model", modelVersion });
-        }
-        if (chunk.promptFeedback?.blockReason) {
+        } : 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 candidates = chunk.candidates;
-        if (!candidates || candidates.length === 0) {
-          continue;
-        }
-        const primary = candidates[0];
-        if (primary && isModerationFinish(primary.finishReason)) {
-          blocked = true;
-          queue.push({ type: "blocked" });
+        const textOutput = extractFireworksMessageText(
+          choice?.message
+        );
+        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 = 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 } : {}
           }
-          if (candidate.groundingMetadata) {
-            latestGrounding = candidate.groundingMetadata;
+        } : {}
+      };
+      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 });
           }
-          const content2 = convertGeminiContentToLlmContent(candidateContent);
-          if (!responseRole) {
-            responseRole = content2.role;
+          if (chunk.promptFeedback?.blockReason) {
+            blocked = true;
+            queue.push({ type: "blocked" });
           }
-          for (const part of content2.parts) {
-            if (part.type === "text") {
-              pushDelta(part.thought === true ? "thought" : "response", part.text);
-            } else {
-              pushInline(part.data, part.mimeType);
+          latestUsage = mergeTokenUpdates(
+            latestUsage,
+            extractGeminiUsageTokens(chunk.usageMetadata)
+          );
+          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" });
+          }
+          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 {
+                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 costUsd = estimateCallCostUsd({
-    modelId: modelVersion,
-    tokens: latestUsage,
-    responseImages,
-    imageSize: request.imageSize
-  });
-  if (latestUsage) {
-    queue.push({ type: "usage", usage: latestUsage, costUsd, modelVersion });
+        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 costUsd = estimateCallCostUsd({
+      modelId: modelVersion,
+      tokens: latestUsage,
+      responseImages,
+      imageSize: request.imageSize
+    });
+    if (latestUsage) {
+      queue.push({ type: "usage", usage: latestUsage, costUsd, modelVersion });
+    }
+    callLogger?.complete({
+      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) {
+    callLogger?.fail(error, {
+      provider,
+      model: request.model,
+      modelVersion,
+      blocked,
+      usage: latestUsage,
+      partialResponseParts: responseParts.length,
+      responseImages
+    });
+    throw error;
   }
-  return {
-    provider,
-    model: request.model,
-    modelVersion,
-    content,
-    text,
-    thoughts,
-    blocked,
-    usage: latestUsage,
-    costUsd,
-    grounding
-  };
 }
 function streamText(request) {
   const queue = createAsyncQueue();
@@ -5286,6 +5883,23 @@ async function runToolLoop(request) {
         let modelVersion = request.model;
         let usageTokens;
         let thoughtDeltaEmitted = false;
+        let blocked = false;
+        const stepRequestPayload = {
+          model: providerInfo.model,
+          input,
+          ...previousResponseId ? { previous_response_id: previousResponseId } : {},
+          ...openAiTools.length > 0 ? { tools: openAiTools } : {},
+          ...openAiTools.length > 0 ? { parallel_tool_calls: true } : {},
+          reasoning,
+          text: textConfig,
+          include: ["reasoning.encrypted_content"]
+        };
+        const stepCallLogger = startLlmCallLoggerFromPayload({
+          provider: "openai",
+          modelId: request.model,
+          requestPayload: stepRequestPayload,
+          step: turn
+        });
         const emitEvent = (ev) => {
           onEvent?.(ev);
         };
@@ -5294,226 +5908,276 @@ async function runToolLoop(request) {
             firstModelEventAtMs = Date.now();
           }
         };
-        const finalResponse = await runOpenAiCall(
-          async (client) => {
-            const stream = client.responses.stream(
-              {
-                model: providerInfo.model,
-                input,
-                ...previousResponseId ? { previous_response_id: previousResponseId } : {},
-                ...openAiTools.length > 0 ? { tools: openAiTools } : {},
-                ...openAiTools.length > 0 ? { parallel_tool_calls: true } : {},
-                reasoning,
-                text: textConfig,
-                include: ["reasoning.encrypted_content"]
-              },
-              { signal: abortController.signal }
-            );
-            for await (const event of stream) {
-              markFirstModelEvent();
-              switch (event.type) {
-                case "response.output_text.delta":
-                  emitEvent({
-                    type: "delta",
-                    channel: "response",
-                    text: typeof event.delta === "string" ? event.delta : ""
-                  });
-                  break;
-                case "response.reasoning_summary_text.delta":
-                  thoughtDeltaEmitted = true;
-                  emitEvent({
-                    type: "delta",
-                    channel: "thought",
-                    text: typeof event.delta === "string" ? event.delta : ""
-                  });
-                  break;
-                case "response.refusal.delta":
-                  emitEvent({ type: "blocked" });
-                  break;
-                default:
-                  break;
+        try {
+          const finalResponse = await runOpenAiCall(
+            async (client) => {
+              const stream = client.responses.stream(
+                {
+                  model: providerInfo.model,
+                  input,
+                  ...previousResponseId ? { previous_response_id: previousResponseId } : {},
+                  ...openAiTools.length > 0 ? { tools: openAiTools } : {},
+                  ...openAiTools.length > 0 ? { parallel_tool_calls: true } : {},
+                  reasoning,
+                  text: textConfig,
+                  include: ["reasoning.encrypted_content"]
+                },
+                { signal: abortController.signal }
+              );
+              for await (const event of stream) {
+                markFirstModelEvent();
+                switch (event.type) {
+                  case "response.output_text.delta": {
+                    const text = typeof event.delta === "string" ? event.delta : "";
+                    if (text.length > 0) {
+                      stepCallLogger?.appendResponseDelta(text);
+                    }
+                    emitEvent({
+                      type: "delta",
+                      channel: "response",
+                      text
+                    });
+                    break;
+                  }
+                  case "response.reasoning_summary_text.delta": {
+                    thoughtDeltaEmitted = true;
+                    const text = typeof event.delta === "string" ? event.delta : "";
+                    if (text.length > 0) {
+                      stepCallLogger?.appendThoughtDelta(text);
+                    }
+                    emitEvent({
+                      type: "delta",
+                      channel: "thought",
+                      text
+                    });
+                    break;
+                  }
+                  case "response.refusal.delta":
+                    blocked = true;
+                    emitEvent({ type: "blocked" });
+                    break;
+                  default:
+                    break;
+                }
+              }
+              return await stream.finalResponse();
+            },
+            providerInfo.model,
+            {
+              onSettled: (metrics) => {
+                schedulerMetrics = metrics;
               }
             }
-            return await stream.finalResponse();
-          },
-          providerInfo.model,
-          {
-            onSettled: (metrics) => {
-              schedulerMetrics = metrics;
+          );
+          modelVersion = typeof finalResponse.model === "string" ? finalResponse.model : request.model;
+          emitEvent({ type: "model", modelVersion });
+          if (finalResponse.error) {
+            const message = typeof finalResponse.error.message === "string" ? finalResponse.error.message : "OpenAI response failed";
+            throw new Error(message);
+          }
+          usageTokens = extractOpenAiUsageTokens(finalResponse.usage);
+          const responseText = extractOpenAiResponseParts(finalResponse).parts.filter((p) => p.type === "text" && p.thought !== true).map((p) => p.text).join("").trim();
+          const reasoningSummary = extractOpenAiReasoningSummary(finalResponse).trim();
+          if (!thoughtDeltaEmitted && reasoningSummary.length > 0) {
+            stepCallLogger?.appendThoughtDelta(reasoningSummary);
+            emitEvent({ type: "delta", channel: "thought", text: reasoningSummary });
+          }
+          const modelCompletedAtMs = Date.now();
+          const stepCostUsd = estimateCallCostUsd({
+            modelId: modelVersion,
+            tokens: usageTokens,
+            responseImages: 0
+          });
+          totalCostUsd += stepCostUsd;
+          if (usageTokens) {
+            emitEvent({ type: "usage", usage: usageTokens, costUsd: stepCostUsd, modelVersion });
+          }
+          const responseToolCalls = extractOpenAiToolCalls(finalResponse.output);
+          const stepToolCalls = [];
+          if (responseToolCalls.length === 0) {
+            const steeringInput2 = steeringInternal?.drainPendingContents() ?? [];
+            const steeringItems2 = steeringInput2.length > 0 ? toOpenAiInput(steeringInput2) : [];
+            finalText = responseText;
+            finalThoughts = reasoningSummary;
+            const stepCompletedAtMs2 = Date.now();
+            const timing2 = buildStepTiming({
+              stepStartedAtMs,
+              stepCompletedAtMs: stepCompletedAtMs2,
+              modelCompletedAtMs,
+              firstModelEventAtMs,
+              schedulerMetrics,
+              toolExecutionMs: 0,
+              waitToolMs: 0
+            });
+            steps.push({
+              step: steps.length + 1,
+              modelVersion,
+              text: responseText || void 0,
+              thoughts: reasoningSummary || void 0,
+              toolCalls: [],
+              usage: usageTokens,
+              costUsd: stepCostUsd,
+              timing: timing2
+            });
+            stepCallLogger?.complete({
+              provider: "openai",
+              model: request.model,
+              modelVersion,
+              step: turn,
+              usage: usageTokens,
+              costUsd: stepCostUsd,
+              blocked,
+              responseChars: responseText.length,
+              thoughtChars: reasoningSummary.length,
+              toolCalls: 0,
+              finalStep: steeringItems2.length === 0
+            });
+            if (steeringItems2.length === 0) {
+              return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
             }
+            previousResponseId = finalResponse.id;
+            input = steeringItems2;
+            continue;
           }
-        );
-        modelVersion = typeof finalResponse.model === "string" ? finalResponse.model : request.model;
-        emitEvent({ type: "model", modelVersion });
-        if (finalResponse.error) {
-          const message = typeof finalResponse.error.message === "string" ? finalResponse.error.message : "OpenAI response failed";
-          throw new Error(message);
-        }
-        usageTokens = extractOpenAiUsageTokens(finalResponse.usage);
-        const responseText = extractOpenAiResponseParts(finalResponse).parts.filter((p) => p.type === "text" && p.thought !== true).map((p) => p.text).join("").trim();
-        const reasoningSummary = extractOpenAiReasoningSummary(finalResponse).trim();
-        if (!thoughtDeltaEmitted && reasoningSummary.length > 0) {
-          emitEvent({ type: "delta", channel: "thought", text: reasoningSummary });
-        }
-        const modelCompletedAtMs = Date.now();
-        const stepCostUsd = estimateCallCostUsd({
-          modelId: modelVersion,
-          tokens: usageTokens,
-          responseImages: 0
-        });
-        totalCostUsd += stepCostUsd;
-        if (usageTokens) {
-          emitEvent({ type: "usage", usage: usageTokens, costUsd: stepCostUsd, modelVersion });
-        }
-        const responseToolCalls = extractOpenAiToolCalls(finalResponse.output);
-        const stepToolCalls = [];
-        if (responseToolCalls.length === 0) {
-          const steeringInput2 = steeringInternal?.drainPendingContents() ?? [];
-          const steeringItems2 = steeringInput2.length > 0 ? toOpenAiInput(steeringInput2) : [];
-          finalText = responseText;
-          finalThoughts = reasoningSummary;
-          const stepCompletedAtMs2 = Date.now();
-          const timing2 = buildStepTiming({
+          const callInputs = responseToolCalls.map((call, index) => {
+            const toolIndex = index + 1;
+            const toolId = buildToolLogId(turn, toolIndex);
+            const toolName = call.name;
+            if (call.kind === "custom") {
+              return {
+                call,
+                toolName,
+                value: call.input,
+                parseError: void 0,
+                toolId,
+                turn,
+                toolIndex
+              };
+            }
+            const { value, error: parseError } = parseOpenAiToolArguments(call.arguments);
+            return { call, toolName, value, parseError, toolId, turn, toolIndex };
+          });
+          for (const entry of callInputs) {
+            emitEvent({
+              type: "tool_call",
+              phase: "started",
+              turn: entry.turn,
+              toolIndex: entry.toolIndex,
+              toolName: entry.toolName,
+              toolId: entry.toolId,
+              callKind: entry.call.kind,
+              callId: entry.call.call_id,
+              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,
+                    toolName: entry.toolName,
+                    tool: request.tools[entry.toolName],
+                    rawInput: entry.value,
+                    parseError: entry.parseError
+                  });
+                  return { entry, result, outputPayload };
+                }
+              );
+            })
+          );
+          const toolOutputs = [];
+          let toolExecutionMs = 0;
+          let waitToolMs = 0;
+          for (const { entry, result, outputPayload } of callResults) {
+            stepToolCalls.push({ ...result, callId: entry.call.call_id });
+            const callDurationMs = toToolResultDuration(result);
+            toolExecutionMs += callDurationMs;
+            if (entry.toolName.toLowerCase() === SUBAGENT_WAIT_TOOL_NAME) {
+              waitToolMs += callDurationMs;
+            }
+            emitEvent({
+              type: "tool_call",
+              phase: "completed",
+              turn: entry.turn,
+              toolIndex: entry.toolIndex,
+              toolName: entry.toolName,
+              toolId: entry.toolId,
+              callKind: entry.call.kind,
+              callId: entry.call.call_id,
+              input: entry.value,
+              output: result.output,
+              error: result.error,
+              durationMs: result.durationMs
+            });
+            if (entry.call.kind === "custom") {
+              toolOutputs.push({
+                type: "custom_tool_call_output",
+                call_id: entry.call.call_id,
+                output: toOpenAiToolOutput(outputPayload)
+              });
+            } else {
+              toolOutputs.push({
+                type: "function_call_output",
+                call_id: entry.call.call_id,
+                output: toOpenAiToolOutput(outputPayload)
+              });
+            }
+          }
+          const stepCompletedAtMs = Date.now();
+          const timing = buildStepTiming({
             stepStartedAtMs,
-            stepCompletedAtMs: stepCompletedAtMs2,
+            stepCompletedAtMs,
             modelCompletedAtMs,
             firstModelEventAtMs,
             schedulerMetrics,
-            toolExecutionMs: 0,
-            waitToolMs: 0
+            toolExecutionMs,
+            waitToolMs
           });
           steps.push({
             step: steps.length + 1,
             modelVersion,
             text: responseText || void 0,
             thoughts: reasoningSummary || void 0,
-            toolCalls: [],
+            toolCalls: stepToolCalls,
             usage: usageTokens,
             costUsd: stepCostUsd,
-            timing: timing2
+            timing
           });
-          if (steeringItems2.length === 0) {
-            return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
-          }
-          previousResponseId = finalResponse.id;
-          input = steeringItems2;
-          continue;
-        }
-        const callInputs = responseToolCalls.map((call, index) => {
-          const toolIndex = index + 1;
-          const toolId = buildToolLogId(turn, toolIndex);
-          const toolName = call.name;
-          if (call.kind === "custom") {
-            return {
-              call,
-              toolName,
-              value: call.input,
-              parseError: void 0,
-              toolId,
-              turn,
-              toolIndex
-            };
-          }
-          const { value, error: parseError } = parseOpenAiToolArguments(call.arguments);
-          return { call, toolName, value, parseError, toolId, turn, toolIndex };
-        });
-        for (const entry of callInputs) {
-          emitEvent({
-            type: "tool_call",
-            phase: "started",
-            turn: entry.turn,
-            toolIndex: entry.toolIndex,
-            toolName: entry.toolName,
-            toolId: entry.toolId,
-            callKind: entry.call.kind,
-            callId: entry.call.call_id,
-            input: entry.value
+          const steeringInput = steeringInternal?.drainPendingContents() ?? [];
+          const steeringItems = steeringInput.length > 0 ? toOpenAiInput(steeringInput) : [];
+          stepCallLogger?.complete({
+            provider: "openai",
+            model: request.model,
+            modelVersion,
+            step: turn,
+            usage: usageTokens,
+            costUsd: stepCostUsd,
+            blocked,
+            responseChars: responseText.length,
+            thoughtChars: reasoningSummary.length,
+            toolCalls: stepToolCalls.length,
+            finalStep: false
           });
-        }
-        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,
-                  toolName: entry.toolName,
-                  tool: request.tools[entry.toolName],
-                  rawInput: entry.value,
-                  parseError: entry.parseError
-                });
-                return { entry, result, outputPayload };
-              }
-            );
-          })
-        );
-        const toolOutputs = [];
-        let toolExecutionMs = 0;
-        let waitToolMs = 0;
-        for (const { entry, result, outputPayload } of callResults) {
-          stepToolCalls.push({ ...result, callId: entry.call.call_id });
-          const callDurationMs = toToolResultDuration(result);
-          toolExecutionMs += callDurationMs;
-          if (entry.toolName.toLowerCase() === SUBAGENT_WAIT_TOOL_NAME) {
-            waitToolMs += callDurationMs;
-          }
-          emitEvent({
-            type: "tool_call",
-            phase: "completed",
-            turn: entry.turn,
-            toolIndex: entry.toolIndex,
-            toolName: entry.toolName,
-            toolId: entry.toolId,
-            callKind: entry.call.kind,
-            callId: entry.call.call_id,
-            input: entry.value,
-            output: result.output,
-            error: result.error,
-            durationMs: result.durationMs
+          previousResponseId = finalResponse.id;
+          input = steeringItems.length > 0 ? toolOutputs.concat(steeringItems) : toolOutputs;
+        } catch (error) {
+          stepCallLogger?.fail(error, {
+            provider: "openai",
+            model: request.model,
+            modelVersion,
+            step: turn,
+            usage: usageTokens,
+            blocked
           });
-          if (entry.call.kind === "custom") {
-            toolOutputs.push({
-              type: "custom_tool_call_output",
-              call_id: entry.call.call_id,
-              output: toOpenAiToolOutput(outputPayload)
-            });
-          } else {
-            toolOutputs.push({
-              type: "function_call_output",
-              call_id: entry.call.call_id,
-              output: toOpenAiToolOutput(outputPayload)
-            });
-          }
+          throw error;
         }
-        const stepCompletedAtMs = Date.now();
-        const timing = buildStepTiming({
-          stepStartedAtMs,
-          stepCompletedAtMs,
-          modelCompletedAtMs,
-          firstModelEventAtMs,
-          schedulerMetrics,
-          toolExecutionMs,
-          waitToolMs
-        });
-        steps.push({
-          step: steps.length + 1,
-          modelVersion,
-          text: responseText || void 0,
-          thoughts: reasoningSummary || void 0,
-          toolCalls: stepToolCalls,
-          usage: usageTokens,
-          costUsd: stepCostUsd,
-          timing
-        });
-        const steeringInput = steeringInternal?.drainPendingContents() ?? [];
-        const steeringItems = steeringInput.length > 0 ? toOpenAiInput(steeringInput) : [];
-        previousResponseId = finalResponse.id;
-        input = steeringItems.length > 0 ? toolOutputs.concat(steeringItems) : toolOutputs;
       }
       throw new Error(`Tool loop exceeded max steps (${maxSteps}) without final response.`);
     }
@@ -5531,242 +6195,655 @@ async function runToolLoop(request) {
         const stepStartedAtMs = Date.now();
         let firstModelEventAtMs;
         let thoughtDeltaEmitted = false;
+        let sawResponseDelta = false;
+        let modelVersion = request.model;
+        let usageTokens;
+        let responseText = "";
+        let reasoningSummaryText = "";
         const markFirstModelEvent = () => {
           if (firstModelEventAtMs === void 0) {
             firstModelEventAtMs = Date.now();
           }
         };
-        const response = await collectChatGptCodexResponseWithRetry({
-          sessionId: conversationId,
-          request: {
-            model: providerInfo.model,
-            store: false,
-            stream: true,
-            instructions: toolLoopInput.instructions ?? "You are a helpful assistant.",
-            input,
-            prompt_cache_key: promptCacheKey,
-            include: ["reasoning.encrypted_content"],
-            tools: openAiTools,
-            tool_choice: "auto",
-            parallel_tool_calls: true,
-            reasoning: {
-              effort: toOpenAiReasoningEffort(reasoningEffort),
-              summary: "detailed"
-            },
-            text: { verbosity: resolveOpenAiVerbosity(request.model) }
+        const stepRequestPayload = {
+          model: providerInfo.model,
+          store: false,
+          stream: true,
+          instructions: toolLoopInput.instructions ?? "You are a helpful assistant.",
+          input,
+          prompt_cache_key: promptCacheKey,
+          include: ["reasoning.encrypted_content"],
+          tools: openAiTools,
+          tool_choice: "auto",
+          parallel_tool_calls: true,
+          reasoning: {
+            effort: toOpenAiReasoningEffort(reasoningEffort),
+            summary: "detailed"
           },
-          signal: request.signal,
-          onDelta: (delta) => {
-            if (delta.thoughtDelta) {
-              markFirstModelEvent();
-              thoughtDeltaEmitted = true;
-              request.onEvent?.({ type: "delta", channel: "thought", text: delta.thoughtDelta });
+          text: { verbosity: resolveOpenAiVerbosity(request.model) }
+        };
+        const stepCallLogger = startLlmCallLoggerFromPayload({
+          provider: "chatgpt",
+          modelId: request.model,
+          requestPayload: stepRequestPayload,
+          step: turn
+        });
+        try {
+          const response = await collectChatGptCodexResponseWithRetry({
+            sessionId: conversationId,
+            request: stepRequestPayload,
+            signal: request.signal,
+            onDelta: (delta) => {
+              if (delta.thoughtDelta) {
+                markFirstModelEvent();
+                thoughtDeltaEmitted = true;
+                stepCallLogger?.appendThoughtDelta(delta.thoughtDelta);
+                request.onEvent?.({ type: "delta", channel: "thought", text: delta.thoughtDelta });
+              }
+              if (delta.textDelta) {
+                markFirstModelEvent();
+                sawResponseDelta = true;
+                stepCallLogger?.appendResponseDelta(delta.textDelta);
+                request.onEvent?.({ type: "delta", channel: "response", text: delta.textDelta });
+              }
             }
-            if (delta.textDelta) {
-              markFirstModelEvent();
-              request.onEvent?.({ type: "delta", channel: "response", text: delta.textDelta });
+          });
+          const modelCompletedAtMs = Date.now();
+          modelVersion = response.model ? `chatgpt-${response.model}` : request.model;
+          usageTokens = extractChatGptUsageTokens(response.usage);
+          const stepCostUsd = estimateCallCostUsd({
+            modelId: modelVersion,
+            tokens: usageTokens,
+            responseImages: 0
+          });
+          totalCostUsd += stepCostUsd;
+          responseText = (response.text ?? "").trim();
+          reasoningSummaryText = (response.reasoningSummaryText ?? "").trim();
+          if (!thoughtDeltaEmitted && reasoningSummaryText.length > 0) {
+            stepCallLogger?.appendThoughtDelta(reasoningSummaryText);
+            request.onEvent?.({ type: "delta", channel: "thought", text: reasoningSummaryText });
+          }
+          if (!sawResponseDelta && responseText.length > 0) {
+            stepCallLogger?.appendResponseDelta(responseText);
+          }
+          const responseToolCalls = response.toolCalls ?? [];
+          if (responseToolCalls.length === 0) {
+            const steeringInput2 = steeringInternal?.drainPendingContents() ?? [];
+            const steeringItems2 = steeringInput2.length > 0 ? toChatGptInput(steeringInput2).input : [];
+            finalText = responseText;
+            finalThoughts = reasoningSummaryText;
+            const stepCompletedAtMs2 = Date.now();
+            const timing2 = buildStepTiming({
+              stepStartedAtMs,
+              stepCompletedAtMs: stepCompletedAtMs2,
+              modelCompletedAtMs,
+              firstModelEventAtMs,
+              toolExecutionMs: 0,
+              waitToolMs: 0
+            });
+            steps.push({
+              step: steps.length + 1,
+              modelVersion,
+              text: responseText || void 0,
+              thoughts: reasoningSummaryText || void 0,
+              toolCalls: [],
+              usage: usageTokens,
+              costUsd: stepCostUsd,
+              timing: timing2
+            });
+            stepCallLogger?.complete({
+              provider: "chatgpt",
+              model: request.model,
+              modelVersion,
+              step: turn,
+              usage: usageTokens,
+              costUsd: stepCostUsd,
+              responseChars: responseText.length,
+              thoughtChars: reasoningSummaryText.length,
+              toolCalls: 0,
+              finalStep: steeringItems2.length === 0
+            });
+            if (steeringItems2.length === 0) {
+              return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
             }
+            const assistantItem = toChatGptAssistantMessage(responseText);
+            input = assistantItem ? input.concat(assistantItem, steeringItems2) : input.concat(steeringItems2);
+            continue;
           }
-        });
-        const modelCompletedAtMs = Date.now();
-        const modelVersion = response.model ? `chatgpt-${response.model}` : request.model;
-        const usageTokens = extractChatGptUsageTokens(response.usage);
-        const stepCostUsd = estimateCallCostUsd({
-          modelId: modelVersion,
-          tokens: usageTokens,
-          responseImages: 0
-        });
-        totalCostUsd += stepCostUsd;
-        const responseText = (response.text ?? "").trim();
-        const reasoningSummaryText = (response.reasoningSummaryText ?? "").trim();
-        if (!thoughtDeltaEmitted && reasoningSummaryText.length > 0) {
-          request.onEvent?.({ type: "delta", channel: "thought", text: reasoningSummaryText });
-        }
-        const responseToolCalls = response.toolCalls ?? [];
-        if (responseToolCalls.length === 0) {
-          const steeringInput2 = steeringInternal?.drainPendingContents() ?? [];
-          const steeringItems2 = steeringInput2.length > 0 ? toChatGptInput(steeringInput2).input : [];
-          finalText = responseText;
-          finalThoughts = reasoningSummaryText;
-          const stepCompletedAtMs2 = Date.now();
-          const timing2 = buildStepTiming({
+          const toolCalls = [];
+          const toolOutputs = [];
+          const callInputs = responseToolCalls.map((call, index) => {
+            const toolIndex = index + 1;
+            const toolId = buildToolLogId(turn, toolIndex);
+            const toolName = call.name;
+            const { value, error: parseError } = call.kind === "custom" ? { value: call.input, error: void 0 } : parseOpenAiToolArguments(call.arguments);
+            const ids = normalizeChatGptToolIds({
+              callKind: call.kind,
+              callId: call.callId,
+              itemId: call.id
+            });
+            return { call, toolName, value, parseError, ids, toolId, turn, toolIndex };
+          });
+          for (const entry of callInputs) {
+            request.onEvent?.({
+              type: "tool_call",
+              phase: "started",
+              turn: entry.turn,
+              toolIndex: entry.toolIndex,
+              toolName: entry.toolName,
+              toolId: entry.toolId,
+              callKind: entry.call.kind,
+              callId: entry.ids.callId,
+              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,
+                    toolName: entry.toolName,
+                    tool: request.tools[entry.toolName],
+                    rawInput: entry.value,
+                    parseError: entry.parseError
+                  });
+                  return { entry, result, outputPayload };
+                }
+              );
+            })
+          );
+          let toolExecutionMs = 0;
+          let waitToolMs = 0;
+          for (const { entry, result, outputPayload } of callResults) {
+            toolCalls.push({ ...result, callId: entry.ids.callId });
+            const callDurationMs = toToolResultDuration(result);
+            toolExecutionMs += callDurationMs;
+            if (entry.toolName.toLowerCase() === SUBAGENT_WAIT_TOOL_NAME) {
+              waitToolMs += callDurationMs;
+            }
+            request.onEvent?.({
+              type: "tool_call",
+              phase: "completed",
+              turn: entry.turn,
+              toolIndex: entry.toolIndex,
+              toolName: entry.toolName,
+              toolId: entry.toolId,
+              callKind: entry.call.kind,
+              callId: entry.ids.callId,
+              input: entry.value,
+              output: result.output,
+              error: result.error,
+              durationMs: result.durationMs
+            });
+            if (entry.call.kind === "custom") {
+              toolOutputs.push({
+                type: "custom_tool_call",
+                id: entry.ids.itemId,
+                call_id: entry.ids.callId,
+                name: entry.toolName,
+                input: entry.call.input,
+                status: "completed"
+              });
+              toolOutputs.push({
+                type: "custom_tool_call_output",
+                call_id: entry.ids.callId,
+                output: toOpenAiToolOutput(outputPayload)
+              });
+            } else {
+              toolOutputs.push({
+                type: "function_call",
+                id: entry.ids.itemId,
+                call_id: entry.ids.callId,
+                name: entry.toolName,
+                arguments: entry.call.arguments,
+                status: "completed"
+              });
+              toolOutputs.push({
+                type: "function_call_output",
+                call_id: entry.ids.callId,
+                output: toOpenAiToolOutput(outputPayload)
+              });
+            }
+          }
+          const stepCompletedAtMs = Date.now();
+          const timing = buildStepTiming({
             stepStartedAtMs,
-            stepCompletedAtMs: stepCompletedAtMs2,
+            stepCompletedAtMs,
             modelCompletedAtMs,
             firstModelEventAtMs,
-            toolExecutionMs: 0,
-            waitToolMs: 0
+            toolExecutionMs,
+            waitToolMs
           });
           steps.push({
             step: steps.length + 1,
             modelVersion,
             text: responseText || void 0,
             thoughts: reasoningSummaryText || void 0,
-            toolCalls: [],
+            toolCalls,
             usage: usageTokens,
             costUsd: stepCostUsd,
-            timing: timing2
+            timing
           });
-          if (steeringItems2.length === 0) {
-            return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
-          }
-          const assistantItem = toChatGptAssistantMessage(responseText);
-          input = assistantItem ? input.concat(assistantItem, steeringItems2) : input.concat(steeringItems2);
-          continue;
-        }
-        const toolCalls = [];
-        const toolOutputs = [];
-        const callInputs = responseToolCalls.map((call, index) => {
-          const toolIndex = index + 1;
-          const toolId = buildToolLogId(turn, toolIndex);
-          const toolName = call.name;
-          const { value, error: parseError } = call.kind === "custom" ? { value: call.input, error: void 0 } : parseOpenAiToolArguments(call.arguments);
-          const ids = normalizeChatGptToolIds({
-            callKind: call.kind,
-            callId: call.callId,
-            itemId: call.id
+          const steeringInput = steeringInternal?.drainPendingContents() ?? [];
+          const steeringItems = steeringInput.length > 0 ? toChatGptInput(steeringInput).input : [];
+          stepCallLogger?.complete({
+            provider: "chatgpt",
+            model: request.model,
+            modelVersion,
+            step: turn,
+            usage: usageTokens,
+            costUsd: stepCostUsd,
+            responseChars: responseText.length,
+            thoughtChars: reasoningSummaryText.length,
+            toolCalls: toolCalls.length,
+            finalStep: false
           });
-          return { call, toolName, value, parseError, ids, toolId, turn, toolIndex };
-        });
-        for (const entry of callInputs) {
-          request.onEvent?.({
-            type: "tool_call",
-            phase: "started",
-            turn: entry.turn,
-            toolIndex: entry.toolIndex,
-            toolName: entry.toolName,
-            toolId: entry.toolId,
-            callKind: entry.call.kind,
-            callId: entry.ids.callId,
-            input: entry.value
+          input = steeringItems.length > 0 ? input.concat(toolOutputs, steeringItems) : input.concat(toolOutputs);
+        } catch (error) {
+          stepCallLogger?.fail(error, {
+            provider: "chatgpt",
+            model: request.model,
+            modelVersion,
+            step: turn,
+            usage: usageTokens
           });
+          throw error;
         }
-        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,
-                  toolName: entry.toolName,
-                  tool: request.tools[entry.toolName],
-                  rawInput: entry.value,
-                  parseError: entry.parseError
-                });
-                return { entry, result, outputPayload };
-              }
-            );
-          })
+      }
+      throw new Error(`Tool loop exceeded max steps (${maxSteps}) without final response.`);
+    }
+    if (providerInfo.provider === "fireworks") {
+      if (request.modelTools && request.modelTools.length > 0) {
+        throw new Error(
+          "Fireworks provider does not support provider-native modelTools in runToolLoop."
         );
-        let toolExecutionMs = 0;
-        let waitToolMs = 0;
-        for (const { entry, result, outputPayload } of callResults) {
-          toolCalls.push({ ...result, callId: entry.ids.callId });
-          const callDurationMs = toToolResultDuration(result);
-          toolExecutionMs += callDurationMs;
-          if (entry.toolName.toLowerCase() === SUBAGENT_WAIT_TOOL_NAME) {
-            waitToolMs += callDurationMs;
+      }
+      const fireworksTools = buildFireworksToolsFromToolSet(request.tools);
+      const messages = toFireworksMessages(contents);
+      for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
+        const turn = stepIndex + 1;
+        const stepStartedAtMs = Date.now();
+        let schedulerMetrics;
+        let modelVersion = request.model;
+        let usageTokens;
+        let responseText = "";
+        let blocked = false;
+        const stepRequestPayload = {
+          model: providerInfo.model,
+          messages,
+          tools: fireworksTools,
+          tool_choice: "auto",
+          parallel_tool_calls: true
+        };
+        const stepCallLogger = startLlmCallLoggerFromPayload({
+          provider: "fireworks",
+          modelId: request.model,
+          requestPayload: stepRequestPayload,
+          step: turn
+        });
+        try {
+          const response = await runFireworksCall(
+            async (client) => {
+              return await client.chat.completions.create(
+                {
+                  model: providerInfo.model,
+                  messages,
+                  tools: fireworksTools,
+                  tool_choice: "auto",
+                  parallel_tool_calls: true
+                },
+                { signal: request.signal }
+              );
+            },
+            providerInfo.model,
+            {
+              onSettled: (metrics) => {
+                schedulerMetrics = metrics;
+              }
+            }
+          );
+          const modelCompletedAtMs = Date.now();
+          modelVersion = typeof response.model === "string" ? response.model : request.model;
+          request.onEvent?.({ type: "model", modelVersion });
+          const choice = Array.isArray(response.choices) ? response.choices[0] : void 0;
+          if (choice?.finish_reason === "content_filter") {
+            blocked = true;
+            request.onEvent?.({ type: "blocked" });
           }
-          request.onEvent?.({
-            type: "tool_call",
-            phase: "completed",
-            turn: entry.turn,
-            toolIndex: entry.toolIndex,
-            toolName: entry.toolName,
-            toolId: entry.toolId,
-            callKind: entry.call.kind,
-            callId: entry.ids.callId,
-            input: entry.value,
-            output: result.output,
-            error: result.error,
-            durationMs: result.durationMs
+          const message = choice?.message;
+          responseText = extractFireworksMessageText(message).trim();
+          if (responseText.length > 0) {
+            stepCallLogger?.appendResponseDelta(responseText);
+            request.onEvent?.({ type: "delta", channel: "response", text: responseText });
+          }
+          usageTokens = extractFireworksUsageTokens(response.usage);
+          const stepCostUsd = estimateCallCostUsd({
+            modelId: modelVersion,
+            tokens: usageTokens,
+            responseImages: 0
           });
-          if (entry.call.kind === "custom") {
-            toolOutputs.push({
-              type: "custom_tool_call",
-              id: entry.ids.itemId,
-              call_id: entry.ids.callId,
-              name: entry.toolName,
-              input: entry.call.input,
-              status: "completed"
+          totalCostUsd += stepCostUsd;
+          if (usageTokens) {
+            request.onEvent?.({
+              type: "usage",
+              usage: usageTokens,
+              costUsd: stepCostUsd,
+              modelVersion
             });
-            toolOutputs.push({
-              type: "custom_tool_call_output",
-              call_id: entry.ids.callId,
-              output: toOpenAiToolOutput(outputPayload)
+          }
+          const responseToolCalls = extractFireworksToolCalls(message);
+          if (responseToolCalls.length === 0) {
+            const steeringInput2 = steeringInternal?.drainPendingContents() ?? [];
+            const steeringMessages = steeringInput2.length > 0 ? toFireworksMessages(steeringInput2) : [];
+            finalText = responseText;
+            finalThoughts = "";
+            const stepCompletedAtMs2 = Date.now();
+            const timing2 = buildStepTiming({
+              stepStartedAtMs,
+              stepCompletedAtMs: stepCompletedAtMs2,
+              modelCompletedAtMs,
+              schedulerMetrics,
+              toolExecutionMs: 0,
+              waitToolMs: 0
             });
-          } else {
-            toolOutputs.push({
-              type: "function_call",
-              id: entry.ids.itemId,
-              call_id: entry.ids.callId,
-              name: entry.toolName,
-              arguments: entry.call.arguments,
-              status: "completed"
+            steps.push({
+              step: steps.length + 1,
+              modelVersion,
+              text: responseText || void 0,
+              thoughts: void 0,
+              toolCalls: [],
+              usage: usageTokens,
+              costUsd: stepCostUsd,
+              timing: timing2
             });
-            toolOutputs.push({
-              type: "function_call_output",
-              call_id: entry.ids.callId,
-              output: toOpenAiToolOutput(outputPayload)
+            stepCallLogger?.complete({
+              provider: "fireworks",
+              model: request.model,
+              modelVersion,
+              step: turn,
+              usage: usageTokens,
+              costUsd: stepCostUsd,
+              blocked,
+              responseChars: responseText.length,
+              thoughtChars: 0,
+              toolCalls: 0,
+              finalStep: steeringMessages.length === 0
             });
+            if (steeringMessages.length === 0) {
+              return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
+            }
+            if (responseText.length > 0) {
+              messages.push({ role: "assistant", content: responseText });
+            }
+            messages.push(...steeringMessages);
+            continue;
           }
-        }
-        const stepCompletedAtMs = Date.now();
-        const timing = buildStepTiming({
-          stepStartedAtMs,
-          stepCompletedAtMs,
-          modelCompletedAtMs,
-          firstModelEventAtMs,
-          toolExecutionMs,
-          waitToolMs
-        });
-        steps.push({
-          step: steps.length + 1,
-          modelVersion,
-          text: responseText || void 0,
-          thoughts: reasoningSummaryText || void 0,
-          toolCalls,
-          usage: usageTokens,
-          costUsd: stepCostUsd,
-          timing
-        });
-        const steeringInput = steeringInternal?.drainPendingContents() ?? [];
-        const steeringItems = steeringInput.length > 0 ? toChatGptInput(steeringInput).input : [];
-        input = steeringItems.length > 0 ? input.concat(toolOutputs, steeringItems) : input.concat(toolOutputs);
+          const stepToolCalls = [];
+          const callInputs = responseToolCalls.map((call, index) => {
+            const toolIndex = index + 1;
+            const toolId = buildToolLogId(turn, toolIndex);
+            const { value, error: parseError } = parseOpenAiToolArguments(call.arguments);
+            return { call, toolName: call.name, value, parseError, toolId, turn, toolIndex };
+          });
+          for (const entry of callInputs) {
+            request.onEvent?.({
+              type: "tool_call",
+              phase: "started",
+              turn: entry.turn,
+              toolIndex: entry.toolIndex,
+              toolName: entry.toolName,
+              toolId: entry.toolId,
+              callKind: "function",
+              callId: entry.call.id,
+              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",
+                    toolName: entry.toolName,
+                    tool: request.tools[entry.toolName],
+                    rawInput: entry.value,
+                    parseError: entry.parseError
+                  });
+                  return { entry, result, outputPayload };
+                }
+              );
+            })
+          );
+          const assistantToolCalls = [];
+          const toolMessages = [];
+          let toolExecutionMs = 0;
+          let waitToolMs = 0;
+          for (const { entry, result, outputPayload } of callResults) {
+            stepToolCalls.push({ ...result, callId: entry.call.id });
+            const callDurationMs = toToolResultDuration(result);
+            toolExecutionMs += callDurationMs;
+            if (entry.toolName.toLowerCase() === SUBAGENT_WAIT_TOOL_NAME) {
+              waitToolMs += callDurationMs;
+            }
+            request.onEvent?.({
+              type: "tool_call",
+              phase: "completed",
+              turn: entry.turn,
+              toolIndex: entry.toolIndex,
+              toolName: entry.toolName,
+              toolId: entry.toolId,
+              callKind: "function",
+              callId: entry.call.id,
+              input: entry.value,
+              output: result.output,
+              error: result.error,
+              durationMs: result.durationMs
+            });
+            assistantToolCalls.push({
+              id: entry.call.id,
+              type: "function",
+              function: {
+                name: entry.toolName,
+                arguments: entry.call.arguments
+              }
+            });
+            toolMessages.push({
+              role: "tool",
+              tool_call_id: entry.call.id,
+              content: mergeToolOutput(outputPayload)
+            });
+          }
+          const stepCompletedAtMs = Date.now();
+          const timing = buildStepTiming({
+            stepStartedAtMs,
+            stepCompletedAtMs,
+            modelCompletedAtMs,
+            schedulerMetrics,
+            toolExecutionMs,
+            waitToolMs
+          });
+          steps.push({
+            step: steps.length + 1,
+            modelVersion,
+            text: responseText || void 0,
+            thoughts: void 0,
+            toolCalls: stepToolCalls,
+            usage: usageTokens,
+            costUsd: stepCostUsd,
+            timing
+          });
+          stepCallLogger?.complete({
+            provider: "fireworks",
+            model: request.model,
+            modelVersion,
+            step: turn,
+            usage: usageTokens,
+            costUsd: stepCostUsd,
+            blocked,
+            responseChars: responseText.length,
+            thoughtChars: 0,
+            toolCalls: stepToolCalls.length,
+            finalStep: false
+          });
+          messages.push({
+            role: "assistant",
+            ...responseText.length > 0 ? { content: responseText } : {},
+            tool_calls: assistantToolCalls
+          });
+          messages.push(...toolMessages);
+          const steeringInput = steeringInternal?.drainPendingContents() ?? [];
+          if (steeringInput.length > 0) {
+            messages.push(...toFireworksMessages(steeringInput));
+          }
+        } catch (error) {
+          stepCallLogger?.fail(error, {
+            provider: "fireworks",
+            model: request.model,
+            modelVersion,
+            step: turn,
+            usage: usageTokens,
+            blocked
+          });
+          throw error;
+        }
       }
       throw new Error(`Tool loop exceeded max steps (${maxSteps}) without final response.`);
     }
-    if (providerInfo.provider === "fireworks") {
-      if (request.modelTools && request.modelTools.length > 0) {
-        throw new Error(
-          "Fireworks provider does not support provider-native modelTools in runToolLoop."
-        );
-      }
-      const fireworksTools = buildFireworksToolsFromToolSet(request.tools);
-      const messages = toFireworksMessages(contents);
-      for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
-        const turn = stepIndex + 1;
-        const stepStartedAtMs = Date.now();
-        let schedulerMetrics;
-        const response = await runFireworksCall(
+    const geminiFunctionTools = buildGeminiFunctionDeclarations(request.tools);
+    const geminiNativeTools = toGeminiTools(request.modelTools);
+    const geminiTools = geminiNativeTools ? geminiNativeTools.concat(geminiFunctionTools) : geminiFunctionTools;
+    const geminiContents = contents.map(convertLlmContentToGeminiContent);
+    for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
+      const turn = stepIndex + 1;
+      const stepStartedAtMs = Date.now();
+      let firstModelEventAtMs;
+      let schedulerMetrics;
+      let modelVersion = request.model;
+      let usageTokens;
+      let responseText = "";
+      let thoughtsText = "";
+      const markFirstModelEvent = () => {
+        if (firstModelEventAtMs === void 0) {
+          firstModelEventAtMs = Date.now();
+        }
+      };
+      const thinkingConfig = resolveGeminiThinkingConfig(request.model, request.thinkingLevel);
+      const config = {
+        maxOutputTokens: 32e3,
+        tools: geminiTools,
+        toolConfig: {
+          functionCallingConfig: {
+            mode: import_genai2.FunctionCallingConfigMode.VALIDATED
+          }
+        },
+        ...thinkingConfig ? { thinkingConfig } : {}
+      };
+      const onEvent = request.onEvent;
+      const stepRequestPayload = {
+        model: request.model,
+        contents: geminiContents,
+        config
+      };
+      const stepCallLogger = startLlmCallLoggerFromPayload({
+        provider: "gemini",
+        modelId: request.model,
+        requestPayload: stepRequestPayload,
+        step: turn
+      });
+      try {
+        const response = await runGeminiCall(
           async (client) => {
-            return await client.chat.completions.create(
-              {
-                model: providerInfo.model,
-                messages,
-                tools: fireworksTools,
-                tool_choice: "auto",
-                parallel_tool_calls: true
-              },
-              { signal: request.signal }
-            );
+            const stream = await client.models.generateContentStream({
+              model: request.model,
+              contents: geminiContents,
+              config
+            });
+            let responseText2 = "";
+            let thoughtsText2 = "";
+            const modelParts = [];
+            const functionCalls = [];
+            const seenFunctionCallIds = /* @__PURE__ */ new Set();
+            const seenFunctionCallKeys = /* @__PURE__ */ new Set();
+            let latestUsageMetadata;
+            let resolvedModelVersion;
+            for await (const chunk of stream) {
+              markFirstModelEvent();
+              if (chunk.modelVersion) {
+                resolvedModelVersion = chunk.modelVersion;
+                onEvent?.({ type: "model", modelVersion: chunk.modelVersion });
+              }
+              if (chunk.usageMetadata) {
+                latestUsageMetadata = chunk.usageMetadata;
+              }
+              const candidates = chunk.candidates;
+              if (!candidates || candidates.length === 0) {
+                continue;
+              }
+              const primary = candidates[0];
+              const parts = primary?.content?.parts;
+              if (!parts || parts.length === 0) {
+                continue;
+              }
+              for (const part of parts) {
+                modelParts.push(part);
+                const call = part.functionCall;
+                if (call) {
+                  const id = typeof call.id === "string" ? call.id : "";
+                  const shouldAdd = (() => {
+                    if (id.length > 0) {
+                      if (seenFunctionCallIds.has(id)) {
+                        return false;
+                      }
+                      seenFunctionCallIds.add(id);
+                      return true;
+                    }
+                    const key = JSON.stringify({ name: call.name ?? "", args: call.args ?? null });
+                    if (seenFunctionCallKeys.has(key)) {
+                      return false;
+                    }
+                    seenFunctionCallKeys.add(key);
+                    return true;
+                  })();
+                  if (shouldAdd) {
+                    functionCalls.push(call);
+                  }
+                }
+                if (typeof part.text === "string" && part.text.length > 0) {
+                  if (part.thought) {
+                    thoughtsText2 += part.text;
+                    stepCallLogger?.appendThoughtDelta(part.text);
+                    onEvent?.({ type: "delta", channel: "thought", text: part.text });
+                  } else {
+                    responseText2 += part.text;
+                    stepCallLogger?.appendResponseDelta(part.text);
+                    onEvent?.({ type: "delta", channel: "response", text: part.text });
+                  }
+                }
+              }
+            }
+            return {
+              responseText: responseText2,
+              thoughtsText: thoughtsText2,
+              functionCalls,
+              modelParts,
+              usageMetadata: latestUsageMetadata,
+              modelVersion: resolvedModelVersion ?? request.model
+            };
           },
-          providerInfo.model,
+          request.model,
           {
             onSettled: (metrics) => {
               schedulerMetrics = metrics;
@@ -5774,43 +6851,26 @@ async function runToolLoop(request) {
           }
         );
         const modelCompletedAtMs = Date.now();
-        const modelVersion = typeof response.model === "string" ? response.model : request.model;
-        request.onEvent?.({ type: "model", modelVersion });
-        const choice = Array.isArray(response.choices) ? response.choices[0] : void 0;
-        if (choice?.finish_reason === "content_filter") {
-          request.onEvent?.({ type: "blocked" });
-        }
-        const message = choice?.message;
-        const responseText = extractFireworksMessageText(message).trim();
-        if (responseText.length > 0) {
-          request.onEvent?.({ type: "delta", channel: "response", text: responseText });
-        }
-        const usageTokens = extractFireworksUsageTokens(response.usage);
+        usageTokens = extractGeminiUsageTokens(response.usageMetadata);
+        modelVersion = response.modelVersion ?? request.model;
+        responseText = response.responseText.trim();
+        thoughtsText = response.thoughtsText.trim();
         const stepCostUsd = estimateCallCostUsd({
           modelId: modelVersion,
           tokens: usageTokens,
           responseImages: 0
         });
         totalCostUsd += stepCostUsd;
-        if (usageTokens) {
-          request.onEvent?.({
-            type: "usage",
-            usage: usageTokens,
-            costUsd: stepCostUsd,
-            modelVersion
-          });
-        }
-        const responseToolCalls = extractFireworksToolCalls(message);
-        if (responseToolCalls.length === 0) {
+        if (response.functionCalls.length === 0) {
           const steeringInput2 = steeringInternal?.drainPendingContents() ?? [];
-          const steeringMessages = steeringInput2.length > 0 ? toFireworksMessages(steeringInput2) : [];
           finalText = responseText;
-          finalThoughts = "";
+          finalThoughts = thoughtsText;
           const stepCompletedAtMs2 = Date.now();
           const timing2 = buildStepTiming({
             stepStartedAtMs,
             stepCompletedAtMs: stepCompletedAtMs2,
             modelCompletedAtMs,
+            firstModelEventAtMs,
             schedulerMetrics,
             toolExecutionMs: 0,
             waitToolMs: 0
@@ -5818,31 +6878,65 @@ async function runToolLoop(request) {
           steps.push({
             step: steps.length + 1,
             modelVersion,
-            text: responseText || void 0,
-            thoughts: void 0,
+            text: finalText || void 0,
+            thoughts: finalThoughts || void 0,
             toolCalls: [],
             usage: usageTokens,
             costUsd: stepCostUsd,
             timing: timing2
           });
-          if (steeringMessages.length === 0) {
+          stepCallLogger?.complete({
+            provider: "gemini",
+            model: request.model,
+            modelVersion,
+            step: turn,
+            usage: usageTokens,
+            costUsd: stepCostUsd,
+            responseChars: responseText.length,
+            thoughtChars: thoughtsText.length,
+            toolCalls: 0,
+            finalStep: steeringInput2.length === 0
+          });
+          if (steeringInput2.length === 0) {
             return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
           }
-          if (responseText.length > 0) {
-            messages.push({ role: "assistant", content: responseText });
+          const modelPartsForHistory2 = response.modelParts.filter(
+            (part) => !(typeof part.text === "string" && part.thought === true)
+          );
+          if (modelPartsForHistory2.length > 0) {
+            geminiContents.push({ role: "model", parts: modelPartsForHistory2 });
+          } else if (response.responseText.length > 0) {
+            geminiContents.push({ role: "model", parts: [{ text: response.responseText }] });
           }
-          messages.push(...steeringMessages);
+          geminiContents.push(...steeringInput2.map(convertLlmContentToGeminiContent));
           continue;
         }
-        const stepToolCalls = [];
-        const callInputs = responseToolCalls.map((call, index) => {
+        const toolCalls = [];
+        const modelPartsForHistory = response.modelParts.filter(
+          (part) => !(typeof part.text === "string" && part.thought === true)
+        );
+        if (modelPartsForHistory.length > 0) {
+          geminiContents.push({ role: "model", parts: modelPartsForHistory });
+        } else {
+          const parts = [];
+          if (response.responseText) {
+            parts.push({ text: response.responseText });
+          }
+          for (const call of response.functionCalls) {
+            parts.push({ functionCall: call });
+          }
+          geminiContents.push({ role: "model", parts });
+        }
+        const responseParts = [];
+        const callInputs = response.functionCalls.map((call, index) => {
           const toolIndex = index + 1;
           const toolId = buildToolLogId(turn, toolIndex);
-          const { value, error: parseError } = parseOpenAiToolArguments(call.arguments);
-          return { call, toolName: call.name, value, parseError, toolId, turn, toolIndex };
+          const toolName = call.name ?? "unknown";
+          const rawInput = call.args ?? {};
+          return { call, toolName, rawInput, toolId, turn, toolIndex };
         });
         for (const entry of callInputs) {
-          request.onEvent?.({
+          onEvent?.({
             type: "tool_call",
             phase: "started",
             turn: entry.turn,
@@ -5851,7 +6945,7 @@ async function runToolLoop(request) {
             toolId: entry.toolId,
             callKind: "function",
             callId: entry.call.id,
-            input: entry.value
+            input: entry.rawInput
           });
         }
         const callResults = await Promise.all(
@@ -5868,26 +6962,23 @@ async function runToolLoop(request) {
                   callKind: "function",
                   toolName: entry.toolName,
                   tool: request.tools[entry.toolName],
-                  rawInput: entry.value,
-                  parseError: entry.parseError
+                  rawInput: entry.rawInput
                 });
                 return { entry, result, outputPayload };
               }
             );
           })
         );
-        const assistantToolCalls = [];
-        const toolMessages = [];
         let toolExecutionMs = 0;
         let waitToolMs = 0;
         for (const { entry, result, outputPayload } of callResults) {
-          stepToolCalls.push({ ...result, callId: entry.call.id });
+          toolCalls.push({ ...result, callId: entry.call.id });
           const callDurationMs = toToolResultDuration(result);
           toolExecutionMs += callDurationMs;
           if (entry.toolName.toLowerCase() === SUBAGENT_WAIT_TOOL_NAME) {
             waitToolMs += callDurationMs;
           }
-          request.onEvent?.({
+          onEvent?.({
             type: "tool_call",
             phase: "completed",
             turn: entry.turn,
@@ -5896,30 +6987,26 @@ async function runToolLoop(request) {
             toolId: entry.toolId,
             callKind: "function",
             callId: entry.call.id,
-            input: entry.value,
+            input: entry.rawInput,
             output: result.output,
             error: result.error,
             durationMs: result.durationMs
           });
-          assistantToolCalls.push({
-            id: entry.call.id,
-            type: "function",
-            function: {
+          const responsePayload = isPlainRecord(outputPayload) ? outputPayload : { output: outputPayload };
+          responseParts.push({
+            functionResponse: {
               name: entry.toolName,
-              arguments: entry.call.arguments
+              response: responsePayload,
+              ...entry.call.id ? { id: entry.call.id } : {}
             }
           });
-          toolMessages.push({
-            role: "tool",
-            tool_call_id: entry.call.id,
-            content: mergeToolOutput(outputPayload)
-          });
         }
         const stepCompletedAtMs = Date.now();
         const timing = buildStepTiming({
           stepStartedAtMs,
           stepCompletedAtMs,
           modelCompletedAtMs,
+          firstModelEventAtMs,
           schedulerMetrics,
           toolExecutionMs,
           waitToolMs
@@ -5928,296 +7015,40 @@ async function runToolLoop(request) {
           step: steps.length + 1,
           modelVersion,
           text: responseText || void 0,
-          thoughts: void 0,
-          toolCalls: stepToolCalls,
+          thoughts: thoughtsText || void 0,
+          toolCalls,
           usage: usageTokens,
           costUsd: stepCostUsd,
           timing
         });
-        messages.push({
-          role: "assistant",
-          ...responseText.length > 0 ? { content: responseText } : {},
-          tool_calls: assistantToolCalls
+        stepCallLogger?.complete({
+          provider: "gemini",
+          model: request.model,
+          modelVersion,
+          step: turn,
+          usage: usageTokens,
+          costUsd: stepCostUsd,
+          responseChars: responseText.length,
+          thoughtChars: thoughtsText.length,
+          toolCalls: toolCalls.length,
+          finalStep: false
         });
-        messages.push(...toolMessages);
+        geminiContents.push({ role: "user", parts: responseParts });
         const steeringInput = steeringInternal?.drainPendingContents() ?? [];
         if (steeringInput.length > 0) {
-          messages.push(...toFireworksMessages(steeringInput));
-        }
-      }
-      throw new Error(`Tool loop exceeded max steps (${maxSteps}) without final response.`);
-    }
-    const geminiFunctionTools = buildGeminiFunctionDeclarations(request.tools);
-    const geminiNativeTools = toGeminiTools(request.modelTools);
-    const geminiTools = geminiNativeTools ? geminiNativeTools.concat(geminiFunctionTools) : geminiFunctionTools;
-    const geminiContents = contents.map(convertLlmContentToGeminiContent);
-    for (let stepIndex = 0; stepIndex < maxSteps; stepIndex += 1) {
-      const stepStartedAtMs = Date.now();
-      let firstModelEventAtMs;
-      let schedulerMetrics;
-      const markFirstModelEvent = () => {
-        if (firstModelEventAtMs === void 0) {
-          firstModelEventAtMs = Date.now();
-        }
-      };
-      const thinkingConfig = resolveGeminiThinkingConfig(request.model, request.thinkingLevel);
-      const config = {
-        maxOutputTokens: 32e3,
-        tools: geminiTools,
-        toolConfig: {
-          functionCallingConfig: {
-            mode: import_genai2.FunctionCallingConfigMode.VALIDATED
-          }
-        },
-        ...thinkingConfig ? { thinkingConfig } : {}
-      };
-      const onEvent = request.onEvent;
-      const response = await runGeminiCall(
-        async (client) => {
-          const stream = await client.models.generateContentStream({
-            model: request.model,
-            contents: geminiContents,
-            config
-          });
-          let responseText = "";
-          let thoughtsText = "";
-          const modelParts = [];
-          const functionCalls = [];
-          const seenFunctionCallIds = /* @__PURE__ */ new Set();
-          const seenFunctionCallKeys = /* @__PURE__ */ new Set();
-          let latestUsageMetadata;
-          let resolvedModelVersion;
-          for await (const chunk of stream) {
-            markFirstModelEvent();
-            if (chunk.modelVersion) {
-              resolvedModelVersion = chunk.modelVersion;
-              onEvent?.({ type: "model", modelVersion: chunk.modelVersion });
-            }
-            if (chunk.usageMetadata) {
-              latestUsageMetadata = chunk.usageMetadata;
-            }
-            const candidates = chunk.candidates;
-            if (!candidates || candidates.length === 0) {
-              continue;
-            }
-            const primary = candidates[0];
-            const parts = primary?.content?.parts;
-            if (!parts || parts.length === 0) {
-              continue;
-            }
-            for (const part of parts) {
-              modelParts.push(part);
-              const call = part.functionCall;
-              if (call) {
-                const id = typeof call.id === "string" ? call.id : "";
-                const shouldAdd = (() => {
-                  if (id.length > 0) {
-                    if (seenFunctionCallIds.has(id)) {
-                      return false;
-                    }
-                    seenFunctionCallIds.add(id);
-                    return true;
-                  }
-                  const key = JSON.stringify({ name: call.name ?? "", args: call.args ?? null });
-                  if (seenFunctionCallKeys.has(key)) {
-                    return false;
-                  }
-                  seenFunctionCallKeys.add(key);
-                  return true;
-                })();
-                if (shouldAdd) {
-                  functionCalls.push(call);
-                }
-              }
-              if (typeof part.text === "string" && part.text.length > 0) {
-                if (part.thought) {
-                  thoughtsText += part.text;
-                  onEvent?.({ type: "delta", channel: "thought", text: part.text });
-                } else {
-                  responseText += part.text;
-                  onEvent?.({ type: "delta", channel: "response", text: part.text });
-                }
-              }
-            }
-          }
-          return {
-            responseText,
-            thoughtsText,
-            functionCalls,
-            modelParts,
-            usageMetadata: latestUsageMetadata,
-            modelVersion: resolvedModelVersion ?? request.model
-          };
-        },
-        request.model,
-        {
-          onSettled: (metrics) => {
-            schedulerMetrics = metrics;
-          }
+          geminiContents.push(...steeringInput.map(convertLlmContentToGeminiContent));
         }
-      );
-      const modelCompletedAtMs = Date.now();
-      const usageTokens = extractGeminiUsageTokens(response.usageMetadata);
-      const modelVersion = response.modelVersion ?? request.model;
-      const stepCostUsd = estimateCallCostUsd({
-        modelId: modelVersion,
-        tokens: usageTokens,
-        responseImages: 0
-      });
-      totalCostUsd += stepCostUsd;
-      if (response.functionCalls.length === 0) {
-        const steeringInput2 = steeringInternal?.drainPendingContents() ?? [];
-        finalText = response.responseText.trim();
-        finalThoughts = response.thoughtsText.trim();
-        const stepCompletedAtMs2 = Date.now();
-        const timing2 = buildStepTiming({
-          stepStartedAtMs,
-          stepCompletedAtMs: stepCompletedAtMs2,
-          modelCompletedAtMs,
-          firstModelEventAtMs,
-          schedulerMetrics,
-          toolExecutionMs: 0,
-          waitToolMs: 0
-        });
-        steps.push({
-          step: steps.length + 1,
+      } catch (error) {
+        stepCallLogger?.fail(error, {
+          provider: "gemini",
+          model: request.model,
           modelVersion,
-          text: finalText || void 0,
-          thoughts: finalThoughts || void 0,
-          toolCalls: [],
+          step: turn,
           usage: usageTokens,
-          costUsd: stepCostUsd,
-          timing: timing2
-        });
-        if (steeringInput2.length === 0) {
-          return { text: finalText, thoughts: finalThoughts, steps, totalCostUsd };
-        }
-        const modelPartsForHistory2 = response.modelParts.filter(
-          (part) => !(typeof part.text === "string" && part.thought === true)
-        );
-        if (modelPartsForHistory2.length > 0) {
-          geminiContents.push({ role: "model", parts: modelPartsForHistory2 });
-        } else if (response.responseText.length > 0) {
-          geminiContents.push({ role: "model", parts: [{ text: response.responseText }] });
-        }
-        geminiContents.push(...steeringInput2.map(convertLlmContentToGeminiContent));
-        continue;
-      }
-      const toolCalls = [];
-      const modelPartsForHistory = response.modelParts.filter(
-        (part) => !(typeof part.text === "string" && part.thought === true)
-      );
-      if (modelPartsForHistory.length > 0) {
-        geminiContents.push({ role: "model", parts: modelPartsForHistory });
-      } else {
-        const parts = [];
-        if (response.responseText) {
-          parts.push({ text: response.responseText });
-        }
-        for (const call of response.functionCalls) {
-          parts.push({ functionCall: call });
-        }
-        geminiContents.push({ role: "model", parts });
-      }
-      const responseParts = [];
-      const callInputs = response.functionCalls.map((call, index) => {
-        const turn = stepIndex + 1;
-        const toolIndex = index + 1;
-        const toolId = buildToolLogId(turn, toolIndex);
-        const toolName = call.name ?? "unknown";
-        const rawInput = call.args ?? {};
-        return { call, toolName, rawInput, toolId, turn, toolIndex };
-      });
-      for (const entry of callInputs) {
-        onEvent?.({
-          type: "tool_call",
-          phase: "started",
-          turn: entry.turn,
-          toolIndex: entry.toolIndex,
-          toolName: entry.toolName,
-          toolId: entry.toolId,
-          callKind: "function",
-          callId: entry.call.id,
-          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",
-                toolName: entry.toolName,
-                tool: request.tools[entry.toolName],
-                rawInput: entry.rawInput
-              });
-              return { entry, result, outputPayload };
-            }
-          );
-        })
-      );
-      let toolExecutionMs = 0;
-      let waitToolMs = 0;
-      for (const { entry, result, outputPayload } of callResults) {
-        toolCalls.push({ ...result, callId: entry.call.id });
-        const callDurationMs = toToolResultDuration(result);
-        toolExecutionMs += callDurationMs;
-        if (entry.toolName.toLowerCase() === SUBAGENT_WAIT_TOOL_NAME) {
-          waitToolMs += callDurationMs;
-        }
-        onEvent?.({
-          type: "tool_call",
-          phase: "completed",
-          turn: entry.turn,
-          toolIndex: entry.toolIndex,
-          toolName: entry.toolName,
-          toolId: entry.toolId,
-          callKind: "function",
-          callId: entry.call.id,
-          input: entry.rawInput,
-          output: result.output,
-          error: result.error,
-          durationMs: result.durationMs
-        });
-        const responsePayload = isPlainRecord(outputPayload) ? outputPayload : { output: outputPayload };
-        responseParts.push({
-          functionResponse: {
-            name: entry.toolName,
-            response: responsePayload,
-            ...entry.call.id ? { id: entry.call.id } : {}
-          }
+          responseChars: responseText.length,
+          thoughtChars: thoughtsText.length
         });
-      }
-      const stepCompletedAtMs = Date.now();
-      const timing = buildStepTiming({
-        stepStartedAtMs,
-        stepCompletedAtMs,
-        modelCompletedAtMs,
-        firstModelEventAtMs,
-        schedulerMetrics,
-        toolExecutionMs,
-        waitToolMs
-      });
-      steps.push({
-        step: steps.length + 1,
-        modelVersion,
-        text: response.responseText.trim() || void 0,
-        thoughts: response.thoughtsText.trim() || void 0,
-        toolCalls,
-        usage: usageTokens,
-        costUsd: stepCostUsd,
-        timing
-      });
-      geminiContents.push({ role: "user", parts: responseParts });
-      const steeringInput = steeringInternal?.drainPendingContents() ?? [];
-      if (steeringInput.length > 0) {
-        geminiContents.push(...steeringInput.map(convertLlmContentToGeminiContent));
+        throw error;
       }
     }
     throw new Error(`Tool loop exceeded max steps (${maxSteps}) without final response.`);
@@ -6531,6 +7362,7 @@ ${lines}`;
 
 // src/agent.ts
 var import_node_crypto3 = require("crypto");
+var import_node_path7 = __toESM(require("path"), 1);
 
 // src/agent/subagents.ts
 var import_node_crypto2 = require("crypto");
@@ -7005,26 +7837,26 @@ function resolveInputItemsText(items) {
     }
     const itemType = typeof item.type === "string" ? item.type.trim() : "";
     const name = typeof item.name === "string" ? item.name.trim() : "";
-    const path6 = typeof item.path === "string" ? item.path.trim() : "";
+    const path8 = 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" && path6) {
-      lines.push(`[local_image:${path6}]`);
+    if (itemType === "local_image" && path8) {
+      lines.push(`[local_image:${path8}]`);
       continue;
     }
-    if (itemType === "skill" && name && path6) {
-      lines.push(`[skill:$${name}](${path6})`);
+    if (itemType === "skill" && name && path8) {
+      lines.push(`[skill:$${name}](${path8})`);
       continue;
     }
-    if (itemType === "mention" && name && path6) {
-      lines.push(`[mention:$${name}](${path6})`);
+    if (itemType === "mention" && name && path8) {
+      lines.push(`[mention:$${name}](${path8})`);
       continue;
     }
-    if (path6 || imageUrl) {
-      lines.push(`[${itemType || "input"}:${path6 || imageUrl}]`);
+    if (path8 || imageUrl) {
+      lines.push(`[${itemType || "input"}:${path8 || imageUrl}]`);
       continue;
     }
     if (name) {
@@ -7149,7 +7981,7 @@ function startRun(agent, options) {
         setLifecycle(agent, "idle", "input_queued", `Subagent ${agent.id} run interrupted.`);
         return;
       }
-      const message = toErrorMessage(error);
+      const message = toErrorMessage2(error);
       agent.lastError = message;
       setLifecycle(agent, "failed", "run_failed", `Subagent ${agent.id} failed: ${message}`);
       emitBackgroundNotification(agent, options);
@@ -7329,7 +8161,7 @@ function trimToUndefined(value) {
   const trimmed = value?.trim();
   return trimmed && trimmed.length > 0 ? trimmed : void 0;
 }
-function toErrorMessage(error) {
+function toErrorMessage2(error) {
   if (error instanceof Error) {
     return error.message;
   }
@@ -7342,27 +8174,27 @@ function sleep2(ms) {
 }
 
 // src/tools/filesystemTools.ts
-var import_node_path5 = __toESM(require("path"), 1);
-var import_node_buffer3 = require("buffer");
+var import_node_path6 = __toESM(require("path"), 1);
+var import_node_buffer4 = require("buffer");
 var import_zod6 = require("zod");
 
 // src/tools/applyPatch.ts
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 var import_zod5 = require("zod");
 
 // src/tools/filesystem.ts
 var import_node_fs3 = require("fs");
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 var InMemoryAgentFilesystem = class {
   #files = /* @__PURE__ */ new Map();
   #dirs = /* @__PURE__ */ new Map();
   #clock = 0;
   constructor(initialFiles = {}) {
-    const root = import_node_path3.default.resolve("/");
+    const root = import_node_path4.default.resolve("/");
     this.#dirs.set(root, { mtimeMs: this.#nextMtime() });
     for (const [filePath, content] of Object.entries(initialFiles)) {
-      const absolutePath = import_node_path3.default.resolve(filePath);
-      this.#ensureDirSync(import_node_path3.default.dirname(absolutePath));
+      const absolutePath = import_node_path4.default.resolve(filePath);
+      this.#ensureDirSync(import_node_path4.default.dirname(absolutePath));
       this.#files.set(absolutePath, {
         content,
         mtimeMs: this.#nextMtime()
@@ -7370,7 +8202,7 @@ var InMemoryAgentFilesystem = class {
     }
   }
   async readTextFile(filePath) {
-    const absolutePath = import_node_path3.default.resolve(filePath);
+    const absolutePath = import_node_path4.default.resolve(filePath);
     const file = this.#files.get(absolutePath);
     if (!file) {
       throw createNoSuchFileError("open", absolutePath);
@@ -7382,24 +8214,24 @@ var InMemoryAgentFilesystem = class {
     return Buffer.from(content, "utf8");
   }
   async writeTextFile(filePath, content) {
-    const absolutePath = import_node_path3.default.resolve(filePath);
-    const parentPath = import_node_path3.default.dirname(absolutePath);
+    const absolutePath = import_node_path4.default.resolve(filePath);
+    const parentPath = import_node_path4.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_path3.default.resolve(filePath);
+    const absolutePath = import_node_path4.default.resolve(filePath);
     if (!this.#files.delete(absolutePath)) {
       throw createNoSuchFileError("unlink", absolutePath);
     }
   }
   async ensureDir(directoryPath) {
-    this.#ensureDirSync(import_node_path3.default.resolve(directoryPath));
+    this.#ensureDirSync(import_node_path4.default.resolve(directoryPath));
   }
   async readDir(directoryPath) {
-    const absolutePath = import_node_path3.default.resolve(directoryPath);
+    const absolutePath = import_node_path4.default.resolve(directoryPath);
     const directory = this.#dirs.get(absolutePath);
     if (!directory) {
       throw createNoSuchFileError("scandir", absolutePath);
@@ -7410,10 +8242,10 @@ var InMemoryAgentFilesystem = class {
       if (dirPath === absolutePath) {
         continue;
       }
-      if (import_node_path3.default.dirname(dirPath) !== absolutePath) {
+      if (import_node_path4.default.dirname(dirPath) !== absolutePath) {
         continue;
       }
-      const name = import_node_path3.default.basename(dirPath);
+      const name = import_node_path4.default.basename(dirPath);
       if (seenNames.has(name)) {
         continue;
       }
@@ -7426,10 +8258,10 @@ var InMemoryAgentFilesystem = class {
       });
     }
     for (const [filePath, fileRecord] of this.#files.entries()) {
-      if (import_node_path3.default.dirname(filePath) !== absolutePath) {
+      if (import_node_path4.default.dirname(filePath) !== absolutePath) {
         continue;
       }
-      const name = import_node_path3.default.basename(filePath);
+      const name = import_node_path4.default.basename(filePath);
       if (seenNames.has(name)) {
         continue;
       }
@@ -7445,7 +8277,7 @@ var InMemoryAgentFilesystem = class {
     return entries;
   }
   async stat(entryPath) {
-    const absolutePath = import_node_path3.default.resolve(entryPath);
+    const absolutePath = import_node_path4.default.resolve(entryPath);
     const file = this.#files.get(absolutePath);
     if (file) {
       return { kind: "file", mtimeMs: file.mtimeMs };
@@ -7461,7 +8293,7 @@ var InMemoryAgentFilesystem = class {
     return Object.fromEntries(entries.map(([filePath, record]) => [filePath, record.content]));
   }
   #ensureDirSync(directoryPath) {
-    const absolutePath = import_node_path3.default.resolve(directoryPath);
+    const absolutePath = import_node_path4.default.resolve(directoryPath);
     const parts = [];
     let cursor = absolutePath;
     for (; ; ) {
@@ -7469,7 +8301,7 @@ var InMemoryAgentFilesystem = class {
         break;
       }
       parts.push(cursor);
-      const parent = import_node_path3.default.dirname(cursor);
+      const parent = import_node_path4.default.dirname(cursor);
       if (parent === cursor) {
         break;
       }
@@ -7503,7 +8335,7 @@ function createNodeAgentFilesystem() {
       const entries = await import_node_fs3.promises.readdir(directoryPath, { withFileTypes: true });
       const result = [];
       for (const entry of entries) {
-        const entryPath = import_node_path3.default.resolve(directoryPath, entry.name);
+        const entryPath = import_node_path4.default.resolve(directoryPath, entry.name);
         const stats = await import_node_fs3.promises.lstat(entryPath);
         result.push({
           name: entry.name,
@@ -7667,7 +8499,7 @@ function createApplyPatchTool(options = {}) {
   });
 }
 async function applyPatch(request) {
-  const cwd = import_node_path4.default.resolve(request.cwd ?? process.cwd());
+  const cwd = import_node_path5.default.resolve(request.cwd ?? process.cwd());
   const adapter = request.fs ?? createNodeAgentFilesystem();
   const allowOutsideCwd = request.allowOutsideCwd === true;
   const patchBytes = Buffer.byteLength(request.patch, "utf8");
@@ -7689,7 +8521,7 @@ async function applyPatch(request) {
         kind: "add",
         path: absolutePath2
       });
-      await adapter.ensureDir(import_node_path4.default.dirname(absolutePath2));
+      await adapter.ensureDir(import_node_path5.default.dirname(absolutePath2));
       await adapter.writeTextFile(absolutePath2, operation.content);
       added.push(toDisplayPath(absolutePath2, cwd));
       continue;
@@ -7723,7 +8555,7 @@ async function applyPatch(request) {
         fromPath: absolutePath,
         toPath: destinationPath
       });
-      await adapter.ensureDir(import_node_path4.default.dirname(destinationPath));
+      await adapter.ensureDir(import_node_path5.default.dirname(destinationPath));
       await adapter.writeTextFile(destinationPath, next);
       await adapter.deleteFile(absolutePath);
       modified.push(toDisplayPath(destinationPath, cwd));
@@ -7754,22 +8586,22 @@ function resolvePatchPath(rawPath, cwd, allowOutsideCwd) {
   if (trimmed.length === 0) {
     throw new Error("apply_patch failed: empty file path");
   }
-  const absolutePath = import_node_path4.default.isAbsolute(trimmed) ? import_node_path4.default.resolve(trimmed) : import_node_path4.default.resolve(cwd, trimmed);
+  const absolutePath = import_node_path5.default.isAbsolute(trimmed) ? import_node_path5.default.resolve(trimmed) : import_node_path5.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_path4.default.relative(cwd, candidatePath);
-  return relative === "" || !relative.startsWith("..") && !import_node_path4.default.isAbsolute(relative);
+  const relative = import_node_path5.default.relative(cwd, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !import_node_path5.default.isAbsolute(relative);
 }
 function toDisplayPath(absolutePath, cwd) {
-  const relative = import_node_path4.default.relative(cwd, absolutePath);
+  const relative = import_node_path5.default.relative(cwd, absolutePath);
   if (relative === "") {
     return ".";
   }
-  if (!relative.startsWith("..") && !import_node_path4.default.isAbsolute(relative)) {
+  if (!relative.startsWith("..") && !import_node_path5.default.isAbsolute(relative)) {
     return relative;
   }
   return absolutePath;
@@ -8536,7 +9368,7 @@ async function readBinaryFile(filesystem, filePath) {
     return await filesystem.readBinaryFile(filePath);
   }
   const text = await filesystem.readTextFile(filePath);
-  return import_node_buffer3.Buffer.from(text, "utf8");
+  return import_node_buffer4.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) {
@@ -8554,7 +9386,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_path5.default.extname(filePath).toLowerCase()];
+  const fromExtension = IMAGE_MIME_BY_EXTENSION[import_node_path6.default.extname(filePath).toLowerCase()];
   if (fromExtension && SUPPORTED_IMAGE_MIME_TYPES.has(fromExtension)) {
     return fromExtension;
   }
@@ -8564,13 +9396,13 @@ function isPdfFile(buffer, filePath) {
   if (buffer.length >= 5 && buffer.subarray(0, 5).toString("ascii") === "%PDF-") {
     return true;
   }
-  return import_node_path5.default.extname(filePath).toLowerCase() === ".pdf";
+  return import_node_path6.default.extname(filePath).toLowerCase() === ".pdf";
 }
 function isValidUtf8(buffer) {
   if (buffer.length === 0) {
     return true;
   }
-  return import_node_buffer3.Buffer.from(buffer.toString("utf8"), "utf8").equals(buffer);
+  return import_node_buffer4.Buffer.from(buffer.toString("utf8"), "utf8").equals(buffer);
 }
 async function readFileGemini(input, options) {
   const runtime = resolveRuntime(options);
@@ -8602,7 +9434,7 @@ async function writeFileGemini(input, options) {
     action: "write",
     path: filePath
   });
-  await runtime.filesystem.ensureDir(import_node_path5.default.dirname(filePath));
+  await runtime.filesystem.ensureDir(import_node_path6.default.dirname(filePath));
   await runtime.filesystem.writeTextFile(filePath, input.content);
   return `Successfully wrote file: ${toDisplayPath2(filePath, runtime.cwd)}`;
 }
@@ -8623,7 +9455,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_path5.default.dirname(filePath));
+      await runtime.filesystem.ensureDir(import_node_path6.default.dirname(filePath));
       await runtime.filesystem.writeTextFile(filePath, newValue);
       return `Successfully wrote new file: ${toDisplayPath2(filePath, runtime.cwd)}`;
     }
@@ -8801,7 +9633,7 @@ async function globFilesGemini(input, options) {
   });
   const matched = [];
   for (const filePath of files) {
-    const relativePath = normalizeSlashes(import_node_path5.default.relative(dirPath, filePath));
+    const relativePath = normalizeSlashes(import_node_path6.default.relative(dirPath, filePath));
     if (!matcher(relativePath)) {
       continue;
     }
@@ -8819,7 +9651,7 @@ async function globFilesGemini(input, options) {
 }
 function resolveRuntime(options) {
   return {
-    cwd: import_node_path5.default.resolve(options.cwd ?? process.cwd()),
+    cwd: import_node_path6.default.resolve(options.cwd ?? process.cwd()),
     filesystem: options.fs ?? createNodeAgentFilesystem(),
     allowOutsideCwd: options.allowOutsideCwd === true,
     checkAccess: options.checkAccess,
@@ -8850,13 +9682,13 @@ function mapApplyPatchAction(action) {
   return "move";
 }
 function resolvePathWithPolicy(inputPath, cwd, allowOutsideCwd) {
-  const absolutePath = import_node_path5.default.isAbsolute(inputPath) ? import_node_path5.default.resolve(inputPath) : import_node_path5.default.resolve(cwd, inputPath);
+  const absolutePath = import_node_path6.default.isAbsolute(inputPath) ? import_node_path6.default.resolve(inputPath) : import_node_path6.default.resolve(cwd, inputPath);
   if (allowOutsideCwd || isPathInsideCwd2(absolutePath, cwd)) {
     return absolutePath;
   }
-  if (import_node_path5.default.isAbsolute(inputPath)) {
+  if (import_node_path6.default.isAbsolute(inputPath)) {
     const sandboxRelativePath = inputPath.replace(/^[/\\]+/, "");
-    const sandboxRootedPath = import_node_path5.default.resolve(cwd, sandboxRelativePath);
+    const sandboxRootedPath = import_node_path6.default.resolve(cwd, sandboxRelativePath);
     if (isPathInsideCwd2(sandboxRootedPath, cwd)) {
       return sandboxRootedPath;
     }
@@ -8864,25 +9696,25 @@ function resolvePathWithPolicy(inputPath, cwd, allowOutsideCwd) {
   throw new Error(`path "${inputPath}" resolves outside cwd "${cwd}"`);
 }
 function isPathInsideCwd2(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_path6.default.relative(cwd, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !import_node_path6.default.isAbsolute(relative);
 }
 function toDisplayPath2(absolutePath, cwd) {
-  const relative = import_node_path5.default.relative(cwd, absolutePath);
+  const relative = import_node_path6.default.relative(cwd, absolutePath);
   if (relative === "") {
     return ".";
   }
-  if (!relative.startsWith("..") && !import_node_path5.default.isAbsolute(relative)) {
+  if (!relative.startsWith("..") && !import_node_path6.default.isAbsolute(relative)) {
     return relative;
   }
   return absolutePath;
 }
 function toSandboxDisplayPath(absolutePath, cwd) {
-  const relative = import_node_path5.default.relative(cwd, absolutePath);
+  const relative = import_node_path6.default.relative(cwd, absolutePath);
   if (relative === "") {
     return "/";
   }
-  if (!relative.startsWith("..") && !import_node_path5.default.isAbsolute(relative)) {
+  if (!relative.startsWith("..") && !import_node_path6.default.isAbsolute(relative)) {
     return `/${normalizeSlashes(relative)}`;
   }
   return normalizeSlashes(absolutePath);
@@ -8998,7 +9830,7 @@ function createGlobMatcher(pattern, caseSensitive = false) {
   }));
   return (candidatePath) => {
     const normalizedPath = normalizeSlashes(candidatePath);
-    const basename = import_node_path5.default.posix.basename(normalizedPath);
+    const basename = import_node_path6.default.posix.basename(normalizedPath);
     return compiled.some(
       (entry) => entry.regex.test(entry.applyToBasename ? basename : normalizedPath)
     );
@@ -9114,10 +9946,18 @@ function isNoEntError(error) {
 // src/agent.ts
 async function runAgentLoop(request) {
   const telemetry = createAgentTelemetrySession(request.telemetry);
+  const logging = createRootAgentLoggingSession(request);
   try {
-    return await runAgentLoopInternal(request, { depth: 0, telemetry });
+    return await runWithAgentLoggingSession(logging, async () => {
+      return await runAgentLoopInternal(request, {
+        depth: 0,
+        telemetry,
+        logging
+      });
+    });
   } finally {
     await telemetry?.flush();
+    await logging?.flush();
   }
 }
 function mergeAbortSignals2(first, second) {
@@ -9188,9 +10028,11 @@ async function runAgentLoopInternal(request, context) {
     subagent_tool,
     subagents,
     telemetry,
+    logging: _logging,
     ...toolLoopRequest
   } = request;
   const telemetrySession = context.telemetry ?? createAgentTelemetrySession(telemetry);
+  const loggingSession = context.logging;
   const runId = randomRunId();
   const startedAtMs = Date.now();
   const steeringChannel = toolLoopRequest.steering ?? createToolLoopSteeringChannel();
@@ -9204,6 +10046,7 @@ async function runAgentLoopInternal(request, context) {
     model: request.model,
     depth: context.depth,
     telemetry: telemetrySession,
+    logging: loggingSession,
     customTools: customTools ?? {},
     filesystemSelection,
     subagentSelection,
@@ -9240,6 +10083,16 @@ async function runAgentLoopInternal(request, context) {
     filesystemToolsEnabled: Object.keys(filesystemTools).length > 0,
     subagentToolsEnabled: resolvedSubagentConfig.enabled
   });
+  loggingSession?.logLine(
+    [
+      `[agent:${runId}] run_started`,
+      `depth=${context.depth.toString()}`,
+      `model=${request.model}`,
+      `tools=${Object.keys(mergedTools).length.toString()}`,
+      `filesystemTools=${Object.keys(filesystemTools).length > 0 ? "true" : "false"}`,
+      `subagentTools=${resolvedSubagentConfig.enabled ? "true" : "false"}`
+    ].join(" ")
+  );
   const sourceOnEvent = toolLoopRequestWithSteering.onEvent;
   const includeLlmStreamEvents = telemetrySession?.includeLlmStreamEvents === true;
   const wrappedOnEvent = sourceOnEvent || includeLlmStreamEvents ? (event) => {
@@ -9247,6 +10100,14 @@ async function runAgentLoopInternal(request, context) {
     if (includeLlmStreamEvents) {
       emitTelemetry({ type: "agent.run.stream", event });
     }
+    if (loggingSession) {
+      appendAgentStreamEventLog({
+        event,
+        append: (line) => {
+          loggingSession.logLine(`[agent:${runId}] ${line}`);
+        }
+      });
+    }
   } : void 0;
   try {
     const result = await runToolLoop({
@@ -9264,14 +10125,43 @@ async function runAgentLoopInternal(request, context) {
       totalCostUsd: result.totalCostUsd,
       usage: summarizeResultUsage(result)
     });
+    loggingSession?.logLine(
+      [
+        `[agent:${runId}] run_completed`,
+        `status=ok`,
+        `durationMs=${Math.max(0, Date.now() - startedAtMs).toString()}`,
+        `steps=${result.steps.length.toString()}`,
+        `toolCalls=${countToolCalls(result).toString()}`,
+        `totalCostUsd=${(result.totalCostUsd ?? 0).toFixed(6)}`
+      ].join(" ")
+    );
+    for (const step of result.steps) {
+      loggingSession?.logLine(
+        [
+          `[agent:${runId}] step_completed`,
+          `step=${step.step.toString()}`,
+          `modelVersion=${step.modelVersion}`,
+          `toolCalls=${step.toolCalls.length.toString()}`,
+          `costUsd=${(step.costUsd ?? 0).toFixed(6)}`
+        ].join(" ")
+      );
+    }
     return result;
   } catch (error) {
     emitTelemetry({
       type: "agent.run.completed",
       success: false,
       durationMs: Math.max(0, Date.now() - startedAtMs),
-      error: toErrorMessage2(error)
+      error: toErrorMessage3(error)
     });
+    loggingSession?.logLine(
+      [
+        `[agent:${runId}] run_completed`,
+        `status=error`,
+        `durationMs=${Math.max(0, Date.now() - startedAtMs).toString()}`,
+        `error=${toErrorMessage3(error)}`
+      ].join(" ")
+    );
     throw error;
   } finally {
     await subagentController?.closeAll();
@@ -9342,7 +10232,8 @@ function createSubagentController(params) {
         {
           depth: params.depth + 1,
           parentRunId: params.runId,
-          telemetry: params.telemetry
+          telemetry: params.telemetry,
+          logging: params.logging
         }
       );
     }
@@ -9406,10 +10297,10 @@ function trimToUndefined2(value) {
 function randomRunId() {
   return (0, import_node_crypto3.randomBytes)(8).toString("hex");
 }
-function toIsoNow() {
+function toIsoNow2() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
-function toErrorMessage2(error) {
+function toErrorMessage3(error) {
   if (error instanceof Error && error.message) {
     return error.message;
   }
@@ -9454,9 +10345,41 @@ function summarizeResultUsage(result) {
   }
   return summary;
 }
-function isPromiseLike(value) {
+function isPromiseLike2(value) {
   return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
 }
+function resolveAgentLoggingSelection(value) {
+  if (value === false) {
+    return void 0;
+  }
+  if (value === void 0 || value === true) {
+    return {
+      mirrorToConsole: true
+    };
+  }
+  return value;
+}
+function resolveWorkspaceDirForLogging(request) {
+  const explicitSelection = request.filesystemTool ?? request.filesystem_tool;
+  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 process.cwd();
+}
+function createRootAgentLoggingSession(request) {
+  const selected = resolveAgentLoggingSelection(request.logging);
+  if (!selected) {
+    return void 0;
+  }
+  return createAgentLoggingSession({
+    ...selected,
+    workspaceDir: typeof selected.workspaceDir === "string" && selected.workspaceDir.trim().length > 0 ? import_node_path7.default.resolve(selected.workspaceDir) : resolveWorkspaceDirForLogging(request),
+    mirrorToConsole: selected.mirrorToConsole !== false
+  });
+}
 function isAgentTelemetrySink(value) {
   return typeof value === "object" && value !== null && typeof value.emit === "function";
 }
@@ -9487,7 +10410,7 @@ function createAgentTelemetrySession(telemetry) {
   const emit = (event) => {
     try {
       const output = config.sink.emit(event);
-      if (isPromiseLike(output)) {
+      if (isPromiseLike2(output)) {
         const task = Promise.resolve(output).then(() => void 0).catch(() => void 0);
         trackPromise(task);
       }
@@ -9518,7 +10441,7 @@ function createAgentTelemetryEmitter(params) {
     }
     params.session.emit({
       ...event,
-      timestamp: toIsoNow(),
+      timestamp: toIsoNow2(),
       runId: params.runId,
       ...params.parentRunId ? { parentRunId: params.parentRunId } : {},
       depth: params.depth,