zcbot 1.8.7__py3-none-any.whl

core_plugins/__init__.py

@@ -0,0 +1,2 @@
+# core_plugins - 官方插件目录
+# 框架加载器会扫描此目录下的子目录，每个子目录是一个官方插件

core_plugins/aiwriter/agent.py

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+"""智能体循环（工具调用闭环）。
+
+把用户的话交给模型 → 模型流式输出文本 / 点名要调哪只「手」（工具）→ 本地执行
+→ 结果回灌 → 模型再说话，直到不再调用工具。多轮收敛，到达 max_rounds 强制收口。
+
+整轮以「事件」对外汇报（text / tool_start / tool_end /
+error / done），终端据此实时渲染过程；循环本身不打印，便于测试与复用。
+"""
+import json
+
+try:  # 包导入（测试 / 包内引用）
+    from .llm import LLMError, stream_chat
+except ImportError:  # 框架 loader 以「顶层模块」加载本插件：无父包，退回同目录绝对导入
+    import os as _os
+    import sys as _sys
+    _sys.path.insert(0, _os.path.dirname(_os.path.abspath(__file__)))
+    from llm import LLMError, stream_chat
+
+
+class Agent:
+    """一次会话内的智能体执行器（无状态之外仅持 cfg / tools / 事件回调）。"""
+
+    def __init__(self, cfg, tools, on_event=None, should_stop=None):
+        self.cfg = cfg
+        self.tools = tools
+        self._emit = on_event or (lambda kind, payload=None: None)
+        self._should_stop = should_stop or (lambda: False)
+
+    # ── 主循环 ─────────────────────────────────────────────────────────
+    def run(self, messages):
+        """就地把一轮交互追加进 messages，返回本轮最终文本。
+
+        messages 需自带 system 提示（见 prompt.build）。返回值为模型最后一段
+        自然语言（可能为空字符串）；历史与工具轮均已写入 messages。
+        """
+        tool_specs = self.tools.specs()
+        max_rounds = max(1, int(self.cfg.get('max_rounds', 12) or 12))
+        last_text = ''
+
+        for _ in range(max_rounds):
+            if self._should_stop():
+                return last_text or '(已取消)'
+
+            text_acc, calls = self._one_turn(messages, tool_specs)
+            last_text = text_acc
+
+            if not calls:
+                messages.append({'role': 'assistant', 'content': text_acc})
+                return text_acc or '(模型未返回内容)'
+
+            # 记录 assistant 的工具调用（OpenAI 兼容格式）
+            asst_calls = []
+            for i, c in enumerate(calls):
+                asst_calls.append({
+                    'id': 'c%d' % i,
+                    'type': 'function',
+                    'function': {'name': c['name'], 'arguments': c.get('arguments', '')},
+                })
+            messages.append({'role': 'assistant', 'content': text_acc or None,
+                             'tool_calls': asst_calls})
+
+            # 逐个执行工具并回灌
+            for i, c in enumerate(calls):
+                if self._should_stop():
+                    return last_text or '(已取消)'
+                try:
+                    args = json.loads(c.get('arguments') or '{}')
+                    if not isinstance(args, dict):
+                        args = {}
+                except Exception:
+                    args = {}
+                self._emit('tool_start', {'name': c['name'], 'args': args})
+                try:
+                    out = self.tools.call(c['name'], args)
+                    ok = True
+                except Exception as e:  # noqa: BLE001 —— 工具异常回灌给模型，不外抛
+                    out = '错误: %s' % e
+                    ok = False
+                self._emit('tool_end', {'name': c['name'], 'args': args,
+                                        'ok': ok, 'result': str(out)})
+                messages.append({
+                    'role': 'tool',
+                    'tool_call_id': 'c%d' % i,
+                    'content': str(out)[:4000],
+                })
+
+        self._emit('error', {'message': '达到最大轮数（%d），已强制收口' % max_rounds})
+        return last_text or '(达到最大轮数，已强制收口)'
+
+    # ── 单轮：流式取回文本与工具调用 ────────────────────────────────────
+    def _one_turn(self, messages, tool_specs):
+        text_acc = ''
+        calls = []
+        try:
+            for kind, val in stream_chat(self.cfg, messages, tool_specs):
+                if kind == 'text':
+                    text_acc += val
+                    self._emit('text', val)
+                elif kind == 'reason':
+                    self._emit('reason', val)
+                elif kind == 'tool':
+                    calls.append(val)
+        except LLMError as e:
+            self._emit('error', {'message': str(e)})
+            raise
+        return text_acc, calls

