classOpenAIResponsesModel(Model):""" Implementation of `Model` that uses the OpenAI Responses API. """def__init__(self,model:str|ChatModel,openai_client:AsyncOpenAI,*,model_is_explicit:bool=True,)->None:self.model=modelself._model_is_explicit=model_is_explicitself._client=openai_clientdef_non_null_or_omit(self,value:Any)->Any:returnvalueifvalueisnotNoneelseomitasyncdefget_response(self,system_instructions:str|None,input:str|list[TResponseInputItem],model_settings:ModelSettings,tools:list[Tool],output_schema:AgentOutputSchemaBase|None,handoffs:list[Handoff],tracing:ModelTracing,previous_response_id:str|None=None,conversation_id:str|None=None,prompt:ResponsePromptParam|None=None,)->ModelResponse:withresponse_span(disabled=tracing.is_disabled())asspan_response:try:response=awaitself._fetch_response(system_instructions,input,model_settings,tools,output_schema,handoffs,previous_response_id=previous_response_id,conversation_id=conversation_id,stream=False,prompt=prompt,)if_debug.DONT_LOG_MODEL_DATA:logger.debug("LLM responded")else:logger.debug("LLM resp:\n"f"""{json.dumps([x.model_dump()forxinresponse.output],indent=2,ensure_ascii=False,)}\n""")usage=(Usage(requests=1,input_tokens=response.usage.input_tokens,output_tokens=response.usage.output_tokens,total_tokens=response.usage.total_tokens,input_tokens_details=response.usage.input_tokens_details,output_tokens_details=response.usage.output_tokens_details,)ifresponse.usageelseUsage())iftracing.include_data():span_response.span_data.response=responsespan_response.span_data.input=inputexceptExceptionase:span_response.set_error(SpanError(message="Error getting response",data={"error":str(e)iftracing.include_data()elsee.__class__.__name__,},))request_id=e.request_idifisinstance(e,APIStatusError)elseNonelogger.error(f"Error getting response:{e}. (request_id:{request_id})")raisereturnModelResponse(output=response.output,usage=usage,response_id=response.id,)asyncdefstream_response(self,system_instructions:str|None,input:str|list[TResponseInputItem],model_settings:ModelSettings,tools:list[Tool],output_schema:AgentOutputSchemaBase|None,handoffs:list[Handoff],tracing:ModelTracing,previous_response_id:str|None=None,conversation_id:str|None=None,prompt:ResponsePromptParam|None=None,)->AsyncIterator[ResponseStreamEvent]:""" Yields a partial message as it is generated, as well as the usage information. """withresponse_span(disabled=tracing.is_disabled())asspan_response:try:stream=awaitself._fetch_response(system_instructions,input,model_settings,tools,output_schema,handoffs,previous_response_id=previous_response_id,conversation_id=conversation_id,stream=True,prompt=prompt,)final_response:Response|None=Noneasyncforchunkinstream:ifisinstance(chunk,ResponseCompletedEvent):final_response=chunk.responseyieldchunkiffinal_responseandtracing.include_data():span_response.span_data.response=final_responsespan_response.span_data.input=inputexceptExceptionase:span_response.set_error(SpanError(message="Error streaming response",data={"error":str(e)iftracing.include_data()elsee.__class__.__name__,},))logger.error(f"Error streaming response:{e}")raise@overloadasyncdef_fetch_response(self,system_instructions:str|None,input:str|list[TResponseInputItem],model_settings:ModelSettings,tools:list[Tool],output_schema:AgentOutputSchemaBase|None,handoffs:list[Handoff],previous_response_id:str|None,conversation_id:str|None,stream:Literal[True],prompt:ResponsePromptParam|None=None,)->AsyncStream[ResponseStreamEvent]:...@overloadasyncdef_fetch_response(self,system_instructions:str|None,input:str|list[TResponseInputItem],model_settings:ModelSettings,tools:list[Tool],output_schema:AgentOutputSchemaBase|None,handoffs:list[Handoff],previous_response_id:str|None,conversation_id:str|None,stream:Literal[False],prompt:ResponsePromptParam|None=None,)->Response:...asyncdef_fetch_response(self,system_instructions:str|None,input:str|list[TResponseInputItem],model_settings:ModelSettings,tools:list[Tool],output_schema:AgentOutputSchemaBase|None,handoffs:list[Handoff],previous_response_id:str|None=None,conversation_id:str|None=None,stream:Literal[True]|Literal[False]=False,prompt:ResponsePromptParam|None=None,)->Response|AsyncStream[ResponseStreamEvent]:list_input=ItemHelpers.input_to_new_input_list(input)list_input=_to_dump_compatible(list_input)ifmodel_settings.parallel_tool_callsandtools:parallel_tool_calls:bool|Omit=Trueelifmodel_settings.parallel_tool_callsisFalse:parallel_tool_calls=Falseelse:parallel_tool_calls=omittool_choice=Converter.convert_tool_choice(model_settings.tool_choice)converted_tools=Converter.convert_tools(tools,handoffs)converted_tools_payload=_to_dump_compatible(converted_tools.tools)response_format=Converter.get_response_format(output_schema)should_omit_model=promptisnotNoneandnotself._model_is_explicitmodel_param:str|ChatModel|Omit=self.modelifnotshould_omit_modelelseomitshould_omit_tools=promptisnotNoneandlen(converted_tools_payload)==0tools_param:list[ToolParam]|Omit=(converted_tools_payloadifnotshould_omit_toolselseomit)include_set:set[str]=set(converted_tools.includes)ifmodel_settings.response_includeisnotNone:include_set.update(model_settings.response_include)ifmodel_settings.top_logprobsisnotNone:include_set.add("message.output_text.logprobs")include=cast(list[ResponseIncludable],list(include_set))if_debug.DONT_LOG_MODEL_DATA:logger.debug("Calling LLM")else:input_json=json.dumps(list_input,indent=2,ensure_ascii=False,)tools_json=json.dumps(converted_tools_payload,indent=2,ensure_ascii=False,)logger.debug(f"Calling LLM{self.model} with input:\n"f"{input_json}\n"f"Tools:\n{tools_json}\n"f"Stream:{stream}\n"f"Tool choice:{tool_choice}\n"f"Response format:{response_format}\n"f"Previous response id:{previous_response_id}\n"f"Conversation id:{conversation_id}\n")extra_args=dict(model_settings.extra_argsor{})ifmodel_settings.top_logprobsisnotNone:extra_args["top_logprobs"]=model_settings.top_logprobsifmodel_settings.verbosityisnotNone:ifresponse_formatisnotomit:response_format["verbosity"]=model_settings.verbosity# type: ignore [index]else:response_format={"verbosity":model_settings.verbosity}stream_param:Literal[True]|Omit=Trueifstreamelseomitresponse=awaitself._client.responses.create(previous_response_id=self._non_null_or_omit(previous_response_id),conversation=self._non_null_or_omit(conversation_id),instructions=self._non_null_or_omit(system_instructions),model=model_param,input=list_input,include=include,tools=tools_param,prompt=self._non_null_or_omit(prompt),temperature=self._non_null_or_omit(model_settings.temperature),top_p=self._non_null_or_omit(model_settings.top_p),truncation=self._non_null_or_omit(model_settings.truncation),max_output_tokens=self._non_null_or_omit(model_settings.max_tokens),tool_choice=tool_choice,parallel_tool_calls=parallel_tool_calls,stream=cast(Any,stream_param),extra_headers=self._merge_headers(model_settings),extra_query=model_settings.extra_query,extra_body=model_settings.extra_body,text=response_format,store=self._non_null_or_omit(model_settings.store),prompt_cache_retention=self._non_null_or_omit(model_settings.prompt_cache_retention),reasoning=self._non_null_or_omit(model_settings.reasoning),metadata=self._non_null_or_omit(model_settings.metadata),**extra_args,)returncast(Union[Response,AsyncStream[ResponseStreamEvent]],response)def_get_client(self)->AsyncOpenAI:ifself._clientisNone:self._client=AsyncOpenAI()returnself._clientdef_merge_headers(self,model_settings:ModelSettings):return{**_HEADERS,**(model_settings.extra_headersor{}),**(_HEADERS_OVERRIDE.get()or{}),}