302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524

classRunner:@classmethodasyncdefrun(cls,starting_agent:Agent[TContext],input:str|list[TResponseInputItem],*,context:TContext|None=None,max_turns:int=DEFAULT_MAX_TURNS,hooks:RunHooks[TContext]|None=None,run_config:RunConfig|None=None,previous_response_id:str|None=None,auto_previous_response_id:bool=False,conversation_id:str|None=None,session:Session|None=None,)->RunResult:"""        Run a workflow starting at the given agent.        The agent will run in a loop until a final output is generated. The loop runs like so:          1. The agent is invoked with the given input.          2. If there is a final output (i.e. the agent produces something of type             `agent.output_type`), the loop terminates.          3. If there's a handoff, we run the loop again, with the new agent.          4. Else, we run tool calls (if any), and re-run the loop.        In two cases, the agent may raise an exception:          1. If the max_turns is exceeded, a MaxTurnsExceeded exception is raised.          2. If a guardrail tripwire is triggered, a GuardrailTripwireTriggered             exception is raised.        Note:            Only the first agent's input guardrails are run.        Args:            starting_agent: The starting agent to run.            input: The initial input to the agent. You can pass a single string for a                user message, or a list of input items.            context: The context to run the agent with.            max_turns: The maximum number of turns to run the agent for. A turn is                defined as one AI invocation (including any tool calls that might occur).            hooks: An object that receives callbacks on various lifecycle events.            run_config: Global settings for the entire agent run.            previous_response_id: The ID of the previous response. If using OpenAI                models via the Responses API, this allows you to skip passing in input                from the previous turn.            conversation_id: The conversation ID                (https://platform.openai.com/docs/guides/conversation-state?api-mode=responses).                If provided, the conversation will be used to read and write items.                Every agent will have access to the conversation history so far,                and its output items will be written to the conversation.                We recommend only using this if you are exclusively using OpenAI models;                other model providers don't write to the Conversation object,                so you'll end up having partial conversations stored.            session: A session for automatic conversation history management.        Returns:            A run result containing all the inputs, guardrail results and the output of            the last agent. Agents may perform handoffs, so we don't know the specific            type of the output.        """runner=DEFAULT_AGENT_RUNNERreturnawaitrunner.run(starting_agent,input,context=context,max_turns=max_turns,hooks=hooks,run_config=run_config,previous_response_id=previous_response_id,auto_previous_response_id=auto_previous_response_id,conversation_id=conversation_id,session=session,)@classmethoddefrun_sync(cls,starting_agent:Agent[TContext],input:str|list[TResponseInputItem],*,context:TContext|None=None,max_turns:int=DEFAULT_MAX_TURNS,hooks:RunHooks[TContext]|None=None,run_config:RunConfig|None=None,previous_response_id:str|None=None,auto_previous_response_id:bool=False,conversation_id:str|None=None,session:Session|None=None,)->RunResult:"""        Run a workflow synchronously, starting at the given agent.        Note:            This just wraps the `run` method, so it will not work if there's already an            event loop (e.g. inside an async function, or in a Jupyter notebook or async            context like FastAPI). For those cases, use the `run` method instead.        The agent will run in a loop until a final output is generated. The loop runs:          1. The agent is invoked with the given input.          2. If there is a final output (i.e. the agent produces something of type             `agent.output_type`), the loop terminates.          3. If there's a handoff, we run the loop again, with the new agent.          4. Else, we run tool calls (if any), and re-run the loop.        In two cases, the agent may raise an exception:          1. If the max_turns is exceeded, a MaxTurnsExceeded exception is raised.          2. If a guardrail tripwire is triggered, a GuardrailTripwireTriggered             exception is raised.        Note:            Only the first agent's input guardrails are run.        Args:            starting_agent: The starting agent to run.            input: The initial input to the agent. You can pass a single string for a                user message, or a list of input items.            context: The context to run the agent with.            max_turns: The maximum number of turns to run the agent for. A turn is                defined as one AI invocation (including any tool calls that might occur).            hooks: An object that receives callbacks on various lifecycle events.            run_config: Global settings for the entire agent run.            previous_response_id: The ID of the previous response, if using OpenAI                models via the Responses API, this allows you to skip passing in input                from the previous turn.            conversation_id: The ID of the stored conversation, if any.            session: A session for automatic conversation history management.        Returns:            A run result containing all the inputs, guardrail results and the output of            the last agent. Agents may perform handoffs, so we don't know the specific            type of the output.        """runner=DEFAULT_AGENT_RUNNERreturnrunner.run_sync(starting_agent,input,context=context,max_turns=max_turns,hooks=hooks,run_config=run_config,previous_response_id=previous_response_id,conversation_id=conversation_id,session=session,auto_previous_response_id=auto_previous_response_id,)@classmethoddefrun_streamed(cls,starting_agent:Agent[TContext],input:str|list[TResponseInputItem],context:TContext|None=None,max_turns:int=DEFAULT_MAX_TURNS,hooks:RunHooks[TContext]|None=None,run_config:RunConfig|None=None,previous_response_id:str|None=None,auto_previous_response_id:bool=False,conversation_id:str|None=None,session:Session|None=None,)->RunResultStreaming:"""        Run a workflow starting at the given agent in streaming mode.        The returned result object contains a method you can use to stream semantic        events as they are generated.        The agent will run in a loop until a final output is generated. The loop runs like so:          1. The agent is invoked with the given input.          2. If there is a final output (i.e. the agent produces something of type             `agent.output_type`), the loop terminates.          3. If there's a handoff, we run the loop again, with the new agent.          4. Else, we run tool calls (if any), and re-run the loop.        In two cases, the agent may raise an exception:          1. If the max_turns is exceeded, a MaxTurnsExceeded exception is raised.          2. If a guardrail tripwire is triggered, a GuardrailTripwireTriggered             exception is raised.        Note:            Only the first agent's input guardrails are run.        Args:            starting_agent: The starting agent to run.            input: The initial input to the agent. You can pass a single string for a                user message, or a list of input items.            context: The context to run the agent with.            max_turns: The maximum number of turns to run the agent for. A turn is                defined as one AI invocation (including any tool calls that might occur).            hooks: An object that receives callbacks on various lifecycle events.            run_config: Global settings for the entire agent run.            previous_response_id: The ID of the previous response, if using OpenAI                models via the Responses API, this allows you to skip passing in input                from the previous turn.            conversation_id: The ID of the stored conversation, if any.            session: A session for automatic conversation history management.        Returns:            A result object that contains data about the run, as well as a method to            stream events.        """runner=DEFAULT_AGENT_RUNNERreturnrunner.run_streamed(starting_agent,input,context=context,max_turns=max_turns,hooks=hooks,run_config=run_config,previous_response_id=previous_response_id,auto_previous_response_id=auto_previous_response_id,conversation_id=conversation_id,session=session,)

