langchain 0.3.26__py3-none-any.whl → 0.3.27__py3-none-any.whl

langchain/agents/openai_assistant/base.py

@@ -20,7 +20,7 @@ from langchain_core.runnables import RunnableConfig, RunnableSerializable, ensur
 from langchain_core.tools import BaseTool
 from langchain_core.utils.function_calling import convert_to_openai_tool
 from pydantic import BaseModel, Field, model_validator
-from typing_extensions import Self
+from typing_extensions import Self, override
 
 if TYPE_CHECKING:
     import openai
@@ -80,14 +80,14 @@ def _get_openai_client() -> openai.OpenAI:
 
         return openai.OpenAI()
     except ImportError as e:
-        raise ImportError(
-            "Unable to import openai, please install with `pip install openai`."
-        ) from e
+        msg = "Unable to import openai, please install with `pip install openai`."
+        raise ImportError(msg) from e
     except AttributeError as e:
-        raise AttributeError(
+        msg = (
             "Please make sure you are using a v1.1-compatible version of openai. You "
             'can install with `pip install "openai>=1.1"`.'
-        ) from e
+        )
+        raise AttributeError(msg) from e
 
 
 def _get_openai_async_client() -> openai.AsyncOpenAI:
@@ -96,14 +96,14 @@ def _get_openai_async_client() -> openai.AsyncOpenAI:
 
         return openai.AsyncOpenAI()
     except ImportError as e:
-        raise ImportError(
-            "Unable to import openai, please install with `pip install openai`."
-        ) from e
+        msg = "Unable to import openai, please install with `pip install openai`."
+        raise ImportError(msg) from e
     except AttributeError as e:
-        raise AttributeError(
+        msg = (
             "Please make sure you are using a v1.1-compatible version of openai. You "
             'can install with `pip install "openai>=1.1"`.'
-        ) from e
+        )
+        raise AttributeError(msg) from e
 
 
 def _is_assistants_builtin_tool(
@@ -128,8 +128,7 @@ def _get_assistants_tool(
     """
     if _is_assistants_builtin_tool(tool):
         return tool  # type: ignore[return-value]
-    else:
-        return convert_to_openai_tool(tool)
+    return convert_to_openai_tool(tool)
 
 
 OutputType = Union[
@@ -272,8 +271,12 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
         )
         return cls(assistant_id=assistant.id, client=client, **kwargs)
 
+    @override
     def invoke(
-        self, input: dict, config: Optional[RunnableConfig] = None, **kwargs: Any
+        self,
+        input: dict,
+        config: Optional[RunnableConfig] = None,
+        **kwargs: Any,
     ) -> OutputType:
         """Invoke assistant.
 
@@ -314,13 +317,15 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
             inheritable_metadata=config.get("metadata"),
         )
         run_manager = callback_manager.on_chain_start(
-            dumpd(self), input, name=config.get("run_name") or self.get_name()
+            dumpd(self),
+            input,
+            name=config.get("run_name") or self.get_name(),
         )
         try:
             # Being run within AgentExecutor and there are tool outputs to submit.
             if self.as_agent and input.get("intermediate_steps"):
                 tool_outputs = self._parse_intermediate_steps(
-                    input["intermediate_steps"]
+                    input["intermediate_steps"],
                 )
                 run = self.client.beta.threads.runs.submit_tool_outputs(**tool_outputs)
             # Starting a new thread and a new run.
@@ -332,7 +337,7 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
                             "content": input["content"],
                             "metadata": input.get("message_metadata"),
                             "attachments": input.get("attachments"),
-                        }
+                        },
                     ],
                     "metadata": input.get("thread_metadata"),
                 }
@@ -353,12 +358,12 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
             run = self._wait_for_run(run.id, run.thread_id)
         except BaseException as e:
             run_manager.on_chain_error(e)
-            raise e
+            raise
         try:
             response = self._get_response(run)
         except BaseException as e:
             run_manager.on_chain_error(e, metadata=run.dict())
-            raise e
+            raise
         else:
             run_manager.on_chain_end(response)
             return response
@@ -399,8 +404,12 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
         )
         return cls(assistant_id=assistant.id, async_client=async_client, **kwargs)
 
