@anvia/core 1.1.2 → 1.2.1

package/dist/chunk-RT5LUEO3.js

@@ -0,0 +1,2339 @@
+import {
+  fetchContextDocuments,
+  fetchToolDefinitions
+} from "./chunk-GDY2Z2SZ.js";
+import {
+  getInternalAgentRunOptions
+} from "./chunk-KITX3HDN.js";
+import {
+  assertNonnegativeSafeInteger,
+  assertPositiveSafeInteger
+} from "./chunk-NPJ2T3L5.js";
+import {
+  addTurn,
+  addTurnToToolCallDelta,
+  isGenerationDeltaEvent
+} from "./chunk-YWRXOPHC.js";
+import {
+  STRUCTURED_OUTPUT_RETRY_PROMPT,
+  STRUCTURED_OUTPUT_TRUNCATED_RETRY_PROMPT,
+  normalizeStructuredOutput,
+  structuredOutputRepairPreview
+} from "./chunk-SXE4J43E.js";
+import {
+  ToolCallExecutor
+} from "./chunk-J4SINPUA.js";
+import {
+  parseContinuationState,
+  questionResult,
+  serializeContinuationState
+} from "./chunk-5I2NVRHC.js";
+import {
+  AgentInteractionSignal,
+  ToolExecutionSuspension,
+  approvalInteraction
+} from "./chunk-5IURMWFN.js";
+import {
+  normalizeMemoryScope
+} from "./chunk-LAIATEUB.js";
+import {
+  AgentRunMemory
+} from "./chunk-F3E2RLC7.js";
+import {
+  isQuestionTool
+} from "./chunk-IV6YQTY2.js";
+import {
+  startAgentRunObservers
+} from "./chunk-XJRNBTIV.js";
+import {
+  MemoryCompactionError
+} from "./chunk-LQJ4KHMY.js";
+import {
+  extractRagText
+} from "./chunk-MJCMKZFP.js";
+import {
+  createAsyncQueue
+} from "./chunk-EZR5AV3J.js";
+import {
+  runControl
+} from "./chunk-FAPIZJS2.js";
+import {
+  getAgentToolState
+} from "./chunk-A7BXVZXZ.js";
+import {
+  mergeCompletionControlValues
+} from "./chunk-6RQYWZI3.js";
+import {
+  assertAgentInteractionResponse,
+  parseAgentContinuation,
+  parseAgentInteractionResponse
+} from "./chunk-LBYJPMHC.js";
+import {
+  composeAgentLifecycle,
+  lifecycleSnapshot
+} from "./chunk-KFAVEL5F.js";
+import {
+  getAgentProviderOutputSchema
+} from "./chunk-GLMYZ6OA.js";
+import {
+  runInputGuardrails,
+  runOutputGuardrails
+} from "./chunk-VZ5ZZBNX.js";
+import {
+  appendGuardrailPolicies,
+  hasEnforcedOutputGuardrails
+} from "./chunk-6BTJC3ES.js";
+import {
+  isStreamingCompletionModel
+} from "./chunk-BDKFFFVX.js";
+import {
+  createCompletionRequest
+} from "./chunk-CKKNO4XB.js";
+import {
+  assertJsonObject
+} from "./chunk-4ONUNWGC.js";
+import {
+  CompletionStreamAccumulator
+} from "./chunk-UTAB3XQI.js";
+import {
+  assertCompletionResponseIntegrity
+} from "./chunk-XQV3XNVT.js";
+import {
+  toolMayRequireApproval
+} from "./chunk-YZVFIW5D.js";
+import {
+  Usage,
+  assertCompletionRequestSupported,
+  getAssistantGenerationMetadata,
+  textFromAssistantContent
+} from "./chunk-IDNL6IH4.js";
+import {
+  parseMessage,
+  parseMessages
+} from "./chunk-BONQTXRQ.js";
+import {
+  isJsonValue
+} from "./chunk-4C7AXYOM.js";
+import {
+  completionProviderOutputErrorUsage,
+  resolveRetryOptions,
+  retryDelayMs,
+  retryErrorAttributes,
+  retryOptionsForFailure,
+  waitForRetry
+} from "./chunk-POXHJF3H.js";
+import {
+  abortError,
+  throwIfAborted
+} from "./chunk-USRKPEQN.js";
+import {
+  AgentRunCancelledError,
+  AgentStreamClosedError,
+  AgentStructuredOutputError,
+  MaxTurnsError
+} from "./chunk-WN6AVBO4.js";
+
+// src/internal/agent-runtime/agent-run.ts
+async function settleFailureCleanup(operations) {
+  for (const operation of operations) {
+    try {
+      await operation();
+    } catch {
+    }
+  }
+}
+var AgentRun = class _AgentRun {
+  constructor(agent, promptMessage, initialHistory = [], options = {}) {
+    this.agent = agent;
+    this.promptMessage = promptMessage;
+    this.chatHistory = initialHistory;
+    this.maxTurnCount = assertNonnegativeSafeInteger(
+      options.maxTurns ?? agent.defaultMaxTurns ?? 0,
+      "maxTurns"
+    );
+    const internalOptions = getInternalAgentRunOptions(options);
+    this.activeHook = internalOptions?.hook;
+    this.onInternalFailure = internalOptions?.onFailure;
+    this.beforeFinish = internalOptions?.beforeFinish;
+    this.onSteeringApplied = internalOptions?.onSteeringApplied;
+    this.onInternalMemoryCompaction = internalOptions?.onMemoryCompaction;
+    this.requestedRunId = normalizeRequestedRunId(internalOptions?.runId);
+    this.activeLifecycle = composeAgentLifecycle(agent.lifecycle, options.lifecycle);
+    this.guardrailPolicies = options.guardrails === void 0 ? [...agent.guardrails] : appendGuardrailPolicies([...agent.guardrails], options.guardrails);
+    const configuredConcurrency = assertPositiveSafeInteger(
+      options.toolConcurrency ?? 1,
+      "toolConcurrency"
+    );
+    this.concurrency = this.activeHook !== void 0 || agent.tools.some(
+      (tool) => toolMayRequireApproval(tool.requiresApproval) || isQuestionTool(tool)
+    ) ? 1 : configuredConcurrency;
+    this.traceOptions = options.trace;
+    const retrySetting = options.retries === void 0 ? agent.retries : options.retries;
+    this.completionRetryOptions = retrySetting === void 0 || retrySetting === false ? void 0 : resolveRetryOptions(retrySetting);
+    this.requestMiddlewares = [...options.middlewares ?? []];
+    this.controls = mergeCompletionControlValues(agent.controls, options.controls);
+    this.memoryScope = options.memoryScope;
+    this.memoryRecorder = new AgentRunMemory(agent, options.memoryScope, initialHistory);
+    this.continuationState = options.continuationState;
+    this.interactionResponse = options.interactionResponse;
+    if (options.continuationState !== void 0) {
+      this.steeringMessages.push(
+        ...options.continuationState.steering.map((entry) => ({
+          id: entry.id,
+          messages: [...entry.messages]
+        }))
+      );
+    }
+    this.resumedFrom = options.sourceRunId === void 0 || options.interactionId === void 0 ? void 0 : { runId: options.sourceRunId, interactionId: options.interactionId };
+    this.linkExternalAbortSignal(options.abortSignal);
+  }
+  agent;
+  promptMessage;
+  chatHistory;
+  maxTurnCount;
+  activeHook;
+  activeLifecycle;
+  guardrailPolicies;
+  guardrailDecisions = [];
+  concurrency;
+  traceOptions;
+  generationPromptRef;
+  completionRetryOptions;
+  requestMiddlewares;
+  controls;
+  steeringMessages = [];
+  runState = "idle";
+  memoryRecorder;
+  memoryScope;
+  onInternalFailure;
+  beforeFinish;
+  onSteeringApplied;
+  onInternalMemoryCompaction;
+  memoryCompaction;
+  requestedRunId;
+  continuationState;
+  interactionResponse;
+  resumedFrom;
+  currentMessages = [];
+  cancellationError;
+  activeGeneration;
+  validatedStructuredOutput;
+  failedCompletionUsage = Usage.empty();
+  abortController = new AbortController();
+  removeExternalAbortListener;
+  static fromAgent(agent, options) {
+    const normalized = normalizeAgentInput(agent.id, options);
+    if (normalized.scope !== void 0 && agent.memory === void 0) {
+      throw new TypeError(`Agent "${agent.id}" cannot use a session without a memory store.`);
+    }
+    return new _AgentRun(agent, normalized.prompt, normalized.history, {
+      ...options,
+      memoryScope: normalized.scope,
+      continuationState: normalized.continuationState,
+      interactionResponse: normalized.interactionResponse,
+      sourceRunId: normalized.sourceRunId,
+      interactionId: normalized.interactionId
+    });
+  }
+  steer(input) {
+    if (this.isTerminal() || this.cancellationError !== void 0) {
+      throw new AgentStreamClosedError();
+    }
+    const receipt = Object.freeze({
+      id: globalThis.crypto.randomUUID(),
+      status: "queued"
+    });
+    this.steeringMessages.push({ id: receipt.id, messages: normalizeSteeringInput(input) });
+    return receipt;
+  }
+  cancel(reason) {
+    if (this.isTerminal() || this.cancellationError !== void 0) {
+      return this.cancellationError;
+    }
+    const messages = this.currentMessages.length === 0 ? [this.promptMessage] : [...this.currentMessages];
+    const error = new AgentRunCancelledError([...this.chatHistory, ...messages], reason);
+    this.setCancellationError(error);
+    return error;
+  }
+  setCancellationError(error) {
+    this.cancellationError = error;
+    if (!this.abortController.signal.aborted) this.abortController.abort(error);
+  }
+  async generate() {
+    this.startRun();
+    const runId = this.requestedRunId ?? globalThis.crypto.randomUUID();
+    let usage = Usage.empty();
+    let currentTurns = 0;
+    let lastPrompt = this.promptMessage;
+    let newMessages = [this.promptMessage];
+    let runObservers;
+    let pendingTurnMessages = [];
+    try {
+      this.throwIfCancelled();
+      const memoryPreparation = this.continuationState === void 0 ? await this.memoryRecorder.prepareHistory(
+        runId,
+        newMessages,
+        this.abortController.signal
+      ) : void 0;
+      if (memoryPreparation !== void 0) {
+        this.chatHistory = memoryPreparation.history;
+        usage = Usage.add(usage, memoryPreparation.usage);
+        this.memoryCompaction = memoryPreparation.compaction;
+        await this.notifyInternalMemoryCompaction(memoryPreparation.compaction);
+      }
+      runObservers = await this.startRunObservers(runId);
+      if (memoryPreparation !== void 0) {
+        await this.recordMemoryCompaction(memoryPreparation, runObservers);
+      }
+      this.throwIfCancelled();
+      await this.activeLifecycle?.onStart?.({
+        runId,
+        input: lifecycleSnapshot(this.promptMessage),
+        history: lifecycleSnapshot(this.chatHistory),
+        maxTurns: this.maxTurnCount
+      });
+      if (this.continuationState === void 0) {
+        const inputResult = await runInputGuardrails(this.guardrailPolicies, {
+          prompt: this.promptMessage,
+          history: this.chatHistory,
+          inputText: textFromMessage(this.promptMessage),
+          run: this.guardrailRunContext(runId)
+        });
+        for (const decision of inputResult.decisions) {
+          await this.recordGuardrailDecision(decision, runObservers);
+        }
+        this.promptMessage = inputResult.prompt;
+        if (inputResult.blocked) {
+          const text = inputResult.message ?? "The request was blocked by a guardrail.";
+          const result = {
+            type: "blocked",
+            stage: "input",
+            ...blockedOutcomeDetails(
+              this.guardrailDecisions,
+              "The request was blocked by a guardrail."
+            ),
+            runId,
+            text,
+            usage,
+            messages: [this.promptMessage, { role: "assistant", content: text }],
+            trace: runObservers.trace,
+            guardrails: [...this.guardrailDecisions],
+            ...this.memoryCompactionResult()
+          };
+          if (this.resumedFrom !== void 0) result.resumedFrom = this.resumedFrom;
+          this.runState = "closing";
+          await this.runLifecycleFinish(result);
+          await runObservers.end(observerRunEnd(result));
+          this.runState = "completed";
+          this.disposeAbortLink();
+          return result;
+        }
+      }
+      newMessages = [this.promptMessage];
+      await this.memoryRecorder.commitAcceptedInput(runId, newMessages);
+      pendingTurnMessages = this.memoryRecorder.pendingTurnMessages(newMessages);
+      await this.runRunStartHook(newMessages);
+      if (this.continuationState !== void 0) {
+        const interactionAttributes = {};
+        if (this.resumedFrom?.runId !== void 0) {
+          interactionAttributes.sourceRunId = this.resumedFrom.runId;
+        }
+        if (this.resumedFrom?.interactionId !== void 0) {
+          interactionAttributes.interactionId = this.resumedFrom.interactionId;
+        }
+        if (this.interactionResponse?.type !== void 0) {
+          interactionAttributes.interactionType = this.interactionResponse.type;
+        }
+        await runObservers.event({
+          name: "agent.interaction_response",
+          attributes: interactionAttributes
+        });
+        try {
+          const toolResults = await this.resolveContinuationTools(
+            runId,
+            newMessages,
+            void 0,
+            void 0,
+            {
+              turn: 1,
+              runObservers
+            }
+          );
+          const toolMessage = { role: "tool", content: toolResults };
+          newMessages.push(toolMessage);
+          await this.memoryRecorder.commitMessages(runId, 1, [toolMessage], pendingTurnMessages);
+          await this.drainSteeringMessages(runId, 1, newMessages, pendingTurnMessages);
+          await this.memoryRecorder.commitCompletedTurn(runId, 1, pendingTurnMessages);
+        } catch (error) {
+          if (error instanceof ToolExecutionSuspension) {
+            return this.finishSuspension({
+              runId,
+              turn: 1,
+              usage,
+              newMessages,
+              pendingTurnMessages,
+              runObservers,
+              suspension: error,
+              uncommittedMessages: []
+            });
+          }
+          throw error;
+        }
+      }
+      while (currentTurns <= this.maxTurnCount) {
+        const prompt = newMessages.at(-1);
+        if (prompt === void 0) {
+          throw new Error("AgentRun requires at least one message");
+        }
+        lastPrompt = prompt;
+        currentTurns += 1;
+        const historyForRequest = [...this.chatHistory, ...newMessages.slice(0, -1)];
+        await this.runTurnStartHook(currentTurns, prompt, historyForRequest, newMessages);
+        await this.runCompletionCallHook(prompt, historyForRequest, newMessages);
+        const request = await this.createTurnRequest(prompt, historyForRequest, currentTurns);
+        let response;
+        try {
+          response = await this.runCompletion(request, currentTurns, runObservers);
+        } catch (error) {
+          await settleFailureCleanup([
+            () => this.runCompletionErrorHook(prompt, error, newMessages)
+          ]);
+          throw error;
+        }
+        response = await this.runCompletionResponseMiddlewares(request, response, currentTurns);
+        try {
+          assertCompletionResponseIntegrity({ response });
+        } catch (error) {
+          const providerOutputUsage = completionProviderOutputErrorUsage(error);
+          if (providerOutputUsage !== void 0) usage = Usage.add(usage, providerOutputUsage);
+          throw error;
+        }
+        usage = Usage.add(usage, response.usage);
+        this.updateRunProgress(newMessages);
+        await this.runCompletionResponseHook(prompt, response, newMessages);
+        await this.runTurnEndHook(currentTurns, response, newMessages);
+        await this.activeLifecycle?.onStepFinish?.({
+          runId,
+          step: currentTurns,
+          response: lifecycleSnapshot(response),
+          usage: lifecycleSnapshot(usage)
+        });
+        const toolCalls = response.choice.filter(
+          (item) => item.type === "tool-call"
+        );
+        const assistantMessage = this.generatedAssistantMessage(response, request);
+        newMessages.push(assistantMessage);
+        if (toolCalls.length === 0) {
+          await this.beforeFinish?.();
+          if (this.steeringMessages.length > 0) {
+            await this.memoryRecorder.commitMessages(
+              runId,
+              currentTurns,
+              [assistantMessage],
+              pendingTurnMessages
+            );
+          }
+          const appliedSteering = await this.drainSteeringMessages(
+            runId,
+            currentTurns,
+            newMessages,
+            pendingTurnMessages,
+            { closeWhenEmpty: true }
+          );
+          if (appliedSteering.length > 0) {
+            for (const receipt of appliedSteering) {
+              await runObservers.event({
+                name: "agent.steering_applied",
+                attributes: { id: receipt.id, turn: currentTurns }
+              });
+            }
+            await this.memoryRecorder.commitCompletedTurn(runId, currentTurns, pendingTurnMessages);
+            continue;
+          }
+          const guardedOutput = await this.runOutputGuardrailsForResponse(
+            runId,
+            usage,
+            response,
+            newMessages,
+            runObservers
+          );
+          response = guardedOutput.response;
+          const finalAssistantMessage = this.generatedAssistantMessage(response, request);
+          newMessages[newMessages.length - 1] = finalAssistantMessage;
+          await this.memoryRecorder.commitMessages(
+            runId,
+            currentTurns,
+            [finalAssistantMessage],
+            pendingTurnMessages
+          );
+          const result = this.createTerminalResult(
+            runId,
+            guardedOutput.text,
+            guardedOutput.blocked,
+            usage,
+            newMessages,
+            runObservers
+          );
+          if (result.type === "response") {
+            await this.runRunEndHook(result, newMessages);
+          }
+          await this.memoryRecorder.commitCompletedRun(
+            runId,
+            currentTurns,
+            newMessages,
+            pendingTurnMessages
+          );
+          await this.runLifecycleFinish(result);
+          await runObservers.end(observerRunEnd(result));
+          this.runState = "completed";
+          this.disposeAbortLink();
+          return result;
+        }
+        this.updateRunProgress(newMessages);
+        let toolResults;
+        try {
+          toolResults = await this.executeToolCalls(
+            runId,
+            toolCalls,
+            newMessages,
+            void 0,
+            void 0,
+            {
+              turn: currentTurns,
+              runObservers,
+              toolDefinitions: request.tools
+            }
+          );
+        } catch (error) {
+          if (error instanceof ToolExecutionSuspension) {
+            return this.finishSuspension({
+              runId,
+              turn: currentTurns,
+              usage,
+              newMessages,
+              pendingTurnMessages,
+              runObservers,
+              suspension: error,
+              uncommittedMessages: [assistantMessage]
+            });
+          }
+          throw error;
+        }
+        const toolMessage = { role: "tool", content: toolResults };
+        newMessages.push(toolMessage);
+        await this.memoryRecorder.commitMessages(
+          runId,
+          currentTurns,
+          [assistantMessage, toolMessage],
+          pendingTurnMessages
+        );
+        await this.drainSteeringMessages(runId, currentTurns, newMessages, pendingTurnMessages);
+        await this.memoryRecorder.commitCompletedTurn(runId, currentTurns, pendingTurnMessages);
+      }
+      throw new MaxTurnsError(this.maxTurnCount, [...this.chatHistory, ...newMessages], lastPrompt);
+    } catch (error) {
+      if (error instanceof MemoryCompactionError && error.usage !== void 0) {
+        usage = Usage.add(usage, error.usage);
+      }
+      const failedCompletionUsage = this.takeFailedCompletionUsage();
+      if (error instanceof AgentStructuredOutputError) {
+        usage = Usage.add(usage, error.usage);
+      } else {
+        usage = Usage.add(usage, failedCompletionUsage);
+      }
+      this.runState = "closing";
+      const runError = this.normalizeRunError(error);
+      const reportedError = await this.reportRunFailure(
+        runError,
+        runId,
+        usage,
+        newMessages,
+        runObservers
+      );
+      this.runState = reportedError instanceof AgentRunCancelledError ? "cancelled" : "errored";
+      this.disposeAbortLink();
+      throw reportedError;
+    }
+  }
+  async *events() {
+    this.startRun();
+    const runId = this.requestedRunId ?? globalThis.crypto.randomUUID();
+    let usage = Usage.empty();
+    let currentTurns = 0;
+    let lastPrompt = this.promptMessage;
+    let newMessages = [this.promptMessage];
+    const bufferOutputDeltas = hasEnforcedOutputGuardrails(this.guardrailPolicies);
+    let runObservers;
+    let pendingTurnMessages = [];
+    try {
+      this.throwIfCancelled();
+      const memoryPreparation = this.continuationState === void 0 ? await this.memoryRecorder.prepareHistory(
+        runId,
+        newMessages,
+        this.abortController.signal
+      ) : void 0;
+      if (memoryPreparation !== void 0) {
+        this.chatHistory = memoryPreparation.history;
+        usage = Usage.add(usage, memoryPreparation.usage);
+        this.memoryCompaction = memoryPreparation.compaction;
+        await this.notifyInternalMemoryCompaction(memoryPreparation.compaction);
+      }
+      runObservers = await this.startRunObservers(runId);
+      if (memoryPreparation !== void 0) {
+        await this.recordMemoryCompaction(memoryPreparation, runObservers);
+      }
+      if (memoryPreparation?.compaction !== void 0) {
+        yield { type: "memory_compaction", ...memoryPreparation.compaction };
+      }
+      this.throwIfCancelled();
+      await this.activeLifecycle?.onStart?.({
+        runId,
+        input: lifecycleSnapshot(this.promptMessage),
+        history: lifecycleSnapshot(this.chatHistory),
+        maxTurns: this.maxTurnCount
+      });
+      if (this.continuationState === void 0) {
+        const inputResult = await runInputGuardrails(this.guardrailPolicies, {
+          prompt: this.promptMessage,
+          history: this.chatHistory,
+          inputText: textFromMessage(this.promptMessage),
+          run: this.guardrailRunContext(runId)
+        });
+        for (const decision of inputResult.decisions) {
+          await this.recordGuardrailDecision(decision, runObservers);
+          yield { type: "guardrail_decision", decision };
+        }
+        this.promptMessage = inputResult.prompt;
+        if (inputResult.blocked) {
+          const text = inputResult.message ?? "The request was blocked by a guardrail.";
+          const result = {
+            type: "blocked",
+            stage: "input",
+            ...blockedOutcomeDetails(
+              this.guardrailDecisions,
+              "The request was blocked by a guardrail."
+            ),
+            runId,
+            text,
+            usage,
+            messages: [this.promptMessage, { role: "assistant", content: text }],
+            trace: runObservers.trace,
+            guardrails: [...this.guardrailDecisions],
+            ...this.memoryCompactionResult()
+          };
+          if (this.resumedFrom !== void 0) result.resumedFrom = this.resumedFrom;
+          this.runState = "closing";
+          await this.runLifecycleFinish(result);
+          await runObservers.end(observerRunEnd(result));
+          this.runState = "completed";
+          this.disposeAbortLink();
+          yield result;
+          return;
+        }
+      }
+      newMessages = [this.promptMessage];
+      await this.memoryRecorder.commitAcceptedInput(runId, newMessages);
+      pendingTurnMessages = this.memoryRecorder.pendingTurnMessages(newMessages);
+      await this.runRunStartHook(newMessages);
+      if (this.continuationState !== void 0) {
+        const responsePart = this.promptMessage.role === "tool" ? this.promptMessage.content[0] : void 0;
+        if (responsePart === void 0 || responsePart.type === "tool-result") {
+          throw new TypeError("Agent continuation response message is invalid.");
+        }
+        yield {
+          type: "interaction_response",
+          response: responsePart,
+          sourceRunId: this.resumedFrom?.runId ?? this.continuationState.kind
+        };
+        try {
+          const execution = this.executeContinuationToolStream(runId, newMessages, {
+            turn: 1,
+            runObservers
+          });
+          for await (const event of execution.events) {
+            yield { turn: 1, ...event };
+          }
+          const toolResults = await execution.results;
+          const toolMessage = { role: "tool", content: toolResults };
+          newMessages.push(toolMessage);
+          await this.memoryRecorder.commitMessages(runId, 1, [toolMessage], pendingTurnMessages);
+          for (const receipt of await this.drainSteeringMessages(
+            runId,
+            1,
+            newMessages,
+            pendingTurnMessages
+          )) {
+            yield { type: "steering_applied", id: receipt.id, turn: 1 };
+          }
+          await this.memoryRecorder.commitCompletedTurn(runId, 1, pendingTurnMessages);
+        } catch (error) {
+          if (error instanceof ToolExecutionSuspension) {
+            const result = await this.finishSuspension({
+              runId,
+              turn: 1,
+              usage,
+              newMessages,
+              pendingTurnMessages,
+              runObservers,
+              suspension: error,
+              uncommittedMessages: []
+            });
+            yield result;
+            return;
+          }
+          throw error;
+        }
+      }
+      while (currentTurns <= this.maxTurnCount) {
+        const prompt = newMessages.at(-1);
+        if (prompt === void 0) {
+          throw new Error("AgentRun requires at least one message");
+        }
+        lastPrompt = prompt;
+        currentTurns += 1;
+        const historyForRequest = [...this.chatHistory, ...newMessages.slice(0, -1)];
+        yield {
+          type: "turn_start",
+          turn: currentTurns,
+          prompt,
+          history: historyForRequest
+        };
+        await this.runTurnStartHook(currentTurns, prompt, historyForRequest, newMessages);
+        await this.runCompletionCallHook(prompt, historyForRequest, newMessages);
+        const request = await this.createTurnRequest(prompt, historyForRequest, currentTurns);
+        assertCompletionRequestSupported(this.agent.model, request, { streaming: true });
+        const providerRequest = this.providerTraceRequest(request, { stream: true });
+        const generationStartArgs = this.generationStartArgs(
+          currentTurns,
+          request,
+          providerRequest
+        );
+        const generationObservers = await runObservers.startGeneration(generationStartArgs);
+        this.activeGeneration = { turn: currentTurns, observers: generationObservers };
+        const generationStartedAt = Date.now();
+        yield {
+          type: "generation_start",
+          turn: currentTurns,
+          request,
+          modelInfo: generationStartArgs.modelInfo,
+          promptRef: generationStartArgs.promptRef
+        };
+        const bufferResponseEvents = this.shouldBufferStreamResponseEvents() || this.agent.outputSchema !== void 0;
+        const completionState = {
+          response: void 0,
+          firstDeltaMs: void 0,
+          emittedToolCallIds: /* @__PURE__ */ new Set(),
+          providerErrorUsage: Usage.empty()
+        };
+        let response;
+        try {
+          try {
+            for await (const event of this.streamCompletion({
+              request,
+              turn: currentTurns,
+              bufferResponseEvents,
+              bufferOutputDeltas,
+              generationStartedAt,
+              generationObservers,
+              runObservers,
+              state: completionState
+            })) {
+              yield event;
+            }
+          } finally {
+            usage = Usage.add(usage, completionState.providerErrorUsage);
+          }
+          if (completionState.response === void 0) {
+            throw new Error("Streaming completion ended without a response.");
+          }
+          response = completionState.response;
+        } catch (error) {
+          await settleFailureCleanup([
+            () => this.closeActiveGeneration(error),
+            () => this.runCompletionErrorHook(prompt, error, newMessages)
+          ]);
+          throw error;
+        }
+        const { firstDeltaMs, emittedToolCallIds } = completionState;
+        let generationEndArgs = {
+          turn: currentTurns,
+          response
+        };
+        if (firstDeltaMs !== void 0) {
+          generationEndArgs = { ...generationEndArgs, firstDeltaMs };
+        }
+        this.activeGeneration = void 0;
+        await generationObservers.end(generationEndArgs);
+        response = await this.runCompletionResponseMiddlewares(request, response, currentTurns);
+        try {
+          assertCompletionResponseIntegrity({ response });
+        } catch (error) {
+          const providerOutputUsage = completionProviderOutputErrorUsage(error);
+          if (providerOutputUsage !== void 0) usage = Usage.add(usage, providerOutputUsage);
+          throw error;
+        }
+        usage = Usage.add(usage, response.usage);
+        this.updateRunProgress(newMessages);
+        await this.runCompletionResponseHook(prompt, response, newMessages);
+        await this.runTurnEndHook(currentTurns, response, newMessages);
+        await this.activeLifecycle?.onStepFinish?.({
+          runId,
+          step: currentTurns,
+          response: lifecycleSnapshot(response),
+          usage: lifecycleSnapshot(usage)
+        });
+        const toolCalls = response.choice.filter(
+          (item) => item.type === "tool-call"
+        );
+        const assistantMessage = this.generatedAssistantMessage(response, request);
+        newMessages.push(assistantMessage);
+        if (toolCalls.length === 0) {
+          await this.beforeFinish?.();
+          let emittedTurnEnd = false;
+          if (!bufferOutputDeltas) {
+            if (bufferResponseEvents) {
+              for (const event of responseStreamEvents(currentTurns, response)) {
+                yield event;
+              }
+            }
+            yield {
+              type: "turn_end",
+              turn: currentTurns,
+              response,
+              firstDeltaMs
+            };
+            emittedTurnEnd = true;
+          }
+          if (this.steeringMessages.length > 0) {
+            await this.memoryRecorder.commitMessages(
+              runId,
+              currentTurns,
+              [assistantMessage],
+              pendingTurnMessages
+            );
+          }
+          const appliedSteering = await this.drainSteeringMessages(
+            runId,
+            currentTurns,
+            newMessages,
+            pendingTurnMessages,
+            { closeWhenEmpty: true }
+          );
+          for (const receipt of appliedSteering) {
+            yield { type: "steering_applied", id: receipt.id, turn: currentTurns };
+          }
+          if (appliedSteering.length > 0) {
+            await this.memoryRecorder.commitCompletedTurn(runId, currentTurns, pendingTurnMessages);
+            continue;
+          }
+          for await (const event of this.completeStreamingRun({
+            runId,
+            turn: currentTurns,
+            request,
+            response,
+            firstDeltaMs,
+            usage,
+            newMessages,
+            pendingTurnMessages,
+            runObservers,
+            bufferResponseEvents,
+            bufferOutputDeltas,
+            emittedTurnEnd
+          })) {
+            yield event;
+          }
+          return;
+        }
+        if (bufferResponseEvents) {
+          for (const event of responseStreamEvents(currentTurns, response)) {
+            yield event;
+          }
+        } else {
+          for (const toolCall of toolCalls) {
+            if (!emittedToolCallIds.has(toolCall.toolCallId)) {
+              yield { type: "tool_call", turn: currentTurns, toolCall };
+            }
+          }
+        }
+        this.updateRunProgress(newMessages);
+        yield {
+          type: "turn_end",
+          turn: currentTurns,
+          response,
+          firstDeltaMs
+        };
+        let toolResults;
+        try {
+          const toolExecution = this.executeStreamingToolCalls(runId, toolCalls, newMessages, {
+            turn: currentTurns,
+            runObservers,
+            toolDefinitions: request.tools
+          });
+          for await (const result of toolExecution.events) {
+            yield { turn: currentTurns, ...result };
+          }
+          toolResults = await toolExecution.results;
+        } catch (error) {
+          if (error instanceof ToolExecutionSuspension) {
+            const result = await this.finishSuspension({
+              runId,
+              turn: currentTurns,
+              usage,
+              newMessages,
+              pendingTurnMessages,
+              runObservers,
+              suspension: error,
+              uncommittedMessages: [assistantMessage]
+            });
+            yield result;
+            return;
+          }
+          throw error;
+        }
+        const toolMessage = { role: "tool", content: toolResults };
+        newMessages.push(toolMessage);
+        await this.memoryRecorder.commitMessages(
+          runId,
+          currentTurns,
+          [assistantMessage, toolMessage],
+          pendingTurnMessages
+        );
+        for (const receipt of await this.drainSteeringMessages(
+          runId,
+          currentTurns,
+          newMessages,
+          pendingTurnMessages
+        )) {
+          yield { type: "steering_applied", id: receipt.id, turn: currentTurns };
+        }
+        await this.memoryRecorder.commitCompletedTurn(runId, currentTurns, pendingTurnMessages);
+      }
+      throw new MaxTurnsError(this.maxTurnCount, [...this.chatHistory, ...newMessages], lastPrompt);
+    } catch (error) {
+      if (error instanceof MemoryCompactionError && error.usage !== void 0) {
+        usage = Usage.add(usage, error.usage);
+      }
+      if (error instanceof AgentStructuredOutputError) {
+        usage = Usage.add(usage, error.usage);
+      }
+      this.runState = "closing";
+      const runError = this.normalizeRunError(error);
+      const reportedError = await this.reportRunFailure(
+        runError,
+        runId,
+        usage,
+        newMessages,
+        runObservers
+      );
+      this.runState = reportedError instanceof AgentRunCancelledError ? "cancelled" : "errored";
+      const finalUsage = usage;
+      yield { type: "error", error: reportedError, usage: finalUsage };
+      this.disposeAbortLink();
+      return;
+    } finally {
+      if (this.runState === "running" || this.runState === "closing") {
+        const cancellation = this.cancellationError ?? new AgentRunCancelledError([...this.chatHistory, ...newMessages], "Agent stream closed.");
+        this.cancellationError = cancellation;
+        await settleFailureCleanup([() => this.closeActiveGeneration(cancellation)]);
+        await this.reportRunFailure(cancellation, runId, usage, newMessages, runObservers);
+        this.runState = "cancelled";
+        this.disposeAbortLink();
+      }
+    }
+  }
+  async runCompletion(request, turn, runObservers) {
+    assertCompletionRequestSupported(this.agent.model, request);
+    this.validatedStructuredOutput = void 0;
+    this.failedCompletionUsage = Usage.empty();
+    const providerRequest = this.providerTraceRequest(request);
+    const generationObservers = await runObservers.startGeneration(
+      this.generationStartArgs(turn, request, providerRequest)
+    );
+    let currentRequest = request;
+    let failedAttemptUsage = Usage.empty();
+    try {
+      for (let attempt = 1; ; attempt += 1) {
+        let response;
+        try {
+          this.throwIfCancelled();
+          response = await this.agent.model.completion(currentRequest, this.modelCallOptions());
+          assertCompletionResponseIntegrity({ response });
+        } catch (error) {
+          const attemptUsage = completionProviderOutputErrorUsage(error);
+          if (attemptUsage !== void 0) {
+            failedAttemptUsage = Usage.add(failedAttemptUsage, attemptUsage);
+            this.failedCompletionUsage = failedAttemptUsage;
+          }
+          const retryOptions = this.retryOptionsForFailure(error, attempt, turn, false);
+          if (retryOptions === void 0) {
+            throw error;
+          }
+          await this.scheduleCompletionRetry(
+            error,
+            attempt,
+            turn,
+            false,
+            retryOptions,
+            runObservers,
+            providerOutputRetryEventAttributes(error, failedAttemptUsage)
+          );
+          continue;
+        }
+        const cumulativeUsage = Usage.add(failedAttemptUsage, response.usage);
+        try {
+          this.validateStructuredResponse(response, attempt, cumulativeUsage);
+        } catch (error) {
+          const retryOptions = this.retryOptionsForFailure(error, attempt, turn, false);
+          if (retryOptions === void 0) {
+            throw error;
+          }
+          failedAttemptUsage = cumulativeUsage;
+          this.failedCompletionUsage = failedAttemptUsage;
+          const retryRequest = structuredOutputRetryRequest(request, response, error);
+          currentRequest = retryRequest.request;
+          await this.scheduleCompletionRetry(
+            error,
+            attempt,
+            turn,
+            false,
+            retryOptions,
+            runObservers,
+            structuredOutputRetryEventAttributes(error, retryRequest)
+          );
+          continue;
+        }
+        const finalResponse = Usage.isEmpty(failedAttemptUsage) ? response : { ...response, usage: cumulativeUsage };
+        await generationObservers.end({ turn, response: finalResponse });
+        this.failedCompletionUsage = Usage.empty();
+        return finalResponse;
+      }
+    } catch (error) {
+      await settleFailureCleanup([() => generationObservers.error({ turn, error })]);
+      throw error;
+    }
+  }
+  async createTurnRequest(prompt, history, turn) {
+    const ragText = extractRagText(prompt);
+    const abortSignal = this.abortController.signal;
+    const documents = await fetchContextDocuments(this.agent, ragText, abortSignal);
+    const toolDefinitions = await fetchToolDefinitions(this.agent, ragText, abortSignal);
+    const request = createCompletionRequest(providerMessages([...history, prompt]), {
+      instructions: this.agent.instructions,
+      documents,
+      tools: [...toolDefinitions, ...getAgentToolState(this.agent).providerTools],
+      temperature: this.agent.temperature,
+      maxTokens: this.agent.maxTokens,
+      providerOptions: this.agent.providerOptions,
+      toolChoice: this.agent.toolChoice,
+      controls: this.controls,
+      outputSchema: getAgentProviderOutputSchema(this.agent)
+    });
+    return this.runCompletionRequestMiddlewares(request, turn);
+  }
+  async *streamCompletion(args) {
+    const model = this.agent.model;
+    if (!isStreamingCompletionModel(model)) {
+      throw new TypeError("Streaming completion requires a streaming-capable model.");
+    }
+    this.validatedStructuredOutput = void 0;
+    let currentRequest = args.request;
+    for (let attempt = 1; ; attempt += 1) {
+      const accumulator = new CompletionStreamAccumulator();
+      let hasProviderProgress = false;
+      let recordedErrorUsage = false;
+      let attemptErrorUsage;
+      try {
+        this.throwIfCancelled();
+        for await (const event of model.streamCompletion(currentRequest, this.modelCallOptions())) {
+          if (event.type === "error") {
+            const eventUsage = event.usage ?? completionProviderOutputErrorUsage(event.error);
+            if (eventUsage !== void 0) {
+              args.state.providerErrorUsage = Usage.add(args.state.providerErrorUsage, eventUsage);
+              recordedErrorUsage = true;
+              attemptErrorUsage = eventUsage;
+            }
+            throw event.error;
+          }
+          const mapped = accumulator.accept(event);
+          if (event.type === "final") break;
+          if (event.type === "tool_call_delta" || mapped !== void 0) {
+            hasProviderProgress = true;
+          }
+          if (args.state.firstDeltaMs === void 0 && isGenerationDeltaEvent(event.type)) {
+            args.state.firstDeltaMs = Date.now() - args.generationStartedAt;
+          }
+          if (event.type === "tool_call_delta") {
+            yield addTurnToToolCallDelta(args.turn, event);
+          }
+          if (mapped !== void 0) {
+            await args.generationObservers.update?.({ turn: args.turn, delta: mapped });
+            if (mapped.type === "tool_call") {
+              args.state.emittedToolCallIds.add(mapped.toolCall.toolCallId);
+            }
+            const shouldBuffer = args.bufferResponseEvents || args.bufferOutputDeltas && (mapped.type === "text_delta" || mapped.type === "reasoning_delta");
+            if (!shouldBuffer) {
+              yield addTurn(args.turn, mapped);
+            }
+          }
+        }
+        const response = accumulator.response();
+        assertCompletionResponseIntegrity({ response });
+        const cumulativeStructuredUsage = Usage.add(args.state.providerErrorUsage, response.usage);
+        try {
+          this.validateStructuredResponse(response, attempt, cumulativeStructuredUsage);
+        } catch (error) {
+          const retryOptions = this.retryOptionsForFailure(error, attempt, args.turn, true);
+          if (retryOptions === void 0) {
+            if (error instanceof AgentStructuredOutputError) {
+              args.state.providerErrorUsage = Usage.empty();
+            }
+            throw error;
+          }
+          args.state.providerErrorUsage = Usage.add(args.state.providerErrorUsage, response.usage);
+          args.state.firstDeltaMs = void 0;
+          args.state.emittedToolCallIds.clear();
+          const retryRequest = structuredOutputRetryRequest(args.request, response, error);
+          currentRequest = retryRequest.request;
+          await this.scheduleCompletionRetry(
+            error,
+            attempt,
+            args.turn,
+            true,
+            retryOptions,
+            args.runObservers,
+            structuredOutputRetryEventAttributes(error, retryRequest)
+          );
+          continue;
+        }
+        args.state.response = Usage.isEmpty(args.state.providerErrorUsage) ? response : { ...response, usage: cumulativeStructuredUsage };
+        args.state.providerErrorUsage = Usage.empty();
+        return;
+      } catch (error) {
+        if (!recordedErrorUsage) {
+          const attemptUsage = completionProviderOutputErrorUsage(error);
+          if (attemptUsage !== void 0) {
+            args.state.providerErrorUsage = Usage.add(args.state.providerErrorUsage, attemptUsage);
+            attemptErrorUsage = attemptUsage;
+          }
+        }
+        const retryOptions = hasProviderProgress ? void 0 : this.retryOptionsForFailure(error, attempt, args.turn, true);
+        if (retryOptions === void 0) {
+          throw error;
+        }
+        await this.scheduleCompletionRetry(
+          error,
+          attempt,
+          args.turn,
+          true,
+          retryOptions,
+          args.runObservers,
+          providerOutputRetryEventAttributes(
+            error,
+            args.state.providerErrorUsage,
+            attemptErrorUsage
+          )
+        );
+      }
+    }
+  }
+  async *completeStreamingRun(args) {
+    const guardedOutput = await this.runOutputGuardrailsForResponse(
+      args.runId,
+      args.usage,
+      args.response,
+      args.newMessages,
+      args.runObservers
+    );
+    for (const decision of guardedOutput.decisions) {
+      yield { type: "guardrail_decision", decision };
+    }
+    const response = guardedOutput.response;
+    const assistantMessage = this.generatedAssistantMessage(response, args.request);
+    args.newMessages[args.newMessages.length - 1] = assistantMessage;
+    await this.memoryRecorder.commitMessages(
+      args.runId,
+      args.turn,
+      [assistantMessage],
+      args.pendingTurnMessages
+    );
+    if (!args.emittedTurnEnd && (args.bufferResponseEvents || args.bufferOutputDeltas)) {
+      for (const event of responseStreamEvents(args.turn, response, args.bufferResponseEvents)) {
+        yield event;
+      }
+    }
+    if (!args.emittedTurnEnd) {
+      yield {
+        type: "turn_end",
+        turn: args.turn,
+        response,
+        firstDeltaMs: args.firstDeltaMs
+      };
+    }
+    const result = this.createTerminalResult(
+      args.runId,
+      guardedOutput.text,
+      guardedOutput.blocked,
+      args.usage,
+      args.newMessages,
+      args.runObservers
+    );
+    if (result.type === "response") {
+      await this.runRunEndHook(result, args.newMessages);
+    }
+    await this.memoryRecorder.commitCompletedRun(
+      args.runId,
+      args.turn,
+      args.newMessages,
+      args.pendingTurnMessages
+    );
+    await this.runLifecycleFinish(result);
+    await args.runObservers.end(observerRunEnd(result));
+    this.runState = "completed";
+    this.disposeAbortLink();
+    yield result;
+  }
+  async finishSuspension(args) {
+    const partialToolMessage = args.suspension.completedResults.length === 0 ? void 0 : { role: "tool", content: [...args.suspension.completedResults] };
+    if (partialToolMessage !== void 0) {
+      args.newMessages.push(partialToolMessage);
+      args.uncommittedMessages.push(partialToolMessage);
+    }
+    await this.memoryRecorder.commitMessages(
+      args.runId,
+      args.turn,
+      args.uncommittedMessages,
+      args.pendingTurnMessages
+    );
+    await this.memoryRecorder.commitCompletedRun(
+      args.runId,
+      args.turn,
+      args.newMessages,
+      args.pendingTurnMessages
+    );
+    this.runState = "closing";
+    const continuationState = {
+      kind: "anvia.agent-continuation",
+      history: [...this.chatHistory],
+      messages: [...args.newMessages],
+      pending: args.suspension.pending,
+      remainingToolCalls: [...args.suspension.remainingToolCalls],
+      steering: this.steeringMessages.map((entry) => ({
+        id: entry.id,
+        messages: [...entry.messages]
+      }))
+    };
+    if (this.memoryScope !== void 0) continuationState.memoryScope = this.memoryScope;
+    const continuation = parseAgentContinuation({
+      version: 1,
+      agentId: this.agent.id,
+      sourceRunId: args.runId,
+      interaction: args.suspension.interaction,
+      state: serializeContinuationState(continuationState)
+    });
+    const result = {
+      type: "interaction",
+      runId: args.runId,
+      text: latestAssistantText([...this.chatHistory, ...args.newMessages]),
+      usage: args.usage,
+      messages: [...args.newMessages],
+      trace: args.runObservers.trace,
+      guardrails: [...this.guardrailDecisions],
+      interaction: continuation.interaction,
+      continuation,
+      ...generationArtifacts([...this.chatHistory, ...args.newMessages]),
+      ...this.memoryCompactionResult()
+    };
+    if (this.resumedFrom !== void 0) result.resumedFrom = this.resumedFrom;
+    await this.runLifecycleFinish(result);
+    await args.runObservers.end(observerRunEnd(result));
+    this.runState = "completed";
+    this.currentMessages = [...args.newMessages];
+    this.disposeAbortLink();
+    return result;
+  }
+  generatedAssistantMessage(response, _request) {
+    const generation = {
+      provider: this.agent.model.provider,
+      modelId: this.agent.model.modelId,
+      usage: { ...response.usage }
+    };
+    if (response.finishReason !== void 0) generation.finishReason = response.finishReason;
+    if (response.providerFinishReason !== void 0) {
+      generation.providerFinishReason = response.providerFinishReason;
+    }
+    if (response.contextUsage !== void 0) generation.contextUsage = response.contextUsage;
+    if (response.sources !== void 0) generation.sources = response.sources;
+    if (response.providerToolCalls !== void 0) {
+      generation.providerToolCalls = response.providerToolCalls;
+    }
+    const metadata = { anvia: { generation } };
+    let message = {
+      role: "assistant",
+      content: response.choice,
+      metadata
+    };
+    if (response.messageId !== void 0) message = { ...message, id: response.messageId };
+    return message;
+  }
+  providerTraceRequest(request, options = {}) {
+    try {
+      return this.agent.model.traceRequest?.(request, options);
+    } catch (error) {
+      return {
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  generationStartArgs(turn, request, providerRequest) {
+    let args = {
+      turn,
+      request,
+      promptRef: this.generationPromptRef,
+      modelInfo: {
+        provider: this.agent.model.provider,
+        modelId: this.agent.model.modelId,
+        capabilities: this.agent.model.capabilities
+      }
+    };
+    if (providerRequest !== void 0) args = { ...args, providerRequest };
+    return args;
+  }
+  retryOptionsForFailure(error, attempt, turn, streaming) {
+    if (this.abortController.signal.aborted) return void 0;
+    return retryOptionsForFailure(this.completionRetryOptions, {
+      error,
+      attempt,
+      turn,
+      streaming
+    });
+  }
+  async scheduleCompletionRetry(error, attempt, turn, streaming, options, runObservers, additionalAttributes) {
+    const delayMs = retryDelayMs(options, attempt);
+    const attributes = {
+      turn,
+      attempt,
+      nextAttempt: attempt + 1,
+      maxAttempts: options.maxAttempts,
+      delayMs,
+      streaming,
+      ...retryErrorAttributes(error)
+    };
+    if (additionalAttributes !== void 0) {
+      Object.assign(attributes, additionalAttributes);
+    }
+    await runObservers.event({
+      name: "completion.retry",
+      level: "WARNING",
+      attributes
+    });
+    await waitForRetry(delayMs, this.abortController.signal);
+  }
+  async executeToolCalls(runId, toolCalls, newMessages, onResult, onStreamEvent, observation) {
+    const executor = this.createToolExecutor(runId, newMessages);
+    return executor.execute(toolCalls, onResult, onStreamEvent, observation);
+  }
+  createToolExecutor(runId, newMessages) {
+    return new ToolCallExecutor(
+      this.agent,
+      this.activeHook,
+      async (request) => {
+        throw new AgentInteractionSignal(approvalInteraction(request), request.rejectMessage);
+      },
+      this.activeLifecycle,
+      {
+        runId,
+        sessionId: this.memoryScope?.sessionId,
+        metadata: this.memoryScope?.metadata
+      },
+      this.concurrency,
+      this.requestMiddlewares,
+      this.abortController.signal,
+      (reason) => this.cancelled(newMessages, reason)
+    );
+  }
+  async resolveContinuationTools(runId, newMessages, onResult, onStreamEvent, observation) {
+    const state = this.continuationState;
+    const response = this.interactionResponse;
+    if (state === void 0 || response === void 0) {
+      return [];
+    }
+    const pending = state.pending;
+    const interaction = this.resumedFrom;
+    if (interaction === void 0) {
+      throw new TypeError("Agent continuation is missing its source run linkage.");
+    }
+    const executor = this.createToolExecutor(runId, newMessages);
+    const results = [];
+    if (response.type === "tool-approval") {
+      const attributes = {
+        approvalId: interaction.interactionId,
+        toolName: pending.toolCall.toolName,
+        toolCallId: pending.toolCall.toolCallId,
+        internalCallId: pending.internalCallId,
+        approved: response.approved
+      };
+      if (response.reason !== void 0) attributes.decisionReason = response.reason;
+      await observation.runObservers.event({
+        name: "tool.approval_resolved",
+        attributes
+      });
+      if (response.approved) {
+        results.push(await executor.executeResumed(pending, onResult, onStreamEvent, observation));
+      } else {
+        const output = {
+          type: "execution-denied",
+          reason: response.reason ?? pending.rejectMessage ?? "Tool approval was rejected."
+        };
+        results.push(await executor.resolveResumed(pending, output, onResult, observation));
+      }
+    } else {
+      const currentTool = this.agent.getTool(pending.toolCall.toolName);
+      if (currentTool === void 0 || !isQuestionTool(currentTool)) {
+        throw new TypeError(
+          `Cannot resume question interaction because tool "${pending.toolCall.toolName}" is no longer registered as a question tool.`
+        );
+      }
+      const output = questionResult(response.answers);
+      results.push(await executor.resolveResumed(pending, output, onResult, observation));
+    }
+    try {
+      results.push(
+        ...await executor.execute(state.remainingToolCalls, onResult, onStreamEvent, observation)
+      );
+    } catch (error) {
+      if (error instanceof ToolExecutionSuspension) {
+        error.completedResults = [...results, ...error.completedResults];
+      }
+      throw error;
+    }
+    return results;
+  }
+  executeStreamingToolCalls(runId, toolCalls, newMessages, observation) {
+    const events = createAsyncQueue();
+    const results = this.executeToolCalls(
+      runId,
+      toolCalls,
+      newMessages,
+      (result) => events.enqueue(result),
+      (event) => events.enqueue(event),
+      observation
+    );
+    results.then(
+      () => events.close(),
+      (error) => events.throw(error)
+    );
+    return { events, results };
+  }
+  executeContinuationToolStream(runId, newMessages, observation) {
+    const events = createAsyncQueue();
+    const results = this.resolveContinuationTools(
+      runId,
+      newMessages,
+      (result) => events.enqueue(result),
+      (event) => events.enqueue(event),
+      observation
+    );
+    results.then(
+      () => events.close(),
+      (error) => events.throw(error)
+    );
+    return { events, results };
+  }
+  async closeActiveGeneration(error) {
+    const active = this.activeGeneration;
+    if (active === void 0) {
+      return;
+    }
+    this.activeGeneration = void 0;
+    await active.observers.error({ turn: active.turn, error });
+  }
+  updateRunProgress(messages) {
+    this.currentMessages = [...messages];
+  }
+  async runLifecycleFinish(result) {
+    const common = {
+      runId: result.runId,
+      text: result.text,
+      usage: lifecycleSnapshot(result.usage),
+      messages: lifecycleSnapshot(result.messages)
+    };
+    if (result.memoryCompaction !== void 0) {
+      Object.assign(common, { memoryCompaction: lifecycleSnapshot(result.memoryCompaction) });
+    }
+    const event = result.type === "response" ? {
+      ...common,
+      status: "completed",
+      output: lifecycleSnapshot(result.output)
+    } : result.type === "blocked" ? {
+      ...common,
+      status: "blocked",
+      stage: result.stage
+    } : {
+      ...common,
+      status: "suspended",
+      interaction: lifecycleSnapshot(result.interaction)
+    };
+    await this.activeLifecycle?.onFinish?.(event);
+  }
+  async runLifecycleError(error, runId, usage, messages) {
+    try {
+      await this.activeLifecycle?.onError?.({
+        runId,
+        error: lifecycleSnapshot(error),
+        usage: lifecycleSnapshot(usage),
+        messages: lifecycleSnapshot([...this.chatHistory, ...messages])
+      });
+      return void 0;
+    } catch (lifecycleError) {
+      return lifecycleError;
+    }
+  }
+  async reportRunFailure(error, runId, usage, messages, runObservers) {
+    const reportedError = await this.resolveReportedRunError(error, runId, usage, messages);
+    await settleFailureCleanup([
+      () => this.onInternalFailure?.({
+        error: reportedError,
+        messages: lifecycleSnapshot(messages)
+      }),
+      () => runObservers?.error({
+        status: reportedError instanceof AgentRunCancelledError ? "cancelled" : "failed",
+        error: reportedError,
+        usage,
+        messages: [...messages]
+      }),
+      () => this.memoryRecorder.recordError(runId, reportedError, messages)
+    ]);
+    return reportedError;
+  }
+  async resolveReportedRunError(error, runId, usage, messages) {
+    try {
+      await this.runRunErrorHook(error, usage, messages);
+    } catch {
+    }
+    const reportedError = this.cancellationError ?? error;
+    await this.runLifecycleError(reportedError, runId, usage, messages);
+    return reportedError;
+  }
+  async runOutputGuardrailsForResponse(runId, usage, response, messages, runObservers) {
+    const originalOutput = textFromAssistantContent(response.choice);
+    const result = await runOutputGuardrails(this.guardrailPolicies, {
+      outputText: originalOutput,
+      messages: [...this.chatHistory, ...messages],
+      usage,
+      run: this.guardrailRunContext(runId)
+    });
+    for (const decision of result.decisions) {
+      await this.recordGuardrailDecision(decision, runObservers);
+    }
+    const text = result.blocked ? result.message ?? "The response was blocked by a guardrail." : result.outputText;
+    if (text === originalOutput) {
+      return { text, blocked: result.blocked, response, decisions: result.decisions };
+    }
+    return {
+      text,
+      blocked: result.blocked,
+      response: {
+        ...response,
+        choice: [{ type: "text", text }]
+      },
+      decisions: result.decisions
+    };
+  }
+  createTerminalResult(runId, text, blocked, usage, messages, runObservers) {
+    const common = {
+      runId,
+      text,
+      usage,
+      messages: [...messages],
+      trace: runObservers.trace,
+      guardrails: [...this.guardrailDecisions],
+      ...generationArtifacts(messages),
+      ...this.memoryCompactionResult()
+    };
+    if (this.resumedFrom !== void 0) Object.assign(common, { resumedFrom: this.resumedFrom });
+    if (blocked) {
+      return {
+        ...common,
+        type: "blocked",
+        stage: "output",
+        ...blockedOutcomeDetails(
+          this.guardrailDecisions,
+          "The response was blocked by a guardrail."
+        )
+      };
+    }
+    return {
+      ...common,
+      type: "response",
+      output: this.parseOutput(text)
+    };
+  }
+  validateStructuredResponse(response, attempt, usage) {
+    if (this.agent.outputSchema === void 0) return;
+    if (response.choice.some((item) => item.type === "tool-call")) return;
+    const text = textFromAssistantContent(response.choice);
+    const normalized = normalizeStructuredOutput(text);
+    if (response.finishReason === "content-filter") {
+      throw new AgentStructuredOutputError({
+        phase: "content-filter",
+        attempt,
+        maxAttempts: this.completionRetryOptions?.maxAttempts ?? 1,
+        outputLength: text.length,
+        normalizedLength: normalized.text.length,
+        outputFormat: normalized.format,
+        attemptUsage: response.usage,
+        usage,
+        finishReason: response.finishReason,
+        providerFinishReason: response.providerFinishReason
+      });
+    }
+    if (response.finishReason === "length") {
+      throw new AgentStructuredOutputError({
+        phase: "truncated",
+        attempt,
+        maxAttempts: this.completionRetryOptions?.maxAttempts ?? 1,
+        outputLength: text.length,
+        normalizedLength: normalized.text.length,
+        outputFormat: normalized.format,
+        attemptUsage: response.usage,
+        usage,
+        finishReason: response.finishReason,
+        providerFinishReason: response.providerFinishReason
+      });
+    }
+    const output = this.parseOutput(text, attempt, usage, {
+      useValidatedOutput: false,
+      attemptUsage: response.usage,
+      finishReason: response.finishReason,
+      providerFinishReason: response.providerFinishReason
+    });
+    this.validatedStructuredOutput = { text, output };
+  }
+  takeFailedCompletionUsage() {
+    const usage = this.failedCompletionUsage;
+    this.failedCompletionUsage = Usage.empty();
+    return usage;
+  }
+  parseOutput(text, attempt = 1, usage = Usage.empty(), options = {}) {
+    const schema = this.agent.outputSchema;
+    if (schema === void 0) return text;
+    if (options.useValidatedOutput !== false && this.validatedStructuredOutput?.text === text) {
+      return this.validatedStructuredOutput.output;
+    }
+    const normalized = normalizeStructuredOutput(text);
+    const maxAttempts = this.completionRetryOptions?.maxAttempts ?? 1;
+    let json;
+    try {
+      json = JSON.parse(normalized.text);
+      if (!isJsonValue(json)) {
+        throw new TypeError("Agent structured output is not a JSON value.");
+      }
+    } catch (error) {
+      throw new AgentStructuredOutputError({
+        phase: "parse",
+        attempt,
+        maxAttempts,
+        outputLength: text.length,
+        normalizedLength: normalized.text.length,
+        outputFormat: normalized.format,
+        attemptUsage: options.attemptUsage ?? usage,
+        usage,
+        finishReason: options.finishReason,
+        providerFinishReason: options.providerFinishReason,
+        cause: error
+      });
+    }
+    try {
+      return schema.parse(json);
+    } catch (error) {
+      throw new AgentStructuredOutputError({
+        phase: "schema",
+        attempt,
+        maxAttempts,
+        outputLength: text.length,
+        normalizedLength: normalized.text.length,
+        outputFormat: normalized.format,
+        attemptUsage: options.attemptUsage ?? usage,
+        usage,
+        finishReason: options.finishReason,
+        providerFinishReason: options.providerFinishReason,
+        cause: error
+      });
+    }
+  }
+  memoryCompactionResult() {
+    return this.memoryCompaction === void 0 ? {} : { memoryCompaction: lifecycleSnapshot(this.memoryCompaction) };
+  }
+  async recordGuardrailDecision(decision, runObservers) {
+    this.guardrailDecisions.push(decision);
+    await runObservers.event({
+      name: "guardrail.decision",
+      level: decision.action === "block" ? "WARNING" : "DEFAULT",
+      attributes: guardrailDecisionAttributes(decision)
+    });
+  }
+  async recordMemoryCompaction(preparation, runObservers) {
+    const compaction = preparation.compaction;
+    if (compaction === void 0) {
+      return;
+    }
+    await runObservers.event({
+      name: "memory.compaction",
+      attributes: {
+        originalMessageCount: compaction.originalMessageCount,
+        compactedMessageCount: compaction.compactedMessageCount,
+        retainedMessageCount: compaction.retainedMessageCount,
+        originalTokenCount: compaction.originalTokenCount,
+        compactedTokenCount: compaction.compactedTokenCount,
+        retainedTokenCount: compaction.retainedTokenCount,
+        resultTokenCount: compaction.resultTokenCount,
+        attempts: compaction.attempts,
+        inputTokens: compaction.usage.inputTokens,
+        outputTokens: compaction.usage.outputTokens,
+        totalTokens: compaction.usage.totalTokens
+      }
+    });
+  }
+  async notifyInternalMemoryCompaction(compaction) {
+    if (compaction === void 0) {
+      return;
+    }
+    await this.onInternalMemoryCompaction?.(lifecycleSnapshot(compaction));
+  }
+  guardrailRunContext(runId) {
+    const context = {
+      agentId: this.agent.id,
+      runId
+    };
+    if (this.memoryScope !== void 0) {
+      context.sessionId = this.memoryScope.sessionId;
+      if (this.memoryScope.metadata !== void 0) {
+        context.metadata = this.memoryScope.metadata;
+      }
+    }
+    return context;
+  }
+  async startRunObservers(runId) {
+    const observability = this.agent.observability;
+    return startAgentRunObservers(
+      observability?.observers ?? {},
+      {
+        runId,
+        agentName: this.agent.name,
+        agentDescription: this.agent.description,
+        instructions: this.agent.instructions,
+        trace: this.traceOptions,
+        promptRef: this.traceOptions?.promptRef,
+        prompt: this.promptMessage,
+        history: this.chatHistory,
+        maxTurns: this.maxTurnCount
+      },
+      {
+        primaryTrace: observability?.primaryTrace,
+        errorPolicy: observability?.errorPolicy ?? "ignore"
+      }
+    );
+  }
+  async runCompletionCallHook(prompt, history, newMessages) {
+    const action = await this.activeHook?.onCompletionCall?.({
+      prompt,
+      history,
+      run: runControl
+    });
+    if (action?.type === "terminate") {
+      throw this.cancelled(newMessages, action.reason);
+    }
+  }
+  async runRunStartHook(newMessages) {
+    const action = await this.activeHook?.onRunStart?.({
+      prompt: this.promptMessage,
+      history: this.chatHistory,
+      maxTurns: this.maxTurnCount,
+      run: runControl
+    });
+    if (action?.type === "terminate") {
+      throw this.cancelled(newMessages, action.reason);
+    }
+  }
+  async runRunEndHook(result, newMessages) {
+    const action = await this.activeHook?.onRunEnd?.({
+      status: "completed",
+      output: result.output,
+      text: result.text,
+      usage: result.usage,
+      messages: result.messages,
+      run: runControl
+    });
+    if (action?.type === "terminate") {
+      throw this.cancelled(newMessages, action.reason);
+    }
+  }
+  async runRunErrorHook(error, usage, newMessages) {
+    const action = await this.activeHook?.onRunError?.({
+      error,
+      usage,
+      messages: [...this.chatHistory, ...newMessages],
+      run: runControl
+    });
+    if (action?.type === "terminate") {
+      this.cancelled(newMessages, action.reason);
+    }
+  }
+  async runTurnStartHook(turn, prompt, history, newMessages) {
+    const action = await this.activeHook?.onTurnStart?.({
+      turn,
+      prompt,
+      history,
+      run: runControl
+    });
+    if (action?.type === "terminate") {
+      throw this.cancelled(newMessages, action.reason);
+    }
+  }
+  async runTurnEndHook(turn, response, newMessages) {
+    const action = await this.activeHook?.onTurnEnd?.({
+      turn,
+      response,
+      run: runControl
+    });
+    if (action?.type === "terminate") {
+      throw this.cancelled(newMessages, action.reason);
+    }
+  }
+  async runCompletionRequestMiddlewares(request, turn) {
+    let current = request;
+    this.generationPromptRef = this.traceOptions?.promptRef;
+    for (const middleware of this.activeMiddlewares()) {
+      const replacement = await middleware.onCompletionRequest?.({
+        turn,
+        request: current,
+        originalRequest: request,
+        promptRef: this.generationPromptRef
+      });
+      if (replacement?.promptRef !== void 0) {
+        this.generationPromptRef = replacement.promptRef ?? void 0;
+      }
+      if (replacement?.request !== void 0) {
+        current = replacement.request;
+        if (current.providerOptions !== void 0) {
+          assertJsonObject(current.providerOptions, "providerOptions");
+        }
+      }
+    }
+    return current;
+  }
+  async runCompletionResponseMiddlewares(request, response, turn) {
+    let current = response;
+    for (const middleware of this.activeMiddlewares()) {
+      const replacement = await middleware.onCompletionResponse?.({
+        turn,
+        request,
+        response: current,
+        originalResponse: response
+      });
+      if (replacement?.response !== void 0) {
+        current = replacement.response;
+      }
+    }
+    return current;
+  }
+  async runCompletionResponseHook(prompt, response, newMessages) {
+    const action = await this.activeHook?.onCompletionResponse?.({
+      prompt,
+      response,
+      run: runControl
+    });
+    if (action?.type === "terminate") {
+      throw this.cancelled(newMessages, action.reason);
+    }
+  }
+  async runCompletionErrorHook(prompt, error, newMessages) {
+    const action = await this.activeHook?.onCompletionError?.({
+      prompt,
+      error,
+      run: runControl
+    });
+    if (action?.type === "terminate") {
+      throw this.cancelled(newMessages, action.reason);
+    }
+  }
+  activeMiddlewares() {
+    return [...this.agent.middlewares, ...this.requestMiddlewares];
+  }
+  shouldBufferStreamResponseEvents() {
+    return this.activeHook?.onCompletionResponse !== void 0 || this.activeMiddlewares().some((middleware) => middleware.onCompletionResponse !== void 0);
+  }
+  async drainSteeringMessages(runId, turn, newMessages, pendingTurnMessages, options = {}) {
+    const receipts = this.steeringMessages.splice(0);
+    if (receipts.length === 0) {
+      if (options.closeWhenEmpty === true) {
+        this.runState = "closing";
+      }
+      return [];
+    }
+    const messages = receipts.flatMap((receipt) => receipt.messages);
+    newMessages.push(...messages);
+    await this.memoryRecorder.commitMessages(runId, turn, messages, pendingTurnMessages);
+    for (const receipt of receipts) this.onSteeringApplied?.(receipt.id);
+    return receipts;
+  }
+  startRun() {
+    if (this.runState === "idle") {
+      this.runState = "running";
+      return;
+    }
+    if (this.runState === "running") {
+      throw new Error("Agent stream is already running.");
+    }
+    throw new Error("Agent stream has already been consumed.");
+  }
+  isTerminal() {
+    return this.runState !== "idle" && this.runState !== "running";
+  }
+  cancelled(newMessages, reason) {
+    if (this.cancellationError !== void 0) return this.cancellationError;
+    const error = new AgentRunCancelledError([...this.chatHistory, ...newMessages], reason);
+    this.setCancellationError(error);
+    return error;
+  }
+  linkExternalAbortSignal(signal) {
+    if (signal === void 0) return;
+    const cancelFromSignal = () => {
+      if (this.cancellationError !== void 0 || this.isTerminal()) return;
+      const cause = abortError(signal.reason);
+      const reason = abortReason(signal.reason);
+      const messages = this.currentMessages.length === 0 ? [this.promptMessage] : [...this.currentMessages];
+      this.setCancellationError(
+        new AgentRunCancelledError([...this.chatHistory, ...messages], reason, { cause })
+      );
+    };
+    if (signal.aborted) {
+      cancelFromSignal();
+      return;
+    }
+    signal.addEventListener("abort", cancelFromSignal, { once: true });
+    this.removeExternalAbortListener = () => signal.removeEventListener("abort", cancelFromSignal);
+  }
+  throwIfCancelled() {
+    if (this.cancellationError !== void 0) throw this.cancellationError;
+    throwIfAborted(this.abortController.signal);
+  }
+  normalizeRunError(error) {
+    return this.abortController.signal.aborted && this.cancellationError !== void 0 ? this.cancellationError : error;
+  }
+  modelCallOptions() {
+    return { abortSignal: this.abortController.signal };
+  }
+  disposeAbortLink() {
+    this.removeExternalAbortListener?.();
+    this.removeExternalAbortListener = void 0;
+  }
+};
+function abortReason(reason) {
+  if (typeof reason === "string" && reason.trim().length > 0) return reason;
+  if (reason instanceof Error && reason.message.trim().length > 0) return reason.message;
+  return "External abort signal.";
+}
+function normalizeAgentInput(agentId, input) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    throw new TypeError("Agent runs require one options object with prompt or messages.");
+  }
+  const hasContinuation = "continuation" in input && input.continuation !== void 0;
+  const hasPrompt = "prompt" in input && input.prompt !== void 0;
+  const hasMessages = "messages" in input && input.messages !== void 0;
+  if (Number(hasContinuation) + Number(hasPrompt) + Number(hasMessages) !== 1) {
+    throw new TypeError("Agent runs require exactly one of prompt, messages, or continuation.");
+  }
+  if (hasContinuation) {
+    if (!("response" in input) || input.response === void 0) {
+      throw new TypeError("Agent continuation runs require an interaction response.");
+    }
+    if ("session" in input && input.session !== void 0) {
+      throw new TypeError("Agent continuations carry their memory scope and cannot use session.");
+    }
+    const continuation = parseAgentContinuation(input.continuation);
+    if (continuation.agentId !== agentId) {
+      throw new TypeError(
+        `Agent continuation belongs to "${continuation.agentId}", not "${agentId}".`
+      );
+    }
+    const response = parseAgentInteractionResponse(input.response);
+    assertAgentInteractionResponse(continuation.interaction, response);
+    const state = parseContinuationState(continuation.state, continuation.interaction);
+    let responsePart;
+    if (response.type === "tool-approval") {
+      responsePart = {
+        type: "tool-approval-response",
+        interactionId: continuation.interaction.id,
+        toolCallId: continuation.interaction.toolCallId,
+        toolName: continuation.interaction.toolName,
+        approved: response.approved
+      };
+      if (response.reason !== void 0)
+        responsePart = { ...responsePart, reason: response.reason };
+    } else {
+      responsePart = {
+        type: "tool-question-response",
+        interactionId: continuation.interaction.id,
+        toolCallId: continuation.interaction.toolCallId,
+        toolName: continuation.interaction.toolName,
+        answers: response.answers
+      };
+    }
+    if (continuation.interaction.callId !== void 0) {
+      responsePart = { ...responsePart, callId: continuation.interaction.callId };
+    }
+    const normalized = {
+      prompt: parseMessage({ role: "tool", content: [responsePart] }),
+      history: [...state.history, ...state.messages],
+      continuationState: state,
+      interactionResponse: response,
+      sourceRunId: continuation.sourceRunId,
+      interactionId: continuation.interaction.id
+    };
+    if (state.memoryScope !== void 0) {
+      Object.assign(normalized, { scope: normalizeMemoryScope(state.memoryScope) });
+    }
+    return normalized;
+  }
+  if (hasPrompt) {
+    const prompt = input.prompt;
+    if (typeof prompt !== "string" && (typeof prompt !== "object" || prompt === null || prompt.role !== "user")) {
+      throw new TypeError("Agent prompt must be text or a user message.");
+    }
+    const parsedPrompt = parseMessage(
+      typeof prompt === "string" ? { role: "user", content: prompt } : prompt
+    );
+    if (parsedPrompt.role !== "user") {
+      throw new TypeError("Agent prompt must be text or a user message.");
+    }
+    const normalized = {
+      prompt: parsedPrompt,
+      history: []
+    };
+    if (input.session !== void 0) {
+      Object.assign(normalized, { scope: normalizeMemoryScope(input.session) });
+    }
+    return normalized;
+  }
+  if (input.session !== void 0) {
+    throw new TypeError("Agent messages cannot be combined with a persisted session.");
+  }
+  const messages = input.messages;
+  if (!Array.isArray(messages) || messages.length === 0) {
+    throw new TypeError("Agent input transcript must contain at least one message.");
+  }
+  const parsedMessages = parseMessages(messages);
+  const activePrompt = parsedMessages.at(-1);
+  if (activePrompt === void 0) {
+    throw new TypeError("Agent input transcript must contain at least one message.");
+  }
+  if (activePrompt.role !== "user") {
+    throw new TypeError("Agent input transcript must end with a user message.");
+  }
+  return {
+    prompt: activePrompt,
+    history: parsedMessages.slice(0, -1)
+  };
+}
+function normalizeSteeringInput(input) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    throw new TypeError("Agent steering requires one options object with prompt or messages.");
+  }
+  const hasPrompt = "prompt" in input && input.prompt !== void 0;
+  const hasMessages = "messages" in input && input.messages !== void 0;
+  if (hasPrompt === hasMessages) {
+    throw new TypeError("Agent steering requires exactly one of prompt or messages.");
+  }
+  if (hasPrompt) {
+    const prompt = input.prompt;
+    if (typeof prompt !== "string" && (typeof prompt !== "object" || prompt === null || prompt.role !== "user")) {
+      throw new TypeError("Agent steering prompt must be text or a user message.");
+    }
+    const parsedPrompt = parseMessage(
+      typeof prompt === "string" ? { role: "user", content: prompt } : prompt
+    );
+    if (parsedPrompt.role !== "user") {
+      throw new TypeError("Agent steering prompt must be text or a user message.");
+    }
+    return [parsedPrompt];
+  }
+  const messages = input.messages;
+  if (!Array.isArray(messages) || messages.length === 0) {
+    throw new TypeError("Agent steering messages must contain at least one user message.");
+  }
+  const parsedMessages = parseMessages(messages);
+  if (parsedMessages.some((message) => message.role !== "user")) {
+    throw new TypeError("Agent steering messages must all be user messages.");
+  }
+  return parsedMessages;
+}
+function normalizeRequestedRunId(runId) {
+  if (runId === void 0) {
+    return void 0;
+  }
+  if (typeof runId !== "string" || runId.trim().length === 0) {
+    throw new TypeError("runId must be a non-empty string.");
+  }
+  return runId;
+}
+function responseStreamEvents(turn, response, includeProviderArtifacts = true) {
+  const events = [];
+  for (const item of response.choice) {
+    if (item.type === "text") {
+      if (item.text.length > 0) {
+        events.push({ type: "text_delta", turn, delta: item.text });
+      }
+      continue;
+    }
+    if (item.type === "reasoning") {
+      if (item.details === void 0) {
+        if (item.text.length > 0) {
+          events.push(reasoningDeltaEvent(turn, item.text, { id: item.id }));
+        }
+        continue;
+      }
+      for (const content of item.details) {
+        const delta = content.type === "encrypted" || content.type === "redacted" ? content.data : content.text;
+        events.push(
+          reasoningDeltaEvent(turn, delta, {
+            id: item.id,
+            contentType: content.type,
+            signature: content.type === "text" ? content.signature : void 0
+          })
+        );
+      }
+      continue;
+    }
+    if (item.type === "tool-call") {
+      events.push({ type: "tool_call", turn, toolCall: item });
+    }
+  }
+  if (includeProviderArtifacts) {
+    for (const source of response.sources ?? []) {
+      events.push({ type: "source", turn, source });
+    }
+    for (const toolCall of response.providerToolCalls ?? []) {
+      events.push({ type: "provider_tool_call", turn, toolCall });
+    }
+  }
+  return events;
+}
+function generationArtifacts(messages) {
+  const sources = /* @__PURE__ */ new Map();
+  const providerToolCalls = /* @__PURE__ */ new Map();
+  let finishReason;
+  let providerFinishReason;
+  let contextUsage;
+  for (const message of messages) {
+    const metadata = getAssistantGenerationMetadata(message);
+    if (metadata !== void 0) {
+      finishReason = metadata.finishReason;
+      providerFinishReason = metadata.providerFinishReason;
+      contextUsage = metadata.contextUsage;
+    }
+    for (const source of metadata?.sources ?? []) {
+      const key = `${source.url}\0${source.startIndex ?? ""}\0${source.endIndex ?? ""}`;
+      sources.set(key, source);
+    }
+    for (const toolCall of metadata?.providerToolCalls ?? []) {
+      providerToolCalls.set(toolCall.id, toolCall);
+    }
+  }
+  const artifacts = {};
+  if (sources.size > 0) artifacts.sources = [...sources.values()];
+  if (providerToolCalls.size > 0) {
+    artifacts.providerToolCalls = [...providerToolCalls.values()];
+  }
+  if (finishReason !== void 0) artifacts.finishReason = finishReason;
+  if (providerFinishReason !== void 0) {
+    artifacts.providerFinishReason = providerFinishReason;
+  }
+  if (contextUsage !== void 0) artifacts.contextUsage = contextUsage;
+  return artifacts;
+}
+function reasoningDeltaEvent(turn, delta, details = {}) {
+  const event = {
+    type: "reasoning_delta",
+    turn,
+    delta
+  };
+  if (details.id !== void 0) {
+    event.id = details.id;
+  }
+  if (details.contentType !== void 0) {
+    event.contentType = details.contentType;
+  }
+  if (details.signature !== void 0) {
+    event.signature = details.signature;
+  }
+  return event;
+}
+function textFromMessage(message) {
+  if (message.role === "system") {
+    return message.content;
+  }
+  if (typeof message.content === "string") {
+    return message.content;
+  }
+  return message.content.flatMap((content) => {
+    if (content.type === "text") {
+      return [content.text];
+    }
+    if (content.type === "file" && content.data.type === "text") {
+      return [content.data.text];
+    }
+    return [];
+  }).join("\n");
+}
+function latestAssistantText(messages) {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role === "assistant") {
+      return typeof message.content === "string" ? message.content : textFromAssistantContent(message.content);
+    }
+  }
+  return "";
+}
+function structuredOutputRetryRequest(request, response, error) {
+  const truncated = error instanceof AgentStructuredOutputError && error.phase === "truncated";
+  const correction = {
+    role: "user",
+    content: truncated ? STRUCTURED_OUTPUT_TRUNCATED_RETRY_PROMPT : STRUCTURED_OUTPUT_RETRY_PROMPT
+  };
+  if (truncated) {
+    return {
+      request: {
+        ...request,
+        chatHistory: [...request.chatHistory, correction]
+      },
+      previousResponse: "omitted",
+      includedOutputLength: 0
+    };
+  }
+  const preview = structuredOutputRepairPreview(textFromAssistantContent(response.choice));
+  if (preview.includedOutputLength === 0) {
+    return {
+      request: {
+        ...request,
+        chatHistory: [...request.chatHistory, correction]
+      },
+      previousResponse: "omitted",
+      includedOutputLength: 0
+    };
+  }
+  const invalidResponse = {
+    role: "assistant",
+    content: [{ type: "text", text: preview.text }]
+  };
+  return {
+    request: {
+      ...request,
+      chatHistory: [...request.chatHistory, invalidResponse, correction]
+    },
+    previousResponse: "preview",
+    includedOutputLength: preview.includedOutputLength
+  };
+}
+function structuredOutputRetryEventAttributes(error, retryRequest) {
+  const attributes = {
+    previousResponse: retryRequest.previousResponse,
+    includedOutputLength: retryRequest.includedOutputLength
+  };
+  if (!(error instanceof AgentStructuredOutputError)) return attributes;
+  Object.assign(attributes, {
+    failurePhase: error.phase,
+    outputLength: error.outputLength,
+    normalizedLength: error.normalizedLength,
+    attemptUsage: usageEventValue(error.attemptUsage),
+    cumulativeUsage: usageEventValue(error.usage)
+  });
+  if (error.finishReason !== void 0) attributes.finishReason = error.finishReason;
+  if (error.providerFinishReason !== void 0) {
+    attributes.providerFinishReason = error.providerFinishReason;
+  }
+  return attributes;
+}
+function providerOutputRetryEventAttributes(error, cumulativeUsage, attemptUsage) {
+  const resolvedAttemptUsage = attemptUsage ?? completionProviderOutputErrorUsage(error);
+  if (resolvedAttemptUsage === void 0) return void 0;
+  return {
+    attemptUsage: usageEventValue(resolvedAttemptUsage),
+    cumulativeUsage: usageEventValue(cumulativeUsage)
+  };
+}
+function usageEventValue(usage) {
+  const value = {
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    totalTokens: usage.totalTokens,
+    cachedInputTokens: usage.cachedInputTokens,
+    cacheCreationInputTokens: usage.cacheCreationInputTokens
+  };
+  if (usage.details !== void 0) value.details = { ...usage.details };
+  return value;
+}
+function providerMessages(messages) {
+  const providerMessages2 = [];
+  for (const message of messages) {
+    if (message.role !== "tool") {
+      providerMessages2.push(message);
+      continue;
+    }
+    const results = message.content.filter((part) => part.type === "tool-result");
+    if (results.length > 0) {
+      providerMessages2.push({ ...message, content: results });
+    }
+  }
+  return providerMessages2;
+}
+function guardrailDecisionAttributes(decision) {
+  const attributes = {
+    policyId: decision.policyId,
+    guardrailId: decision.guardrailId,
+    boundary: decision.boundary,
+    mode: decision.mode,
+    action: decision.action,
+    applied: decision.applied,
+    latencyMs: decision.latencyMs
+  };
+  if (decision.reason !== void 0) {
+    attributes.reason = decision.reason;
+  }
+  if (decision.message !== void 0) {
+    attributes.message = decision.message;
+  }
+  return attributes;
+}
+function blockedOutcomeDetails(decisions, fallbackReason) {
+  for (let index = decisions.length - 1; index >= 0; index -= 1) {
+    const decision = decisions[index];
+    if (decision?.applied !== true || decision.action !== "block") continue;
+    return decision.message === void 0 ? { reason: decision.reason ?? fallbackReason } : { reason: decision.reason ?? fallbackReason, message: decision.message };
+  }
+  return { reason: fallbackReason };
+}
+function observerRunEnd(outcome) {
+  const common = {
+    runId: outcome.runId,
+    text: outcome.text,
+    usage: outcome.usage,
+    messages: outcome.messages,
+    sources: outcome.sources,
+    providerToolCalls: outcome.providerToolCalls,
+    resumedFrom: outcome.resumedFrom
+  };
+  switch (outcome.type) {
+    case "response":
+      return { ...common, status: "completed", output: outcome.output };
+    case "blocked":
+      return { ...common, status: "blocked", stage: outcome.stage };
+    case "interaction":
+      return { ...common, status: "suspended", interaction: outcome.interaction };
+  }
+}
+
+export {
+  AgentRun
+};
+//# sourceMappingURL=chunk-RT5LUEO3.js.map