183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271

@dataclassclassRunConfig:"""Configures settings for the entire agent run."""model:str|Model|None=None"""The model to use for the entire agent run. If set, will override the model set on every    agent. The model_provider passed in below must be able to resolve this model name.    """model_provider:ModelProvider=field(default_factory=MultiProvider)"""The model provider to use when looking up string model names. Defaults to OpenAI."""model_settings:ModelSettings|None=None"""Configure global model settings. Any non-null values will override the agent-specific model    settings.    """handoff_input_filter:HandoffInputFilter|None=None"""A global input filter to apply to all handoffs. If `Handoff.input_filter` is set, then that    will take precedence. The input filter allows you to edit the inputs that are sent to the new    agent. See the documentation in `Handoff.input_filter` for more details.    """nest_handoff_history:bool=True"""Wrap prior run history in a single assistant message before handing off when no custom    input filter is set. Set to False to preserve the raw transcript behavior from previous    releases.    """handoff_history_mapper:HandoffHistoryMapper|None=None"""Optional function that receives the normalized transcript (history + handoff items) and    returns the input history that should be passed to the next agent. When left as `None`, the    runner collapses the transcript into a single assistant message. This function only runs when    `nest_handoff_history` is True.    """input_guardrails:list[InputGuardrail[Any]]|None=None"""A list of input guardrails to run on the initial run input."""output_guardrails:list[OutputGuardrail[Any]]|None=None"""A list of output guardrails to run on the final output of the run."""tracing_disabled:bool=False"""Whether tracing is disabled for the agent run. If disabled, we will not trace the agent run.    """trace_include_sensitive_data:bool=field(default_factory=_default_trace_include_sensitive_data)"""Whether we include potentially sensitive data (for example: inputs/outputs of tool calls or    LLM generations) in traces. If False, we'll still create spans for these events, but the    sensitive data will not be included.    """workflow_name:str="Agent workflow""""The name of the run, used for tracing. Should be a logical name for the run, like    "Code generation workflow" or "Customer support agent".    """trace_id:str|None=None"""A custom trace ID to use for tracing. If not provided, we will generate a new trace ID."""group_id:str|None=None"""    A grouping identifier to use for tracing, to link multiple traces from the same conversation    or process. For example, you might use a chat thread ID.    """trace_metadata:dict[str,Any]|None=None"""    An optional dictionary of additional metadata to include with the trace.    """session_input_callback:SessionInputCallback|None=None"""Defines how to handle session history when new input is provided.    - `None` (default): The new input is appended to the session history.    - `SessionInputCallback`: A custom function that receives the history and new input, and      returns the desired combined list of items.    """call_model_input_filter:CallModelInputFilter|None=None"""    Optional callback that is invoked immediately before calling the model. It receives the current    agent, context and the model input (instructions and input items), and must return a possibly    modified `ModelInputData` to use for the model call.    This allows you to edit the input sent to the model e.g. to stay within a token limit.    For example, you can use this to add a system prompt to the input.    """