@ai-sdk/harness 1.0.100 → 1.0.102

package/dist/agent/index.js

@@ -42,9 +42,11 @@ var HarnessCapabilityUnsupportedError = class extends (_b2 = HarnessError, _a2 =
 import {
   asArray as asArray2,
   asSchema,
-  generateId as generateId5,
+  generateId as generateId3,
+  normalizeHeaders,
   validateTypes
 } from "@ai-sdk/provider-utils";
+import { mergeCallbacks } from "ai/internal";
 
 // src/agent/internal/lifecycle-state-validation.ts
 import { safeValidateTypes } from "@ai-sdk/provider-utils";
@@ -155,19 +157,18 @@ async function toHarnessStream(options) {
 // src/agent/internal/run-prompt.ts
 import {
   executeTool,
-  generateId as generateId4,
+  generateId as generateId2,
   isExecutableTool,
   safeParseJSON as safeParseJSON2
 } from "@ai-sdk/provider-utils";
 import {
   getErrorMessage
 } from "@ai-sdk/provider";
-import { parseToolCall } from "ai/internal";
+import { asLanguageModelUsage as asLanguageModelUsage2, parseToolCall } from "ai/internal";
 
 // src/agent/internal/harness-stream-text-result.ts
 import {
-  DelayedPromise,
-  generateId
+  DelayedPromise
 } from "@ai-sdk/provider-utils";
 import {
   addLanguageModelUsage,
@@ -224,7 +225,8 @@ var HarnessStreamTextResult = class {
     this.runtimeContext = options.runtimeContext;
     this.toolsContext = options.toolsContext;
     this.providerName = `harness:${options.harnessId}`;
-    this.modelId = options.sessionId;
+    this.callId = options.callId;
+    this.modelId = options.modelId;
     this.outputSpecification = options.output;
     let controllerRef;
     const baseStream = new ReadableStream({
@@ -252,6 +254,11 @@ var HarnessStreamTextResult = class {
     this.fullStreamController.enqueue(part);
     this.appendToCurrentStepContent(part);
   }
+  setModelId(modelId) {
+    if (this.stepsBuffer.length === 0) {
+      this.modelId = modelId;
+    }
+  }
   /**
    * Push a continuation input into the consumer stream without attributing it
    * to the next model step. Approval responses and client tool results arrive
@@ -281,7 +288,7 @@ var HarnessStreamTextResult = class {
     const finishReason = input.finishReason.unified;
     const rawFinishReason = input.finishReason.raw;
     const step = new DefaultStepResult({
-      callId: generateId(),
+      callId: this.callId,
       stepNumber: this.stepNumber,
       provider: this.providerName,
       modelId: this.modelId,
@@ -295,7 +302,7 @@ var HarnessStreamTextResult = class {
       warnings: input.warnings.length > 0 ? input.warnings : void 0,
       request: {},
       response: {
-        id: generateId(),
+        id: `${this.callId}-${this.stepNumber}`,
         timestamp: /* @__PURE__ */ new Date(),
         modelId: this.modelId,
         messages: []
@@ -357,7 +364,7 @@ var HarnessStreamTextResult = class {
     }
     this.settled = true;
     const finalStep = this.stepsBuffer.length > 0 ? this.stepsBuffer[this.stepsBuffer.length - 1] : new DefaultStepResult({
-      callId: generateId(),
+      callId: this.callId,
       stepNumber: 0,
       provider: this.providerName,
       modelId: this.modelId,
@@ -371,7 +378,7 @@ var HarnessStreamTextResult = class {
       warnings: void 0,
       request: {},
       response: {
-        id: generateId(),
+        id: `${this.callId}-0`,
         timestamp: /* @__PURE__ */ new Date(),
         modelId: this.modelId,
         messages: []
@@ -733,6 +740,18 @@ var HarnessStreamTextResult = class {
         }
         return;
       }
+      case "reasoning-delta": {
+        const last = this.currentStepContent[this.currentStepContent.length - 1];
+        if (last && last.type === "reasoning") {
+          last.text += part.text;
+        } else {
+          this.currentStepContent.push({
+            type: "reasoning",
+            text: part.text
+          });
+        }
+        return;
+      }
       case "tool-call":
       case "tool-approval-request":
       case "tool-approval-response":
@@ -833,7 +852,7 @@ function notSupportedYet(feature) {
 }
 
 // src/agent/internal/translate-stream-part.ts
-import { generateId as generateId2 } from "@ai-sdk/provider-utils";
+import { generateId } from "@ai-sdk/provider-utils";
 function translateStreamPart(event, options = {}) {
   var _a4, _b4;
   switch (event.type) {
@@ -925,7 +944,7 @@ function translateStreamPart(event, options = {}) {
         }
       ];
     case "file-change": {
-      const toolCallId = `harness-file-change-${generateId2()}`;
+      const toolCallId = `harness-file-change-${generateId()}`;
       const payload = { event: event.event, path: event.path };
       return [
         {
@@ -950,7 +969,7 @@ function translateStreamPart(event, options = {}) {
       ];
     }
     case "compaction": {
-      const toolCallId = `harness-compaction-${generateId2()}`;
+      const toolCallId = `harness-compaction-${generateId()}`;
       const output = {
         trigger: event.trigger,
         summary: event.summary,
@@ -1097,371 +1116,255 @@ function stripDeep(value, workDir) {
 }
 
 // src/agent/internal/turn-telemetry.ts
-import {
-  generateId as generateId3
-} from "@ai-sdk/provider-utils";
 import { createTelemetryDispatcher } from "ai/internal";
-var NOOP = {
-  async start() {
-  },
-  async ensureStepOpen() {
-  },
-  async stepFinish() {
-  },
-  async toolStart() {
-  },
-  async executeTool({ execute }) {
-    return await execute();
-  },
-  async toolEnd() {
-  },
-  async end() {
-  },
-  async error() {
-  }
-};
-function normalizeFinishReason(finishReason) {
-  if (finishReason != null && typeof finishReason === "object" && "unified" in finishReason) {
-    return finishReason.unified;
-  }
-  return finishReason;
-}
-function addTokenCounts(tokenCount1, tokenCount2) {
-  return tokenCount1 == null && tokenCount2 == null ? void 0 : (tokenCount1 != null ? tokenCount1 : 0) + (tokenCount2 != null ? tokenCount2 : 0);
-}
-function normalizeUsage(usage) {
-  if (usage == null || typeof usage !== "object" || !("inputTokens" in usage) || !("outputTokens" in usage)) {
-    return usage;
-  }
-  const inputTokens = usage.inputTokens;
-  const outputTokens = usage.outputTokens;
-  if (inputTokens == null || typeof inputTokens !== "object" || outputTokens == null || typeof outputTokens !== "object") {
-    return usage;
-  }
-  const input = inputTokens;
-  const output = outputTokens;
-  return {
-    inputTokens: input.total,
-    inputTokenDetails: {
-      noCacheTokens: input.noCache,
-      cacheReadTokens: input.cacheRead,
-      cacheWriteTokens: input.cacheWrite
-    },
-    outputTokens: output.total,
-    outputTokenDetails: {
-      textTokens: output.text,
-      reasoningTokens: output.reasoning
-    },
-    totalTokens: addTokenCounts(input.total, output.total),
-    raw: usage.raw
-  };
+async function notify(event, ...callbacks) {
+  await Promise.allSettled(
+    callbacks.map(async (callback) => {
+      await (callback == null ? void 0 : callback(event));
+    })
+  );
 }
-function createTurnTelemetry(opts) {
+function createTurnLifecycle(options) {
   var _a4;
-  if (opts.telemetry == null) return NOOP;
-  const dispatcher = createTelemetryDispatcher({ telemetry: opts.telemetry });
-  const callId = generateId3();
-  const provider = opts.harnessId;
-  let modelId = (_a4 = opts.modelId) != null ? _a4 : "";
-  const runtimeContext = opts.runtimeContext;
-  const inputMessages = [
-    { role: "user", content: opts.promptText }
-  ];
-  const languageModelTools = opts.toolSpecs.length === 0 ? void 0 : opts.toolSpecs.map((tool) => ({
-    type: "function",
-    name: tool.name,
-    ...tool.description != null ? { description: tool.description } : {},
-    ...tool.inputSchema != null ? { inputSchema: tool.inputSchema } : {}
-  }));
+  const telemetry = options.telemetry == null ? {} : createTelemetryDispatcher({ telemetry: options.telemetry });
+  const provider = `harness:${options.harnessId}`;
+  let modelId = (_a4 = options.modelId) != null ? _a4 : "";
   let started = false;
   let stepOpen = false;
   let stepNumber = 0;
   let ended = false;
-  let finalStepText = "";
-  let finalStepReasoning = [];
-  let finalStepProviderMetadata;
-  let outputToolCalls = [];
-  const openTools = /* @__PURE__ */ new Map();
-  const cast = (event) => event;
-  const fireStart = async () => {
-    var _a5;
-    if (started) return;
-    started = true;
-    await ((_a5 = dispatcher.onStart) == null ? void 0 : _a5.call(
-      dispatcher,
-      cast({
-        callId,
-        operationId: "ai.harness",
-        provider,
-        modelId,
-        tools: opts.tools,
-        toolChoice: void 0,
-        activeTools: opts.activeToolNames,
-        maxRetries: 0,
-        timeout: void 0,
-        headers: void 0,
-        providerOptions: void 0,
-        output: void 0,
-        toolsContext: void 0,
-        runtimeContext,
-        instructions: opts.instructions,
-        messages: inputMessages
-      })
-    ));
-  };
+  let modelCallStartedAt = 0;
+  const completedSteps = [];
+  const languageModelTools = options.toolSpecs.length === 0 ? void 0 : options.toolSpecs.map((tool) => ({
+    type: "function",
+    name: tool.name,
+    ...tool.description == null ? {} : { description: tool.description },
+    ...tool.inputSchema == null ? {} : { inputSchema: tool.inputSchema }
+  }));
   const start = async (overrideModelId) => {
     if (started) return;
-    if (overrideModelId) modelId = overrideModelId;
-    await fireStart();
+    if (overrideModelId != null) modelId = overrideModelId;
+    started = true;
+    const event = {
+      callId: options.callId,
+      operationId: "ai.harness",
+      provider,
+      modelId,
+      tools: options.tools,
+      toolChoice: void 0,
+      activeTools: options.activeToolNames,
+      toolOrder: [],
+      maxRetries: 0,
+      timeout: void 0,
+      headers: void 0,
+      providerOptions: void 0,
+      output: options.output,
+      toolsContext: options.toolsContext,
+      runtimeContext: options.runtimeContext,
+      instructions: options.instructions,
+      messages: options.messages
+    };
+    await notify(
+      event,
+      options.callbacks.onStart,
+      telemetry.onStart
+    );
   };
   const ensureStepOpen = async () => {
-    var _a5, _b4;
-    if (!started) await fireStart();
+    if (!started) await start();
     if (stepOpen || ended) return;
     stepOpen = true;
-    await ((_a5 = dispatcher.onStepStart) == null ? void 0 : _a5.call(
-      dispatcher,
-      cast({
-        callId,
-        provider,
-        modelId,
-        stepNumber,
-        tools: opts.tools,
-        toolChoice: void 0,
-        activeTools: opts.activeToolNames,
-        steps: new Array(stepNumber),
-        providerOptions: void 0,
-        output: void 0,
-        runtimeContext,
-        instructions: opts.instructions,
-        messages: inputMessages
-      })
-    ));
-    await ((_b4 = dispatcher.onLanguageModelCallStart) == null ? void 0 : _b4.call(
-      dispatcher,
-      cast({
-        callId,
-        provider,
-        modelId,
-        instructions: opts.instructions,
-        messages: inputMessages,
-        tools: languageModelTools
-      })
-    ));
+    const stepStartEvent = {
+      callId: options.callId,
+      provider,
+      modelId,
+      stepNumber,
+      tools: options.tools,
+      toolChoice: void 0,
+      activeTools: options.activeToolNames,
+      toolOrder: [],
+      steps: [...completedSteps],
+      providerOptions: void 0,
+      output: options.output,
+      runtimeContext: options.runtimeContext,
+      toolsContext: options.toolsContext,
+      instructions: options.instructions,
+      messages: options.messages
+    };
+    await notify(
+      stepStartEvent,
+      options.callbacks.onStepStart,
+      telemetry.onStepStart
+    );
+    const modelStartEvent = {
+      callId: options.callId,
+      provider,
+      modelId,
+      instructions: options.instructions,
+      messages: options.messages,
+      tools: languageModelTools
+    };
+    modelCallStartedAt = Date.now();
+    await notify(
+      modelStartEvent,
+      options.callbacks.onLanguageModelCallStart,
+      telemetry.onLanguageModelCallStart
+    );
   };
-  const inferenceEnd = async (info) => {
-    var _a5;
-    const finishReason = normalizeFinishReason(info.finishReason);
-    const usage = normalizeUsage(info.usage);
-    await ((_a5 = dispatcher.onLanguageModelCallEnd) == null ? void 0 : _a5.call(
-      dispatcher,
-      cast({
-        callId,
+  return {
+    start,
+    ensureStepOpen,
+    async languageModelCallEnd(input) {
+      await ensureStepOpen();
+      const event = {
+        callId: options.callId,
         provider,
         modelId,
-        finishReason,
-        responseId: callId,
-        usage,
-        content: info.content,
-        ...info.providerMetadata != null ? { providerMetadata: info.providerMetadata } : {},
+        finishReason: input.finishReason,
+        usage: input.usage,
+        content: input.content,
+        responseId: `${options.callId}-${stepNumber}`,
+        providerMetadata: input.providerMetadata,
         performance: {
-          responseTimeMs: void 0,
+          responseTimeMs: Math.max(0, Date.now() - modelCallStartedAt),
+          effectiveOutputTokensPerSecond: 0,
+          outputTokensPerSecond: void 0,
+          inputTokensPerSecond: void 0,
+          effectiveTotalTokensPerSecond: 0,
           timeToFirstOutputMs: void 0,
           timeBetweenOutputChunksMs: void 0
         }
-      })
-    ));
-  };
-  const recordOutputContent = (content) => {
-    finalStepText = "";
-    finalStepReasoning = [];
-    for (const part of content) {
-      if (part.type === "text") {
-        finalStepText += part.text;
-      } else if (part.type === "reasoning") {
-        finalStepReasoning.push({ text: part.text });
-      } else if (part.type === "tool-call") {
-        outputToolCalls.push(part);
-      }
-    }
-  };
-  const closeOpenTools = async () => {
-    var _a5;
-    for (const call of openTools.values()) {
-      await ((_a5 = dispatcher.onToolExecutionEnd) == null ? void 0 : _a5.call(
-        dispatcher,
-        cast({
-          callId,
-          toolExecutionMs: 0,
-          messages: [],
-          toolCall: {
-            type: "tool-call",
-            toolCallId: call.toolCallId,
-            toolName: call.toolName,
-            input: call.input,
-            dynamic: true
-          },
-          toolContext: void 0,
-          toolOutput: { type: "error", error: new Error("tool span unclosed") }
-        })
-      ));
-    }
-    openTools.clear();
-  };
-  return {
-    start,
-    ensureStepOpen,
-    async stepFinish(info) {
-      var _a5, _b4;
+      };
+      await notify(
+        event,
+        options.callbacks.onLanguageModelCallEnd,
+        telemetry.onLanguageModelCallEnd
+      );
+    },
+    async toolExecutionStart({ toolCall }) {
+      const event = {
+        callId: options.callId,
+        messages: options.messages,
+        toolCall,
+        toolContext: void 0
+      };
+      await notify(
+        event,
+        options.callbacks.onToolExecutionStart,
+        telemetry.onToolExecutionStart
+      );
+    },
+    async toolExecutionEnd({ toolCall, toolOutput, toolExecutionMs }) {
+      const event = {
+        callId: options.callId,
+        messages: options.messages,
+        toolCall,
+        toolContext: void 0,
+        toolOutput,
+        toolExecutionMs
+      };
+      await notify(
+        event,
+        options.callbacks.onToolExecutionEnd,
+        telemetry.onToolExecutionEnd
+      );
+    },
+    async stepEnd(step) {
+      var _a5, _b4, _c;
       if (!stepOpen) return;
-      const content = (_a5 = info.content) != null ? _a5 : [];
-      const finishReason = normalizeFinishReason(info.finishReason);
-      const usage = normalizeUsage(info.usage);
-      recordOutputContent(content);
-      finalStepProviderMetadata = info.providerMetadata;
-      await closeOpenTools();
-      await inferenceEnd({
-        finishReason,
-        usage,
-        content,
-        providerMetadata: info.providerMetadata
+      completedSteps.push(step);
+      const telemetryStepEndEvent = Object.assign(/* @__PURE__ */ Object.create(null), {
+        callId: step.callId,
+        stepNumber: step.stepNumber,
+        model: step.model,
+        toolsContext: step.toolsContext,
+        runtimeContext: step.runtimeContext,
+        content: step.content,
+        finishReason: step.finishReason,
+        rawFinishReason: step.rawFinishReason,
+        usage: step.usage,
+        performance: step.performance,
+        warnings: step.warnings,
+        request: step.request,
+        response: step.response,
+        providerMetadata: step.providerMetadata,
+        text: step.text,
+        reasoning: step.reasoning,
+        reasoningText: step.reasoningText,
+        files: step.files,
+        sources: step.sources,
+        toolCalls: step.toolCalls,
+        staticToolCalls: step.staticToolCalls,
+        dynamicToolCalls: step.dynamicToolCalls,
+        toolResults: step.toolResults,
+        staticToolResults: step.staticToolResults,
+        dynamicToolResults: step.dynamicToolResults
       });
-      await ((_b4 = dispatcher.onStepEnd) == null ? void 0 : _b4.call(
-        dispatcher,
-        cast({
-          callId,
-          stepNumber,
-          finishReason,
-          usage,
-          providerMetadata: info.providerMetadata,
-          content,
-          response: {
-            id: callId,
-            modelId,
-            timestamp: /* @__PURE__ */ new Date(0),
-            messages: []
-          }
-        })
-      ));
+      await Promise.allSettled([
+        (_b4 = (_a5 = options.callbacks).onStepEnd) == null ? void 0 : _b4.call(_a5, step),
+        (_c = telemetry.onStepEnd) == null ? void 0 : _c.call(telemetry, telemetryStepEndEvent)
+      ]);
       stepOpen = false;
       stepNumber += 1;
     },
-    async toolStart(call) {
-      var _a5;
-      await ensureStepOpen();
-      if (openTools.has(call.toolCallId)) return;
-      openTools.set(call.toolCallId, call);
-      await ((_a5 = dispatcher.onToolExecutionStart) == null ? void 0 : _a5.call(
-        dispatcher,
-        cast({
-          callId,
-          messages: [],
-          toolCall: {
-            type: "tool-call",
-            toolCallId: call.toolCallId,
-            toolName: call.toolName,
-            input: call.input,
-            dynamic: true
-          },
-          toolContext: void 0
-        })
-      ));
+    async end({ steps, usage }) {
+      if (!started) await start();
+      if (ended || steps.length === 0) return;
+      ended = true;
+      const finalStep = steps[steps.length - 1];
+      const event = {
+        callId: options.callId,
+        stepNumber: finalStep.stepNumber,
+        model: finalStep.model,
+        toolsContext: finalStep.toolsContext,
+        runtimeContext: finalStep.runtimeContext,
+        content: steps.flatMap((step) => step.content),
+        text: finalStep.text,
+        reasoning: finalStep.reasoning,
+        reasoningText: finalStep.reasoningText,
+        files: steps.flatMap((step) => step.files),
+        sources: steps.flatMap((step) => step.sources),
+        toolCalls: steps.flatMap((step) => step.toolCalls),
+        staticToolCalls: steps.flatMap((step) => step.staticToolCalls),
+        dynamicToolCalls: steps.flatMap((step) => step.dynamicToolCalls),
+        toolResults: steps.flatMap((step) => step.toolResults),
+        staticToolResults: steps.flatMap((step) => step.staticToolResults),
+        dynamicToolResults: steps.flatMap((step) => step.dynamicToolResults),
+        finishReason: finalStep.finishReason,
+        rawFinishReason: finalStep.rawFinishReason,
+        usage,
+        totalUsage: usage,
+        warnings: steps.flatMap((step) => {
+          var _a5;
+          return (_a5 = step.warnings) != null ? _a5 : [];
+        }),
+        request: finalStep.request,
+        response: finalStep.response,
+        providerMetadata: finalStep.providerMetadata,
+        responseMessages: steps.flatMap((step) => step.response.messages),
+        steps,
+        finalStep
+      };
+      await notify(
+        event,
+        options.callbacks.onEnd,
+        telemetry.onEnd
+      );
     },
     async executeTool({ toolCallId, execute }) {
-      if (dispatcher.executeTool == null) return await execute();
-      return await dispatcher.executeTool({ callId, toolCallId, execute });
-    },
-    async toolEnd(toolCallId, output) {
-      var _a5;
-      const call = openTools.get(toolCallId);
-      const normalizedOutput = output.ok ? { type: "tool-result", output: output.output } : { type: "error", error: output.error };
-      if (call == null) return;
-      openTools.delete(toolCallId);
-      await ((_a5 = dispatcher.onToolExecutionEnd) == null ? void 0 : _a5.call(
-        dispatcher,
-        cast({
-          callId,
-          toolExecutionMs: 0,
-          messages: [],
-          toolCall: {
-            type: "tool-call",
-            toolCallId: call.toolCallId,
-            toolName: call.toolName,
-            input: call.input,
-            dynamic: true
-          },
-          toolContext: void 0,
-          toolOutput: normalizedOutput
-        })
-      ));
-    },
-    async end(info) {
-      var _a5, _b4;
-      if (ended) return;
-      const finishReason = normalizeFinishReason(info.finishReason);
-      const usage = normalizeUsage(info.usage);
-      if (!started) await fireStart();
-      if (stepOpen) {
-        await closeOpenTools();
-        await inferenceEnd({
-          finishReason,
-          usage,
-          content: []
-        });
-        await ((_a5 = dispatcher.onStepEnd) == null ? void 0 : _a5.call(
-          dispatcher,
-          cast({
-            callId,
-            stepNumber,
-            finishReason,
-            usage,
-            providerMetadata: void 0,
-            content: [],
-            response: {
-              id: callId,
-              modelId,
-              timestamp: /* @__PURE__ */ new Date(0),
-              messages: []
-            }
-          })
-        ));
-        stepOpen = false;
-      }
-      ended = true;
-      await ((_b4 = dispatcher.onEnd) == null ? void 0 : _b4.call(
-        dispatcher,
-        cast({
-          callId,
-          operationId: "ai.harness",
-          finishReason,
-          usage,
-          totalUsage: usage,
-          content: [],
-          text: finalStepText,
-          finalStep: {
-            reasoning: finalStepReasoning,
-            providerMetadata: finalStepProviderMetadata
-          },
-          toolCalls: outputToolCalls,
-          files: [],
-          steps: new Array(stepNumber),
-          response: {
-            id: callId,
-            modelId,
-            timestamp: /* @__PURE__ */ new Date(0),
-            messages: []
-          },
-          runtimeContext
-        })
-      ));
+      if (telemetry.executeTool == null) return await execute();
+      return await telemetry.executeTool({
+        callId: options.callId,
+        toolCallId,
+        execute
+      });
     },
-    async error(err) {
+    async error(error) {
       var _a5;
       if (ended) return;
-      if (!started) await fireStart();
-      await closeOpenTools();
+      if (!started) await start();
       ended = true;
-      await ((_a5 = dispatcher.onError) == null ? void 0 : _a5.call(dispatcher, err));
+      await ((_a5 = telemetry.onError) == null ? void 0 : _a5.call(telemetry, error));
     }
   };
 }
@@ -1556,28 +1459,49 @@ function pinSandboxChannelEventCheckpoint(event) {
 }
 
 // src/agent/internal/run-prompt.ts
+function unwrapToolResultOutput(toolResult) {
+  switch (toolResult.output.type) {
+    case "text":
+    case "json":
+      return { output: toolResult.output.value };
+    case "error-text":
+    case "error-json":
+      return { output: toolResult.output.value, isError: true };
+    case "execution-denied":
+      return {
+        output: {
+          type: toolResult.output.type,
+          reason: toolResult.output.reason
+        }
+      };
+    case "content":
+      return { output: toolResult.output };
+  }
+}
 function runPrompt(input) {
-  var _a4, _b4, _c, _d, _e, _f, _g;
+  var _a4, _b4, _c, _d, _e, _f, _g, _h, _i;
+  const callId = generateId2();
+  const toolsContext = {};
   const result = new HarnessStreamTextResult({
     tools: input.tools,
     runtimeContext: input.runtimeContext,
-    // toolsContext is not configurable for harnesses; pass undefined cast.
-    toolsContext: void 0,
+    toolsContext,
     harnessId: input.harness.harnessId,
-    sessionId: input.session.sessionId,
+    callId,
+    modelId: (_a4 = input.model) != null ? _a4 : "",
     output: input.output
   });
-  const pendingToolApprovals = (_a4 = input.pendingToolApprovals) != null ? _a4 : [];
-  const pendingToolResults = (_b4 = input.pendingToolResults) != null ? _b4 : [];
-  const onPendingToolApproval = (_c = input.onPendingToolApproval) != null ? _c : (() => {
+  const pendingToolApprovals = (_b4 = input.pendingToolApprovals) != null ? _b4 : [];
+  const pendingToolResults = (_c = input.pendingToolResults) != null ? _c : [];
+  const onPendingToolApproval = (_d = input.onPendingToolApproval) != null ? _d : (() => {
   });
-  const onToolApprovalSettled = (_d = input.onToolApprovalSettled) != null ? _d : (() => {
+  const onToolApprovalSettled = (_e = input.onToolApprovalSettled) != null ? _e : (() => {
   });
-  const onPendingToolResult = (_e = input.onPendingToolResult) != null ? _e : (() => {
+  const onPendingToolResult = (_f = input.onPendingToolResult) != null ? _f : (() => {
   });
-  const onToolResultSettled = (_f = input.onToolResultSettled) != null ? _f : (() => {
+  const onToolResultSettled = (_g = input.onToolResultSettled) != null ? _g : (() => {
   });
-  const activeTools = (_g = input.activeTools) != null ? _g : input.tools;
+  const activeTools = (_h = input.activeTools) != null ? _h : input.tools;
   const activeToolNames = Object.keys(input.tools).filter(
     (toolName) => Object.prototype.hasOwnProperty.call(activeTools, toolName) || Object.prototype.hasOwnProperty.call(
       input.harness.builtinTools,
@@ -1587,16 +1511,20 @@ function runPrompt(input) {
       toolFiltering: input.builtinToolFiltering
     })
   );
-  const telemetry = createTurnTelemetry({
+  const lifecycle = createTurnLifecycle({
+    callId,
     telemetry: input.telemetry,
+    callbacks: (_i = input.callbacks) != null ? _i : {},
     harnessId: input.harness.harnessId,
     modelId: input.model,
     instructions: input.instructions,
     tools: input.tools,
     activeToolNames,
     toolSpecs: input.toolSpecs,
-    promptText: input.prompt != null ? promptToText(input.prompt) : "",
-    runtimeContext: input.runtimeContext
+    messages: input.prompt == null ? [] : [{ role: "user", content: promptToText(input.prompt) }],
+    runtimeContext: input.runtimeContext,
+    toolsContext,
+    output: input.output
   });
   const settleFailure = (err) => {
     var _a5, _b5, _c2;
@@ -1613,7 +1541,7 @@ function runPrompt(input) {
     result.fail(err);
   };
   const done = (async () => {
-    var _a5, _b5, _c2, _d2, _e2, _f2, _g2, _h, _i, _j, _k, _l, _m, _n;
+    var _a5, _b5, _c2, _d2, _e2, _f2, _g2, _h2, _i2, _j, _k, _l, _m, _n, _o;
     let bridge;
     try {
       bridge = await toHarnessStream({
@@ -1648,7 +1576,7 @@ function runPrompt(input) {
         }
       });
     } catch (err) {
-      await telemetry.error(err);
+      await lifecycle.error(err);
       logBridgeError({
         harnessId: input.harness.harnessId,
         sessionId: input.session.sessionId,
@@ -1680,7 +1608,7 @@ function runPrompt(input) {
     );
     const continuationsByApprovalId = new Map(
       ((_b5 = input.toolApprovalContinuations) != null ? _b5 : []).map((continuation) => [
-        continuation.approvalResponse.approvalId,
+        continuation.approvalId,
         continuation
       ])
     );
@@ -1727,20 +1655,47 @@ function runPrompt(input) {
     let stepText = "";
     let stepReasoning = "";
     let stepToolCalls = [];
+    let stepProviderToolResults = [];
+    let stepApprovalRequests = [];
+    let bufferedToolOutcomes = [];
+    const toolExecutions = /* @__PURE__ */ new Map();
+    const publishToolExecutions = async () => {
+      var _a6;
+      for (const execution of toolExecutions.values()) {
+        if (execution.toolOutput == null) continue;
+        await lifecycle.toolExecutionStart({
+          toolCall: execution.toolCall
+        });
+        await lifecycle.toolExecutionEnd({
+          toolCall: execution.toolCall,
+          toolOutput: execution.toolOutput,
+          toolExecutionMs: (_a6 = execution.toolExecutionMs) != null ? _a6 : 0
+        });
+      }
+      for (const publish of bufferedToolOutcomes) publish();
+      toolExecutions.clear();
+      bufferedToolOutcomes = [];
+    };
     let expectedStepToolCallCount;
     let observedStepToolCallCount = 0;
     let pauseAfterStepToolCalls = false;
-    const buildStepContent = () => {
+    const buildModelCallContent = () => {
       const parts = [];
       if (stepText) parts.push({ type: "text", text: stepText });
       if (stepReasoning) parts.push({ type: "reasoning", text: stepReasoning });
       parts.push(...stepToolCalls);
+      parts.push(...stepApprovalRequests);
+      parts.push(...stepProviderToolResults);
       return parts;
     };
     const resetStepContent = () => {
       stepText = "";
       stepReasoning = "";
       stepToolCalls = [];
+      stepProviderToolResults = [];
+      stepApprovalRequests = [];
+      bufferedToolOutcomes = [];
+      toolExecutions.clear();
       expectedStepToolCallCount = void 0;
       observedStepToolCallCount = 0;
       pauseAfterStepToolCalls = false;
@@ -1763,13 +1718,13 @@ function runPrompt(input) {
       raw: void 0
     };
     const completeStep = async (input2) => {
-      await telemetry.stepFinish({
-        finishReason: input2.finishReason,
-        usage: input2.usage,
+      await lifecycle.languageModelCallEnd({
+        finishReason: input2.finishReason.unified,
+        usage: asLanguageModelUsage2(input2.usage),
         providerMetadata: input2.providerMetadata,
-        content: buildStepContent()
+        content: buildModelCallContent()
       });
-      resetStepContent();
+      await publishToolExecutions();
       const step = result.finishStep({
         finishReason: input2.finishReason,
         usage: input2.usage,
@@ -1777,6 +1732,8 @@ function runPrompt(input) {
         warnings: []
       });
       completedSteps.push(step);
+      await lifecycle.stepEnd(step);
+      resetStepContent();
       return step;
     };
     const finishForHostInputPause = async (options) => {
@@ -1787,20 +1744,24 @@ function runPrompt(input) {
           usage: zeroUsage,
           providerMetadata: void 0
         });
+      } else {
+        await publishToolExecutions();
       }
-      await telemetry.end({
-        finishReason: toolCallsFinishReason,
-        usage: zeroUsage
+      await lifecycle.end({
+        steps: completedSteps,
+        usage: asLanguageModelUsage2(zeroUsage)
       });
       await result.finish();
     };
     const enqueueApprovalRequest = (approval) => {
-      result.enqueue({
+      const part = {
         type: "tool-approval-request",
         approvalId: approval.approvalId,
         toolCall: approval.toolCall,
         ...approval.isAutomatic !== void 0 ? { isAutomatic: approval.isAutomatic } : {}
-      });
+      };
+      result.enqueue(part);
+      stepApprovalRequests.push(part);
     };
     const enqueueAutomaticApprovalResponse = (input2) => {
       result.enqueue({
@@ -1812,13 +1773,13 @@ function runPrompt(input) {
         ...input2.providerExecuted !== void 0 ? { providerExecuted: input2.providerExecuted } : {}
       });
     };
-    const enqueueApprovalResponse = (approval, continuation) => {
+    const enqueueApprovalResponse = (approval, continuation, toolCall) => {
       result.enqueueContinuation({
         type: "tool-approval-response",
         approvalId: approval.approvalId,
-        toolCall: continuation.toolCall,
-        approved: continuation.approvalResponse.approved,
-        ...continuation.approvalResponse.reason !== void 0 ? { reason: continuation.approvalResponse.reason } : {},
+        toolCall,
+        approved: continuation.approved,
+        ...continuation.reason !== void 0 ? { reason: continuation.reason } : {},
         ...approval.providerExecuted !== void 0 ? { providerExecuted: approval.providerExecuted } : {}
       });
     };
@@ -1827,20 +1788,27 @@ function runPrompt(input) {
       const pendingResult = (_a6 = pendingResultsByToolCallId.get(options.toolCall.toolCallId)) != null ? _a6 : {
         toolCallId: options.toolCall.toolCallId,
         toolName: options.toolCall.toolName,
-        input: options.toolCall.input
+        input: options.toolCall.input,
+        ...options.toolCall.providerMetadata !== void 0 ? { providerOptions: options.toolCall.providerMetadata } : {}
       };
       pendingResultsByToolCallId.set(pendingResult.toolCallId, pendingResult);
       onPendingToolResult(pendingResult);
       return pendingResult;
     };
     const processPendingToolResultContinuation = async (pendingResult, continuation) => {
+      const result2 = unwrapToolResultOutput(continuation);
       onToolResultSettled(pendingResult.toolCallId);
       pendingResultsByToolCallId.delete(pendingResult.toolCallId);
       settledHostToolCallIds.add(pendingResult.toolCallId);
       await control.submitToolResult({
         toolCallId: pendingResult.toolCallId,
-        output: continuation.output,
-        isError: continuation.isError
+        output: result2.output,
+        isError: result2.isError,
+        toolResult: {
+          ...continuation,
+          toolName: pendingResult.toolName,
+          ...continuation.providerOptions == null && pendingResult.providerOptions != null ? { providerOptions: pendingResult.providerOptions } : {}
+        }
       });
     };
     const enqueueHostToolOutcome = (options) => {
@@ -1873,7 +1841,23 @@ function runPrompt(input) {
     };
     const processPendingApprovalContinuation = async (approval, continuation) => {
       var _a6;
-      enqueueApprovalResponse(approval, continuation);
+      const rawToolCall = (_a6 = rawToolCallsByToolCallId.get(approval.toolCallId)) != null ? _a6 : {
+        type: "tool-call",
+        toolCallId: approval.toolCallId,
+        toolName: approval.toolName,
+        input: approval.input,
+        providerExecuted: approval.providerExecuted,
+        nativeName: approval.nativeName
+      };
+      const parsedInput = await safeParseJSON2({ text: rawToolCall.input });
+      const toolCall = {
+        type: "tool-call",
+        toolCallId: rawToolCall.toolCallId,
+        toolName: rawToolCall.toolName,
+        input: parsedInput.success ? parsedInput.value : rawToolCall.input,
+        ...rawToolCall.providerExecuted !== void 0 ? { providerExecuted: rawToolCall.providerExecuted } : {}
+      };
+      enqueueApprovalResponse(approval, continuation, toolCall);
       onToolApprovalSettled(approval.approvalId);
       pendingApprovalsByApprovalId.delete(approval.approvalId);
       pendingApprovalsByToolCallId.delete(approval.toolCallId);
@@ -1886,38 +1870,31 @@ function runPrompt(input) {
         }
         await control.submitToolApproval({
           approvalId: approval.approvalId,
-          approved: continuation.approvalResponse.approved,
-          reason: continuation.approvalResponse.reason
+          approved: continuation.approved,
+          reason: continuation.reason
         });
         return "continued";
       }
       settledHostToolCallIds.add(approval.toolCallId);
-      if (!continuation.approvalResponse.approved) {
+      if (!continuation.approved) {
         await control.submitToolResult({
           toolCallId: approval.toolCallId,
           output: {
             type: "execution-denied",
-            reason: continuation.approvalResponse.reason
+            reason: continuation.reason
           }
         });
         return "continued";
       }
-      const rawToolCall = (_a6 = rawToolCallsByToolCallId.get(approval.toolCallId)) != null ? _a6 : {
-        type: "tool-call",
-        toolCallId: approval.toolCallId,
-        toolName: approval.toolName,
-        input: approval.input
-      };
-      await telemetry.start(input.model);
-      await telemetry.toolStart({
-        toolCallId: rawToolCall.toolCallId,
-        toolName: rawToolCall.toolName,
-        input: rawToolCall.input
+      await lifecycle.start(input.model);
+      toolExecutions.set(rawToolCall.toolCallId, {
+        toolCall
       });
+      const executionStartedAt = Date.now();
       const execution = await maybeExecuteHostTool({
         event: rawToolCall,
         tools: activeTools,
-        wrappedExecuteTool: telemetry.executeTool,
+        wrappedExecuteTool: lifecycle.executeTool,
         sandboxSession: input.sandboxSession,
         abortSignal: input.abortSignal,
         control,
@@ -1931,13 +1908,15 @@ function runPrompt(input) {
             },
             input.sessionWorkDir
           );
-          result.enqueue({
-            type: "tool-result",
-            toolCallId: rawToolCall.toolCallId,
-            toolName: rawToolCall.toolName,
-            input: void 0,
-            output: stripped.result,
-            preliminary: true
+          bufferedToolOutcomes.push(() => {
+            result.enqueue({
+              type: "tool-result",
+              toolCallId: rawToolCall.toolCallId,
+              toolName: rawToolCall.toolName,
+              input: void 0,
+              output: stripped.result,
+              preliminary: true
+            });
           });
         }
       });
@@ -1946,11 +1925,19 @@ function runPrompt(input) {
         await finishForHostInputPause({ completeCurrentStep: false });
         return "awaiting-tool-result";
       }
-      enqueueHostToolOutcome({
-        toolCall: continuation.toolCall,
+      const toolExecution = toolExecutions.get(rawToolCall.toolCallId);
+      toolExecution.toolOutput = toToolOutput({
+        toolCall,
         outcome: execution.outcome
       });
-      await telemetry.toolEnd(rawToolCall.toolCallId, execution.outcome);
+      toolExecution.toolExecutionMs = Date.now() - executionStartedAt;
+      bufferedToolOutcomes.push(() => {
+        enqueueHostToolOutcome({
+          toolCall,
+          outcome: execution.outcome
+        });
+      });
+      await publishToolExecutions();
       return "continued";
     };
     try {
@@ -1997,9 +1984,12 @@ function runPrompt(input) {
             )
           )).some(Boolean)) {
             await ((_d2 = input.onStopConditionMet) == null ? void 0 : _d2.call(input));
-            const { finishReason, usage } = pendingStopBoundary;
+            const { usage } = pendingStopBoundary;
             releasePendingStopBoundary();
-            await telemetry.end({ finishReason, usage });
+            await lifecycle.end({
+              steps: completedSteps,
+              usage: asLanguageModelUsage2(usage)
+            });
             await result.finish();
             return;
           } else {
@@ -2007,10 +1997,12 @@ function runPrompt(input) {
           }
         }
         if (value.type === "stream-start") {
-          await telemetry.start((_e2 = value.modelId) != null ? _e2 : input.model);
+          const modelId = (_e2 = value.modelId) != null ? _e2 : input.model;
+          if (modelId != null) result.setModelId(modelId);
+          await lifecycle.start(modelId);
         }
         if (value.type !== "stream-start" && value.type !== "finish-step" && value.type !== "finish" && value.type !== "error") {
-          await telemetry.ensureStepOpen();
+          await lifecycle.ensureStepOpen();
         }
         if (value.type === "tool-input-start" || value.type === "tool-input-delta" || value.type === "tool-input-end") {
           if (settledHostToolCallIds.has(value.id) || settledBuiltinApprovalToolCallIds.has(value.id)) {
@@ -2034,6 +2026,7 @@ function runPrompt(input) {
         }
         if (displayValue.type === "finish-step" && closingResumedStep) {
           closingResumedStep = false;
+          await publishToolExecutions();
           resetStepContent();
           result.discardCurrentStepContent();
           continue;
@@ -2070,7 +2063,7 @@ function runPrompt(input) {
         }
         if (value.type === "error" && displayValue.type === "error") {
           await waitForOutstandingHostToolExecutions();
-          await telemetry.error(value.error);
+          await lifecycle.error(value.error);
           if (!((_g2 = input.abortSignal) == null ? void 0 : _g2.aborted)) {
             logBridgeError({
               harnessId: input.harness.harnessId,
@@ -2082,11 +2075,16 @@ function runPrompt(input) {
           settleFailure(displayValue.error);
           return;
         }
-        for (const part of translateStreamPart(
+        const translatedParts = translateStreamPart(
           displayValue,
           translateOptions
-        )) {
-          result.enqueue(part);
+        );
+        if (value.type === "tool-result") {
+          bufferedToolOutcomes.push(() => {
+            for (const part of translatedParts) result.enqueue(part);
+          });
+        } else {
+          for (const part of translatedParts) result.enqueue(part);
         }
         if (displayValue.type === "tool-call") {
           const parsed = await validateToolCall({
@@ -2106,23 +2104,32 @@ function runPrompt(input) {
         if (value.type === "tool-call") {
           observedStepToolCallCount += 1;
           expectedStepToolCallCount != null ? expectedStepToolCallCount : expectedStepToolCallCount = value.stepToolCallCount;
-          stepToolCalls.push({
-            type: "tool-call",
-            toolCallId: value.toolCallId,
-            toolName: value.toolName,
-            input: value.input
-          });
-          await telemetry.toolStart({
-            toolCallId: value.toolCallId,
-            toolName: value.toolName,
-            input: value.input
-          });
+          const toolCall = toolCallsByToolCallId.get(value.toolCallId);
+          if (toolCall != null) {
+            stepToolCalls.push(toolCall);
+            toolExecutions.set(value.toolCallId, {
+              toolCall
+            });
+          }
         }
         if (value.type === "tool-result") {
-          await telemetry.toolEnd(
-            value.toolCallId,
-            value.isError ? { ok: false, error: value.result } : { ok: true, output: value.result }
-          );
+          const execution = toolExecutions.get(value.toolCallId);
+          if (execution != null && execution.toolOutput == null) {
+            execution.toolOutput = value.isError ? {
+              ...execution.toolCall,
+              type: "tool-error",
+              error: value.result
+            } : {
+              ...execution.toolCall,
+              type: "tool-result",
+              output: value.result
+            };
+          }
+          if (((_h2 = rawToolCallsByToolCallId.get(value.toolCallId)) == null ? void 0 : _h2.providerExecuted) === true && (execution == null ? void 0 : execution.toolOutput) != null) {
+            stepProviderToolResults.push(
+              execution.toolOutput
+            );
+          }
         }
         if (value.type === "tool-approval-request") {
           const toolCall = toolCallsByToolCallId.get(value.toolCallId);
@@ -2132,13 +2139,13 @@ function runPrompt(input) {
             );
           }
           const rawToolCall = rawToolCallsByToolCallId.get(value.toolCallId);
-          const pendingApproval = (_j = pendingApprovalsByApprovalId.get(value.approvalId)) != null ? _j : {
+          const pendingApproval = (_k = pendingApprovalsByApprovalId.get(value.approvalId)) != null ? _k : {
             approvalId: value.approvalId,
             toolCallId: value.toolCallId,
             toolName: toolCall.toolName,
-            input: (_h = rawToolCall == null ? void 0 : rawToolCall.input) != null ? _h : JSON.stringify(toolCall.input),
+            input: (_i2 = rawToolCall == null ? void 0 : rawToolCall.input) != null ? _i2 : JSON.stringify(toolCall.input),
             kind: "builtin",
-            providerExecuted: (_i = rawToolCall == null ? void 0 : rawToolCall.providerExecuted) != null ? _i : true,
+            providerExecuted: (_j = rawToolCall == null ? void 0 : rawToolCall.providerExecuted) != null ? _j : true,
             ...(rawToolCall == null ? void 0 : rawToolCall.nativeName) !== void 0 ? { nativeName: rawToolCall.nativeName } : {}
           };
           pendingApprovalsByApprovalId.set(
@@ -2187,9 +2194,9 @@ function runPrompt(input) {
         if (value.type === "finish") {
           await waitForOutstandingHostToolExecutions();
           finalFinish = value;
-          await telemetry.end({
-            finishReason: value.finishReason,
-            usage: value.totalUsage
+          await lifecycle.end({
+            steps: completedSteps,
+            usage: asLanguageModelUsage2(value.totalUsage)
           });
         }
         if (value.type === "tool-call" && !value.providerExecuted) {
@@ -2200,7 +2207,11 @@ function runPrompt(input) {
               `Harness '${input.harness.harnessId}' could not find parsed tool call '${toolCall.toolCallId}' for custom tool approval.`
             );
           }
-          if (!hasTool({ tools: activeTools, toolName: toolCall.toolName })) {
+          const isClientExecutedBuiltin = toolCall.toolName === "askUserQuestions" && Object.prototype.hasOwnProperty.call(
+            input.harness.builtinTools,
+            toolCall.toolName
+          );
+          if (!isClientExecutedBuiltin && !hasTool({ tools: activeTools, toolName: toolCall.toolName })) {
             const output = {
               type: "execution-denied",
               reason: getHarnessV1BuiltinToolFilteringDenialReason({
@@ -2211,15 +2222,30 @@ function runPrompt(input) {
               toolCallId: toolCall.toolCallId,
               output
             });
-            await telemetry.toolEnd(toolCall.toolCallId, { ok: true, output });
+            const execution = toolExecutions.get(toolCall.toolCallId);
+            if (execution != null) {
+              execution.toolOutput = toToolOutput({
+                toolCall: parsedToolCall,
+                outcome: { ok: true, output }
+              });
+            }
             continue;
           }
+          if (isClientExecutedBuiltin) {
+            recordPendingToolResult({ toolCall });
+            if (expectedStepToolCallCount != null && observedStepToolCallCount < expectedStepToolCallCount) {
+              pauseAfterStepToolCalls = true;
+              continue;
+            }
+            await finishForHostInputPause({ completeCurrentStep: true });
+            return;
+          }
           const customToolApprovalDecision = resolveCustomToolApproval({
             toolName: toolCall.toolName,
             toolApproval: input.toolApproval
           });
           if (customToolApprovalDecision.type === "deny") {
-            const approvalId = generateId4();
+            const approvalId = generateId2();
             enqueueApprovalRequest({
               approvalId,
               toolCall: parsedToolCall,
@@ -2240,11 +2266,17 @@ function runPrompt(input) {
               toolCallId: toolCall.toolCallId,
               output
             });
-            await telemetry.toolEnd(toolCall.toolCallId, { ok: true, output });
+            const execution = toolExecutions.get(toolCall.toolCallId);
+            if (execution != null) {
+              execution.toolOutput = toToolOutput({
+                toolCall: parsedToolCall,
+                outcome: { ok: true, output }
+              });
+            }
             continue;
           }
-          const pendingApproval = (_k = pendingApprovalsByToolCallId.get(toolCall.toolCallId)) != null ? _k : customToolApprovalDecision.type === "request" ? {
-            approvalId: generateId4(),
+          const pendingApproval = (_l = pendingApprovalsByToolCallId.get(toolCall.toolCallId)) != null ? _l : customToolApprovalDecision.type === "request" ? {
+            approvalId: generateId2(),
             toolCallId: toolCall.toolCallId,
             toolName: toolCall.toolName,
             input: toolCall.input,
@@ -2304,10 +2336,11 @@ function runPrompt(input) {
           }
           startHostToolExecution(
             (async () => {
+              const executionStartedAt = Date.now();
               const execution = await maybeExecuteHostTool({
                 event: toolCall,
                 tools: activeTools,
-                wrappedExecuteTool: telemetry.executeTool,
+                wrappedExecuteTool: lifecycle.executeTool,
                 sandboxSession: input.sandboxSession,
                 abortSignal: input.abortSignal,
                 control,
@@ -2321,13 +2354,15 @@ function runPrompt(input) {
                     },
                     input.sessionWorkDir
                   );
-                  result.enqueue({
-                    type: "tool-result",
-                    toolCallId: toolCall.toolCallId,
-                    toolName: toolCall.toolName,
-                    input: void 0,
-                    output: stripped.result,
-                    preliminary: true
+                  bufferedToolOutcomes.push(() => {
+                    result.enqueue({
+                      type: "tool-result",
+                      toolCallId: toolCall.toolCallId,
+                      toolName: toolCall.toolName,
+                      input: void 0,
+                      output: stripped.result,
+                      preliminary: true
+                    });
                   });
                 }
               });
@@ -2336,21 +2371,28 @@ function runPrompt(input) {
                   `Harness '${input.harness.harnessId}' could not execute host tool '${toolCall.toolName}'.`
                 );
               }
-              await telemetry.toolEnd(toolCall.toolCallId, execution.outcome);
+              const toolExecution = toolExecutions.get(toolCall.toolCallId);
+              if (toolExecution != null) {
+                toolExecution.toolOutput = toToolOutput({
+                  toolCall: parsedToolCall,
+                  outcome: execution.outcome
+                });
+                toolExecution.toolExecutionMs = Date.now() - executionStartedAt;
+              }
             })()
           );
         }
       }
       await waitForOutstandingHostToolExecutions();
-      const isTurnSuspending = ((_l = input.isTurnSuspending) == null ? void 0 : _l.call(input)) === true;
+      const isTurnSuspending = ((_m = input.isTurnSuspending) == null ? void 0 : _m.call(input)) === true;
       if (isTurnSuspending) {
         if (finalFinish == null) {
           result.discardCurrentStepContent();
         }
       } else if (finalFinish != null) {
-        (_m = input.onTurnFinished) == null ? void 0 : _m.call(input);
+        (_n = input.onTurnFinished) == null ? void 0 : _n.call(input);
       } else {
-        (_n = input.onTurnFailed) == null ? void 0 : _n.call(input);
+        (_o = input.onTurnFailed) == null ? void 0 : _o.call(input);
       }
       await result.finish(
         finalFinish ? {
@@ -2364,7 +2406,7 @@ function runPrompt(input) {
         await waitForOutstandingHostToolExecutions();
       } catch (e) {
       }
-      await telemetry.error(err);
+      await lifecycle.error(err);
       logBridgeError({
         harnessId: input.harness.harnessId,
         sessionId: input.session.sessionId,
@@ -2381,6 +2423,17 @@ function runPrompt(input) {
   });
   return { result, done };
 }
+function toToolOutput(input) {
+  return input.outcome.ok ? {
+    ...input.toolCall,
+    type: "tool-result",
+    output: input.outcome.output
+  } : {
+    ...input.toolCall,
+    type: "tool-error",
+    error: input.outcome.error
+  };
+}
 function asToolCallTextStreamPart(input) {
   if (input.part.type !== "tool-call") {
     throw new Error(
@@ -2562,6 +2615,7 @@ var HarnessAgentSession = class {
         responseFormat: options.responseFormat,
         output: options.output,
         telemetry: options.telemetry,
+        callbacks: options.callbacks,
         stopConditions: options.stopConditions,
         toolApproval: this.toolApproval,
         pendingToolApprovals: this.getPendingToolApprovals(),
@@ -2634,6 +2688,7 @@ var HarnessAgentSession = class {
         responseFormat: options.responseFormat,
         output: options.output,
         telemetry: options.telemetry,
+        callbacks: options.callbacks,
         stopConditions: options.stopConditions,
         toolApproval: this.toolApproval,
         pendingToolApprovals: this.getPendingToolApprovals(),
@@ -3030,7 +3085,7 @@ var HarnessAgentSession = class {
 function collectHarnessAgentToolApprovalContinuations(input) {
   const lastMessage = input.messages.at(-1);
   if ((lastMessage == null ? void 0 : lastMessage.role) !== "tool") return [];
-  const toolCallsByToolCallId = /* @__PURE__ */ new Map();
+  const toolCallIds = /* @__PURE__ */ new Set();
   const approvalRequestsByApprovalId = /* @__PURE__ */ new Map();
   for (const message of input.messages) {
     if (message.role !== "assistant" || typeof message.content === "string") {
@@ -3038,13 +3093,7 @@ function collectHarnessAgentToolApprovalContinuations(input) {
     }
     for (const part of message.content) {
       if (part.type === "tool-call") {
-        toolCallsByToolCallId.set(part.toolCallId, {
-          type: "tool-call",
-          toolCallId: part.toolCallId,
-          toolName: part.toolName,
-          input: part.input,
-          ...part.providerExecuted !== void 0 ? { providerExecuted: part.providerExecuted } : {}
-        });
+        toolCallIds.add(part.toolCallId);
       } else if (part.type === "tool-approval-request") {
         approvalRequestsByApprovalId.set(part.approvalId, part);
       }
@@ -3066,16 +3115,12 @@ function collectHarnessAgentToolApprovalContinuations(input) {
       });
     }
     if (toolResultIds.has(approvalRequest.toolCallId)) continue;
-    const toolCall = toolCallsByToolCallId.get(approvalRequest.toolCallId);
-    if (toolCall == null) {
+    if (!toolCallIds.has(approvalRequest.toolCallId)) {
       throw new HarnessError({
         message: `Tool approval request '${approvalRequest.approvalId}' references unknown tool call '${approvalRequest.toolCallId}'.`
       });
     }
-    continuations.push({
-      approvalResponse: part,
-      toolCall
-    });
+    continuations.push(part);
   }
   return continuations;
 }
@@ -3084,42 +3129,7 @@ function collectHarnessAgentToolApprovalContinuations(input) {
 function collectHarnessAgentToolResultContinuations(input) {
   const lastMessage = input.messages.at(-1);
   if ((lastMessage == null ? void 0 : lastMessage.role) !== "tool") return [];
-  return lastMessage.content.filter((part) => part.type === "tool-result").map(
-    (part) => toToolResultContinuation({
-      toolCallId: part.toolCallId,
-      output: part.output
-    })
-  );
-}
-function toToolResultContinuation(input) {
-  switch (input.output.type) {
-    case "text":
-    case "json":
-      return {
-        toolCallId: input.toolCallId,
-        output: input.output.value
-      };
-    case "error-text":
-    case "error-json":
-      return {
-        toolCallId: input.toolCallId,
-        output: input.output.value,
-        isError: true
-      };
-    case "execution-denied":
-      return {
-        toolCallId: input.toolCallId,
-        output: {
-          type: input.output.type,
-          reason: input.output.reason
-        }
-      };
-    case "content":
-      return {
-        toolCallId: input.toolCallId,
-        output: input.output
-      };
-  }
+  return lastMessage.content.filter((part) => part.type === "tool-result");
 }
 
 // src/agent/internal/bootstrap-recipe.ts
@@ -3574,14 +3584,32 @@ function filterToolSet(input) {
 var HarnessAgent = class {
   constructor(settings) {
     this.version = "agent-v1";
-    var _a4;
+    var _a4, _b4;
     const sandboxConfig = resolveSandboxConfig(settings);
     validateSandboxBootstrapSettings(sandboxConfig);
     this.settings = settings;
     this.stopConditions = settings.stopWhen == null ? [] : asArray2(settings.stopWhen);
     this.sandboxConfig = sandboxConfig;
+    const forbiddenHeaders = /* @__PURE__ */ new Set([
+      "authorization",
+      "x-api-key",
+      "user-agent",
+      "x-client-app"
+    ]);
+    const forbiddenHeader = Object.keys((_a4 = settings.headers) != null ? _a4 : {}).map((name4) => name4.toLowerCase()).find((name4) => forbiddenHeaders.has(name4));
+    if (forbiddenHeader != null) {
+      throw new Error(
+        `HarnessAgent: \`headers\` must not include the managed header \`${forbiddenHeader}\`.`
+      );
+    }
+    const headers = normalizeHeaders(settings.headers);
+    this.headers = Object.keys(headers).length === 0 ? void 0 : headers;
     this.id = settings.id;
-    const userTools = (_a4 = settings.tools) != null ? _a4 : {};
+    const userTools = (_b4 = settings.tools) != null ? _b4 : {};
+    assertNoReservedQuestionTool({
+      harness: settings.harness,
+      userTools
+    });
     this.permissionMode = resolvePermissionMode({
       permissionMode: settings.permissionMode
     });
@@ -3620,7 +3648,7 @@ var HarnessAgent = class {
    */
   async createSession(options) {
     var _a4, _b4, _c;
-    const sessionId = (_a4 = options == null ? void 0 : options.sessionId) != null ? _a4 : generateId5();
+    const sessionId = (_a4 = options == null ? void 0 : options.sessionId) != null ? _a4 : generateId3();
     const resumeFrom = options == null ? void 0 : options.resumeFrom;
     const continueFrom = options == null ? void 0 : options.continueFrom;
     const providedSandboxSession = options == null ? void 0 : options.sandboxSession;
@@ -3788,6 +3816,7 @@ var HarnessAgent = class {
     try {
       const baseStartOptions = {
         sessionId,
+        ...this.headers == null ? {} : { headers: this.headers },
         resumeFrom: validatedResumeFrom,
         continueFrom: effectiveContinueFrom,
         permissionMode: this.permissionMode,
@@ -3907,7 +3936,8 @@ var HarnessAgent = class {
         turnSettings: turnInput,
         runtimeContext: input.runtimeContext,
         abortSignal: input.options.abortSignal,
-        responseFormat
+        responseFormat,
+        callbacks: this._resolveLifecycleCallbacks(input.options)
       }),
       prompt: turnInput.prompt
     });
@@ -3920,7 +3950,8 @@ var HarnessAgent = class {
         turnSettings: turnInput,
         runtimeContext: input.runtimeContext,
         abortSignal: input.abortSignal,
-        responseFormat
+        responseFormat,
+        callbacks: this._resolveLifecycleCallbacks()
       }),
       toolApprovalContinuations: turnInput.toolApprovalContinuations,
       toolResultContinuations: turnInput.toolResultContinuations
@@ -3940,9 +3971,38 @@ var HarnessAgent = class {
       responseFormat: input.responseFormat,
       output: this.settings.output,
       telemetry: this.settings.telemetry,
+      callbacks: input.callbacks,
       stopConditions: this.stopConditions
     };
   }
+  _resolveLifecycleCallbacks(call) {
+    var _a4, _b4, _c, _d, _e, _f;
+    return {
+      onStart: mergeCallbacks(
+        this.settings.onStart,
+        (_a4 = call == null ? void 0 : call.onStart) != null ? _a4 : call == null ? void 0 : call.experimental_onStart
+      ),
+      onStepStart: mergeCallbacks(
+        this.settings.onStepStart,
+        (_b4 = call == null ? void 0 : call.onStepStart) != null ? _b4 : call == null ? void 0 : call.experimental_onStepStart
+      ),
+      onLanguageModelCallStart: this.settings.onLanguageModelCallStart,
+      onLanguageModelCallEnd: this.settings.onLanguageModelCallEnd,
+      onToolExecutionStart: mergeCallbacks(
+        this.settings.onToolExecutionStart,
+        (_c = call == null ? void 0 : call.onToolExecutionStart) != null ? _c : call == null ? void 0 : call.experimental_onToolCallStart
+      ),
+      onToolExecutionEnd: mergeCallbacks(
+        this.settings.onToolExecutionEnd,
+        (_d = call == null ? void 0 : call.onToolExecutionEnd) != null ? _d : call == null ? void 0 : call.experimental_onToolCallFinish
+      ),
+      onStepEnd: mergeCallbacks(
+        this.settings.onStepEnd,
+        (_e = call == null ? void 0 : call.onStepEnd) != null ? _e : call == null ? void 0 : call.onStepFinish
+      ),
+      onEnd: mergeCallbacks(this.settings.onEnd, (_f = call == null ? void 0 : call.onEnd) != null ? _f : call == null ? void 0 : call.onFinish)
+    };
+  }
   _resolveContinueTurnInput(options) {
     if (typeof options.prompt === "string") {
       return void 0;
@@ -4059,6 +4119,10 @@ var HarnessAgent = class {
   _prepareTurnSettings(options) {
     var _a4, _b4;
     const userTools = (_a4 = options.tools) != null ? _a4 : {};
+    assertNoReservedQuestionTool({
+      harness: this.settings.harness,
+      userTools
+    });
     const tools = {
       ...this.settings.harness.builtinTools,
       ...userTools
@@ -4127,6 +4191,16 @@ var HarnessAgent = class {
     };
   }
 };
+function assertNoReservedQuestionTool(input) {
+  if (Object.prototype.hasOwnProperty.call(
+    input.harness.builtinTools,
+    "askUserQuestions"
+  ) && Object.prototype.hasOwnProperty.call(input.userTools, "askUserQuestions")) {
+    throw new Error(
+      "HarnessAgent tool name 'askUserQuestions' is reserved for harness question requests."
+    );
+  }
+}
 var HarnessGenerateTextResult = class {
   constructor(options) {
     this.steps = options.steps;