@openai/agents-core 0.0.16 → 0.1.0

package/dist/run.js

@@ -1,26 +1,37 @@
-import { Agent } from "./agent.js";
-import { defineInputGuardrail, defineOutputGuardrail, } from "./guardrail.js";
-import { getHandoff } from "./handoff.js";
-import { getDefaultModelProvider } from "./providers.js";
-import { RunContext } from "./runContext.js";
-import { RunResult, StreamedRunResult } from "./result.js";
-import { RunHooks } from "./lifecycle.js";
-import logger from "./logger.js";
-import { serializeTool, serializeHandoff } from "./utils/serialize.js";
-import { GuardrailExecutionError, InputGuardrailTripwireTriggered, MaxTurnsExceededError, ModelBehaviorError, OutputGuardrailTripwireTriggered, UserError, } from "./errors.js";
-import { addStepToRunResult, executeInterruptedToolsAndSideEffects, executeToolsAndSideEffects, maybeResetToolChoice, processModelResponse, } from "./runImplementation.js";
-import { getOrCreateTrace, resetCurrentSpan, setCurrentSpan, withNewSpanContext, withTrace, } from "./tracing/context.js";
-import { createAgentSpan, withGuardrailSpan } from "./tracing/index.js";
-import { Usage } from "./usage.js";
-import { RunAgentUpdatedStreamEvent, RunRawModelStreamEvent } from "./events.js";
-import { RunState } from "./runState.js";
-import { StreamEventResponseCompleted } from "./types/protocol.js";
-import { convertAgentOutputTypeToSerializable } from "./utils/tools.js";
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Runner = void 0;
+exports.getTracing = getTracing;
+exports.getTurnInput = getTurnInput;
+exports.selectModel = selectModel;
+exports.run = run;
+const agent_1 = require("./agent.js");
+const guardrail_1 = require("./guardrail.js");
+const handoff_1 = require("./handoff.js");
+const providers_1 = require("./providers.js");
+const runContext_1 = require("./runContext.js");
+const result_1 = require("./result.js");
+const lifecycle_1 = require("./lifecycle.js");
+const logger_1 = __importDefault(require("./logger.js"));
+const serialize_1 = require("./utils/serialize.js");
+const errors_1 = require("./errors.js");
+const runImplementation_1 = require("./runImplementation.js");
+const context_1 = require("./tracing/context.js");
+const tracing_1 = require("./tracing/index.js");
+const usage_1 = require("./usage.js");
+const events_1 = require("./events.js");
+const runState_1 = require("./runState.js");
+const protocol_1 = require("./types/protocol.js");
+const tools_1 = require("./utils/tools.js");
+const defaultModel_1 = require("./defaultModel.js");
 const DEFAULT_MAX_TURNS = 10;
 /**
  * @internal
  */