+    @override
     async def ainvoke(
-        self, input: dict, config: Optional[RunnableConfig] = None, **kwargs: Any
+        self,
+        input: dict,
+        config: Optional[RunnableConfig] = None,
+        **kwargs: Any,
     ) -> OutputType:
         """Async invoke assistant.
 
@@ -441,16 +450,18 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
             inheritable_metadata=config.get("metadata"),
         )
         run_manager = callback_manager.on_chain_start(
-            dumpd(self), input, name=config.get("run_name") or self.get_name()
+            dumpd(self),
+            input,
+            name=config.get("run_name") or self.get_name(),
         )
         try:
             # Being run within AgentExecutor and there are tool outputs to submit.
             if self.as_agent and input.get("intermediate_steps"):
                 tool_outputs = await self._aparse_intermediate_steps(
-                    input["intermediate_steps"]
+                    input["intermediate_steps"],
                 )
                 run = await self.async_client.beta.threads.runs.submit_tool_outputs(
-                    **tool_outputs
+                    **tool_outputs,
                 )
             # Starting a new thread and a new run.
             elif "thread_id" not in input:
@@ -460,7 +471,7 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
                             "role": "user",
                             "content": input["content"],
                             "metadata": input.get("message_metadata"),
-                        }
+                        },
                     ],
                     "metadata": input.get("thread_metadata"),
                 }
@@ -478,23 +489,24 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
             # framework.
             else:
                 run = await self.async_client.beta.threads.runs.submit_tool_outputs(
-                    **input
+                    **input,
                 )
             run = await self._await_for_run(run.id, run.thread_id)
         except BaseException as e:
             run_manager.on_chain_error(e)
-            raise e
+            raise
         try:
             response = self._get_response(run)
         except BaseException as e:
             run_manager.on_chain_error(e, metadata=run.dict())
-            raise e
+            raise
         else:
             run_manager.on_chain_end(response)
             return response
 
     def _parse_intermediate_steps(
-        self, intermediate_steps: list[tuple[OpenAIAssistantAction, str]]
+        self,
+        intermediate_steps: list[tuple[OpenAIAssistantAction, str]],
     ) -> dict:
         last_action, last_output = intermediate_steps[-1]
         run = self._wait_for_run(last_action.run_id, last_action.thread_id)
@@ -508,17 +520,16 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
             for action, output in intermediate_steps
             if action.tool_call_id in required_tool_call_ids
         ]
-        submit_tool_outputs = {
+        return {
             "tool_outputs": tool_outputs,
             "run_id": last_action.run_id,
             "thread_id": last_action.thread_id,
         }
-        return submit_tool_outputs
 
-    def _create_run(self, input: dict) -> Any:
+    def _create_run(self, input_dict: dict) -> Any:
         params = {
             k: v
-            for k, v in input.items()
+            for k, v in input_dict.items()
             if k
             in (
                 "instructions",
@@ -534,15 +545,15 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
             )
         }
         return self.client.beta.threads.runs.create(
-            input["thread_id"],
+            input_dict["thread_id"],
             assistant_id=self.assistant_id,
             **params,
         )
 
-    def _create_thread_and_run(self, input: dict, thread: dict) -> Any:
+    def _create_thread_and_run(self, input_dict: dict, thread: dict) -> Any:
         params = {
             k: v
-            for k, v in input.items()
+            for k, v in input_dict.items()
             if k
             in (
                 "instructions",
@@ -556,12 +567,11 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
                 "run_metadata",
             )
         }
-        run = self.client.beta.threads.create_and_run(
+        return self.client.beta.threads.create_and_run(
             assistant_id=self.assistant_id,
             thread=thread,
             **params,
         )
-        return run
 
     def _get_response(self, run: Any) -> Any:
         # TODO: Pagination
@@ -572,11 +582,12 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
             major_version = int(openai.version.VERSION.split(".")[0])
             minor_version = int(openai.version.VERSION.split(".")[1])
             version_gte_1_14 = (major_version > 1) or (
-                major_version == 1 and minor_version >= 14
+                major_version == 1 and minor_version >= 14  # noqa: PLR2004
             )
 
             messages = self.client.beta.threads.messages.list(
-                run.thread_id, order="asc"
+                run.thread_id,
+                order="asc",
             )
             new_messages = [msg for msg in messages if msg.run_id == run.id]
             if not self.as_agent:
@@ -610,7 +621,7 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
                 run_id=run.id,
                 thread_id=run.thread_id,
             )
-        elif run.status == "requires_action":
+        if run.status == "requires_action":
             if not self.as_agent:
                 return run.required_action.submit_tool_outputs.tool_calls
             actions = []
@@ -619,10 +630,11 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
                 try:
                     args = json.loads(function.arguments, strict=False)
                 except JSONDecodeError as e:
-                    raise ValueError(
+                    msg = (
                         f"Received invalid JSON function arguments: "
                         f"{function.arguments} for function {function.name}"
-                    ) from e
+                    )
+                    raise ValueError(msg) from e
                 if len(args) == 1 and "__arg1" in args:
                     args = args["__arg1"]
                 actions.append(
@@ -633,14 +645,12 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
                         log="",
                         run_id=run.id,
                         thread_id=run.thread_id,
-                    )
+                    ),
                 )
             return actions
-        else:
-            run_info = json.dumps(run.dict(), indent=2)
-            raise ValueError(
-                f"Unexpected run status: {run.status}. Full run info:\n\n{run_info})"
-            )
+        run_info = json.dumps(run.dict(), indent=2)
+        msg = f"Unexpected run status: {run.status}. Full run info:\n\n{run_info}"
+        raise ValueError(msg)
 
     def _wait_for_run(self, run_id: str, thread_id: str) -> Any:
         in_progress = True
@@ -652,7 +662,8 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
         return run
 
     async def _aparse_intermediate_steps(
-        self, intermediate_steps: list[tuple[OpenAIAssistantAction, str]]
+        self,
+        intermediate_steps: list[tuple[OpenAIAssistantAction, str]],
     ) -> dict:
         last_action, last_output = intermediate_steps[-1]
         run = self._wait_for_run(last_action.run_id, last_action.thread_id)
@@ -666,17 +677,16 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
             for action, output in intermediate_steps
             if action.tool_call_id in required_tool_call_ids
         ]
-        submit_tool_outputs = {
+        return {
             "tool_outputs": tool_outputs,
             "run_id": last_action.run_id,
             "thread_id": last_action.thread_id,
         }
-        return submit_tool_outputs
 
-    async def _acreate_run(self, input: dict) -> Any:
+    async def _acreate_run(self, input_dict: dict) -> Any:
         params = {
             k: v
-            for k, v in input.items()
+            for k, v in input_dict.items()
             if k
             in (
                 "instructions",
@@ -692,15 +702,15 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
             )
         }
         return await self.async_client.beta.threads.runs.create(
-            input["thread_id"],
+            input_dict["thread_id"],
             assistant_id=self.assistant_id,
             **params,
         )
 
-    async def _acreate_thread_and_run(self, input: dict, thread: dict) -> Any:
+    async def _acreate_thread_and_run(self, input_dict: dict, thread: dict) -> Any:
         params = {
             k: v
-            for k, v in input.items()
+            for k, v in input_dict.items()
             if k
             in (
                 "instructions",
@@ -714,12 +724,11 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
                 "run_metadata",
             )
         }
-        run = await self.async_client.beta.threads.create_and_run(
+        return await self.async_client.beta.threads.create_and_run(
             assistant_id=self.assistant_id,
             thread=thread,
             **params,
         )
-        return run
 
     async def _aget_response(self, run: Any) -> Any:
         # TODO: Pagination
@@ -730,11 +739,12 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
             major_version = int(openai.version.VERSION.split(".")[0])
             minor_version = int(openai.version.VERSION.split(".")[1])
             version_gte_1_14 = (major_version > 1) or (
-                major_version == 1 and minor_version >= 14
+                major_version == 1 and minor_version >= 14  # noqa: PLR2004
             )
 
             messages = await self.async_client.beta.threads.messages.list(
-                run.thread_id, order="asc"
+                run.thread_id,
+                order="asc",
             )
             new_messages = [msg for msg in messages if msg.run_id == run.id]
             if not self.as_agent:
@@ -764,7 +774,7 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
                 run_id=run.id,
                 thread_id=run.thread_id,
             )
-        elif run.status == "requires_action":
+        if run.status == "requires_action":
             if not self.as_agent:
                 return run.required_action.submit_tool_outputs.tool_calls
             actions = []
@@ -773,10 +783,11 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
                 try:
                     args = json.loads(function.arguments, strict=False)
                 except JSONDecodeError as e:
-                    raise ValueError(
+                    msg = (
                         f"Received invalid JSON function arguments: "
                         f"{function.arguments} for function {function.name}"
-                    ) from e
+                    )
+                    raise ValueError(msg) from e
                 if len(args) == 1 and "__arg1" in args:
                     args = args["__arg1"]
                 actions.append(
@@ -787,20 +798,19 @@ class OpenAIAssistantRunnable(RunnableSerializable[dict, OutputType]):
                         log="",
                         run_id=run.id,
                         thread_id=run.thread_id,
-                    )
+                    ),
                 )
             return actions
-        else:
-            run_info = json.dumps(run.dict(), indent=2)
-            raise ValueError(
-                f"Unexpected run status: {run.status}. Full run info:\n\n{run_info})"
-            )
+        run_info = json.dumps(run.dict(), indent=2)
+        msg = f"Unexpected run status: {run.status}. Full run info:\n\n{run_info}"
+        raise ValueError(msg)
 
     async def _await_for_run(self, run_id: str, thread_id: str) -> Any:
         in_progress = True
         while in_progress:
             run = await self.async_client.beta.threads.runs.retrieve(
-                run_id, thread_id=thread_id
+                run_id,
+                thread_id=thread_id,
             )
             in_progress = run.status in ("in_progress", "queued")
             if in_progress:

langchain/agents/openai_functions_agent/base.py

@@ -32,6 +32,8 @@ from langchain.agents.output_parsers.openai_functions import (
     OpenAIFunctionsAgentOutputParser,
 )
 
+_NOT_SET = object()
+
 
 @deprecated("0.1.0", alternative="create_openai_functions_agent", removal="1.0")
 class OpenAIFunctionsAgent(BaseSingleActionAgent):
@@ -75,10 +77,11 @@ class OpenAIFunctionsAgent(BaseSingleActionAgent):
         """
         prompt: BasePromptTemplate = self.prompt
         if "agent_scratchpad" not in prompt.input_variables:
