bisheng-langchain 1.0.1__py3-none-any.whl → 1.2.0.dev1__py3-none-any.whl

bisheng_langchain/agents/chatglm_functions_agent/base.py

@@ -2,6 +2,8 @@ import json
 import re
 from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
 
+from pydantic import model_validator, Field
+
 from bisheng_langchain.chat_models.host_llm import HostChatGLM
 from langchain.agents.agent import Agent, AgentOutputParser, BaseSingleActionAgent
 from langchain.agents.structured_chat.output_parser import StructuredChatOutputParserWithRetries
@@ -14,7 +16,6 @@ from langchain.schema import AgentAction, AgentFinish, BasePromptTemplate
 from langchain.schema.language_model import BaseLanguageModel
 from langchain.schema.messages import ChatMessage
 from langchain.tools import BaseTool, StructuredTool
-from langchain_core.pydantic_v1 import Field, root_validator
 
 HUMAN_MESSAGE_TEMPLATE = '{input}\n\n{agent_scratchpad}'
 
@@ -81,13 +82,15 @@ class ChatglmFunctionsAgent(BaseSingleActionAgent):
         """Get allowed tools."""
         return list([t.name for t in self.tools])
 
-    @root_validator
+    @model_validator(mode='before')
+    @classmethod
     def validate_llm(cls, values: dict) -> dict:
         if not isinstance(values['llm'], HostChatGLM):
             raise ValueError('Only supported with ChatGLM3 models.')
         return values
 
-    @root_validator
+    @model_validator(mode='before')
+    @classmethod
     def validate_prompt(cls, values: dict) -> dict:
         prompt: BasePromptTemplate = values['prompt']
         if 'agent_scratchpad' not in prompt.input_variables:

bisheng_langchain/agents/llm_functions_agent/base.py

@@ -3,6 +3,8 @@ import json
 from json import JSONDecodeError
 from typing import Any, List, Optional, Sequence, Tuple, Union
 
+from pydantic import model_validator
+
 from bisheng_langchain.chat_models.host_llm import HostQwenChat
 from bisheng_langchain.chat_models.proxy_llm import ProxyChatLLM
 from langchain.agents import BaseSingleActionAgent
@@ -16,7 +18,6 @@ from langchain.schema.messages import AIMessage, BaseMessage, FunctionMessage, S
 from langchain.tools import BaseTool
 from langchain.tools.convert_to_openai import format_tool_to_openai_function
 from langchain_core.agents import AgentActionMessageLog
-from langchain_core.pydantic_v1 import root_validator
 from langchain_openai import ChatOpenAI
 
 
@@ -135,7 +136,8 @@ class LLMFunctionsAgent(BaseSingleActionAgent):
         """Get allowed tools."""
         return list([t.name for t in self.tools])
 
-    @root_validator
+    @model_validator(mode='before')
+    @classmethod
     def validate_llm(cls, values: dict) -> dict:
         if ((not isinstance(values['llm'], ChatOpenAI))
                 and (not isinstance(values['llm'], HostQwenChat))
@@ -144,7 +146,8 @@ class LLMFunctionsAgent(BaseSingleActionAgent):
                 'Only supported with ChatOpenAI and HostQwenChat and ProxyChatLLM models.')
         return values
 
-    @root_validator
+    @model_validator(mode='before')
+    @classmethod
     def validate_prompt(cls, values: dict) -> dict:
         prompt: BasePromptTemplate = values['prompt']
         if 'agent_scratchpad' not in prompt.input_variables:

bisheng_langchain/chains/qa_generation/base.py

@@ -9,7 +9,7 @@ from typing import Any, Dict, List, Optional
 from langchain_core.callbacks import CallbackManagerForChainRun
 from langchain_core.language_models import BaseLanguageModel
 from langchain_core.prompts import BasePromptTemplate, ChatPromptTemplate
-from langchain_core.pydantic_v1 import Field
+from pydantic import Field
 from langchain_text_splitters import RecursiveCharacterTextSplitter, TextSplitter
 
 from langchain.chains.base import Chain

bisheng_langchain/chains/transform.py

@@ -6,7 +6,7 @@ from typing import Any, Awaitable, Callable, Dict, List, Optional
 
 from langchain.chains.base import Chain
 from langchain_core.callbacks import AsyncCallbackManagerForChainRun, CallbackManagerForChainRun
