@openai/agents-core 0.0.15 → 0.0.17

package/dist/runState.js

@@ -1,183 +1,227 @@
-import { z } from '@openai/zod/v3';
-import { Agent } from "./agent.js";
-import { RunMessageOutputItem, RunToolApprovalItem, RunToolCallItem, RunToolCallOutputItem, RunReasoningItem, RunHandoffCallItem, RunHandoffOutputItem, } from "./items.js";
-import { RunContext } from "./runContext.js";
-import { AgentToolUseTracker, nextStepSchema, } from "./runImplementation.js";
-import { SystemError, UserError } from "./errors.js";
-import { getGlobalTraceProvider } from "./tracing/provider.js";
-import { Usage } from "./usage.js";
-import { getCurrentTrace } from "./tracing/index.js";
-import logger from "./logger.js";
-import { handoff } from "./handoff.js";
-import * as protocol from "./types/protocol.js";
-import { safeExecute } from "./utils/safeExecute.js";
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunState = exports.SerializedRunState = exports.CURRENT_SCHEMA_VERSION = void 0;
+exports.buildAgentMap = buildAgentMap;
+exports.deserializeSpan = deserializeSpan;
+exports.deserializeModelResponse = deserializeModelResponse;
+exports.deserializeItem = deserializeItem;
+const zod_1 = require("zod");
+const agent_1 = require("./agent.js");
+const items_1 = require("./items.js");
+const runContext_1 = require("./runContext.js");
+const run_1 = require("./run.js");
+const runImplementation_1 = require("./runImplementation.js");
+const errors_1 = require("./errors.js");
+const provider_1 = require("./tracing/provider.js");
+const usage_1 = require("./usage.js");
+const tracing_1 = require("./tracing/index.js");
+const logger_1 = __importDefault(require("./logger.js"));
+const handoff_1 = require("./handoff.js");
+const protocol = __importStar(require("./types/protocol.js"));
+const safeExecute_1 = require("./utils/safeExecute.js");
 /**
  * The schema version of the serialized run state. This is used to ensure that the serialized
  * run state is compatible with the current version of the SDK.
  * If anything in this schema changes, the version will have to be incremented.
  */