-            raise ValueError(
+            msg = (
                 "`agent_scratchpad` should be one of the variables in the prompt, "
                 f"got {prompt.input_variables}"
             )
+            raise ValueError(msg)
         return self
 
     @property
@@ -96,7 +99,7 @@ class OpenAIFunctionsAgent(BaseSingleActionAgent):
         self,
         intermediate_steps: list[tuple[AgentAction, str]],
         callbacks: Callbacks = None,
-        with_functions: bool = True,
+        with_functions: bool = True,  # noqa: FBT001,FBT002
         **kwargs: Any,
     ) -> Union[AgentAction, AgentFinish]:
         """Given input, decided what to do.
@@ -131,8 +134,7 @@ class OpenAIFunctionsAgent(BaseSingleActionAgent):
                 messages,
                 callbacks=callbacks,
             )
-        agent_decision = self.output_parser._parse_ai_message(predicted_message)
-        return agent_decision
+        return self.output_parser._parse_ai_message(predicted_message)
 
     async def aplan(
         self,
@@ -161,10 +163,11 @@ class OpenAIFunctionsAgent(BaseSingleActionAgent):
         prompt = self.prompt.format_prompt(**full_inputs)
         messages = prompt.to_messages()
         predicted_message = await self.llm.apredict_messages(
-            messages, functions=self.functions, callbacks=callbacks
+            messages,
+            functions=self.functions,
+            callbacks=callbacks,
         )
-        agent_decision = self.output_parser._parse_ai_message(predicted_message)
-        return agent_decision
+        return self.output_parser._parse_ai_message(predicted_message)
 
     def return_stopped_response(
         self,
@@ -189,31 +192,30 @@ class OpenAIFunctionsAgent(BaseSingleActionAgent):
         if early_stopping_method == "force":
             # `force` just returns a constant string
             return AgentFinish(
-                {"output": "Agent stopped due to iteration limit or time limit."}, ""
+                {"output": "Agent stopped due to iteration limit or time limit."},
+                "",
             )
-        elif early_stopping_method == "generate":
+        if early_stopping_method == "generate":
             # Generate does one final forward pass
             agent_decision = self.plan(
-                intermediate_steps, with_functions=False, **kwargs
+                intermediate_steps,
+                with_functions=False,
+                **kwargs,
             )
             if isinstance(agent_decision, AgentFinish):
                 return agent_decision
-            else:
-                raise ValueError(
-                    f"got AgentAction with no functions provided: {agent_decision}"
-                )
-        else:
-            raise ValueError(
-                "early_stopping_method should be one of `force` or `generate`, "
-                f"got {early_stopping_method}"
-            )
+            msg = f"got AgentAction with no functions provided: {agent_decision}"
+            raise ValueError(msg)
+        msg = (
+            "early_stopping_method should be one of `force` or `generate`, "
+            f"got {early_stopping_method}"
+        )
+        raise ValueError(msg)
 
     @classmethod
     def create_prompt(
         cls,
-        system_message: Optional[SystemMessage] = SystemMessage(
-            content="You are a helpful AI assistant."
-        ),
+        system_message: Optional[SystemMessage] = _NOT_SET,  # type: ignore[assignment]
         extra_prompt_messages: Optional[list[BaseMessagePromptTemplate]] = None,
     ) -> ChatPromptTemplate:
         """Create prompt for this agent.