-export function getTracing(tracingDisabled, traceIncludeSensitiveData) {
+function getTracing(tracingDisabled, traceIncludeSensitiveData) {
     if (tracingDisabled) {
         return false;
     }
@@ -29,7 +40,7 @@ export function getTracing(tracingDisabled, traceIncludeSensitiveData) {
     }
     return 'enabled_without_data';
 }
-export function getTurnInput(originalInput, generatedItems) {
+function getTurnInput(originalInput, generatedItems) {
     const rawItems = generatedItems
         .filter((item) => item.type !== 'tool_approval_item') // don't include approval items to avoid double function calls
         .map((item) => item.rawItem);
@@ -41,14 +52,14 @@ export function getTurnInput(originalInput, generatedItems) {
 /**
  * A Runner is responsible for running an agent workflow.
  */
-export class Runner extends RunHooks {
+class Runner extends lifecycle_1.RunHooks {
     config;
     inputGuardrailDefs;
     outputGuardrailDefs;
     constructor(config = {}) {
         super();
         this.config = {
-            modelProvider: config.modelProvider ?? getDefaultModelProvider(),
+            modelProvider: config.modelProvider ?? (0, providers_1.getDefaultModelProvider)(),
             model: config.model,
             modelSettings: config.modelSettings,
             handoffInputFilter: config.handoffInputFilter,
@@ -61,22 +72,25 @@ export class Runner extends RunHooks {
             groupId: config.groupId,
             traceMetadata: config.traceMetadata,
         };
-        this.inputGuardrailDefs = (config.inputGuardrails ?? []).map(defineInputGuardrail);
-        this.outputGuardrailDefs = (config.outputGuardrails ?? []).map(defineOutputGuardrail);
+        this.inputGuardrailDefs = (config.inputGuardrails ?? []).map(guardrail_1.defineInputGuardrail);
+        this.outputGuardrailDefs = (config.outputGuardrails ?? []).map(guardrail_1.defineOutputGuardrail);
     }
     /**
      * @internal
      */
     async #runIndividualNonStream(startingAgent, input, options) {
-        return withNewSpanContext(async () => {
+        return (0, context_1.withNewSpanContext)(async () => {
             // if we have a saved state we use that one, otherwise we create a new one
-            const state = input instanceof RunState
+            const state = input instanceof runState_1.RunState
                 ? input
-                : new RunState(options.context instanceof RunContext
+                : new runState_1.RunState(options.context instanceof runContext_1.RunContext
                     ? options.context
-                    : new RunContext(options.context), input, startingAgent, options.maxTurns ?? DEFAULT_MAX_TURNS);
+                    : new runContext_1.RunContext(options.context), input, startingAgent, options.maxTurns ?? DEFAULT_MAX_TURNS);
             try {
                 while (true) {
+                    const explictlyModelSet = (state._currentAgent.model !== undefined &&
+                        state._currentAgent.model !== '') ||
+                        (this.config.model !== undefined && this.config.model !== '');
                     let model = selectModel(state._currentAgent.model, this.config.model);
                     if (typeof model === 'string') {
                         model = await this.config.modelProvider.getModel(model);
@@ -86,18 +100,18 @@ export class Runner extends RunHooks {
                         type: 'next_step_run_again',
                     };
                     if (state._currentStep.type === 'next_step_interruption') {
-                        logger.debug('Continuing from interruption');
+                        logger_1.default.debug('Continuing from interruption');
                         if (!state._lastTurnResponse || !state._lastProcessedResponse) {
-                            throw new UserError('No model response found in previous state', state);
+                            throw new errors_1.UserError('No model response found in previous state', state);
                         }
-                        const turnResult = await executeInterruptedToolsAndSideEffects(state._currentAgent, state._originalInput, state._generatedItems, state._lastTurnResponse, state._lastProcessedResponse, this, state);
+                        const turnResult = await (0, runImplementation_1.executeInterruptedToolsAndSideEffects)(state._currentAgent, state._originalInput, state._generatedItems, state._lastTurnResponse, state._lastProcessedResponse, this, state);
                         state._toolUseTracker.addToolUse(state._currentAgent, state._lastProcessedResponse.toolsUsed);
                         state._originalInput = turnResult.originalInput;
                         state._generatedItems = turnResult.generatedItems;
                         state._currentStep = turnResult.nextStep;
                         if (turnResult.nextStep.type === 'next_step_interruption') {
                             // we are still in an interruption, so we need to avoid an infinite loop
-                            return new RunResult(state);
+                            return new result_1.RunResult(state);
                         }
                         continue;
                     }
@@ -106,11 +120,11 @@ export class Runner extends RunHooks {
                         if (state._currentAgent.handoffs) {
                             // While this array usually must not be undefined,
                             // we've added this check to prevent unexpected runtime errors like https://github.com/openai/openai-agents-js/issues/138
-                            handoffs.push(...state._currentAgent.handoffs.map(getHandoff));
+                            handoffs.push(...state._currentAgent.handoffs.map(handoff_1.getHandoff));
                         }
                         if (!state._currentAgentSpan) {
                             const handoffNames = handoffs.map((h) => h.agentName);
-                            state._currentAgentSpan = createAgentSpan({
+                            state._currentAgentSpan = (0, tracing_1.createAgentSpan)({
                                 data: {
                                     name: state._currentAgent.name,
                                     handoffs: handoffNames,
@@ -118,11 +132,11 @@ export class Runner extends RunHooks {
                                 },
                             });
                             state._currentAgentSpan.start();
-                            setCurrentSpan(state._currentAgentSpan);
+                            (0, context_1.setCurrentSpan)(state._currentAgentSpan);
                         }
                         const tools = await state._currentAgent.getAllTools(state._context);
-                        const serializedTools = tools.map((t) => serializeTool(t));
-                        const serializedHandoffs = handoffs.map((h) => serializeHandoff(h));
+                        const serializedTools = tools.map((t) => (0, serialize_1.serializeTool)(t));
+                        const serializedHandoffs = handoffs.map((h) => (0, serialize_1.serializeHandoff)(h));
                         if (state._currentAgentSpan) {
                             state._currentAgentSpan.spanData.tools = tools.map((t) => t.name);
                         }
@@ -132,9 +146,9 @@ export class Runner extends RunHooks {
                                 message: 'Max turns exceeded',
                                 data: { max_turns: state._maxTurns },
                             });
-                            throw new MaxTurnsExceededError(`Max turns (${state._maxTurns}) exceeded`, state);
+                            throw new errors_1.MaxTurnsExceededError(`Max turns (${state._maxTurns}) exceeded`, state);
                         }
-                        logger.debug(`Running agent ${state._currentAgent.name} (turn ${state._currentTurn})`);
+                        logger_1.default.debug(`Running agent ${state._currentAgent.name} (turn ${state._currentTurn})`);
                         if (state._currentTurn === 1) {
                             await this.#runInputGuardrails(state);
                         }
@@ -147,15 +161,18 @@ export class Runner extends RunHooks {
                             ...this.config.modelSettings,
                             ...state._currentAgent.modelSettings,
                         };
-                        modelSettings = maybeResetToolChoice(state._currentAgent, state._toolUseTracker, modelSettings);
+                        const agentModelSettings = state._currentAgent.modelSettings;
+                        modelSettings = adjustModelSettingsForNonGPT5RunnerModel(explictlyModelSet, agentModelSettings, model, modelSettings);
+                        modelSettings = (0, runImplementation_1.maybeResetToolChoice)(state._currentAgent, state._toolUseTracker, modelSettings);
                         state._lastTurnResponse = await model.getResponse({
                             systemInstructions: await state._currentAgent.getSystemPrompt(state._context),
                             prompt: await state._currentAgent.getPrompt(state._context),
                             input: turnInput,
                             previousResponseId: options.previousResponseId,
+                            conversationId: options.conversationId,
                             modelSettings,
                             tools: serializedTools,
-                            outputType: convertAgentOutputTypeToSerializable(state._currentAgent.outputType),
+                            outputType: (0, tools_1.convertAgentOutputTypeToSerializable)(state._currentAgent.outputType),
                             handoffs: serializedHandoffs,
                             tracing: getTracing(this.config.tracingDisabled, this.config.traceIncludeSensitiveData),
                             signal: options.signal,
@@ -163,9 +180,9 @@ export class Runner extends RunHooks {
                         state._modelResponses.push(state._lastTurnResponse);
                         state._context.usage.add(state._lastTurnResponse.usage);
                         state._noActiveAgentRun = false;
-                        const processedResponse = processModelResponse(state._lastTurnResponse, state._currentAgent, tools, handoffs);
+                        const processedResponse = (0, runImplementation_1.processModelResponse)(state._lastTurnResponse, state._currentAgent, tools, handoffs);
                         state._lastProcessedResponse = processedResponse;
-                        const turnResult = await executeToolsAndSideEffects(state._currentAgent, state._originalInput, state._generatedItems, state._lastTurnResponse, state._lastProcessedResponse, this, state);
+                        const turnResult = await (0, runImplementation_1.executeToolsAndSideEffects)(state._currentAgent, state._originalInput, state._generatedItems, state._lastTurnResponse, state._lastProcessedResponse, this, state);
                         state._toolUseTracker.addToolUse(state._currentAgent, state._lastProcessedResponse.toolsUsed);
                         state._originalInput = turnResult.originalInput;
                         state._generatedItems = turnResult.generatedItems;
@@ -176,14 +193,14 @@ export class Runner extends RunHooks {
                         await this.#runOutputGuardrails(state, state._currentStep.output);
                         this.emit('agent_end', state._context, state._currentAgent, state._currentStep.output);
                         state._currentAgent.emit('agent_end', state._context, state._currentStep.output);
-                        return new RunResult(state);
+                        return new result_1.RunResult(state);
                     }
                     else if (state._currentStep &&
                         state._currentStep.type === 'next_step_handoff') {
                         state._currentAgent = state._currentStep.newAgent;
                         if (state._currentAgentSpan) {
                             state._currentAgentSpan.end();
-                            resetCurrentSpan();
+                            (0, context_1.resetCurrentSpan)();
                             state._currentAgentSpan = undefined;
                         }
                         state._noActiveAgentRun = true;
@@ -193,10 +210,10 @@ export class Runner extends RunHooks {
                     else if (state._currentStep &&
                         state._currentStep.type === 'next_step_interruption') {
                         // interrupted. Don't run any guardrails
-                        return new RunResult(state);
+                        return new result_1.RunResult(state);
                     }
                     else {
-                        logger.debug('Running next loop');
+                        logger_1.default.debug('Running next loop');
                     }
                 }
             }
@@ -215,13 +232,13 @@ export class Runner extends RunHooks {
                         // don't end the span if the run was interrupted
                         state._currentAgentSpan.end();
                     }
-                    resetCurrentSpan();
+                    (0, context_1.resetCurrentSpan)();
                 }
             }
         });
     }
     async #runInputGuardrails(state) {
-        const guardrails = this.inputGuardrailDefs.concat(state._currentAgent.inputGuardrails.map(defineInputGuardrail));
+        const guardrails = this.inputGuardrailDefs.concat(state._currentAgent.inputGuardrails.map(guardrail_1.defineInputGuardrail));
         if (guardrails.length > 0) {
             const guardrailArgs = {
                 agent: state._currentAgent,
@@ -230,7 +247,7 @@ export class Runner extends RunHooks {
             };
             try {
                 const results = await Promise.all(guardrails.map(async (guardrail) => {
-                    return withGuardrailSpan(async (span) => {
+                    return (0, tracing_1.withGuardrailSpan)(async (span) => {
                         const result = await guardrail.run(guardrailArgs);
                         span.spanData.triggered = result.output.tripwireTriggered;
                         return result;
@@ -244,22 +261,22 @@ export class Runner extends RunHooks {
                                 data: { guardrail: result.guardrail.name },
                             });
                         }
-                        throw new InputGuardrailTripwireTriggered(`Input guardrail triggered: ${JSON.stringify(result.output.outputInfo)}`, result, state);
+                        throw new errors_1.InputGuardrailTripwireTriggered(`Input guardrail triggered: ${JSON.stringify(result.output.outputInfo)}`, result, state);
                     }
                 }
             }
             catch (e) {
-                if (e instanceof InputGuardrailTripwireTriggered) {
+                if (e instanceof errors_1.InputGuardrailTripwireTriggered) {
                     throw e;
                 }
                 // roll back the current turn to enable reruns
                 state._currentTurn--;
-                throw new GuardrailExecutionError(`Input guardrail failed to complete: ${e}`, e, state);
+                throw new errors_1.GuardrailExecutionError(`Input guardrail failed to complete: ${e}`, e, state);
             }
         }
     }
     async #runOutputGuardrails(state, output) {
-        const guardrails = this.outputGuardrailDefs.concat(state._currentAgent.outputGuardrails.map(defineOutputGuardrail));
+        const guardrails = this.outputGuardrailDefs.concat(state._currentAgent.outputGuardrails.map(guardrail_1.defineOutputGuardrail));
         if (guardrails.length > 0) {
             const agentOutput = state._currentAgent.processFinalOutput(output);
             const guardrailArgs = {
@@ -270,7 +287,7 @@ export class Runner extends RunHooks {
             };
             try {
                 const results = await Promise.all(guardrails.map(async (guardrail) => {
-                    return withGuardrailSpan(async (span) => {
+                    return (0, tracing_1.withGuardrailSpan)(async (span) => {
                         const result = await guardrail.run(guardrailArgs);
                         span.spanData.triggered = result.output.tripwireTriggered;
                         return result;
@@ -284,15 +301,15 @@ export class Runner extends RunHooks {
                                 data: { guardrail: result.guardrail.name },
                             });
                         }
-                        throw new OutputGuardrailTripwireTriggered(`Output guardrail triggered: ${JSON.stringify(result.output.outputInfo)}`, result, state);
+                        throw new errors_1.OutputGuardrailTripwireTriggered(`Output guardrail triggered: ${JSON.stringify(result.output.outputInfo)}`, result, state);
                     }
                 }
             }
             catch (e) {
-                if (e instanceof OutputGuardrailTripwireTriggered) {
+                if (e instanceof errors_1.OutputGuardrailTripwireTriggered) {
                     throw e;
                 }
-                throw new GuardrailExecutionError(`Output guardrail failed to complete: ${e}`, e, state);
+                throw new errors_1.GuardrailExecutionError(`Output guardrail failed to complete: ${e}`, e, state);
             }
         }
     }
@@ -303,21 +320,21 @@ export class Runner extends RunHooks {
         try {
             while (true) {
                 const currentAgent = result.state._currentAgent;
-                const handoffs = currentAgent.handoffs.map(getHandoff);
+                const handoffs = currentAgent.handoffs.map(handoff_1.getHandoff);
                 const tools = await currentAgent.getAllTools(result.state._context);
-                const serializedTools = tools.map((t) => serializeTool(t));
-                const serializedHandoffs = handoffs.map((h) => serializeHandoff(h));
+                const serializedTools = tools.map((t) => (0, serialize_1.serializeTool)(t));
+                const serializedHandoffs = handoffs.map((h) => (0, serialize_1.serializeHandoff)(h));
                 result.state._currentStep = result.state._currentStep ?? {
                     type: 'next_step_run_again',
                 };
                 if (result.state._currentStep.type === 'next_step_interruption') {
-                    logger.debug('Continuing from interruption');
+                    logger_1.default.debug('Continuing from interruption');
                     if (!result.state._lastTurnResponse ||
                         !result.state._lastProcessedResponse) {
-                        throw new UserError('No model response found in previous state', result.state);
+                        throw new errors_1.UserError('No model response found in previous state', result.state);
                     }
-                    const turnResult = await executeInterruptedToolsAndSideEffects(result.state._currentAgent, result.state._originalInput, result.state._generatedItems, result.state._lastTurnResponse, result.state._lastProcessedResponse, this, result.state);
-                    addStepToRunResult(result, turnResult);
+                    const turnResult = await (0, runImplementation_1.executeInterruptedToolsAndSideEffects)(result.state._currentAgent, result.state._originalInput, result.state._generatedItems, result.state._lastTurnResponse, result.state._lastProcessedResponse, this, result.state);
+                    (0, runImplementation_1.addStepToRunResult)(result, turnResult);
                     result.state._toolUseTracker.addToolUse(result.state._currentAgent, result.state._lastProcessedResponse.toolsUsed);
                     result.state._originalInput = turnResult.originalInput;
                     result.state._generatedItems = turnResult.generatedItems;
@@ -331,7 +348,7 @@ export class Runner extends RunHooks {
                 if (result.state._currentStep.type === 'next_step_run_again') {
                     if (!result.state._currentAgentSpan) {
                         const handoffNames = handoffs.map((h) => h.agentName);
-                        result.state._currentAgentSpan = createAgentSpan({
+                        result.state._currentAgentSpan = (0, tracing_1.createAgentSpan)({
                             data: {
                                 name: currentAgent.name,
                                 handoffs: handoffNames,
@@ -340,7 +357,7 @@ export class Runner extends RunHooks {
                             },
                         });
                         result.state._currentAgentSpan.start();
-                        setCurrentSpan(result.state._currentAgentSpan);
+                        (0, context_1.setCurrentSpan)(result.state._currentAgentSpan);
                     }
                     result.state._currentTurn++;
                     if (result.state._currentTurn > result.state._maxTurns) {
@@ -348,9 +365,11 @@ export class Runner extends RunHooks {
                             message: 'Max turns exceeded',
                             data: { max_turns: result.state._maxTurns },
                         });
-                        throw new MaxTurnsExceededError(`Max turns (${result.state._maxTurns}) exceeded`, result.state);
+                        throw new errors_1.MaxTurnsExceededError(`Max turns (${result.state._maxTurns}) exceeded`, result.state);
                     }
-                    logger.debug(`Running agent ${currentAgent.name} (turn ${result.state._currentTurn})`);
+                    logger_1.default.debug(`Running agent ${currentAgent.name} (turn ${result.state._currentTurn})`);
+                    const explictlyModelSet = (currentAgent.model !== undefined && currentAgent.model !== '') ||
+                        (this.config.model !== undefined && this.config.model !== '');
                     let model = selectModel(currentAgent.model, this.config.model);
                     if (typeof model === 'string') {
                         model = await this.config.modelProvider.getModel(model);
@@ -362,7 +381,9 @@ export class Runner extends RunHooks {
                         ...this.config.modelSettings,
                         ...currentAgent.modelSettings,
                     };
-                    modelSettings = maybeResetToolChoice(currentAgent, result.state._toolUseTracker, modelSettings);
+                    const agentModelSettings = currentAgent.modelSettings;
+                    modelSettings = adjustModelSettingsForNonGPT5RunnerModel(explictlyModelSet, agentModelSettings, model, modelSettings);
+                    modelSettings = (0, runImplementation_1.maybeResetToolChoice)(currentAgent, result.state._toolUseTracker, modelSettings);
                     const turnInput = getTurnInput(result.input, result.newItems);
                     if (result.state._noActiveAgentRun) {
                         currentAgent.emit('agent_start', result.state._context, currentAgent);
@@ -374,17 +395,18 @@ export class Runner extends RunHooks {
                         prompt: await currentAgent.getPrompt(result.state._context),
                         input: turnInput,
                         previousResponseId: options.previousResponseId,
+                        conversationId: options.conversationId,
                         modelSettings,
                         tools: serializedTools,
                         handoffs: serializedHandoffs,
-                        outputType: convertAgentOutputTypeToSerializable(currentAgent.outputType),
+                        outputType: (0, tools_1.convertAgentOutputTypeToSerializable)(currentAgent.outputType),
                         tracing: getTracing(this.config.tracingDisabled, this.config.traceIncludeSensitiveData),
                         signal: options.signal,
                     })) {
                         if (event.type === 'response_done') {
-                            const parsed = StreamEventResponseCompleted.parse(event);
+                            const parsed = protocol_1.StreamEventResponseCompleted.parse(event);
                             finalResponse = {
-                                usage: new Usage(parsed.response.usage),
+                                usage: new usage_1.Usage(parsed.response.usage),
                                 output: parsed.response.output,
                                 responseId: parsed.response.id,
                             };
@@ -394,18 +416,18 @@ export class Runner extends RunHooks {
                             // this loop to prevent internal false errors and unnecessary processing
                             return;
                         }
-                        result._addItem(new RunRawModelStreamEvent(event));
+                        result._addItem(new events_1.RunRawModelStreamEvent(event));
                     }
                     result.state._noActiveAgentRun = false;
                     if (!finalResponse) {
-                        throw new ModelBehaviorError('Model did not produce a final response!', result.state);
+                        throw new errors_1.ModelBehaviorError('Model did not produce a final response!', result.state);
                     }
                     result.state._lastTurnResponse = finalResponse;
                     result.state._modelResponses.push(result.state._lastTurnResponse);
-                    const processedResponse = processModelResponse(result.state._lastTurnResponse, currentAgent, tools, handoffs);
+                    const processedResponse = (0, runImplementation_1.processModelResponse)(result.state._lastTurnResponse, currentAgent, tools, handoffs);
                     result.state._lastProcessedResponse = processedResponse;
-                    const turnResult = await executeToolsAndSideEffects(currentAgent, result.state._originalInput, result.state._generatedItems, result.state._lastTurnResponse, result.state._lastProcessedResponse, this, result.state);
-                    addStepToRunResult(result, turnResult);
+                    const turnResult = await (0, runImplementation_1.executeToolsAndSideEffects)(currentAgent, result.state._originalInput, result.state._generatedItems, result.state._lastTurnResponse, result.state._lastProcessedResponse, this, result.state);
+                    (0, runImplementation_1.addStepToRunResult)(result, turnResult);
                     result.state._toolUseTracker.addToolUse(currentAgent, processedResponse.toolsUsed);
                     result.state._originalInput = turnResult.originalInput;
                     result.state._generatedItems = turnResult.generatedItems;
@@ -413,6 +435,8 @@ export class Runner extends RunHooks {
                 }
                 if (result.state._currentStep.type === 'next_step_final_output') {
                     await this.#runOutputGuardrails(result.state, result.state._currentStep.output);
+                    this.emit('agent_end', result.state._context, currentAgent, result.state._currentStep.output);
+                    currentAgent.emit('agent_end', result.state._context, result.state._currentStep.output);
                     return;
                 }
                 else if (result.state._currentStep.type === 'next_step_interruption') {
@@ -424,10 +448,10 @@ export class Runner extends RunHooks {
                         ?.newAgent;
                     if (result.state._currentAgentSpan) {
                         result.state._currentAgentSpan.end();
-                        resetCurrentSpan();
+                        (0, context_1.resetCurrentSpan)();
                     }
                     result.state._currentAgentSpan = undefined;
-                    result._addItem(new RunAgentUpdatedStreamEvent(result.state._currentAgent));
+                    result._addItem(new events_1.RunAgentUpdatedStreamEvent(result.state._currentAgent));
                     result.state._noActiveAgentRun = true;
                     // we've processed the handoff, so we need to run the loop again
                     result.state._currentStep = {
@@ -435,7 +459,7 @@ export class Runner extends RunHooks {
                     };
                 }
                 else {
-                    logger.debug('Running next loop');
+                    logger_1.default.debug('Running next loop');
                 }
             }
         }
@@ -453,7 +477,7 @@ export class Runner extends RunHooks {
                 if (result.state._currentStep?.type !== 'next_step_interruption') {
                     result.state._currentAgentSpan.end();
                 }
-                resetCurrentSpan();
+                (0, context_1.resetCurrentSpan)();
             }
         }
     }
@@ -462,15 +486,15 @@ export class Runner extends RunHooks {
      */
     async #runIndividualStream(agent, input, options) {
         options = options ?? {};
-        return withNewSpanContext(async () => {
+        return (0, context_1.withNewSpanContext)(async () => {
             // Initialize or reuse existing state
-            const state = input instanceof RunState
+            const state = input instanceof runState_1.RunState
                 ? input
-                : new RunState(options.context instanceof RunContext
+                : new runState_1.RunState(options.context instanceof runContext_1.RunContext
                     ? options.context
-                    : new RunContext(options.context), input, agent, options.maxTurns ?? DEFAULT_MAX_TURNS);
+                    : new runContext_1.RunContext(options.context), input, agent, options.maxTurns ?? DEFAULT_MAX_TURNS);
             // Initialize the streamed result with existing state
-            const result = new StreamedRunResult({
+            const result = new result_1.StreamedRunResult({
                 signal: options.signal,
                 state,
             });
@@ -489,10 +513,10 @@ export class Runner extends RunHooks {
         stream: false,
         context: undefined,
     }) {
-        if (input instanceof RunState && input._trace) {
-            return withTrace(input._trace, async () => {
+        if (input instanceof runState_1.RunState && input._trace) {
+            return (0, context_1.withTrace)(input._trace, async () => {
                 if (input._currentAgentSpan) {
-                    setCurrentSpan(input._currentAgentSpan);
+                    (0, context_1.setCurrentSpan)(input._currentAgentSpan);
                 }
                 if (options?.stream) {
                     return this.#runIndividualStream(agent, input, options);
@@ -502,7 +526,7 @@ export class Runner extends RunHooks {
                 }
             });
         }
-        return getOrCreateTrace(async () => {
+        return (0, context_1.getOrCreateTrace)(async () => {
             if (options?.stream) {
                 return this.#runIndividualStream(agent, input, options);
             }
@@ -517,6 +541,7 @@ export class Runner extends RunHooks {
         });
     }
 }
+exports.Runner = Runner;
 let _defaultRunner = undefined;
 function getDefaultRunner() {
     if (_defaultRunner) {
@@ -525,19 +550,19 @@ function getDefaultRunner() {
     _defaultRunner = new Runner();
     return _defaultRunner;
 }
-export function selectModel(agentModel, runConfigModel) {
+function selectModel(agentModel, runConfigModel) {
     // When initializing an agent without model name, the model property is set to an empty string. So,
     // * agentModel === '' & runConfigModel exists, runConfigModel will be used
     // * agentModel is set, the agentModel will be used over runConfigModel
     if ((typeof agentModel === 'string' &&
-        agentModel !== Agent.DEFAULT_MODEL_PLACEHOLDER) ||
+        agentModel !== agent_1.Agent.DEFAULT_MODEL_PLACEHOLDER) ||
         agentModel // any truthy value
     ) {
         return agentModel;
     }
-    return runConfigModel ?? agentModel ?? Agent.DEFAULT_MODEL_PLACEHOLDER;
+    return runConfigModel ?? agentModel ?? agent_1.Agent.DEFAULT_MODEL_PLACEHOLDER;
 }
-export async function run(agent, input, options) {
+async function run(agent, input, options) {
     const runner = getDefaultRunner();
     if (options?.stream) {
         return await runner.run(agent, input, options);
@@ -546,4 +571,29 @@ export async function run(agent, input, options) {
         return await runner.run(agent, input, options);
     }
 }
+/**
+ * When the default model is a GPT-5 variant, agents may carry GPT-5-specific providerData
+ * (e.g., reasoning effort, text verbosity). If a run resolves to a non-GPT-5 model and the
+ * agent relied on the default model (i.e., no explicit model set), these GPT-5-only settings
+ * are incompatible and should be stripped to avoid runtime errors.
+ */
+function adjustModelSettingsForNonGPT5RunnerModel(explictlyModelSet, agentModelSettings, runnerModel, modelSettings) {
+    if (
+    // gpt-5 is enabled for the default model for agents
+    (0, defaultModel_1.isGpt5Default)() &&
+        // explicitly set model for the agent
+        explictlyModelSet &&
+        // this runner uses a non-gpt-5 model
+        (typeof runnerModel !== 'string' ||
+            !(0, defaultModel_1.gpt5ReasoningSettingsRequired)(runnerModel)) &&
+        (agentModelSettings.providerData?.reasoning ||
+            agentModelSettings.providerData?.text?.verbosity ||
+            agentModelSettings.providerData?.reasoning_effort)) {
+        // the incompatible parameters should be removed to avoid runtime errors
+        delete modelSettings.providerData?.reasoning;
+        delete modelSettings.providerData?.text?.verbosity;
+        delete modelSettings.providerData?.reasoning_effort;
+    }
+    return modelSettings;
+}
 //# sourceMappingURL=run.js.map