jarvis-ai-assistant 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

jarvis/jarvis_platform/kimi.py

@@ -156,39 +156,24 @@ class KimiModel(BasePlatform):
                 sleep_time=5,
             )
 
-            response_data = b""
-
             # 处理流式响应
-            for chunk in response_stream:
-                response_data += chunk
-
-                # 尝试解析SSE格式的数据
-                try:
-                    # 查找完整的数据行
-                    lines = response_data.decode("utf-8").split("\n")
-                    response_data = b""  # 重置缓冲区
-
-                    for line in lines:
-                        if not line.strip():
-                            continue
-
-                        # SSE格式的行通常以"data: "开头
-                        if line.startswith("data: "):
-                            try:
-                                data = json.loads(line[6:])
-                                if data.get("event") == "resp":
-                                    status = data.get("file_info", {}).get("status")
-                                    if status == "parsed":
-                                        return True
-                                    elif status == "failed":
-                                        return False
-                            except json.JSONDecodeError:
-                                continue
-
-                except UnicodeDecodeError:
-                    # 如果解码失败，继续累积数据
+            for line in response_stream:
+                if not line.strip():
                     continue
 
+                # SSE格式的行通常以"data: "开头
+                if line.startswith("data: "):
+                    try:
+                        data = json.loads(line[6:])
+                        if data.get("event") == "resp":
+                            status = data.get("file_info", {}).get("status")
+                            if status == "parsed":
+                                return True
+                            elif status == "failed":
+                                return False
+                    except json.JSONDecodeError:
+                        continue
+
             retry_count += 1
             time.sleep(1)
 
@@ -299,40 +284,25 @@ class KimiModel(BasePlatform):
                 sleep_time=5,
             )
 
-            response_data = b""
-
             # 处理流式响应
-            for chunk in response_stream:
-                response_data += chunk
-
-                # 尝试解析SSE格式的数据
-                try:
-                    # 查找完整的数据行
-                    lines = response_data.decode("utf-8").split("\n")
-                    response_data = b""  # 重置缓冲区
-
-                    for line in lines:
-                        if not line.strip():
-                            continue
-
-                        # SSE格式的行通常以"data: "开头
-                        if line.startswith("data: "):
-                            try:
-                                data = json.loads(line[6:])
-                                event = data.get("event")
-
-                                if event == "cmpl":
-                                    # 处理补全文本
-                                    text = data.get("text", "")
-                                    if text:
-                                        yield text
-                            except json.JSONDecodeError:
-                                continue
-
-                except UnicodeDecodeError:
-                    # 如果解码失败，继续累积数据
+            for line in response_stream:
+                if not line.strip():
                     continue
 
+                # SSE格式的行通常以"data: "开头
+                if line.startswith("data: "):
+                    try:
+                        data = json.loads(line[6:])
+                        event = data.get("event")
+
+                        if event == "cmpl":
+                            # 处理补全文本
+                            text = data.get("text", "")
+                            if text:
+                                yield text
+                    except json.JSONDecodeError:
+                        continue
+
             return None
 
         except Exception as e:

jarvis/jarvis_platform/tongyi.py

@@ -8,9 +8,9 @@ from typing import Any, Dict, Generator, List, Tuple
 from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_utils import http
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.tag import ot, ct
 from jarvis.jarvis_utils.utils import while_success
 
-
 class TongyiPlatform(BasePlatform):
     """Tongyi platform implementation"""
 
@@ -81,10 +81,10 @@ class TongyiPlatform(BasePlatform):
                 "contentType": "text",
                 "role": "user",
                 "ext": {
-                    "searchType": "",
+                    "searchType": "depth" if self.web else "",
                     "pptGenerate": False,
-                    "deepThink": False,
-                    "deepResearch": False,
+                    "deepThink": self.model_name == "Thinking",
+                    "deepResearch": self.model_name == "Deep-Research",
                 },
             }
         ]
@@ -98,10 +98,10 @@ class TongyiPlatform(BasePlatform):
                     "contentType": "text",
                     "role": "system",
                     "ext": {
-                        "searchType": "",
+                        "searchType": "depth" if self.web else "",
                         "pptGenerate": False,
-                        "deepThink": False,
-                        "deepResearch": False,
+                        "deepThink": self.model_name == "Thinking",
+                        "deepResearch": self.model_name == "Deep-Research",
                     },
                 },
             )