@@ -228,18 +230,20 @@ class OpenAIFunctionsAgent(BaseSingleActionAgent):
             A prompt template to pass into this agent.
         """
         _prompts = extra_prompt_messages or []
+        system_message_ = (
+            system_message
+            if system_message is not _NOT_SET
+            else SystemMessage(content="You are a helpful AI assistant.")
+        )
         messages: list[Union[BaseMessagePromptTemplate, BaseMessage]]
-        if system_message:
-            messages = [system_message]
-        else:
-            messages = []
+        messages = [system_message_] if system_message_ else []
 
         messages.extend(
             [
                 *_prompts,
                 HumanMessagePromptTemplate.from_template("{input}"),
                 MessagesPlaceholder(variable_name="agent_scratchpad"),
-            ]
+            ],
         )
         return ChatPromptTemplate(messages=messages)
 
@@ -250,9 +254,7 @@ class OpenAIFunctionsAgent(BaseSingleActionAgent):
         tools: Sequence[BaseTool],
         callback_manager: Optional[BaseCallbackManager] = None,
         extra_prompt_messages: Optional[list[BaseMessagePromptTemplate]] = None,
-        system_message: Optional[SystemMessage] = SystemMessage(
-            content="You are a helpful AI assistant."
-        ),
+        system_message: Optional[SystemMessage] = _NOT_SET,  # type: ignore[assignment]
         **kwargs: Any,
     ) -> BaseSingleActionAgent:
         """Construct an agent from an LLM and tools.