-from langchain_core.pydantic_v1 import Field
+from pydantic import Field
 
 logger = logging.getLogger(__name__)
 

bisheng_langchain/chat_models/host_llm.py

@@ -7,6 +7,8 @@ import sys
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Mapping, Optional, Tuple, Union
 
 import requests
+from pydantic import ConfigDict, model_validator, Field
+
 from bisheng_langchain.utils.requests import Requests
 from langchain.callbacks.manager import AsyncCallbackManagerForLLMRun, CallbackManagerForLLMRun
 from langchain.chat_models.base import BaseChatModel
@@ -15,7 +17,6 @@ from langchain.schema.messages import (AIMessage, BaseMessage, ChatMessage, Func
                                        HumanMessage, SystemMessage)
 from langchain.utils import get_from_dict_or_env
 from langchain_core.language_models.llms import create_base_retry_decorator
-from langchain_core.pydantic_v1 import Field, root_validator
 
 # from requests.exceptions import HTTPError
 
@@ -112,6 +113,7 @@ class BaseHostChatLLM(BaseChatModel):
     model_kwargs: Optional[Dict[str, Any]] = Field(default_factory=dict)
     """Holds any model parameters valid for `create` call not explicitly specified."""
     host_base_url: Optional[str] = None
+    is_ssl: Optional[bool] = False
 
     headers: Optional[Dict[str, str]] = Field(default_factory=dict)
 
@@ -137,13 +139,10 @@ class BaseHostChatLLM(BaseChatModel):
     verbose: Optional[bool] = False
 
     decoupled: Optional[bool] = False
+    model_config = ConfigDict(validate_by_name=True)
 
-    class Config:
-        """Configuration for this pydantic object."""
-
-        allow_population_by_field_name = True
-
-    @root_validator()
+    @model_validator(mode='before')
+    @classmethod
     def validate_environment(cls, values: Dict) -> Dict:
         """Validate that api key and python package exists in environment."""
         values['host_base_url'] = get_from_dict_or_env(values, 'host_base_url', 'HostBaseUrl')
@@ -170,7 +169,13 @@ class BaseHostChatLLM(BaseChatModel):
                 headers = values['headers']
             else:
                 headers = {'Content-Type': 'application/json'}
-            values['client'] = Requests(headers=headers, request_timeout=values['request_timeout'])
+            if cls.is_ssl and "https" in values['host_base_url']:
+                import aiohttp
+                values['client'] = Requests(headers=headers,
+                                            aiosession=aiohttp.ClientSession(connector=aiohttp.TCPConnector(ssl=False)),
+                                            request_timeout=values['request_timeout'])
+            else:
+                values['client'] = Requests(headers=headers, request_timeout=values['request_timeout'])
         except AttributeError:
             raise ValueError('Try upgrading it with `pip install --upgrade requests`.')
         return values

bisheng_langchain/chat_models/minimax.py

@@ -12,7 +12,7 @@ from langchain.schema import ChatGeneration, ChatResult
 from langchain.schema.messages import (AIMessage, BaseMessage, ChatMessage, FunctionMessage,
                                        HumanMessage, SystemMessage)
 from langchain.utils import get_from_dict_or_env
-from langchain_core.pydantic_v1 import Field, root_validator
+from pydantic import ConfigDict, model_validator, Field
 from tenacity import (before_sleep_log, retry, retry_if_exception_type, stop_after_attempt,
                       wait_exponential)
 