core_plugins/aiwriter/llm.py

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+"""OpenAI 兼容的流式 LLM 客户端（零三方依赖，仅用标准库）。
+
+对应 dsh 的「模型提供商 / provider」一层：把对话历史换成模型回复。
+这里刻意不依赖 llm_core，插件自带一份最小实现，开箱即连任意 OpenAI 兼容端点
+（DeepSeek / Moonshot / 智谱 / vLLM / Ollama / One-API 等，判断标准只有一条：
+能不能用 Bearer + {"messages": [...]} 说话）。
+"""
+import json
+import urllib.error
+import urllib.request
+
+
+class LLMError(Exception):
+    pass
+
+
+def _sse_stream(cfg, messages, tools):
+    """向 chat/completions 发流式请求，逐事件 yield。
+
+    yield 形状：
+      ("text", str)            文本增量
+      ("reason", str)          深度思考 / 推理过程增量（reasoning_content 等）
+      ("tool", {"name","arguments"})  完整的一次工具调用（流结束后汇总）
+      ("done", None)           流结束
+    """
+    base = cfg["base_url"].rstrip("/")
+    url = base + "/chat/completions"
+    payload = {
+        "model": cfg["model"],
+        "messages": messages,
+        "temperature": cfg.get("temperature", 0.7),
+        "stream": True,
+    }
+    if tools:
+        payload["tools"] = [{"type": "function", "function": t} for t in tools]
+        payload["tool_choice"] = "auto"
+
+    # 深度思考开关：各家字段不统一，这里按需注入常见写法
+    if cfg.get("thinking"):
+        style = str(cfg.get("thinking_style", "auto") or "auto").lower()
+        if style in ("auto", "anthropic", "claude"):
+            payload["thinking"] = {"type": "enabled"}
+        if style in ("auto", "flag"):
+            payload["enable_thinking"] = True
+        if style in ("auto", "openai"):
+            payload["reasoning_effort"] = str(cfg.get("reasoning_effort", "medium"))
+
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(
+        url, data=data, method="POST",
+        headers={
+            "Content-Type": "application/json",
+            "Authorization": "Bearer %s" % cfg["api_key"],
+        },
+    )
+    try:
+        resp = urllib.request.urlopen(req, timeout=cfg.get("timeout", 120))
+    except urllib.error.HTTPError as e:
+        body = e.read().decode("utf-8", "replace")[:400]
+        raise LLMError("HTTP %s: %s" % (e.code, body))
+    except Exception as e:  # 网络层
+        raise LLMError("请求失败: %s" % e)
+
+    tool_acc = {}  # index -> {name, arguments}
+    for raw in resp:
+        line = raw.decode("utf-8", "replace").strip()
+        if not line or not line.startswith("data:"):
+            continue
+        chunk = line[5:].strip()
+        if chunk == "[DONE]":
+            break
+        try:
+            obj = json.loads(chunk)
+        except Exception:
+            continue
+        if not obj.get("choices"):
+            continue
+        delta = obj["choices"][0].get("delta", {})
+        # 深度思考 / 推理：各家字段名不统一（DeepSeek=reasoning_content、
+        # OpenAI-o 系=reasoning、部分网关=thinking / reasoning_delta）
+        reason = (delta.get("reasoning_content")
+                  or delta.get("reasoning")
+                  or delta.get("thinking")
+                  or (delta.get("reasoning_delta") or {}).get("content")
+                  or "")
+        if reason:
+            yield ("reason", reason)
+        if delta.get("content"):
+            yield ("text", delta["content"])
+        for tc in delta.get("tool_calls", []) or []:
+            idx = tc.get("index", 0)
+            acc = tool_acc.setdefault(idx, {"name": "", "arguments": ""})
+            fn = tc.get("function", {}) or {}
+            if fn.get("name"):
+                acc["name"] += fn["name"]
+            if fn.get("arguments"):
+                acc["arguments"] += fn["arguments"]
+    for acc in tool_acc.values():
+        if acc["name"]:
+            yield ("tool", dict(acc))
+    yield ("done", None)
+
+
+def stream_chat(cfg, messages, tools=None):
+    """公开入口：包一层，便于调用方直接 for kind, val in stream_chat(...)。"""
+    return _sse_stream(cfg, messages, tools or [])