agentica 0.1.0__tar.gz → 0.1.1__tar.gz

{agentica-0.1.0 → agentica-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: agentica
-Version: 0.1.0
+Version: 0.1.1
 Summary: LLM agents
 Home-page: https://github.com/shibing624/agentica
 Author: XuMing
@@ -20,7 +20,7 @@ Requires-Python: >=3.8.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
-[**🇨🇳中文**](https://github.com/shibing624/agentica/blob/main/README.md) | [**🌐English**](https://github.com/shibing624/agentica/blob/main/README_EN.md)
+[**🇨🇳中文**](https://github.com/shibing624/agentica/blob/main/README.md) | [**🌐English**](https://github.com/shibing624/agentica/blob/main/README_EN.md) | [**🇯🇵日本語**](https://github.com/shibing624/agentica/blob/main/README_JP.md)
 
 <div align="center">
   <a href="https://github.com/shibing624/agentica">
@@ -47,7 +47,7 @@ License-File: LICENSE
 ## Overview
 
 #### LLM Agent
-![llm_agnet](https://github.com/shibing624/agentica/blob/main/docs/llm_agent.png)
+![llm_agnet](https://github.com/shibing624/agentica/blob/main/docs/llm_agentv2.png)
 
 - **规划（Planning）**：任务拆解、生成计划、反思
 - **记忆（Memory）**：短期记忆（prompt实现）、长期记忆（RAG实现）
@@ -134,6 +134,7 @@ print(r)
 
 ### LLM OS
 The LLM OS design:
+
 <img alt="LLM OS" src="https://github.com/shibing624/agentica/blob/main/docs/llmos.png" width="600" />
 
 #### Run the LLM OS App

{agentica-0.1.0 → agentica-0.1.1}/README.md

@@ -1,4 +1,4 @@
-[**🇨🇳中文**](https://github.com/shibing624/agentica/blob/main/README.md) | [**🌐English**](https://github.com/shibing624/agentica/blob/main/README_EN.md)
+[**🇨🇳中文**](https://github.com/shibing624/agentica/blob/main/README.md) | [**🌐English**](https://github.com/shibing624/agentica/blob/main/README_EN.md) | [**🇯🇵日本語**](https://github.com/shibing624/agentica/blob/main/README_JP.md)
 
 <div align="center">
   <a href="https://github.com/shibing624/agentica">
@@ -25,7 +25,7 @@
 ## Overview
 
 #### LLM Agent
-![llm_agnet](https://github.com/shibing624/agentica/blob/main/docs/llm_agent.png)
+![llm_agnet](https://github.com/shibing624/agentica/blob/main/docs/llm_agentv2.png)
 
 - **规划（Planning）**：任务拆解、生成计划、反思
 - **记忆（Memory）**：短期记忆（prompt实现）、长期记忆（RAG实现）
@@ -112,6 +112,7 @@ print(r)
 
 ### LLM OS
 The LLM OS design:
+
 <img alt="LLM OS" src="https://github.com/shibing624/agentica/blob/main/docs/llmos.png" width="600" />
 
 #### Run the LLM OS App

{agentica-0.1.0 → agentica-0.1.1}/agentica/__init__.py

@@ -8,9 +8,11 @@ from agentica.config import DOTENV_PATH, SMART_LLM, FAST_LLM  # noqa, isort: ski
 from agentica.assistant import Assistant
 from agentica.python_assistant import PythonAssistant
 from agentica.document import Document
-from agentica.knowledge_base import KnowledgeBase
+from agentica.knowledge.knowledge_base import KnowledgeBase
 from agentica.llm.openai_llm import OpenAILLM
 from agentica.llm.azure_llm import AzureOpenAILLM
+from agentica.llm.together_llm import TogetherLLM
+from agentica.llm.moonshot_llm import MoonshotLLM
 from agentica.task import Task
 from agentica.workflow import Workflow
 

{agentica-0.1.0 → agentica-0.1.1}/agentica/assistant.py

@@ -29,7 +29,7 @@ from uuid import uuid4
 from pydantic import BaseModel, ConfigDict, field_validator, ValidationError
 
 from agentica.document import Document
-from agentica.knowledge_base import KnowledgeBase
+from agentica.knowledge.knowledge_base import KnowledgeBase
 from agentica.llm.base import LLM
 from agentica.memory import AssistantMemory, Memory
 from agentica.message import Message
@@ -1212,13 +1212,13 @@ class Assistant(BaseModel):
     # Default Tools
     ###########################################################################
 
-    def get_chat_history(self, num_chats: Optional[int] = None) -> str:
+    def get_chat_history(self, num_chats: int = 5) -> str:
         """Use this function to get the chat history between the user and assistant.
 
         Args:
             num_chats: The number of chats to return.
                 Each chat contains 2 messages. One from the user and one from the assistant.
-                Default: None
+                Default: 5
 
         Returns:
             str: A JSON of a list of dictionaries representing the chat history.
@@ -1226,8 +1226,8 @@ class Assistant(BaseModel):
         Example:
             - To get the last chat, use num_chats=1.
             - To get the last 5 chats, use num_chats=5.
-            - To get all chats, use num_chats=None.
-            - To get the first chat, use num_chats=None and pick the first message.
+            - To get all chats, use num_chats=-1.
+            - To get the first chat, use num_chats=-1 and pick the first message.
         """
         history: List[Dict[str, Any]] = []
         all_chats = self.memory.get_chats()
@@ -1239,9 +1239,9 @@ class Assistant(BaseModel):
             history.insert(0, chat[1].to_dict())
             history.insert(0, chat[0].to_dict())
             chats_added += 1
-            if num_chats is not None and chats_added >= num_chats:
+            if 0 < num_chats <= chats_added:
                 break
-        return json.dumps(history)
+        return json.dumps(history, ensure_ascii=False)
 
     def get_tool_call_history(self, num_calls: int = 3) -> str:
         """Use this function to get the tools called by the assistant in reverse chronological order.
@@ -1255,13 +1255,13 @@ class Assistant(BaseModel):
 
         Example:
             - To get the last tool call, use num_calls=1.
-            - To get all tool calls, use num_calls=None.
+            - To get all tool calls, use num_calls=-1.
         """
         tool_calls = self.memory.get_tool_calls(num_calls)
         if len(tool_calls) == 0:
             return ""
         logger.debug(f"tool_calls: {tool_calls}")
-        return json.dumps(tool_calls)
+        return json.dumps(tool_calls, ensure_ascii=False)
 
     def search_knowledge_base(self, query: str) -> str:
         """Use this function to search the knowledge base for information about a query.

{agentica-0.1.0 → agentica-0.1.1}/agentica/emb/azure_emb.py

@@ -6,17 +6,14 @@ part of the code from https://github.com/phidatahq/phidata
 """
 from os import getenv
 from typing import Optional, Dict, List, Tuple, Any
+
+from openai import AzureOpenAI as AzureOpenAIClient
+from openai.types.create_embedding_response import CreateEmbeddingResponse
 from typing_extensions import Literal
 
 from agentica.emb.base import Emb
 from agentica.utils.log import logger
 
-try:
-    from openai import AzureOpenAI as AzureOpenAIClient
-    from openai.types.create_embedding_response import CreateEmbeddingResponse
-except ImportError:
-    raise ImportError("`openai` not installed, please run `pip install openai`")
-
 
 class AzureOpenAIEmb(Emb):
     model: str = "text-embedding-ada-002"
@@ -57,7 +54,8 @@ class AzureOpenAIEmb(Emb):
             _client_params["azure_ad_token"] = self.azure_ad_token
         if self.azure_ad_token_provider:
             _client_params["azure_ad_token_provider"] = self.azure_ad_token_provider
-        return AzureOpenAIClient(**_client_params)
+        self.openai_client = AzureOpenAIClient(**_client_params)
+        return self.openai_client
 
     def _response(self, text: str) -> CreateEmbeddingResponse:
         _request_params: Dict[str, Any] = {
@@ -87,3 +85,9 @@ class AzureOpenAIEmb(Emb):
         embedding = response.data[0].embedding
         usage = response.usage
         return embedding, usage.model_dump()
+
+    def get_embeddings(self, texts: List[str]) -> List[List[float]]:
+        embeddings = []
+        for text in texts:
+            embeddings.append(self.get_embedding(text))
+        return embeddings

{agentica-0.1.0 → agentica-0.1.1}/agentica/emb/base.py

@@ -12,3 +12,6 @@ class Emb(BaseModel):
 
     def get_embedding(self, text: str) -> List[float]:
         raise NotImplementedError
+
+    def get_embeddings(self, texts: List[str]) -> List[List[float]]:
+        raise NotImplementedError

{agentica-0.1.0 → agentica-0.1.1}/agentica/emb/hash_emb.py

@@ -20,3 +20,6 @@ class HashEmb(Emb):
         hash_list = list(hash_object.digest())
         float_list = [float(x) / 255.0 for x in hash_list]
         return float_list
+
+    def get_embeddings(self, texts: List[str]) -> List[List[float]]:
+        return [self.get_embedding(text) for text in texts]

{agentica-0.1.0 → agentica-0.1.1}/agentica/emb/ollama_emb.py

@@ -55,3 +55,6 @@ class OllamaEmb(Emb):
         except Exception as e:
             logger.warning(e)
             return []
+
+    def get_embeddings(self, texts: List[str]) -> List[List[float]]:
+        return [self.get_embedding(text) for text in texts]

{agentica-0.1.0 → agentica-0.1.1}/agentica/emb/openai_emb.py

@@ -7,17 +7,13 @@ part of the code from https://github.com/phidatahq/phidata
 from os import getenv
 from typing import Optional, Dict, List, Tuple, Any
 
+from openai import OpenAI as OpenAIClient
+from openai.types.create_embedding_response import CreateEmbeddingResponse
 from typing_extensions import Literal
 
 from agentica.emb.base import Emb
 from agentica.utils.log import logger
 
-try:
-    from openai import OpenAI as OpenAIClient
-    from openai.types.create_embedding_response import CreateEmbeddingResponse
-except ImportError:
-    raise ImportError("`openai` not installed, please run `pip install openai`")
-
 
 class OpenAIEmb(Emb):
     model: str = "text-embedding-ada-002"  # or text-embedding-3-small
@@ -75,3 +71,6 @@ class OpenAIEmb(Emb):
         embedding = response.data[0].embedding
         usage = response.usage
         return embedding, usage.model_dump()
+
+    def get_embeddings(self, texts: List[str]) -> List[List[float]]:
+        return [self.get_embedding(text) for text in texts]

{agentica-0.1.0 → agentica-0.1.1}/agentica/emb/text2vec_emb.py

@@ -38,3 +38,7 @@ class Text2VecEmb(Emb):
     def get_embedding(self, text: str) -> List[float]:
         # Calculate emb of the text
         return self.get_client.encode([text])[0]
+
+    def get_embeddings(self, texts: List[str]) -> List[List[float]]:
+        # Calculate emb of the texts
+        return self.get_client.encode(texts).tolist()  # type: ignore

{agentica-0.1.0 → agentica-0.1.1}/agentica/emb/word2vec_emb.py

@@ -37,3 +37,9 @@ class Word2VecEmb(Emb):
     def get_embedding(self, text: str) -> List[float]:
         # Calculate emb of the text
         return self.get_client.encode([text])[0]
+
+    def get_embeddings(self, texts: List[str]) -> List[List[float]]:
+        # Calculate emb of the texts
+        ndarr = self.get_client.encode(texts)
+        # convert numpy array to list
+        return ndarr.tolist()  # type: ignore

agentica-0.1.1/agentica/knowledge/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+"""
+@author:XuMing(xuming624@qq.com)
+@description: 
+"""

{agentica-0.1.0/agentica → agentica-0.1.1/agentica/knowledge}/knowledge_base.py

@@ -182,12 +182,12 @@ class KnowledgeBase(BaseModel):
         Reads a website and returns a list of documents.
         """
         try:
-            file_contents = UrlCrawlerTool(max_depth=1, max_links=1).url_crawl(url)
+            content = UrlCrawlerTool().url_crawl(url)
             documents = [
                 Document(
                     name=url,
                     id=url,
-                    content=file_contents,
+                    content=content,
                 )
             ]
             if self.chunk:

agentica-0.1.1/agentica/knowledge/langchain.py

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+"""
+@author:XuMing(xuming624@qq.com)
+@description:
+part of the code from https://github.com/phidatahq/phidata
+"""
+from typing import List, Optional, Callable, Any
+
+from agentica.document import Document
+from agentica.knowledge.knowledge_base import KnowledgeBase
+from agentica.utils.log import logger
+
+
+class LangChainKnowledgeBase(KnowledgeBase):
+    loader: Optional[Callable] = None
+
+    vectorstore: Optional[Any] = None
+    search_kwargs: Optional[dict] = None
+
+    retriever: Optional[Any] = None
+
+    def search(self, query: str, num_documents: Optional[int] = None) -> List[Document]:
+        """Returns relevant documents matching the query"""
+
+        try:
+            from langchain_core.vectorstores import VectorStoreRetriever
+            from langchain_core.documents import Document as LangChainDocument
+        except ImportError:
+            raise ImportError(
+                "The `langchain` package is not installed. Please install it via `pip install langchain`."
+            )
+
+        if self.vectorstore is not None and self.retriever is None:
+            logger.debug("Creating retriever")
+            if self.search_kwargs is None:
+                self.search_kwargs = {"k": self.num_documents}
+            self.retriever = self.vectorstore.as_retriever(search_kwargs=self.search_kwargs)
+
+        if self.retriever is None:
+            logger.error("No retriever provided")
+            return []
+
+        if not isinstance(self.retriever, VectorStoreRetriever):
+            raise ValueError(f"Retriever is not of type VectorStoreRetriever: {self.retriever}")
+
+        _num_documents = num_documents or self.num_documents
+        logger.debug(f"Getting {_num_documents} relevant documents for query: {query}")
+        lc_documents: List[LangChainDocument] = self.retriever.invoke(input=query)
+        documents = []
+        for lc_doc in lc_documents:
+            documents.append(
+                Document(
+                    content=lc_doc.page_content,
+                    meta_data=lc_doc.metadata,
+                )
+            )
+        return documents
+
+    def load(self, recreate: bool = False, upsert: bool = True, skip_existing: bool = True) -> None:
+        if self.loader is None:
+            logger.error("No loader provided for LangChainKnowledgeBase")
+            return
+        self.loader()
+
+    def exists(self) -> bool:
+        logger.warning("LangChainKnowledgeBase.exists() not supported - please check the vectorstore manually.")
+        return True

agentica-0.1.1/agentica/knowledge/llamaindex.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+"""
+@author:XuMing(xuming624@qq.com)
+@description:
+part of the code from https://github.com/phidatahq/phidata
+"""
+from typing import List, Optional, Callable
+
+from agentica.document import Document
+from agentica.knowledge.knowledge_base import KnowledgeBase
+from agentica.utils.log import logger
+
+try:
+    from llama_index.core.schema import NodeWithScore
+    from llama_index.core.retrievers import BaseRetriever
+except ImportError:
+    raise ImportError(
+        "The `llama-index-core` package is not installed. Please install it via `pip install llama-index-core`."
+    )
+
+
+class LlamaIndexKnowledgeBase(KnowledgeBase):
+    retriever: BaseRetriever
+    loader: Optional[Callable] = None
+
+    def search(self, query: str, num_documents: Optional[int] = None) -> List[Document]:
+        """
+        Returns relevant documents matching the query.
+
+        Args:
+            query (str): The query string to search for.
+            num_documents (Optional[int]): The maximum number of documents to return. Defaults to None.
+
+        Returns:
+            List[Document]: A list of relevant documents matching the query.
+        Raises:
+            ValueError: If the retriever is not of type BaseRetriever.
+        """
+        if not isinstance(self.retriever, BaseRetriever):
+            raise ValueError(f"Retriever is not of type BaseRetriever: {self.retriever}")
+
+        lc_documents: List[NodeWithScore] = self.retriever.retrieve(query)
+        if num_documents is not None:
+            lc_documents = lc_documents[:num_documents]
+        documents = []
+        for lc_doc in lc_documents:
+            documents.append(
+                Document(
+                    content=lc_doc.text,
+                    meta_data=lc_doc.metadata,
+                )
+            )
+        return documents
+
+    def load(self, recreate: bool = False, upsert: bool = True, skip_existing: bool = True) -> None:
+        if self.loader is None:
+            logger.error("No loader provided for LlamaIndexKnowledgeBase")
+            return
+        self.loader()
+
+    def exists(self) -> bool:
+        logger.warning("LlamaIndexKnowledgeBase.exists() not supported - please check the vectorstore manually.")
+        return True

{agentica-0.1.0 → agentica-0.1.1}/agentica/llm/anthropic_llm.py

@@ -50,7 +50,10 @@ class AnthropicLLM(LLM):
         _client_params: Dict[str, Any] = {}
         if self.api_key:
             _client_params["api_key"] = self.api_key
-        return AnthropicClient(**_client_params)
+        if self.client_params:
+            _client_params.update(self.client_params)
+        self.anthropic_client = AnthropicClient(**_client_params)
+        return self.anthropic_client
 
     @property
     def api_kwargs(self) -> Dict[str, Any]:

{agentica-0.1.0 → agentica-0.1.1}/agentica/llm/azure_llm.py

@@ -53,5 +53,5 @@ class AzureOpenAILLM(OpenAILLM):
             _client_params["http_client"] = self.http_client
         if self.client_params:
             _client_params.update(self.client_params)
-
-        return AzureOpenAIClient(**_client_params)
+        self.client = AzureOpenAIClient(**_client_params)
+        return self.client

{agentica-0.1.0 → agentica-0.1.1}/agentica/llm/base.py

@@ -104,9 +104,11 @@ class LLM(BaseModel):
         tools_for_api = []
         for tool in self.tools:
             if isinstance(tool, Tool):
-                tools_for_api.append(tool.to_dict())
+                if tool.to_dict() not in tools_for_api:
+                    tools_for_api.append(tool.to_dict())
             elif isinstance(tool, Dict):
-                tools_for_api.append(tool)
+                if tool not in tools_for_api:
+                    tools_for_api.append(tool)
         return tools_for_api
 
     def add_tool(self, tool: Union[Tool, Toolkit, Callable, Dict, Function]) -> None:

agentica-0.1.1/agentica/llm/moonshot_llm.py

@@ -0,0 +1,221 @@
+# -*- coding: utf-8 -*-
+"""
+@author:XuMing(xuming624@qq.com)
+@description:
+kimi api refer: https://platform.moonshot.cn/docs/api/tool-use#%E5%B7%A5%E5%85%B7%E8%B0%83%E7%94%A8
+"""
+from os import getenv
+from typing import Optional, List, Iterator, Dict, Any
+
+from openai import OpenAI as OpenAIClient
+
+from agentica.llm.base import LLM
+from agentica.message import Message
+from agentica.tool import FunctionCall, get_function_call_for_tool_call
+from agentica.utils.log import logger
+from agentica.utils.timer import Timer
+
+
+class MoonshotLLM(LLM):
+    name: str = "Moonshot"
+    model: str = "moonshot-v1-8k"
+    api_key: Optional[str] = getenv("MOONSHOT_API_KEY")
+    base_url: str = "https://api.moonshot.cn/v1"
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    top_k: Optional[int] = None
+    max_tokens: Optional[int] = None
+    # Deactivate tool calls after 1 tool call
+    deactivate_tools_after_use: bool = False
+    request_params: Optional[Dict[str, Any]] = None
+    client_params: Optional[Dict[str, Any]] = None
+    # -*- Provide the client manually
+    client: Optional[OpenAIClient] = None
+
+    def get_client(self) -> OpenAIClient:
+        if self.client:
+            return self.client
+
+        _client_params: Dict[str, Any] = {}
+        if self.api_key:
+            _client_params["api_key"] = self.api_key
+        if self.base_url:
+            _client_params["base_url"] = self.base_url
+        if self.client_params:
+            _client_params.update(self.client_params)
+        self.client = OpenAIClient(**_client_params)
+        return self.client
+
+    @property
+    def api_kwargs(self) -> Dict[str, Any]:
+        _request_params: Dict[str, Any] = {}
+        if self.max_tokens:
+            _request_params["max_tokens"] = self.max_tokens
+        if self.temperature:
+            _request_params["temperature"] = self.temperature
+        if self.top_p:
+            _request_params["top_p"] = self.top_p
+        if self.top_k:
+            _request_params["top_k"] = self.top_k
+        if self.tools:
+            _request_params["tools"] = self.get_tools_for_api()
+            if self.tool_choice is None:
+                _request_params["tool_choice"] = "auto"
+            else:
+                _request_params["tool_choice"] = self.tool_choice
+        if self.request_params:
+            _request_params.update(self.request_params)
+        return _request_params
+
+    def to_dict(self) -> Dict[str, Any]:
+        _dict = super().to_dict()
+        if self.max_tokens:
+            _dict["max_tokens"] = self.max_tokens
+        if self.temperature:
+            _dict["temperature"] = self.temperature
+        if self.top_p:
+            _dict["top_p"] = self.top_p
+        if self.tools:
+            _dict["tools"] = self.get_tools_for_api()
+            if self.tool_choice is None:
+                _dict["tool_choice"] = "auto"
+            else:
+                _dict["tool_choice"] = self.tool_choice
+        return _dict
+
+    def invoke(self, messages: List[Message]):
+        return self.get_client().chat.completions.create(
+            model=self.model,
+            messages=[m.to_dict() for m in messages],
+            **self.api_kwargs,
+        )
+
+    def invoke_stream(self, messages: List[Message]):
+        yield from self.get_client().chat.completions.create(
+            model=self.model,
+            messages=[m.to_dict() for m in messages],
+            stream=True,
+            **self.api_kwargs,
+        )
+
+    def response(self, messages: List[Message]) -> str:
+        logger.debug("---------- Moonshot Response Start ----------")
+        # -*- Log messages for debugging
+        for m in messages:
+            m.log()
+
+        t = Timer()
+        t.start()
+        response = self.invoke(messages=messages)
+        t.stop()
+        logger.debug(f"Time to generate response: {t.elapsed:.4f}s")
+
+        # -*- Parse response
+        response_message = response.choices[0].message
+        response_role = response_message.role
+        response_content: Optional[str] = response_message.content
+        response_tool_calls = response_message.tool_calls
+
+        tool_calls = []
+        if response_tool_calls is not None:
+            tool_calls = [t.model_dump() for t in response_tool_calls]
+            if not response_content:
+                response_content = f"Running tool calls: {tool_calls}"
+
+        # -*- Create assistant message
+        assistant_message = Message(
+            role=response_role or "assistant",
+            content=response_content,
+        )
+
+        # -*- Update usage metrics
+        # Add response time to metrics
+        assistant_message.metrics["time"] = t.elapsed
+        if "response_times" not in self.metrics:
+            self.metrics["response_times"] = []
+        self.metrics["response_times"].append(t.elapsed)
+
+        # Add token usage to metrics
+        response_usage = response.usage
+        prompt_tokens = response_usage.prompt_tokens if response_usage is not None else None
+        if prompt_tokens is not None:
+            assistant_message.metrics["prompt_tokens"] = prompt_tokens
+            if "prompt_tokens" not in self.metrics:
+                self.metrics["prompt_tokens"] = prompt_tokens
+            else:
+                self.metrics["prompt_tokens"] += prompt_tokens
+        completion_tokens = response_usage.completion_tokens if response_usage is not None else None
+        if completion_tokens is not None:
+            assistant_message.metrics["completion_tokens"] = completion_tokens
+            if "completion_tokens" not in self.metrics:
+                self.metrics["completion_tokens"] = completion_tokens
+            else:
+                self.metrics["completion_tokens"] += completion_tokens
+        total_tokens = response_usage.total_tokens if response_usage is not None else None
+        if total_tokens is not None:
+            assistant_message.metrics["total_tokens"] = total_tokens
+            if "total_tokens" not in self.metrics:
+                self.metrics["total_tokens"] = total_tokens
+            else:
+                self.metrics["total_tokens"] += total_tokens
+
+        # -*- Add assistant message to messages
+        messages.append(assistant_message)
+        assistant_message.log()
+
+        # -*- Parse and run function call
+        if tool_calls is not None and self.run_tools:
+            final_response = ""
+            function_calls_to_run: List[FunctionCall] = []
+            for tool_call in tool_calls:
+                _function_call = get_function_call_for_tool_call(tool_call, self.functions)
+                if _function_call is None:
+                    messages.append(Message(role="user", content="Could not find function to call."))
+                    continue
+                if _function_call.error is not None:
+                    messages.append(Message(role="user", content=_function_call.error))
+                    continue
+                function_calls_to_run.append(_function_call)
+
+            if self.show_tool_calls:
+                if len(function_calls_to_run) == 1:
+                    final_response += f" - Running: {function_calls_to_run[0].get_call_str()}\n\n"
+                elif len(function_calls_to_run) > 1:
+                    final_response += "Running:"
+                    for _f in function_calls_to_run:
+                        final_response += f"\n - {_f.get_call_str()}"
+                    final_response += "\n\n"
+
+            function_call_results = self.run_function_calls(function_calls_to_run, role="user")
+            if len(function_call_results) > 0:
+                fc_responses = "<tool_results>"
+
+                for _fc_message in function_call_results:
+                    fc_responses += "<result>"
+                    fc_responses += "<tool_name>" + _fc_message.tool_call_name + "</tool_name>"  # type: ignore
+                    fc_responses += "<stdout>" + _fc_message.content + "</stdout>"  # type: ignore
+                    fc_responses += "</result>"
+                fc_responses += "</tool_results>"
+
+                messages.append(Message(role="user", content=fc_responses))
+
+            # Deactivate tool calls after 1 tool call
+            if self.deactivate_tools_after_use:
+                self.deactivate_function_calls()
+
+            # -*- Yield new response using results of tool calls
+            last_message = messages[-1]
+            if last_message.role == "user" and last_message.content is not None:
+                final_response += self.response(messages=messages)
+                return final_response
+        logger.debug("---------- Moonshot Response End ----------")
+        # -*- Return content if no function calls are present
+        if assistant_message.content is not None:
+            return assistant_message.get_content_string()
+        return "Something went wrong, please try again."
+
+    def response_stream(self, messages: List[Message]) -> Iterator[str]:
+        logger.debug("MoonshotLLM tool use not support stream, use response instead.")
+        r = self.response(messages)
+        for i in r:
+            yield i