-export const CURRENT_SCHEMA_VERSION = '1.0';
-const $schemaVersion = z.literal(CURRENT_SCHEMA_VERSION);
-const serializedAgentSchema = z.object({
-    name: z.string(),
+exports.CURRENT_SCHEMA_VERSION = '1.0';
+const $schemaVersion = zod_1.z.literal(exports.CURRENT_SCHEMA_VERSION);
+const serializedAgentSchema = zod_1.z.object({
+    name: zod_1.z.string(),
 });
-const serializedSpanBase = z.object({
-    object: z.literal('trace.span'),
-    id: z.string(),
-    trace_id: z.string(),
-    parent_id: z.string().nullable(),
-    started_at: z.string().nullable(),
-    ended_at: z.string().nullable(),
-    error: z
+const serializedSpanBase = zod_1.z.object({
+    object: zod_1.z.literal('trace.span'),
+    id: zod_1.z.string(),
+    trace_id: zod_1.z.string(),
+    parent_id: zod_1.z.string().nullable(),
+    started_at: zod_1.z.string().nullable(),
+    ended_at: zod_1.z.string().nullable(),
+    error: zod_1.z
         .object({
-        message: z.string(),
-        data: z.record(z.string(), z.any()).optional(),
+        message: zod_1.z.string(),
+        data: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
     })
         .nullable(),
-    span_data: z.record(z.string(), z.any()),
+    span_data: zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
 });
 const SerializedSpan = serializedSpanBase.extend({
-    previous_span: z.lazy(() => SerializedSpan).optional(),
+    previous_span: zod_1.z.lazy(() => SerializedSpan).optional(),
 });
-const usageSchema = z.object({
-    requests: z.number(),
-    inputTokens: z.number(),
-    outputTokens: z.number(),
-    totalTokens: z.number(),
+const usageSchema = zod_1.z.object({
+    requests: zod_1.z.number(),
+    inputTokens: zod_1.z.number(),
+    outputTokens: zod_1.z.number(),
+    totalTokens: zod_1.z.number(),
 });
-const modelResponseSchema = z.object({
+const modelResponseSchema = zod_1.z.object({
     usage: usageSchema,
-    output: z.array(protocol.OutputModelItem),
-    responseId: z.string().optional(),
-    providerData: z.record(z.string(), z.any()).optional(),
+    output: zod_1.z.array(protocol.OutputModelItem),
+    responseId: zod_1.z.string().optional(),
+    providerData: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional(),
 });
-const itemSchema = z.discriminatedUnion('type', [
-    z.object({
-        type: z.literal('message_output_item'),
+const itemSchema = zod_1.z.discriminatedUnion('type', [
+    zod_1.z.object({
+        type: zod_1.z.literal('message_output_item'),
         rawItem: protocol.AssistantMessageItem,
         agent: serializedAgentSchema,
     }),
-    z.object({
-        type: z.literal('tool_call_item'),
+    zod_1.z.object({
+        type: zod_1.z.literal('tool_call_item'),
         rawItem: protocol.ToolCallItem.or(protocol.HostedToolCallItem),
         agent: serializedAgentSchema,
     }),
-    z.object({
-        type: z.literal('tool_call_output_item'),
+    zod_1.z.object({
+        type: zod_1.z.literal('tool_call_output_item'),
         rawItem: protocol.FunctionCallResultItem,
         agent: serializedAgentSchema,
-        output: z.string(),
+        output: zod_1.z.string(),
     }),
-    z.object({
-        type: z.literal('reasoning_item'),
+    zod_1.z.object({
+        type: zod_1.z.literal('reasoning_item'),
         rawItem: protocol.ReasoningItem,
         agent: serializedAgentSchema,
     }),
-    z.object({
-        type: z.literal('handoff_call_item'),
+    zod_1.z.object({
+        type: zod_1.z.literal('handoff_call_item'),
         rawItem: protocol.FunctionCallItem,
         agent: serializedAgentSchema,
     }),
-    z.object({
-        type: z.literal('handoff_output_item'),
+    zod_1.z.object({
+        type: zod_1.z.literal('handoff_output_item'),
         rawItem: protocol.FunctionCallResultItem,
         sourceAgent: serializedAgentSchema,
         targetAgent: serializedAgentSchema,
     }),
-    z.object({
-        type: z.literal('tool_approval_item'),
+    zod_1.z.object({
+        type: zod_1.z.literal('tool_approval_item'),
         rawItem: protocol.FunctionCallItem.or(protocol.HostedToolCallItem),
         agent: serializedAgentSchema,
     }),
 ]);
-const serializedTraceSchema = z.object({
-    object: z.literal('trace'),
-    id: z.string(),
-    workflow_name: z.string(),
-    group_id: z.string().nullable(),
-    metadata: z.record(z.string(), z.any()),
+const serializedTraceSchema = zod_1.z.object({
+    object: zod_1.z.literal('trace'),
+    id: zod_1.z.string(),
+    workflow_name: zod_1.z.string(),
+    group_id: zod_1.z.string().nullable(),
+    metadata: zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
 });
-const serializedProcessedResponseSchema = z.object({
-    newItems: z.array(itemSchema),
-    toolsUsed: z.array(z.string()),
-    handoffs: z.array(z.object({
-        toolCall: z.any(),
-        handoff: z.any(),
+const serializedProcessedResponseSchema = zod_1.z.object({
+    newItems: zod_1.z.array(itemSchema),
+    toolsUsed: zod_1.z.array(zod_1.z.string()),
+    handoffs: zod_1.z.array(zod_1.z.object({
+        toolCall: zod_1.z.any(),
+        handoff: zod_1.z.any(),
     })),
-    functions: z.array(z.object({
-        toolCall: z.any(),
-        tool: z.any(),
+    functions: zod_1.z.array(zod_1.z.object({
+        toolCall: zod_1.z.any(),
+        tool: zod_1.z.any(),
     })),
-    computerActions: z.array(z.object({
-        toolCall: z.any(),
-        computer: z.any(),
+    computerActions: zod_1.z.array(zod_1.z.object({
+        toolCall: zod_1.z.any(),
+        computer: zod_1.z.any(),
     })),
-    mcpApprovalRequests: z
-        .array(z.object({
-        requestItem: z.object({
+    mcpApprovalRequests: zod_1.z
+        .array(zod_1.z.object({
+        requestItem: zod_1.z.object({
             // protocol.HostedToolCallItem
-            rawItem: z.object({
-                type: z.literal('hosted_tool_call'),
-                name: z.string(),
-                arguments: z.string().optional(),
-                status: z.string().optional(),
-                output: z.string().optional(),
+            rawItem: zod_1.z.object({
+                type: zod_1.z.literal('hosted_tool_call'),
+                name: zod_1.z.string(),
+                arguments: zod_1.z.string().optional(),
+                status: zod_1.z.string().optional(),
+                output: zod_1.z.string().optional(),
                 // this always exists but marked as optional for early version compatibility; when releasing 1.0, we can remove the nullable and optional
-                providerData: z.record(z.string(), z.any()).nullable().optional(),
+                providerData: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).nullable().optional(),
             }),
         }),
         // HostedMCPTool
-        mcpTool: z.object({
-            type: z.literal('hosted_tool'),
-            name: z.literal('hosted_mcp'),
-            providerData: z.record(z.string(), z.any()),
+        mcpTool: zod_1.z.object({
+            type: zod_1.z.literal('hosted_tool'),
+            name: zod_1.z.literal('hosted_mcp'),
+            providerData: zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
         }),
     }))
         .optional(),
 });
-const guardrailFunctionOutputSchema = z.object({
-    tripwireTriggered: z.boolean(),
-    outputInfo: z.any(),
+const guardrailFunctionOutputSchema = zod_1.z.object({
+    tripwireTriggered: zod_1.z.boolean(),
+    outputInfo: zod_1.z.any(),
 });
-const inputGuardrailResultSchema = z.object({
-    guardrail: z.object({
-        type: z.literal('input'),
-        name: z.string(),
+const inputGuardrailResultSchema = zod_1.z.object({
+    guardrail: zod_1.z.object({
+        type: zod_1.z.literal('input'),
+        name: zod_1.z.string(),
     }),
     output: guardrailFunctionOutputSchema,
 });
-const outputGuardrailResultSchema = z.object({
-    guardrail: z.object({
-        type: z.literal('output'),
-        name: z.string(),
+const outputGuardrailResultSchema = zod_1.z.object({
+    guardrail: zod_1.z.object({
+        type: zod_1.z.literal('output'),
+        name: zod_1.z.string(),
     }),
-    agentOutput: z.any(),
+    agentOutput: zod_1.z.any(),
     agent: serializedAgentSchema,
     output: guardrailFunctionOutputSchema,
 });
-export const SerializedRunState = z.object({
+exports.SerializedRunState = zod_1.z.object({
     $schemaVersion,
-    currentTurn: z.number(),
+    currentTurn: zod_1.z.number(),
     currentAgent: serializedAgentSchema,
-    originalInput: z.string().or(z.array(protocol.ModelItem)),
-    modelResponses: z.array(modelResponseSchema),
-    context: z.object({
+    originalInput: zod_1.z.string().or(zod_1.z.array(protocol.ModelItem)),
+    modelResponses: zod_1.z.array(modelResponseSchema),
+    context: zod_1.z.object({
         usage: usageSchema,
-        approvals: z.record(z.string(), z.object({
-            approved: z.array(z.string()).or(z.boolean()),
-            rejected: z.array(z.string()).or(z.boolean()),
+        approvals: zod_1.z.record(zod_1.z.string(), zod_1.z.object({
+            approved: zod_1.z.array(zod_1.z.string()).or(zod_1.z.boolean()),
+            rejected: zod_1.z.array(zod_1.z.string()).or(zod_1.z.boolean()),
         })),
-        context: z.record(z.string(), z.any()),
+        context: zod_1.z.record(zod_1.z.string(), zod_1.z.any()),
     }),
-    toolUseTracker: z.record(z.string(), z.array(z.string())),
-    maxTurns: z.number(),
+    toolUseTracker: zod_1.z.record(zod_1.z.string(), zod_1.z.array(zod_1.z.string())),
+    maxTurns: zod_1.z.number(),
     currentAgentSpan: SerializedSpan.nullable().optional(),
-    noActiveAgentRun: z.boolean(),
-    inputGuardrailResults: z.array(inputGuardrailResultSchema),
-    outputGuardrailResults: z.array(outputGuardrailResultSchema),
-    currentStep: nextStepSchema.optional(),
+    noActiveAgentRun: zod_1.z.boolean(),
+    inputGuardrailResults: zod_1.z.array(inputGuardrailResultSchema),
+    outputGuardrailResults: zod_1.z.array(outputGuardrailResultSchema),
+    currentStep: runImplementation_1.nextStepSchema.optional(),
     lastModelResponse: modelResponseSchema.optional(),
-    generatedItems: z.array(itemSchema),
+    generatedItems: zod_1.z.array(itemSchema),
     lastProcessedResponse: serializedProcessedResponseSchema.optional(),
     trace: serializedTraceSchema.nullable(),
 });
@@ -189,7 +233,7 @@ export const SerializedRunState = z.object({
  * Manipulation of the state directly can lead to unexpected behavior and should be avoided.
  * Instead, use the `approve` and `reject` methods to interact with the state.
  */
-export class RunState {
+class RunState {
     /**
      * Current turn number in the conversation.
      */
@@ -260,12 +304,20 @@ export class RunState {
         this._modelResponses = [];
         this._currentAgentSpan = undefined;
         this._currentAgent = startingAgent;
-        this._toolUseTracker = new AgentToolUseTracker();
+        this._toolUseTracker = new runImplementation_1.AgentToolUseTracker();
         this._generatedItems = [];
         this._maxTurns = maxTurns;
         this._inputGuardrailResults = [];
         this._outputGuardrailResults = [];
-        this._trace = getCurrentTrace();
+        this._trace = (0, tracing_1.getCurrentTrace)();
+    }
+    /**
+     * The history of the agent run. This includes the input items and the new items generated during the run.
+     *
+     * This can be used as inputs for the next agent run.
+     */
+    get history() {
+        return (0, run_1.getTurnInput)(this._originalInput, this._generatedItems);
     }
     /**
      * Returns all interruptions if the current step is an interruption otherwise returns an empty array.
@@ -316,7 +368,7 @@ export class RunState {
      */
     toJSON() {
         const output = {
-            $schemaVersion: CURRENT_SCHEMA_VERSION,
+            $schemaVersion: exports.CURRENT_SCHEMA_VERSION,
             currentTurn: this._currentTurn,
             currentAgent: {
                 name: this._currentAgent.name,
@@ -352,9 +404,9 @@ export class RunState {
             trace: this._trace ? this._trace.toJSON() : null,
         };
         // parsing the schema to ensure the output is valid for reparsing
-        const parsed = SerializedRunState.safeParse(output);
+        const parsed = exports.SerializedRunState.safeParse(output);
         if (!parsed.success) {
-            throw new SystemError(`Failed to serialize run state. ${parsed.error.message}`);
+            throw new errors_1.SystemError(`Failed to serialize run state. ${parsed.error.message}`);
         }
         return parsed.data;
     }
@@ -376,44 +428,44 @@ export class RunState {
      * `toString` method.
      */
     static async fromString(initialAgent, str) {
-        const [parsingError, jsonResult] = await safeExecute(() => JSON.parse(str));
+        const [parsingError, jsonResult] = await (0, safeExecute_1.safeExecute)(() => JSON.parse(str));
         if (parsingError) {
-            throw new UserError(`Failed to parse run state. ${parsingError instanceof Error ? parsingError.message : String(parsingError)}`);
+            throw new errors_1.UserError(`Failed to parse run state. ${parsingError instanceof Error ? parsingError.message : String(parsingError)}`);
         }
         const currentSchemaVersion = jsonResult.$schemaVersion;
         if (!currentSchemaVersion) {
-            throw new UserError('Run state is missing schema version');
+            throw new errors_1.UserError('Run state is missing schema version');
         }
-        if (currentSchemaVersion !== CURRENT_SCHEMA_VERSION) {
-            throw new UserError(`Run state schema version ${currentSchemaVersion} is not supported. Please use version ${CURRENT_SCHEMA_VERSION}`);
+        if (currentSchemaVersion !== exports.CURRENT_SCHEMA_VERSION) {
+            throw new errors_1.UserError(`Run state schema version ${currentSchemaVersion} is not supported. Please use version ${exports.CURRENT_SCHEMA_VERSION}`);
         }
-        const stateJson = SerializedRunState.parse(JSON.parse(str));
+        const stateJson = exports.SerializedRunState.parse(JSON.parse(str));
         const agentMap = buildAgentMap(initialAgent);
         //
         // Rebuild the context
         //
-        const context = new RunContext(stateJson.context.context);
+        const context = new runContext_1.RunContext(stateJson.context.context);
         context._rebuildApprovals(stateJson.context.approvals);
         //
         // Find the current agent from the initial agent
         //
         const currentAgent = agentMap.get(stateJson.currentAgent.name);
         if (!currentAgent) {
-            throw new UserError(`Agent ${stateJson.currentAgent.name} not found`);
+            throw new errors_1.UserError(`Agent ${stateJson.currentAgent.name} not found`);
         }
         const state = new RunState(context, '', currentAgent, stateJson.maxTurns);
         state._currentTurn = stateJson.currentTurn;
         // rebuild tool use tracker
-        state._toolUseTracker = new AgentToolUseTracker();
+        state._toolUseTracker = new runImplementation_1.AgentToolUseTracker();
         for (const [agentName, toolNames] of Object.entries(stateJson.toolUseTracker)) {
             state._toolUseTracker.addToolUse(agentMap.get(agentName), toolNames);
         }
         // rebuild current agent span
         if (stateJson.currentAgentSpan) {
             if (!stateJson.trace) {
-                logger.warn('Trace is not set, skipping tracing setup');
+                logger_1.default.warn('Trace is not set, skipping tracing setup');
             }
-            const trace = getGlobalTraceProvider().createTrace({
+            const trace = (0, provider_1.getGlobalTraceProvider)().createTrace({
                 traceId: stateJson.trace?.id,
                 name: stateJson.trace?.workflow_name,
                 groupId: stateJson.trace?.group_id ?? undefined,
@@ -448,10 +500,11 @@ export class RunState {
         return state;
     }
 }
+exports.RunState = RunState;
 /**
  * @internal
  */
-export function buildAgentMap(initialAgent) {
+function buildAgentMap(initialAgent) {
     const map = new Map();
     const queue = [initialAgent];
     while (queue.length > 0) {
@@ -461,7 +514,7 @@ export function buildAgentMap(initialAgent) {
         }
         map.set(currentAgent.name, currentAgent);
         for (const handoff of currentAgent.handoffs) {
-            if (handoff instanceof Agent) {
+            if (handoff instanceof agent_1.Agent) {
                 if (!map.has(handoff.name)) {
                     queue.push(handoff);
                 }
@@ -478,12 +531,12 @@ export function buildAgentMap(initialAgent) {
 /**
  * @internal
  */
-export function deserializeSpan(trace, serializedSpan) {
+function deserializeSpan(trace, serializedSpan) {
     const spanData = serializedSpan.span_data;
     const previousSpan = serializedSpan.previous_span
         ? deserializeSpan(trace, serializedSpan.previous_span)
         : undefined;
-    const span = getGlobalTraceProvider().createSpan({
+    const span = (0, provider_1.getGlobalTraceProvider)().createSpan({
         spanId: serializedSpan.id,
         traceId: serializedSpan.trace_id,
         parentId: serializedSpan.parent_id ?? undefined,
@@ -497,8 +550,8 @@ export function deserializeSpan(trace, serializedSpan) {
 /**
  * @internal
  */
-export function deserializeModelResponse(serializedModelResponse) {
-    const usage = new Usage();
+function deserializeModelResponse(serializedModelResponse) {
+    const usage = new usage_1.Usage();
     usage.requests = serializedModelResponse.usage.requests;
     usage.inputTokens = serializedModelResponse.usage.inputTokens;
     usage.outputTokens = serializedModelResponse.usage.outputTokens;
@@ -513,22 +566,22 @@ export function deserializeModelResponse(serializedModelResponse) {
 /**
  * @internal
  */
-export function deserializeItem(serializedItem, agentMap) {
+function deserializeItem(serializedItem, agentMap) {
     switch (serializedItem.type) {
         case 'message_output_item':
-            return new RunMessageOutputItem(serializedItem.rawItem, agentMap.get(serializedItem.agent.name));
+            return new items_1.RunMessageOutputItem(serializedItem.rawItem, agentMap.get(serializedItem.agent.name));
         case 'tool_call_item':
-            return new RunToolCallItem(serializedItem.rawItem, agentMap.get(serializedItem.agent.name));
+            return new items_1.RunToolCallItem(serializedItem.rawItem, agentMap.get(serializedItem.agent.name));
         case 'tool_call_output_item':
-            return new RunToolCallOutputItem(serializedItem.rawItem, agentMap.get(serializedItem.agent.name), serializedItem.output);
+            return new items_1.RunToolCallOutputItem(serializedItem.rawItem, agentMap.get(serializedItem.agent.name), serializedItem.output);
         case 'reasoning_item':
-            return new RunReasoningItem(serializedItem.rawItem, agentMap.get(serializedItem.agent.name));
+            return new items_1.RunReasoningItem(serializedItem.rawItem, agentMap.get(serializedItem.agent.name));
         case 'handoff_call_item':
-            return new RunHandoffCallItem(serializedItem.rawItem, agentMap.get(serializedItem.agent.name));
+            return new items_1.RunHandoffCallItem(serializedItem.rawItem, agentMap.get(serializedItem.agent.name));
         case 'handoff_output_item':
-            return new RunHandoffOutputItem(serializedItem.rawItem, agentMap.get(serializedItem.sourceAgent.name), agentMap.get(serializedItem.targetAgent.name));
+            return new items_1.RunHandoffOutputItem(serializedItem.rawItem, agentMap.get(serializedItem.sourceAgent.name), agentMap.get(serializedItem.targetAgent.name));
         case 'tool_approval_item':
-            return new RunToolApprovalItem(serializedItem.rawItem, agentMap.get(serializedItem.agent.name));
+            return new items_1.RunToolApprovalItem(serializedItem.rawItem, agentMap.get(serializedItem.agent.name));
     }
 }
 /**
@@ -543,8 +596,8 @@ async function deserializeProcessedResponse(agentMap, currentAgent, context, ser
         .filter((tool) => tool.type === 'computer')
         .map((tool) => [tool.name, tool]));
     const handoffs = new Map(currentAgent.handoffs.map((entry) => {
-        if (entry instanceof Agent) {
-            return [entry.name, handoff(entry)];
+        if (entry instanceof agent_1.Agent) {
+            return [entry.name, (0, handoff_1.handoff)(entry)];
         }
         return [entry.toolName, entry];
     }));
@@ -553,7 +606,7 @@ async function deserializeProcessedResponse(agentMap, currentAgent, context, ser
         toolsUsed: serializedProcessedResponse.toolsUsed,
         handoffs: serializedProcessedResponse.handoffs.map((handoff) => {
             if (!handoffs.has(handoff.handoff.toolName)) {
-                throw new UserError(`Handoff ${handoff.handoff.toolName} not found`);
+                throw new errors_1.UserError(`Handoff ${handoff.handoff.toolName} not found`);
             }
             return {
                 toolCall: handoff.toolCall,
@@ -562,7 +615,7 @@ async function deserializeProcessedResponse(agentMap, currentAgent, context, ser
         }),
         functions: await Promise.all(serializedProcessedResponse.functions.map(async (functionCall) => {
             if (!tools.has(functionCall.tool.name)) {
-                throw new UserError(`Tool ${functionCall.tool.name} not found`);
+                throw new errors_1.UserError(`Tool ${functionCall.tool.name} not found`);
             }
             return {
                 toolCall: functionCall.toolCall,
@@ -572,7 +625,7 @@ async function deserializeProcessedResponse(agentMap, currentAgent, context, ser
         computerActions: serializedProcessedResponse.computerActions.map((computerAction) => {
             const toolName = computerAction.computer.name;
             if (!computerTools.has(toolName)) {
-                throw new UserError(`Computer tool ${toolName} not found`);
+                throw new errors_1.UserError(`Computer tool ${toolName} not found`);
             }
             return {
                 toolCall: computerAction.toolCall,
@@ -580,7 +633,7 @@ async function deserializeProcessedResponse(agentMap, currentAgent, context, ser
             };
         }),
         mcpApprovalRequests: (serializedProcessedResponse.mcpApprovalRequests ?? []).map((approvalRequest) => ({
-            requestItem: new RunToolApprovalItem(approvalRequest.requestItem
+            requestItem: new items_1.RunToolApprovalItem(approvalRequest.requestItem
                 .rawItem, currentAgent),
             mcpTool: approvalRequest.mcpTool,
         })),