@@ -141,13 +141,10 @@ class ChatMinimaxAI(BaseChatModel):
     when tiktoken is called, you can specify a model name to use here."""
 
     verbose: Optional[bool] = False
+    model_config = ConfigDict(validate_by_name=True)
 
-    class Config:
-        """Configuration for this pydantic object."""
-
-        allow_population_by_field_name = True
-
-    @root_validator()
+    @model_validator(mode='before')
+    @classmethod
     def validate_environment(cls, values: Dict) -> Dict:
         """Validate that api key and python package exists in environment."""
         values['minimaxai_api_key'] = get_from_dict_or_env(values, 'minimaxai_api_key',

bisheng_langchain/chat_models/proxy_llm.py

@@ -6,6 +6,8 @@ import logging
 import sys
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Mapping, Optional, Tuple, Union
 
+from pydantic import ConfigDict, model_validator, Field
+
 from bisheng_langchain.utils import requests
 from langchain.callbacks.manager import AsyncCallbackManagerForLLMRun, CallbackManagerForLLMRun
 from langchain.chat_models.base import BaseChatModel
@@ -13,7 +15,6 @@ from langchain.schema import ChatGeneration, ChatResult
 from langchain.schema.messages import (AIMessage, BaseMessage, ChatMessage, FunctionMessage,
                                        HumanMessage, SystemMessage)
 from langchain.utils import get_from_dict_or_env
-from langchain_core.pydantic_v1 import Field, root_validator
 from tenacity import (before_sleep_log, retry, retry_if_exception_type, stop_after_attempt,
                       wait_exponential)
 
@@ -137,13 +138,10 @@ class ProxyChatLLM(BaseChatModel):
     when using one of the many model providers that expose an OpenAI-like
     API but with different models. In those cases, in order to avoid erroring
     when tiktoken is called, you can specify a model name to use here."""
+    model_config = ConfigDict(validate_by_name=True)
 
-    class Config:
-        """Configuration for this pydantic object."""
-
-        allow_population_by_field_name = True
-
-    @root_validator()
+    @model_validator(mode='before')
+    @classmethod
     def validate_environment(cls, values: Dict) -> Dict:
         """Validate that api key and python package exists in environment."""
         values['elemai_api_key'] = get_from_dict_or_env(values, 'elemai_api_key', 'ELEMAI_API_KEY')

bisheng_langchain/chat_models/qwen.py

@@ -7,6 +7,8 @@ import logging
 import sys
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Mapping, Optional, Tuple, Union
 
+from pydantic import ConfigDict, model_validator, Field
+
 from bisheng_langchain.utils.requests import Requests
 # import requests
 from langchain.callbacks.manager import AsyncCallbackManagerForLLMRun, CallbackManagerForLLMRun
@@ -15,7 +17,6 @@ from langchain.schema import ChatGeneration, ChatResult
 from langchain.schema.messages import (AIMessage, BaseMessage, ChatMessage, FunctionMessage,
                                        HumanMessage, SystemMessage, ToolMessage)
 from langchain.utils import get_from_dict_or_env
-from langchain_core.pydantic_v1 import Field, root_validator
 from tenacity import (before_sleep_log, retry, retry_if_exception_type, stop_after_attempt,
                       wait_exponential)
 
@@ -165,13 +166,10 @@ class ChatQWen(BaseChatModel):
     API but with different models. In those cases, in order to avoid erroring
     when tiktoken is called, you can specify a model name to use here."""
     verbose: Optional[bool] = False
+    model_config = ConfigDict(validate_by_name=True)
 
-    class Config:
-        """Configuration for this pydantic object."""
-
-        allow_population_by_field_name = True
-
-    @root_validator()
+    @model_validator(mode='before')
+    @classmethod
     def validate_environment(cls, values: Dict) -> Dict:
         """Validate that api key and python package exists in environment."""
         values['api_key'] = get_from_dict_or_env(values, 'api_key', 'QWEN_API_KEY')

bisheng_langchain/chat_models/sensetime.py

@@ -7,6 +7,8 @@ import time
 from typing import Any, Dict, List, Mapping, Optional, Tuple, Union
 
 import jwt
+from pydantic import ConfigDict, model_validator, Field
+
 from bisheng_langchain.utils.requests import Requests
 from langchain.callbacks.manager import AsyncCallbackManagerForLLMRun, CallbackManagerForLLMRun
 from langchain.chat_models.base import BaseChatModel
@@ -14,7 +16,6 @@ from langchain.schema import ChatGeneration, ChatResult
 from langchain.schema.messages import (AIMessage, BaseMessage, ChatMessage, FunctionMessage,
                                        HumanMessage, SystemMessage)
 from langchain.utils import get_from_dict_or_env
-from langchain_core.pydantic_v1 import Field, root_validator
 from tenacity import (before_sleep_log, retry, retry_if_exception_type, stop_after_attempt,
                       wait_exponential)
 
@@ -157,13 +158,10 @@ class SenseChat(BaseChatModel):
     API but with different models. In those cases, in order to avoid erroring
     when tiktoken is called, you can specify a model name to use here."""
     verbose: Optional[bool] = False