@@ -266,9 +268,14 @@ class OpenAIFunctionsAgent(BaseSingleActionAgent):
                 Defaults to a default system message.
             kwargs: Additional parameters to pass to the agent.
         """
+        system_message_ = (
+            system_message
+            if system_message is not _NOT_SET
+            else SystemMessage(content="You are a helpful AI assistant.")
+        )
         prompt = cls.create_prompt(
             extra_prompt_messages=extra_prompt_messages,
-            system_message=system_message,
+            system_message=system_message_,
         )
         return cls(  # type: ignore[call-arg]
             llm=llm,
@@ -280,7 +287,9 @@ class OpenAIFunctionsAgent(BaseSingleActionAgent):
 
 
 def create_openai_functions_agent(
-    llm: BaseLanguageModel, tools: Sequence[BaseTool], prompt: ChatPromptTemplate
+    llm: BaseLanguageModel,
+    tools: Sequence[BaseTool],
+    prompt: ChatPromptTemplate,
 ) -> Runnable:
     """Create an agent that uses OpenAI function calling.
 
@@ -354,19 +363,19 @@ def create_openai_functions_agent(
     if "agent_scratchpad" not in (
         prompt.input_variables + list(prompt.partial_variables)
     ):
-        raise ValueError(
+        msg = (
             "Prompt must have input variable `agent_scratchpad`, but wasn't found. "
             f"Found {prompt.input_variables} instead."
         )
+        raise ValueError(msg)
     llm_with_tools = llm.bind(functions=[convert_to_openai_function(t) for t in tools])
-    agent = (
+    return (
         RunnablePassthrough.assign(
             agent_scratchpad=lambda x: format_to_openai_function_messages(
-                x["intermediate_steps"]
-            )
+                x["intermediate_steps"],
+            ),
         )
         | prompt
         | llm_with_tools
         | OpenAIFunctionsAgentOutputParser()
     )
-    return agent