feat: merge geekan:cli-etc

metagpt/provider/base_chatbot.py

@@ -14,6 +14,7 @@ class BaseChatbot(ABC):
     """Abstract GPT class"""
 
     mode: str = "API"
+    use_system_prompt: bool = True
 
     @abstractmethod
     def ask(self, msg: str) -> str:

metagpt/provider/base_gpt_api.py

@@ -5,6 +5,7 @@
 @Author  : alexanderwu
 @File    : base_gpt_api.py
 """
+import json
 from abc import abstractmethod
 from typing import Optional
 
@@ -33,15 +34,21 @@ class BaseGPTAPI(BaseChatbot):
         return self._system_msg(self.system_prompt)
 
     def ask(self, msg: str) -> str:
-        message = [self._default_system_msg(), self._user_msg(msg)]
+        message = [self._default_system_msg(), self._user_msg(msg)] if self.use_system_prompt else [self._user_msg(msg)]
         rsp = self.completion(message)
         return self.get_choice_text(rsp)
 
     async def aask(self, msg: str, system_msgs: Optional[list[str]] = None) -> str:
         if system_msgs:
-            message = self._system_msgs(system_msgs) + [self._user_msg(msg)]
+            message = (
+                self._system_msgs(system_msgs) + [self._user_msg(msg)]
+                if self.use_system_prompt
+                else [self._user_msg(msg)]
+            )
         else:
-            message = [self._default_system_msg(), self._user_msg(msg)]
+            message = (
+                [self._default_system_msg(), self._user_msg(msg)] if self.use_system_prompt else [self._user_msg(msg)]
+            )
         rsp = await self.acompletion_text(message, stream=True)
         logger.debug(message)
         # logger.debug(rsp)
@@ -109,6 +116,46 @@ class BaseGPTAPI(BaseChatbot):
         """Required to provide the first text of choice"""
         return rsp.get("choices")[0]["message"]["content"]
 
+    def get_choice_function(self, rsp: dict) -> dict:
+        """Required to provide the first function of choice
+        :param dict rsp: OpenAI chat.comletion respond JSON, Note "message" must include "tool_calls",
+            and "tool_calls" must include "function", for example:
+            {...
+                "choices": [
+                    {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": null,
+                        "tool_calls": [
+                        {
+                            "id": "call_Y5r6Ddr2Qc2ZrqgfwzPX5l72",
+                            "type": "function",
+                            "function": {
+                            "name": "execute",
+                            "arguments": "{\n  \"language\": \"python\",\n  \"code\": \"print('Hello, World!')\"\n}"
+                            }
+                        }
+                        ]
+                    },
+                    "finish_reason": "stop"
+                    }
+                ],
+                ...}
+        :return dict: return first function of choice, for exmaple,
+            {'name': 'execute', 'arguments': '{\n  "language": "python",\n  "code": "print(\'Hello, World!\')"\n}'}
+        """
+        return rsp.get("choices")[0]["message"]["tool_calls"][0]["function"].to_dict()
+
+    def get_choice_function_arguments(self, rsp: dict) -> dict:
+        """Required to provide the first function arguments of choice.
+
+        :param dict rsp: same as in self.get_choice_function(rsp)
+        :return dict: return the first function arguments of choice, for example,
+            {'language': 'python', 'code': "print('Hello, World!')"}
+        """
+        return json.loads(self.get_choice_function(rsp)["arguments"])
+
     def messages_to_prompt(self, messages: list[dict]):
         """[{"role": "user", "content": msg}] to user: <msg> etc."""
         return "\n".join([f"{i['role']}: {i['content']}" for i in messages])

metagpt/provider/constant.py

@@ -0,0 +1,30 @@
+# function in tools, https://platform.openai.com/docs/api-reference/chat/create#chat-create-tools
+# Reference: https://github.com/KillianLucas/open-interpreter/blob/v0.1.14/interpreter/llm/setup_openai_coding_llm.py
+GENERAL_FUNCTION_SCHEMA = {
+    "name": "execute",
+    "description": "Executes code on the user's machine, **in the users local environment**, and returns the output",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "language": {
+                "type": "string",
+                "description": "The programming language (required parameter to the `execute` function)",
+                "enum": [
+                    "python",
+                    "R",
+                    "shell",
+                    "applescript",
+                    "javascript",
+                    "html",
+                    "powershell",
+                ],
+            },
+            "code": {"type": "string", "description": "The code to execute (required)"},
+        },
+        "required": ["language", "code"],
+    },
+}
+
+# tool_choice value for general_function_schema
+# https://platform.openai.com/docs/api-reference/chat/create#chat-create-tool_choice
+GENERAL_TOOL_CHOICE = {"type": "function", "function": {"name": "execute"}}

metagpt/provider/general_api_requestor.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc   : General Async API for http-based LLM model
+
+import asyncio
+from typing import AsyncGenerator, Tuple, Union
+
+import aiohttp
+from openai.api_requestor import APIRequestor
+
+from metagpt.logs import logger
+
+
+class GeneralAPIRequestor(APIRequestor):
+    """
+    usage
+        # full_url = "{api_base}{url}"
+        requester = GeneralAPIRequestor(api_base=api_base)
+        result, _, api_key = await requester.arequest(
+            method=method,
+            url=url,
+            headers=headers,
+            stream=stream,
+            params=kwargs,
+            request_timeout=120
+        )
+    """
+
+    def _interpret_response_line(self, rbody: str, rcode: int, rheaders, stream: bool) -> str:
+        # just do nothing to meet the APIRequestor process and return the raw data
+        # due to the openai sdk will convert the data into OpenAIResponse which we don't need in general cases.
+
+        return rbody
+
+    async def _interpret_async_response(
+        self, result: aiohttp.ClientResponse, stream: bool
+    ) -> Tuple[Union[str, AsyncGenerator[str, None]], bool]:
+        if stream and "text/event-stream" in result.headers.get("Content-Type", ""):
+            return (
+                self._interpret_response_line(line, result.status, result.headers, stream=True)
+                async for line in result.content
+            ), True
+        else:
+            try:
+                await result.read()
+            except (aiohttp.ServerTimeoutError, asyncio.TimeoutError) as e:
+                raise TimeoutError("Request timed out") from e
+            except aiohttp.ClientError as exp:
+                logger.warning(f"response: {result.content}, exp: {exp}")
+            return (
+                self._interpret_response_line(
+                    await result.read(),  # let the caller to decode the msg
+                    result.status,
+                    result.headers,
+                    stream=False,
+                ),
+                False,
+            )

metagpt/provider/human_provider.py

@@ -0,0 +1,37 @@
+"""
+Filename: MetaGPT/metagpt/provider/human_provider.py
+Created Date: Wednesday, November 8th 2023, 11:55:46 pm
+Author: garylin2099
+"""
+from typing import Optional
+
+from metagpt.logs import logger
+from metagpt.provider.base_gpt_api import BaseGPTAPI
+
+
+class HumanProvider(BaseGPTAPI):
+    """Humans provide themselves as a 'model', which actually takes in human input as its response.
+    This enables replacing LLM anywhere in the framework with a human, thus introducing human interaction
+    """
+
+    def ask(self, msg: str) -> str:
+        logger.info("It's your turn, please type in your response. You may also refer to the context below")
+        rsp = input(msg)
+        if rsp in ["exit", "quit"]:
+            exit()
+        return rsp
+
+    async def aask(self, msg: str, system_msgs: Optional[list[str]] = None) -> str:
+        return self.ask(msg)
+
+    def completion(self, messages: list[dict]):
+        """dummy implementation of abstract method in base"""
+        return []
+
+    async def acompletion(self, messages: list[dict]):
+        """dummy implementation of abstract method in base"""
+        return []
+
+    async def acompletion_text(self, messages: list[dict], stream=False) -> str:
+        """dummy implementation of abstract method in base"""
+        return []

metagpt/provider/openai_api.py

@@ -21,6 +21,8 @@ from tenacity import (
 from metagpt.config import CONFIG
 from metagpt.logs import logger
 from metagpt.provider.base_gpt_api import BaseGPTAPI
+from metagpt.provider.constant import GENERAL_FUNCTION_SCHEMA, GENERAL_TOOL_CHOICE
+from metagpt.schema import Message
 from metagpt.utils.singleton import Singleton
 from metagpt.utils.token_counter import (
     TOKEN_COSTS,
@@ -155,6 +157,8 @@ class OpenAIGPTAPI(BaseGPTAPI, RateLimiter):
         if config.openai_api_type:
             openai.api_type = config.openai_api_type
             openai.api_version = config.openai_api_version
+        if config.openai_proxy:
+            openai.proxy = config.openai_proxy
         self.rpm = int(config.get("RPM", 10))
 
     async def _achat_completion_stream(self, messages: list[dict]) -> str:
@@ -179,7 +183,7 @@ class OpenAIGPTAPI(BaseGPTAPI, RateLimiter):
         self._update_costs(usage)
         return full_reply_content
 
-    def _cons_kwargs(self, messages: list[dict]) -> dict:
+    def _cons_kwargs(self, messages: list[dict], **configs) -> dict:
         kwargs = {
             "messages": messages,
             "max_tokens": self.get_max_tokens(messages),
@@ -188,6 +192,9 @@ class OpenAIGPTAPI(BaseGPTAPI, RateLimiter):
             "temperature": 0.3,
             "timeout": 3,
         }
+        if configs:
+            kwargs.update(configs)
+
         if CONFIG.openai_api_type == "azure":
             if CONFIG.deployment_name and CONFIG.deployment_id:
                 raise ValueError("You can only use one of the `deployment_id` or `deployment_name` model")
@@ -237,6 +244,81 @@ class OpenAIGPTAPI(BaseGPTAPI, RateLimiter):
         rsp = await self._achat_completion(messages)
         return self.get_choice_text(rsp)
 
+    def _func_configs(self, messages: list[dict], **kwargs) -> dict:
+        """
+        Note: Keep kwargs consistent with the parameters in the https://platform.openai.com/docs/api-reference/chat/create
+        """
+        if "tools" not in kwargs:
+            configs = {
+                "tools": [{"type": "function", "function": GENERAL_FUNCTION_SCHEMA}],
+                "tool_choice": GENERAL_TOOL_CHOICE,
+            }
+            kwargs.update(configs)
+
+        return self._cons_kwargs(messages, **kwargs)
+
+    def _chat_completion_function(self, messages: list[dict], **kwargs) -> dict:
+        rsp = self.llm.ChatCompletion.create(**self._func_configs(messages, **kwargs))
+        self._update_costs(rsp.get("usage"))
+        return rsp
+
+    async def _achat_completion_function(self, messages: list[dict], **chat_configs) -> dict:
+        rsp = await self.llm.ChatCompletion.acreate(**self._func_configs(messages, **chat_configs))
+        self._update_costs(rsp.get("usage"))
+        return rsp
+
+    def _process_message(self, messages: Union[str, Message, list[dict], list[Message], list[str]]) -> list[dict]:
+        """convert messages to list[dict]."""
+        if isinstance(messages, list):
+            messages = [Message(msg) if isinstance(msg, str) else msg for msg in messages]
+            return [msg if isinstance(msg, dict) else msg.to_dict() for msg in messages]
+
+        if isinstance(messages, Message):
+            messages = [messages.to_dict()]
+        elif isinstance(messages, str):
+            messages = [{"role": "user", "content": messages}]
+        else:
+            raise ValueError(
+                f"Only support messages type are: str, Message, list[dict], but got {type(messages).__name__}!"
+            )
+        return messages
+
+    def ask_code(self, messages: Union[str, Message, list[dict]], **kwargs) -> dict:
+        """Use function of tools to ask a code.
+
+        Note: Keep kwargs consistent with the parameters in the https://platform.openai.com/docs/api-reference/chat/create
+
+        Examples:
+
+        >>> llm = OpenAIGPTAPI()
+        >>> llm.ask_code("Write a python hello world code.")
+        {'language': 'python', 'code': "print('Hello, World!')"}
+        >>> msg = [{'role': 'user', 'content': "Write a python hello world code."}]
+        >>> llm.ask_code(msg)
+        {'language': 'python', 'code': "print('Hello, World!')"}
+        """
+        messages = self._process_message(messages)
+        rsp = self._chat_completion_function(messages, **kwargs)
+        return self.get_choice_function_arguments(rsp)
+
+    async def aask_code(self, messages: Union[str, Message, list[dict]], **kwargs) -> dict:
+        """Use function of tools to ask a code.
+
+        Note: Keep kwargs consistent with the parameters in the https://platform.openai.com/docs/api-reference/chat/create
+
+        Examples:
+
+        >>> llm = OpenAIGPTAPI()
+        >>> rsp = await llm.ask_code("Write a python hello world code.")
+        >>> rsp
+        {'language': 'python', 'code': "print('Hello, World!')"}
+        >>> msg = [{'role': 'user', 'content': "Write a python hello world code."}]
+        >>> rsp = await llm.aask_code(msg)   # -> {'language': 'python', 'code': "print('Hello, World!')"}
+        """
+        messages = self._process_message(messages)
+        rsp = await self._achat_completion_function(messages, **kwargs)
+        return self.get_choice_function_arguments(rsp)
+
     def _calc_usage(self, messages: list[dict], rsp: str) -> dict:
         usage = {}
         if CONFIG.calc_usage:

metagpt/provider/zhipuai/__init__.py

@@ -0,0 +1,3 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc   :

metagpt/provider/zhipuai/async_sse_client.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc   : async_sse_client to make keep the use of Event to access response
+#           refs to `https://github.com/zhipuai/zhipuai-sdk-python/blob/main/zhipuai/utils/sse_client.py`
+
+from zhipuai.utils.sse_client import _FIELD_SEPARATOR, Event, SSEClient
+
+
+class AsyncSSEClient(SSEClient):
+    async def _aread(self):
+        data = b""
+        async for chunk in self._event_source:
+            for line in chunk.splitlines(True):
+                data += line
+                if data.endswith((b"\r\r", b"\n\n", b"\r\n\r\n")):
+                    yield data
+                    data = b""
+        if data:
+            yield data
+
+    async def async_events(self):
+        async for chunk in self._aread():
+            event = Event()
+            # Split before decoding so splitlines() only uses \r and \n
+            for line in chunk.splitlines():
+                # Decode the line.
+                line = line.decode(self._char_enc)
+
+                # Lines starting with a separator are comments and are to be
+                # ignored.
+                if not line.strip() or line.startswith(_FIELD_SEPARATOR):
+                    continue
+
+                data = line.split(_FIELD_SEPARATOR, 1)
+                field = data[0]
+
+                # Ignore unknown fields.
+                if field not in event.__dict__:
+                    self._logger.debug("Saw invalid field %s while parsing " "Server Side Event", field)
+                    continue
+
+                if len(data) > 1:
+                    # From the spec:
+                    # "If value starts with a single U+0020 SPACE character,
+                    # remove it from value."
+                    if data[1].startswith(" "):
+                        value = data[1][1:]
+                    else:
+                        value = data[1]
+                else:
+                    # If no value is present after the separator,
+                    # assume an empty value.
+                    value = ""
+
+                # The data field may come over multiple lines and their values
+                # are concatenated with each other.
+                if field == "data":
+                    event.__dict__[field] += value + "\n"
+                else:
+                    event.__dict__[field] = value
+
+            # Events with no data are not dispatched.
+            if not event.data:
+                continue
+
+            # If the data field ends with a newline, remove it.
+            if event.data.endswith("\n"):
+                event.data = event.data[0:-1]
+
+            # Empty event names default to 'message'
+            event.event = event.event or "message"
+
+            # Dispatch the event
+            self._logger.debug("Dispatching %s...", event)
+            yield event

metagpt/provider/zhipuai/zhipu_model_api.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc   : zhipu model api to support sync & async for invoke & sse_invoke
+
+import zhipuai
+from zhipuai.model_api.api import InvokeType, ModelAPI
+from zhipuai.utils.http_client import headers as zhipuai_default_headers
+
+from metagpt.provider.general_api_requestor import GeneralAPIRequestor
+from metagpt.provider.zhipuai.async_sse_client import AsyncSSEClient
+
+
+class ZhiPuModelAPI(ModelAPI):
+    @classmethod
+    def get_header(cls) -> dict:
+        token = cls._generate_token()
+        zhipuai_default_headers.update({"Authorization": token})
+        return zhipuai_default_headers
+
+    @classmethod
+    def get_sse_header(cls) -> dict:
+        token = cls._generate_token()
+        headers = {"Authorization": token}
+        return headers
+
+    @classmethod
+    def split_zhipu_api_url(cls, invoke_type: InvokeType, kwargs):
+        # use this method to prevent zhipu api upgrading to different version.
+        # and follow the GeneralAPIRequestor implemented based on openai sdk
+        zhipu_api_url = cls._build_api_url(kwargs, invoke_type)
+        """
+            example:
+                zhipu_api_url: https://open.bigmodel.cn/api/paas/v3/model-api/{model}/{invoke_method}
+        """
+        arr = zhipu_api_url.split("/api/")
+        # ("https://open.bigmodel.cn/api/" , "/paas/v3/model-api/chatglm_turbo/invoke")
+        return f"{arr[0]}/api", f"/{arr[1]}"
+
+    @classmethod
+    async def arequest(cls, invoke_type: InvokeType, stream: bool, method: str, headers: dict, kwargs):
+        # TODO to make the async request to be more generic for models in http mode.
+        assert method in ["post", "get"]
+
+        api_base, url = cls.split_zhipu_api_url(invoke_type, kwargs)
+        requester = GeneralAPIRequestor(api_base=api_base)
+        result, _, api_key = await requester.arequest(
+            method=method,
+            url=url,
+            headers=headers,
+            stream=stream,
+            params=kwargs,
+            request_timeout=zhipuai.api_timeout_seconds,
+        )
+
+        return result
+
+    @classmethod
+    async def ainvoke(cls, **kwargs) -> dict:
+        """async invoke different from raw method `async_invoke` which get the final result by task_id"""
+        headers = cls.get_header()
+        resp = await cls.arequest(
+            invoke_type=InvokeType.SYNC, stream=False, method="post", headers=headers, kwargs=kwargs
+        )
+        return resp
+
+    @classmethod
+    async def asse_invoke(cls, **kwargs) -> AsyncSSEClient:
+        """async sse_invoke"""
+        headers = cls.get_sse_header()
+        return AsyncSSEClient(
+            await cls.arequest(invoke_type=InvokeType.SSE, stream=True, method="post", headers=headers, kwargs=kwargs)
+        )

metagpt/provider/zhipuai_api.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc   : zhipuai LLM from https://open.bigmodel.cn/dev/api#sdk
+
+import json
+from enum import Enum
+
+import openai
+import zhipuai
+from requests import ConnectionError
+from tenacity import (
+    after_log,
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_fixed,
+)
+
+from metagpt.config import CONFIG
+from metagpt.logs import logger
+from metagpt.provider.base_gpt_api import BaseGPTAPI
+from metagpt.provider.openai_api import CostManager, log_and_reraise
+from metagpt.provider.zhipuai.zhipu_model_api import ZhiPuModelAPI
+
+
+class ZhiPuEvent(Enum):
+    ADD = "add"
+    ERROR = "error"
+    INTERRUPTED = "interrupted"
+    FINISH = "finish"
+
+
+class ZhiPuAIGPTAPI(BaseGPTAPI):
+    """
+    Refs to `https://open.bigmodel.cn/dev/api#chatglm_turbo`
+    From now, there is only one model named `chatglm_turbo`
+    """
+
+    use_system_prompt: bool = False  # zhipuai has no system prompt when use api
+
+    def __init__(self):
+        self.__init_zhipuai(CONFIG)
+        self.llm = ZhiPuModelAPI
+        self.model = "chatglm_turbo"  # so far only one model, just use it
+        self._cost_manager = CostManager()
+
+    def __init_zhipuai(self, config: CONFIG):
+        assert config.zhipuai_api_key
+        zhipuai.api_key = config.zhipuai_api_key
+        openai.api_key = zhipuai.api_key  # due to use openai sdk, set the api_key but it will't be used.
+
+    def _const_kwargs(self, messages: list[dict]) -> dict:
+        kwargs = {"model": self.model, "prompt": messages, "temperature": 0.3}
+        return kwargs
+
+    def _update_costs(self, usage: dict):
+        """update each request's token cost"""
+        if CONFIG.calc_usage:
+            try:
+                prompt_tokens = int(usage.get("prompt_tokens", 0))
+                completion_tokens = int(usage.get("completion_tokens", 0))
+                self._cost_manager.update_cost(prompt_tokens, completion_tokens, self.model)
+            except Exception as e:
+                logger.error("zhipuai updats costs failed!", e)
+
+    def get_choice_text(self, resp: dict) -> str:
+        """get the first text of choice from llm response"""
+        assist_msg = resp.get("data", {}).get("choices", [{"role": "error"}])[-1]
+        assert assist_msg["role"] == "assistant"
+        return assist_msg.get("content")
+
+    def completion(self, messages: list[dict]) -> dict:
+        resp = self.llm.invoke(**self._const_kwargs(messages))
+        usage = resp.get("data").get("usage")
+        self._update_costs(usage)
+        return resp
+
+    async def _achat_completion(self, messages: list[dict]) -> dict:
+        resp = await self.llm.ainvoke(**self._const_kwargs(messages))
+        usage = resp.get("data").get("usage")
+        self._update_costs(usage)
+        return resp
+
+    async def acompletion(self, messages: list[dict]) -> dict:
+        return await self._achat_completion(messages)
+
+    async def _achat_completion_stream(self, messages: list[dict]) -> str:
+        response = await self.llm.asse_invoke(**self._const_kwargs(messages))
+        collected_content = []
+        usage = {}
+        async for event in response.async_events():
+            if event.event == ZhiPuEvent.ADD.value:
+                content = event.data
+                collected_content.append(content)
+                print(content, end="")
+            elif event.event == ZhiPuEvent.ERROR.value or event.event == ZhiPuEvent.INTERRUPTED.value:
+                content = event.data
+                logger.error(f"event error: {content}", end="")
+                collected_content.append([content])
+            elif event.event == ZhiPuEvent.FINISH.value:
+                """
+                event.meta
+                    {
+                        "task_status":"SUCCESS",
+                        "usage":{
+                            "completion_tokens":351,
+                            "prompt_tokens":595,
+                            "total_tokens":946
+                        },
+                        "task_id":"xx",
+                        "request_id":"xxx"
+                    }
+                """
+                meta = json.loads(event.meta)
+                usage = meta.get("usage")
+            else:
+                print(f"zhipuapi else event: {event.data}", end="")
+
+        self._update_costs(usage)
+        full_content = "".join(collected_content)
+        return full_content
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_fixed(1),
+        after=after_log(logger, logger.level("WARNING").name),
+        retry=retry_if_exception_type(ConnectionError),
+        retry_error_callback=log_and_reraise,
+    )
+    async def acompletion_text(self, messages: list[dict], stream=False) -> str:
+        """response in async with stream or non-stream mode"""
+        if stream:
+            return await self._achat_completion_stream(messages)
+        resp = await self._achat_completion(messages)
+        return self.get_choice_text(resp)