+    model_config = ConfigDict(validate_by_name=True)
 
-    class Config:
-        """Configuration for this pydantic object."""
-
-        allow_population_by_field_name = True
-
-    @root_validator()
+    @model_validator(mode='before')
+    @classmethod
     def validate_environment(cls, values: Dict) -> Dict:
         """Validate that api key and python package exists in environment."""
 

bisheng_langchain/chat_models/wenxin.py

@@ -12,7 +12,7 @@ from langchain.schema import ChatGeneration, ChatResult
 from langchain.schema.messages import (AIMessage, BaseMessage, ChatMessage, FunctionMessage,
                                        HumanMessage, SystemMessage)
 from langchain.utils import get_from_dict_or_env
-from langchain_core.pydantic_v1 import Field, root_validator
+from pydantic import ConfigDict, model_validator, Field
 from tenacity import (before_sleep_log, retry, retry_if_exception_type, stop_after_attempt,
                       wait_exponential)
 
@@ -138,13 +138,10 @@ class ChatWenxin(BaseChatModel):
     API but with different models. In those cases, in order to avoid erroring
     when tiktoken is called, you can specify a model name to use here."""
     verbose: Optional[bool] = False
+    model_config = ConfigDict(validate_by_name=True)
 
-    class Config:
-        """Configuration for this pydantic object."""
-
-        allow_population_by_field_name = True
-
-    @root_validator()
+    @model_validator(mode='before')
+    @classmethod
     def validate_environment(cls, values: Dict) -> Dict:
         """Validate that api key and python package exists in environment."""
         values['wenxin_api_key'] = get_from_dict_or_env(values, 'wenxin_api_key', 'WENXIN_API_KEY')

bisheng_langchain/chat_models/xunfeiai.py

@@ -12,7 +12,7 @@ from langchain.schema import ChatGeneration, ChatResult
 from langchain.schema.messages import (AIMessage, BaseMessage, ChatMessage, FunctionMessage,
                                        HumanMessage, SystemMessage)
 from langchain.utils import get_from_dict_or_env
-from langchain_core.pydantic_v1 import Field, root_validator
+from pydantic import ConfigDict, model_validator, Field
 from tenacity import (before_sleep_log, retry, retry_if_exception_type, stop_after_attempt,
                       wait_exponential)
 
@@ -141,13 +141,10 @@ class ChatXunfeiAI(BaseChatModel):
     API but with different models. In those cases, in order to avoid erroring
     when tiktoken is called, you can specify a model name to use here."""
     verbose: Optional[bool] = False
+    model_config = ConfigDict(validate_by_name=True)
 