@@ -140,13 +140,13 @@ class TongyiPlatform(BasePlatform):
             "parentMsgId": self.msg_id,
             "params": {
                 "agentId": "",
-                "searchType": "",
+                "searchType": "depth" if self.web else "",
                 "pptGenerate": False,
                 "bizScene": "code_chat" if self.model_name == "Code-Chat" else "",
                 "bizSceneInfo": {},
                 "specifiedModel": "",
-                "deepThink": True if self.model_name == "Thinking" else False,
-                "deepResearch": False,
+                "deepThink": self.model_name == "Thinking",
+                "deepResearch": self.model_name == "Deep-Research",
                 "fileUploadBatchId": (
                     self.uploaded_file_info[0]["batchId"]
                     if self.uploaded_file_info
@@ -168,88 +168,74 @@ class TongyiPlatform(BasePlatform):
             thinking_content = ""
             text_content = ""
             in_thinking = False
-            response_data = b""
 
             # 处理流式响应
-            for chunk in response_stream:
-                response_data += chunk
-
-                # 尝试解析SSE格式的数据
-                try:
-                    # 查找完整的数据行
-                    lines = response_data.decode("utf-8").split("\n")
-                    response_data = b""  # 重置缓冲区
-
-                    for line in lines:
-                        if not line.strip():
-                            continue
-
-                        # SSE格式的行通常以"data: "开头
-                        if line.startswith("data: "):
-                            try:
-                                data = json.loads(line[6:])
-                                # 记录消息ID和会话ID
-                                if "msgId" in data:
-                                    msg_id = data["msgId"]
-                                if "sessionId" in data:
-                                    session_id = data["sessionId"]
-
-                                if "contents" in data and len(data["contents"]) > 0:
-                                    for content in data["contents"]:
-                                        if content.get("contentType") == "think":
-                                            if not in_thinking:
-                                                yield "<think>\n\n"
-                                                in_thinking = True
-                                            if content.get("incremental"):
-                                                tmp_content = json.loads(
-                                                    content.get("content")
-                                                )["content"]
-                                                thinking_content += tmp_content
-                                                yield tmp_content
-                                            else:
-                                                tmp_content = json.loads(
-                                                    content.get("content")
-                                                )["content"]
-                                                if len(thinking_content) < len(
-                                                    tmp_content
-                                                ):
-                                                    yield tmp_content[
-                                                        len(thinking_content) :
-                                                    ]
-                                                    thinking_content = tmp_content
-                                                else:
-                                                    yield "\r\n</think>\n"[
-                                                        len(thinking_content)
-                                                        - len(tmp_content) :
-                                                    ]
-                                                    thinking_content = tmp_content
-                                                in_thinking = False
-                                        elif content.get("contentType") == "text":
-                                            if in_thinking:
-                                                continue
-                                            if content.get("incremental"):
-                                                tmp_content = content.get("content")
-                                                text_content += tmp_content
-                                                yield tmp_content
-                                            else:
-                                                tmp_content = content.get("content")
-                                                if len(text_content) < len(tmp_content):
-                                                    yield tmp_content[
-                                                        len(text_content) :
-                                                    ]
-                                                    text_content = tmp_content
-
-                            except json.JSONDecodeError:
-                                continue
-
-                except UnicodeDecodeError:
-                    # 如果解码失败，继续累积数据
+            for line in response_stream:
+                if not line.strip():
                     continue
 
+                # SSE格式的行通常以"data: "开头
+                if line.startswith("data: "):
+                    try:
+                        data = json.loads(line[6:])
+                        # 记录消息ID和会话ID
+                        if "msgId" in data:
+                            msg_id = data["msgId"]
+                        if "sessionId" in data:
+                            session_id = data["sessionId"]
+
+                        if "contents" in data and len(data["contents"]) > 0:
+                            for content in data["contents"]:
+                                if content.get("contentType") == "think":
+                                    if not in_thinking:
+                                        yield f"{ot('think')}\n\n"
+                                        in_thinking = True
+                                    if content.get("incremental"):
+                                        tmp_content = json.loads(
+                                            content.get("content")
+                                        )["content"]
+                                        thinking_content += tmp_content
+                                        yield tmp_content
+                                    else:
+                                        tmp_content = json.loads(
+                                            content.get("content")
+                                        )["content"]
+                                        if len(thinking_content) < len(
+                                            tmp_content
+                                        ):
+                                            yield tmp_content[
+                                                len(thinking_content) :
+                                            ]
+                                            thinking_content = tmp_content
+                                        else:
+                                            yield f"\r\n{ct('think')}\n"[
+                                                len(thinking_content)
+                                                - len(tmp_content) :
+                                            ]
+                                            thinking_content = tmp_content
+                                        in_thinking = False
+                                elif content.get("contentType") == "text":
+                                    if in_thinking:
+                                        continue
+                                    if content.get("incremental"):
+                                        tmp_content = content.get("content")
+                                        text_content += tmp_content
+                                        yield tmp_content
+                                    else:
+                                        tmp_content = content.get("content")
+                                        if len(text_content) < len(tmp_content):
+                                            yield tmp_content[
+                                                len(text_content) :
+                                            ]
+                                            text_content = tmp_content
+
+                    except json.JSONDecodeError:
+                        continue
+
             self.msg_id = msg_id
             self.session_id = session_id
 
-            return None
+            return
 
         except Exception as e:
             raise Exception(f"Chat failed: {str(e)}")

jarvis/jarvis_platform/yuanbao.py

@@ -12,6 +12,7 @@ from PIL import Image  # type: ignore
 from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_utils import http
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.tag import ot, ct
 from jarvis.jarvis_utils.utils import while_success
 
 
@@ -474,61 +475,54 @@ class YuanbaoPlatform(BasePlatform):
             )
 
             in_thinking = False
-            response_data = b""
 
             # 处理流式响应
-            for chunk in response_stream:
-                response_data += chunk
-
-                # 尝试解析SSE格式的数据
-                try:
-                    # 查找完整的数据行
-                    lines = response_data.decode("utf-8").split("\n")
-                    response_data = b""  # 重置缓冲区
-
-                    for line in lines:
-                        if not line.strip():
-                            continue
-
-                        # SSE格式的行通常以"data: "开头
-                        if line.startswith("data: "):
-                            try:
-                                data_str = line[6:]  # 移除"data: "前缀
-
-                                # 检查结束标志
-                                if data_str == "[DONE]":
-                                    self.first_chat = False
-                                    return None
-
-                                data = json.loads(data_str)
-
-                                # 处理文本类型的消息
-                                if data.get("type") == "text":
-                                    if in_thinking:
-                                        yield "</think>\n"
-                                        in_thinking = False
-                                    msg = data.get("msg", "")
-                                    if msg:
-                                        yield msg
-
-                                # 处理思考中的消息
-                                elif data.get("type") == "think":
-                                    if not in_thinking:
-                                        yield "<think>\n"
-                                        in_thinking = True
-                                    think_content = data.get("content", "")
-                                    if think_content:
-                                        yield think_content
-
-                            except json.JSONDecodeError:
-                                pass
-
-                except UnicodeDecodeError:
-                    # 如果解码失败，继续累积数据
+            for line in response_stream:
+                if not line.strip():
                     continue
 
+                # SSE格式的行通常以"data: "开头
+                if line.startswith("data: "):
+                    try:
+                        data_str = line[6:]  # 移除"data: "前缀
+
+                        # 检查结束标志
+                        if data_str == "[DONE]":
+                            self.first_chat = False
+                            return
+
+                        data = json.loads(data_str)
+
+                        # 处理文本类型的消息
+                        if data.get("type") == "text":
+                            if in_thinking:
+                                yield f"{ct('think')}\n"
+                                in_thinking = False
+                            msg = data.get("msg", "")
+                            if msg:
+                                yield msg
+
+                        # 处理思考中的消息
+                        elif data.get("type") == "think":
+                            if not in_thinking:
+                                yield f"{ot('think')}\n"
+                                in_thinking = True
+                            think_content = data.get("content", "")
+                            if think_content:
+                                yield think_content
+
+                    except json.JSONDecodeError:
+                        pass
+                else:
+                    try:
+                        data = json.loads(line)
+                        if "msg" in data:
+                            yield data["msg"]
+                    except json.JSONDecodeError:
+                        pass
+
             self.first_chat = False
-            return None
+            return
 
         except Exception as e:
             raise Exception(f"对话失败: {str(e)}")

jarvis/jarvis_platform_manager/main.py

@@ -3,17 +3,22 @@
 
 该模块提供了Jarvis平台管理器的主要入口点。
 """
-import argparse
 import os
+import sys
 from typing import Any, Dict, List, Optional
 
+import typer
+
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_utils.input import get_multiline_input, get_single_line_input
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import init_env
 from jarvis.jarvis_platform_manager.service import start_service
 
+app = typer.Typer(help="Jarvis AI 平台")
+
 
+@app.command("info")
 def list_platforms() -> None:
     """列出所有支持的平台和模型。"""
     registry = PlatformRegistry.get_global_platform_registry()
@@ -291,8 +296,11 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
             except Exception as exc:
                 PrettyOutput.print(f"聊天失败: {str(exc)}", OutputType.ERROR)
 
+    except typer.Exit:
+        raise
     except Exception as exc:
         PrettyOutput.print(f"初始化会话失败: {str(exc)}", OutputType.ERROR)
+        sys.exit(1)
     finally:
         # Clean up resources
         try:
@@ -301,16 +309,17 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
             pass
 
 
-def validate_platform_model(args: argparse.Namespace) -> bool:
+def validate_platform_model(platform: Optional[str], model: Optional[str]) -> bool:
     """验证平台和模型参数。
 
     参数:
-        args: 命令行参数。
+        platform: 平台名称。
+        model: 模型名称。
 
     返回:
         bool: 如果平台和模型有效返回True，否则返回False。
     """
-    if not args.platform or not args.model:
+    if not platform or not model:
         PrettyOutput.print(
             "请指定平台和模型。使用 'jarvis info' 查看可用平台和模型。",
             OutputType.WARNING,
@@ -319,38 +328,30 @@ def validate_platform_model(args: argparse.Namespace) -> bool:
     return True
 
 
-def chat_command(args: argparse.Namespace) -> None:
-    """处理聊天子命令。
-
-    参数:
-        args: 命令行参数。
-    """
-    if not validate_platform_model(args):
+@app.command("chat")
+def chat_command(
+    platform: Optional[str] = typer.Option(None, "--platform", "-p", help="指定要使用的平台"),
+    model: Optional[str] = typer.Option(None, "--model", "-m", help="指定要使用的模型"),
+) -> None:
+    """与指定平台和模型聊天。"""
+    if not validate_platform_model(platform, model):
         return
-    chat_with_model(args.platform, args.model, "")
+    chat_with_model(platform, model, "") # type: ignore
 
 
-def info_command(args: argparse.Namespace) -> None:
-    """处理信息子命令。
-
-    参数:
-        args: 命令行参数。
-    """
-    list_platforms()
-
-
-def service_command(args: argparse.Namespace) -> None:
-    """处理服务子命令 - 启动OpenAI兼容的API服务。
-
-    参数:
-        args: 命令行参数。
-    """
-    start_service(
-        host=args.host,
-        port=args.port,
-        default_platform=args.platform,
-        default_model=args.model,
-    )
+@app.command("service")
+def service_command(
+    host: str = typer.Option("127.0.0.1", help="服务主机地址 (默认: 127.0.0.1)"),
+    port: int = typer.Option(8000, help="服务端口 (默认: 8000)"),
+    platform: Optional[str] = typer.Option(
+        None, "-p", "--platform", help="指定默认平台，当客户端未指定平台时使用"
+    ),
+    model: Optional[str] = typer.Option(
+        None, "-m", "--model", help="指定默认模型，当客户端未指定平台时使用"
+    ),
+) -> None:
+    """启动OpenAI兼容的API服务。"""
+    start_service(host=host, port=port, default_platform=platform, default_model=model)
 
 
 def load_role_config(config_path: str) -> Dict[str, Any]:
@@ -377,13 +378,24 @@ def load_role_config(config_path: str) -> Dict[str, Any]:
             return {}
 
 
-def role_command(args: argparse.Namespace) -> None:
-    """Process role subcommand - load role config and start chat.
-
-    Args:
-        args: Command line arguments.
-    """
-    config = load_role_config(args.config)
+@app.command("role")
+def role_command(
+    config_file: str = typer.Option(
+        "~/.jarvis/roles.yaml",
+        "--config",
+        "-c",
+        help="角色配置文件路径(YAML格式，默认: ~/.jarvis/roles.yaml)",
+    ),
+    platform: Optional[str] = typer.Option(
+        None, "--platform", "-p", help="指定要使用的平台，覆盖角色配置"
+    ),
+    model: Optional[str] = typer.Option(
+        None, "--model", "-m", help="指定要使用的模型，覆盖角色配置"
+    ),
+) -> None:
+    """加载角色配置文件并开始对话。"""
+    config_path = os.path.expanduser(config_file)
+    config = load_role_config(config_path)
     if not config or "roles" not in config:
         PrettyOutput.print("无效的角色配置文件", OutputType.ERROR)
         return
@@ -407,8 +419,8 @@ def role_command(args: argparse.Namespace) -> None:
         return
 
     # 初始化平台和模型
-    platform_name = args.platform or selected_role["platform"]
-    model_name = args.model or selected_role["model"]
+    platform_name = platform or selected_role["platform"]
+    model_name = model or selected_role["model"]
     system_prompt = selected_role.get("system_prompt", "")
 
     # 开始对话
@@ -419,54 +431,7 @@ def role_command(args: argparse.Namespace) -> None:
 def main() -> None:
     """Jarvis平台管理器的主入口点。"""
     init_env("欢迎使用 Jarvis-PlatformManager，您的平台管理助手已准备就绪！")
-
-    parser = argparse.ArgumentParser(description="Jarvis AI 平台")
-    subparsers = parser.add_subparsers(dest="command", help="可用子命令")
-
-    # info subcommand
-    info_parser = subparsers.add_parser("info", help="显示支持的平台和模型信息")
-    info_parser.set_defaults(func=info_command)
-
-    # chat subcommand
-    chat_parser = subparsers.add_parser("chat", help="与指定平台和模型聊天")
-    chat_parser.add_argument("--platform", "-p", help="指定要使用的平台")
-    chat_parser.add_argument("--model", "-m", help="指定要使用的模型")
-    chat_parser.set_defaults(func=chat_command)
-
-    # service subcommand
-    service_parser = subparsers.add_parser("service", help="启动OpenAI兼容的API服务")
-    service_parser.add_argument(
-        "--host", default="127.0.0.1", help="服务主机地址 (默认: 127.0.0.1)"
-    )
-    service_parser.add_argument(
-        "--port", type=int, default=8000, help="服务端口 (默认: 8000)"
-    )
-    service_parser.add_argument(
-        "--platform", "-p", help="指定默认平台，当客户端未指定平台时使用"
-    )
-    service_parser.add_argument(
-        "--model", "-m", help="指定默认模型，当客户端未指定平台时使用"
-    )
-    service_parser.set_defaults(func=service_command)
-
-    # role subcommand
-    role_parser = subparsers.add_parser("role", help="加载角色配置文件并开始对话")
-    role_parser.add_argument(
-        "--config",
-        "-c",
-        default="~/.jarvis/roles.yaml",
-        help="角色配置文件路径(YAML格式，默认: ~/.jarvis/roles.yaml)",
-    )
-    role_parser.add_argument("--platform", "-p", help="指定要使用的平台，覆盖角色配置")
-    role_parser.add_argument("--model", "-m", help="指定要使用的模型，覆盖角色配置")
-    role_parser.set_defaults(func=role_command)
-
-    args = parser.parse_args()
-
-    if hasattr(args, "func"):
-        args.func(args)
-    else:
-        parser.print_help()
+    app()
 
 
 if __name__ == "__main__":