-    class Config:
-        """Configuration for this pydantic object."""
-
-        allow_population_by_field_name = True
-
-    @root_validator()
+    @model_validator(mode='before')
+    @classmethod
     def validate_environment(cls, values: Dict) -> Dict:
         """Validate that api key and python package exists in environment."""
         values['xunfeiai_appid'] = get_from_dict_or_env(

bisheng_langchain/chat_models/zhipuai.py

@@ -12,7 +12,7 @@ from langchain.schema import ChatGeneration, ChatResult
 from langchain.schema.messages import (AIMessage, BaseMessage, ChatMessage, FunctionMessage,
                                        HumanMessage, SystemMessage)
 from langchain.utils import get_from_dict_or_env
-from langchain_core.pydantic_v1 import Field, root_validator
+from pydantic import ConfigDict, model_validator, Field
 from tenacity import (before_sleep_log, retry, retry_if_exception_type, stop_after_attempt,
                       wait_exponential)
 
@@ -149,13 +149,10 @@ class ChatZhipuAI(BaseChatModel):
     API but with different models. In those cases, in order to avoid erroring
     when tiktoken is called, you can specify a model name to use here."""
     verbose: Optional[bool] = False
+    model_config = ConfigDict(validate_by_name=True)
 
-    class Config:
-        """Configuration for this pydantic object."""
-
-        allow_population_by_field_name = True
-
-    @root_validator()
+    @model_validator(mode='before')
+    @classmethod
     def validate_environment(cls, values: Dict) -> Dict:
         """Validate that api key and python package exists in environment."""
         values['zhipuai_api_key'] = get_from_dict_or_env(values, 'zhipuai_api_key',

bisheng_langchain/embeddings/host_embedding.py

@@ -6,7 +6,7 @@ from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 import requests
 from langchain.embeddings.base import Embeddings
 from langchain.utils import get_from_dict_or_env
-from langchain_core.pydantic_v1 import BaseModel, Field, root_validator
+from pydantic import model_validator, BaseModel, Field
 from tenacity import (before_sleep_log, retry, retry_if_exception_type, stop_after_attempt,
                       wait_exponential)
 
@@ -42,7 +42,7 @@ class HostEmbeddings(BaseModel, Embeddings):
     """host embedding models.
     """
 
-    client: Optional[Any]  #: :meta private:
+    client: Optional[Any] = None  #: :meta private:
     """Model name to use."""
     model: str = 'embedding-host'
     host_base_url: str = None
@@ -64,7 +64,8 @@ class HostEmbeddings(BaseModel, Embeddings):
 
     url_ep: Optional[str] = None
 
-    @root_validator()
+    @model_validator(mode='before')
+    @classmethod
     def validate_environment(cls, values: Dict) -> Dict:
         """Validate that api key and python package exists in environment."""
         values['host_base_url'] = get_from_dict_or_env(values, 'host_base_url', 'HostBaseUrl')
@@ -164,7 +165,8 @@ class CustomHostEmbedding(HostEmbeddings):
     model: str = Field('custom-embedding', alias='model')
     embedding_ctx_length: int = 512
 
-    @root_validator()
+    @model_validator(mode='before')
+    @classmethod
     def validate_environment(cls, values: Dict) -> Dict:
         """Validate that api key and python package exists in environment."""
         values['host_base_url'] = get_from_dict_or_env(values, 'host_base_url', 'HostBaseUrl')

bisheng_langchain/embeddings/huggingfacegte.py

@@ -2,7 +2,7 @@ from typing import Any, Dict, List, Optional
 
 import requests
 from langchain_core.embeddings import Embeddings
-from langchain_core.pydantic_v1 import BaseModel, Extra, Field
+from pydantic import BaseModel, Extra, Field
 DEFAULT_Multilingual_MODEL = "thenlper/gte-large-zh"
 
 
@@ -27,7 +27,7 @@ class HuggingFaceGteEmbeddings(BaseModel, Embeddings):
             )
     """
 
-    client: Any  #: :meta private:
+    client: Any = None  #: :meta private:
     model_name: str = DEFAULT_Multilingual_MODEL
     """Model name to use."""
     cache_folder: Optional[str] = None

bisheng_langchain/embeddings/huggingfacemultilingual.py

@@ -2,7 +2,7 @@ from typing import Any, Dict, List, Optional
 
 import requests
 from langchain_core.embeddings import Embeddings
-from langchain_core.pydantic_v1 import BaseModel, Extra, Field
+from pydantic import BaseModel, Extra, Field
 DEFAULT_Multilingual_MODEL = "intfloat/multilingual-e5-large"
 
 
@@ -27,7 +27,7 @@ class HuggingFaceMultilingualEmbeddings(BaseModel, Embeddings):
             )
     """
 
-    client: Any  #: :meta private:
+    client: Any = None  #: :meta private:
     model_name: str = DEFAULT_Multilingual_MODEL
     """Model name to use."""
     cache_folder: Optional[str] = None

bisheng_langchain/embeddings/wenxin.py

@@ -7,7 +7,7 @@ from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 # import numpy as np
 from langchain.embeddings.base import Embeddings
 from langchain.utils import get_from_dict_or_env
-from langchain_core.pydantic_v1 import BaseModel, Extra, Field, root_validator
+from pydantic import ConfigDict, model_validator, BaseModel, Field
 from requests.exceptions import HTTPError
 from tenacity import (before_sleep_log, retry, retry_if_exception_type, stop_after_attempt,
                       wait_exponential)
@@ -55,7 +55,7 @@ class WenxinEmbeddings(BaseModel, Embeddings):
 
     """
 
-    client: Optional[Any]  #: :meta private:
+    client: Optional[Any] = None  #: :meta private:
     model: str = 'embedding-v1'
 
     deployment: Optional[str] = 'default'
@@ -72,13 +72,10 @@ class WenxinEmbeddings(BaseModel, Embeddings):
 
     model_kwargs: Optional[Dict[str, Any]] = Field(default_factory=dict)
     """Holds any model parameters valid for `create` call not explicitly specified."""
+    model_config = ConfigDict(extra='forbid')
 
-    class Config:
-        """Configuration for this pydantic object."""
-
-        extra = Extra.forbid
-
-    @root_validator()
+    @model_validator(mode='before')
+    @classmethod
     def validate_environment(cls, values: Dict) -> Dict:
         """Validate that api key and python package exists in environment."""
         values['wenxin_api_key'] = get_from_dict_or_env(values, 'wenxin_api_key', 'WENXIN_API_KEY')

bisheng_langchain/gpts/agent_types/llm_functions_agent.py

@@ -8,7 +8,7 @@ from langchain_core.language_models.base import LanguageModelLike
 from langchain_core.messages import FunctionMessage, SystemMessage, ToolMessage
 from langgraph.graph import END
 from langgraph.graph.message import MessageGraph
-from langgraph.prebuilt import ToolExecutor, ToolInvocation
+from langgraph.prebuilt import ToolNode
 from langgraph.utils.runnable import RunnableCallable
 
 
@@ -35,7 +35,7 @@ def get_openai_functions_agent_executor(tools: list[BaseTool], llm: LanguageMode
         llm_with_tools = llm
 
     agent = _get_messages | llm_with_tools
-    tool_executor = ToolExecutor(tools)
+    tool_nodes = ToolNode(tools=tools)
 
     # Define the function that determines whether to continue or not
     def should_continue(messages):
@@ -55,63 +55,11 @@ def get_openai_functions_agent_executor(tools: list[BaseTool], llm: LanguageMode
 
     # Define the function to execute tools
     async def acall_tool(messages):
-        actions: list[ToolInvocation] = []
-        # Based on the continue condition
-        # we know the last message involves a function call
-        last_message = messages[-1]
-        for tool_call in last_message.additional_kwargs['tool_calls']:
-            function = tool_call['function']
-            function_name = function['name']
-            try:
-                _tool_input = json.loads(function['arguments'] or '{}')
-            except Exception as e:
-                raise Exception(f"Error parsing arguments for function: {function_name}. arguments: {function['arguments']}. error: {str(e)}")
-            # We construct an ToolInvocation from the function_call
-            actions.append(ToolInvocation(
-                tool=function_name,
-                tool_input=_tool_input,
-            ))
-        # We call the tool_executor and get back a response
-        responses = await tool_executor.abatch(actions, **kwargs)
-        # We use the response to create a ToolMessage
-        tool_messages = [
-            LiberalToolMessage(
-                tool_call_id=tool_call['id'],
-                content=response,
-                additional_kwargs={'name': tool_call['function']['name']},
-            )
-            for tool_call, response in zip(last_message.additional_kwargs['tool_calls'], responses)
-        ]
+        tool_messages = await tool_nodes._afunc(messages, None, store=None)
         return tool_messages
 
     def call_tool(messages):
-        actions: list[ToolInvocation] = []
-        # Based on the continue condition
-        # we know the last message involves a function call
-        last_message = messages[-1]
-        for tool_call in last_message.additional_kwargs['tool_calls']:
-            function = tool_call['function']
-            function_name = function['name']
-            try:
-                _tool_input = json.loads(function['arguments'] or '{}')
-            except Exception as e:
-                raise Exception(f"Error parsing arguments for function: {function_name}. arguments: {function['arguments']}. error: {str(e)}")
-            # We construct an ToolInvocation from the function_call
-            actions.append(ToolInvocation(
-                tool=function_name,
-                tool_input=_tool_input,
-            ))
-        # We call the tool_executor and get back a response
-        responses = tool_executor.batch(actions, **kwargs)
-        # We use the response to create a ToolMessage
-        tool_messages = [
-            LiberalToolMessage(
-                tool_call_id=tool_call['id'],
-                content=response,
-                additional_kwargs={'name': tool_call['function']['name']},
-            )
-            for tool_call, response in zip(last_message.additional_kwargs['tool_calls'], responses)
-        ]
+        tool_messages = tool_nodes._func(messages, config=None, store=None)
         return tool_messages
 
     workflow = MessageGraph()
@@ -185,7 +133,7 @@ def get_qwen_local_functions_agent_executor(
     else:
         llm_with_tools = llm
     agent = _get_messages | llm_with_tools
-    tool_executor = ToolExecutor(tools)
+    tool_nodes = ToolNode(tools=tools)
 
     # Define the function that determines whether to continue or not
     def should_continue(messages):
@@ -199,27 +147,7 @@ def get_qwen_local_functions_agent_executor(
 
     # Define the function to execute tools
     async def call_tool(messages):
-        actions: list[ToolInvocation] = []
-        # Based on the continue condition
-        # we know the last message involves a function call
-        last_message = messages[-1]
-        # only one function
-        function = last_message.additional_kwargs['function_call']
-        function_name = function['name']
-        try:
-            _tool_input = json.loads(function['arguments'] or '{}')
-        except Exception as e:
-            raise Exception(
-                f"Error parsing arguments for function: {function_name}. arguments: {function['arguments']}. error: {str(e)}")
-        # We construct an ToolInvocation from the function_call
-        actions.append(ToolInvocation(
-            tool=function_name,
-            tool_input=_tool_input,
-        ))
-        # We call the tool_executor and get back a response
-        responses = await tool_executor.abatch(actions, **kwargs)
-        # We use the response to create a ToolMessage
-        tool_messages = [LiberalFunctionMessage(content=responses[0], name=function_name)]
+        tool_messages = await tool_nodes._afunc(messages, config=None, store=None)
         return tool_messages
 
     workflow = MessageGraph()

bisheng_langchain/gpts/agent_types/llm_react_agent.py

@@ -9,7 +9,7 @@ from langchain_core.language_models import LanguageModelLike
 from langchain_core.messages import BaseMessage
 from langgraph.graph import END, StateGraph
 from langgraph.graph.state import CompiledStateGraph
-from langgraph.prebuilt.tool_executor import ToolExecutor
+from langgraph.prebuilt import ToolNode
 from langgraph.utils.runnable import RunnableCallable
 
 
@@ -64,10 +64,7 @@ def create_agent_executor(agent_runnable, tools, input_schema=None) -> CompiledS
         The `CompiledStateGraph` object.
     """
 
-    if isinstance(tools, ToolExecutor):
-        tool_executor = tools
-    else:
-        tool_executor = ToolExecutor(tools)
+    tool_executor = ToolNode(tools=tools)
 
     state = _get_agent_state(input_schema)
 

bisheng_langchain/gpts/tools/api_tools/base.py

@@ -1,7 +1,8 @@
 from typing import Any, Dict, Tuple, Type, Union
 
+from pydantic import ConfigDict, model_validator, BaseModel, Field
+
 from bisheng_langchain.utils.requests import Requests, RequestsWrapper
-from langchain_core.pydantic_v1 import BaseModel, Extra, Field, root_validator
 from langchain_core.tools import BaseTool, Tool
 from loguru import logger
 
@@ -32,13 +33,10 @@ class APIToolBase(BaseModel):
     params: Dict[str, Any] = {}
     input_key: str = 'keyword'
     args_schema: Type[BaseModel] = ApiArg
+    model_config = ConfigDict(extra="forbid")
 
-    class Config:
-        """Configuration for this pydantic object."""
-
-        extra = Extra.forbid
-
-    @root_validator()
+    @model_validator(mode='before')
+    @classmethod
     def validate_environment(cls, values: Dict) -> Dict:
         """Validate that api key and python package exists in environment."""
         timeout = values.get('request_timeout', 30)

bisheng_langchain/gpts/tools/api_tools/firecrawl.py

@@ -3,7 +3,7 @@ from typing import Any, Dict, Type
 
 import requests
 
-from langchain_core.pydantic_v1 import BaseModel, Field, root_validator
+from pydantic import BaseModel, Field
 
 from bisheng_langchain.gpts.tools.api_tools.base import (APIToolBase,
                                                          MultArgsSchemaTool)

bisheng_langchain/gpts/tools/api_tools/flow.py

@@ -1,5 +1,5 @@
 from loguru import logger
-from langchain_core.pydantic_v1 import BaseModel, Field
+from pydantic import BaseModel, Field
 from typing import Any
 from .base import APIToolBase
 from .base import MultArgsSchemaTool