lcode-agent 0.1.0__py3-none-any.whl

lcode/protocol.py

@@ -0,0 +1,800 @@
+"""OpenAI 兼容协议。
+
+运行方式:
+    uv run python -m lcode.protocol
+
+读项目 config.json 里的 url / requestType / model 当默认值,
+用户配置统一在 ~/.lcode/config.json(url/model/apiKey 都在这一个文件)。
+密钥只来自环境变量 LCODE_API_KEY 或 ~/.lcode/config.json 的 apiKey。
+
+TUI 用 ask_stream(messages):每来一块就 yield ("thinking", 文本)、("answer", 文本)
+或 ("usage", 用量 dict)。messages 是多轮 [{role, content}, ...]。
+本文件单独跑时还是用 ask(),打一句 ping 看通不通。
+"""
+
+import asyncio
+import json
+
+import aiohttp
+
+from lcode.settings import api_key, load_runtime
+
+CONFIG = load_runtime()
+
+BASE_URL = str(CONFIG.get("url") or "").rstrip("/")
+REQUEST_TYPE = str(CONFIG.get("requestType") or "completions").strip().lower()
+MODEL = str(CONFIG.get("model") or "deepseek-v4-flash")
+API_KEY = api_key()
+
+# url 已经是 .../v1,这里只加后半段,不要再写 /v1
+COMPLETIONS_URL = BASE_URL + "/chat/completions"
+RESPONSES_URL = BASE_URL + "/responses"
+MODELS_URL = BASE_URL + "/models"
+
+# 拉 /models 失败时的输入预算,宁可偏小也不要按 100 万硬灌
+DEFAULT_INPUT_BUDGET = 128_000
+
+_model_limits_cache: dict | None = None
+
+
+def set_model(name: str) -> str:
+    """运行时切模型:改内存全局并写回 config.json,重启后仍生效。"""
+    global MODEL
+    name = str(name or "").strip()
+    if not name:
+        return MODEL
+    MODEL = name
+    from lcode.settings import save_project_config
+
+    save_project_config({"model": name})
+    reset_model_limits()
+    return MODEL
+
+
+def reset_model_limits() -> None:
+    """切模型后把 /models 缓存清掉,下次重新拉窗口大小。"""
+    global _model_limits_cache
+    _model_limits_cache = None
+
+
+_KNOWN_EFFORTS = ("low", "medium", "high", "minimal")
+
+
+def _reasoning_levels_of(hit: dict) -> list[str]:
+    """从 /models 的模型元数据里抠支持的推理等级。
+
+    没有标准字段;认两种:显式等级列表(reasoning_efforts / reasoning_levels),
+    和 OpenRouter 风格的 supported_parameters 含 reasoning_effort(按 low/medium/high 算)。
+    拿不到就返回空,调用方走启发式。
+    """
+    for key in ("reasoning_efforts", "reasoning_levels", "efforts"):
+        raw = hit.get(key)
+        if isinstance(raw, list):
+            levels = [str(x).strip().lower() for x in raw if str(x).strip()]
+            known = [x for x in _KNOWN_EFFORTS if x in levels]
+            if known:
+                return known
+    params = hit.get("supported_parameters")
+    if isinstance(params, list):
+        names = {str(x).strip().lower() for x in params}
+        if "reasoning_effort" in names or "reasoning" in names:
+            return ["low", "medium", "high"]
+    return []
+
+
+def headers() -> dict:
+    return {
+        "Authorization": f"Bearer {api_key()}",
+        "Content-Type": "application/json",
+    }
+
+
+def _positive_int(*values) -> int:
+    for value in values:
+        if value is None:
+            continue
+        try:
+            number = int(value)
+        except (TypeError, ValueError):
+            continue
+        if number > 0:
+            return number
+    return 0
+
+
+# 单次回答的输出上限和请求超时,可在 config.json 里用 maxTokens / timeoutSeconds 覆盖
+MAX_TOKENS = _positive_int(CONFIG.get("maxTokens"), CONFIG.get("max_tokens")) or 4096
+REQUEST_TIMEOUT = _positive_int(
+    CONFIG.get("timeoutSeconds"), CONFIG.get("timeout")
+) or 180
+
+# 推理等级:OpenAI o 系/gpt-5 的 reasoning_effort(low/medium/high)。
+# 不是所有兼容网关都认;不配置就不发,被 400 拒了会自动去掉再试一次。
+REASONING_EFFORT = str(CONFIG.get("reasoningEffort") or "").strip().lower()
+if REASONING_EFFORT in ("default", "none", "无", "默认"):
+    REASONING_EFFORT = ""
+
+
+def set_reasoning_effort(effort: str) -> str:
+    """设置推理等级并写回 ~/.lcode/config.json;空串表示不发这个参数。"""
+    global REASONING_EFFORT
+    effort = str(effort or "").strip().lower()
+    if effort in ("default", "none", "无", "默认"):
+        effort = ""
+    if effort and effort not in ("low", "medium", "high", "minimal"):
+        return REASONING_EFFORT
+    REASONING_EFFORT = effort
+    from lcode.settings import save_project_config
+
+    save_project_config({"reasoningEffort": effort})
+    return REASONING_EFFORT
+
+
+def input_budget(context_length: int, max_output: int = 0) -> int:
+    """上下文窗口减去输出预留,至少留 1/4 给输入。"""
+    if context_length <= 0:
+        return DEFAULT_INPUT_BUDGET
+    reserve = max_output if max_output > 0 else context_length // 4
+    reserve = min(reserve, context_length * 3 // 4)
+    return max(1024, context_length - reserve)
+
+
+async def fetch_model_limits(model: str | None = None) -> dict:
+    """GET /models,取出当前模型的 context_length / max_completion_tokens。"""
+    global _model_limits_cache
+    name = (model or MODEL).strip()
+    if _model_limits_cache and _model_limits_cache.get("id") == name:
+        return _model_limits_cache
+    info = {
+        "id": name,
+        "context_length": 0,
+        "max_output": 0,
+        "input_budget": DEFAULT_INPUT_BUDGET,
+        "reasoning_levels": [],
+    }
+    if not BASE_URL:
+        _model_limits_cache = info
+        return info
+    timeout = aiohttp.ClientTimeout(total=20)
+    try:
+        async with aiohttp.ClientSession(timeout=timeout, headers=headers()) as session:
+            async with session.get(MODELS_URL) as resp:
+                if resp.status != 200:
+                    _model_limits_cache = info
+                    return info
+                payload = await resp.json()
+    except Exception:
+        _model_limits_cache = info
+        return info
+    data = payload.get("data") if isinstance(payload, dict) else payload
+    if not isinstance(data, list):
+        data = []
+    hit = None
+    for item in data:
+        if isinstance(item, dict) and str(item.get("id") or "") == name:
+            hit = item
+            break
+    if hit:
+        info["context_length"] = _positive_int(
+            hit.get("context_length"),
+            hit.get("context_window"),
+            hit.get("max_model_len"),
+            hit.get("max_input_tokens"),
+        )
+        info["max_output"] = _positive_int(
+            hit.get("max_completion_tokens"),
+            hit.get("max_output_tokens"),
+            hit.get("max_tokens"),
+        )
+        info["input_budget"] = input_budget(info["context_length"], info["max_output"])
+        info["reasoning_levels"] = _reasoning_levels_of(hit)
+    _model_limits_cache = info
+    return info
+
+
+def _extract_usage(obj: dict) -> dict | None:
+    """从一块 SSE JSON 里拿出 token 用量;没有就返回 None。"""
+    usage = obj.get("usage")
+    if isinstance(usage, dict) and usage:
+        return usage
+    response = obj.get("response")
+    if isinstance(response, dict):
+        usage = response.get("usage")
+        if isinstance(usage, dict) and usage:
+            return usage
+    return None
+
+
+def _is_tool_arg_event(typ: str) -> bool:
+    """function_call_arguments.delta 这类是工具 JSON,不是给用户看的正文。"""
+    t = (typ or "").lower()
+    if "function_call" in t or "tool_call" in t:
+        return True
+    if "arguments" in t and "delta" in t:
+        return True
+    return False
+
+
+def _pick_stream_pieces(obj: dict) -> list[tuple[str, object]]:
+    """从一块 SSE JSON 里挑出思考/正文/用量。认不出就返回空列表。"""
+    pieces: list[tuple[str, object]] = []
+    usage = _extract_usage(obj)
+
+    # 旧协议: choices[0].delta.reasoning_content / content
+    # 最后一块常常是 choices=[] 只带 usage
+    choices = obj.get("choices")
+    if isinstance(choices, list):
+        if choices:
+            delta = choices[0].get("delta") or {}
+            thinking = (
+                delta.get("reasoning_content")
+                or delta.get("reasoning")
+                or delta.get("thinking")
+                or ""
+            )
+            answer = delta.get("content") or ""
+            if thinking:
+                pieces.append(("thinking", thinking))
+            if answer:
+                pieces.append(("answer", answer))
+        if usage:
+            pieces.append(("usage", usage))
+        if pieces:
+            return pieces
+
+    # 新协议:只吃带 delta 的增量事件,完成事件会带全文,再拼会重复
+    # 用量多半在 response.completed 里,没有 delta
+    if usage:
+        pieces.append(("usage", usage))
+    typ = str(obj.get("type") or "")
+    if "delta" not in typ:
+        return pieces
+    # 工具参数走 tool_delta,这里再拼进正文会变成满屏 \n 字面量
+    if _is_tool_arg_event(typ):
+        return pieces
+    delta = obj.get("delta")
+    if isinstance(delta, str):
+        text = delta
+    elif isinstance(delta, dict):
+        text = delta.get("text") or delta.get("content") or ""
+    else:
+        text = ""
+    if not text:
+        return pieces
+    if "reasoning" in typ:
+        pieces.append(("thinking", text))
+    else:
+        pieces.append(("answer", text))
+    return pieces
+
+
+async def _iter_sse(resp: aiohttp.ClientResponse):
+    """按行拆 SSE,吐出 data: 后面的 JSON。"""
+    buf = ""
+    async for raw in resp.content:
+        buf += raw.decode("utf-8", errors="ignore")
+        while "\n" in buf:
+            line, buf = buf.split("\n", 1)
+            line = line.strip()
+            if not line.startswith("data:"):
+                continue
+            payload = line[5:].strip()
+            if payload == "[DONE]":
+                return
+            try:
+                yield json.loads(payload)
+            except json.JSONDecodeError:
+                continue
+
+
+def as_messages(prompt: str | list[dict]) -> list[dict]:
+    """单句或已有多轮,都收成 role+content 列表。"""
+    if isinstance(prompt, str):
+        text = prompt.strip()
+        return [{"role": "user", "content": text}] if text else []
+    out: list[dict] = []
+    for item in prompt:
+        role = str(item.get("role") or "")
+        content = str(item.get("content") or "").strip()
+        if role in ("user", "assistant", "system") and content:
+            out.append({"role": role, "content": content})
+    return out
+
+
+def _fix_payload_400(payload: dict, body: str) -> dict | None:
+    """服务端 400 时的自动降级:去掉它不认的 reasoning 参数/换 token 字段名。"""
+    low = (body or "").lower()
+    fixed = dict(payload)
+    changed = False
+    if "reasoning" in low and ("reasoning_effort" in fixed or "reasoning" in fixed):
+        fixed.pop("reasoning_effort", None)
+        fixed.pop("reasoning", None)
+        changed = True
+    if "max_completion_tokens" in low and "max_tokens" in fixed:
+        fixed["max_completion_tokens"] = fixed.pop("max_tokens")
+        changed = True
+    return fixed if changed else None
+
+
+async def _post_stream(
+    session: aiohttp.ClientSession, url: str, payload: dict, label: str
+):
+    """POST 流式请求;400 且响应体点名了可降级的参数时,改完自动再试一次。"""
+    resp = await session.post(url, json=payload)
+    if resp.status == 400:
+        body = await resp.text()
+        fixed = _fix_payload_400(payload, body)
+        if fixed is not None:
+            resp.release()
+            resp = await session.post(url, json=fixed)
+    if resp.status != 200:
+        body = await resp.text()
+        raise RuntimeError(f"{label} 失败 HTTP {resp.status}: {body[:500]}")
+    return resp
+
+
+def _call_id_of(call: dict) -> str:
+    fn = call.get("function") if isinstance(call.get("function"), dict) else {}
+    return str(call.get("call_id") or call.get("id") or fn.get("id") or "").strip()
+
+
+def _call_name_args(call: dict) -> tuple[str, str]:
+    fn = call.get("function") if isinstance(call.get("function"), dict) else {}
+    name = str(call.get("name") or fn.get("name") or "")
+    raw = call.get("arguments")
+    if raw is None:
+        raw = fn.get("arguments")
+    if isinstance(raw, (dict, list)):
+        try:
+            raw = json.dumps(raw, ensure_ascii=False)
+        except (TypeError, ValueError):
+            raw = "{}"
+    return name, str(raw or "{}")
+
+
+def ensure_tool_outputs(messages: list[dict]) -> list[dict]:
+    """每个 tool_call 必须带一条 tool 结果,否则 completions/responses 会 400。"""
+    have: set[str] = set()
+    needed: list[str] = []
+    for msg in messages:
+        if not isinstance(msg, dict):
+            continue
+        if msg.get("role") == "tool":
+            cid = str(msg.get("tool_call_id") or msg.get("call_id") or "").strip()
+            if cid:
+                have.add(cid)
+        for call in msg.get("tool_calls") or []:
+            if isinstance(call, dict):
+                cid = _call_id_of(call)
+                if cid:
+                    needed.append(cid)
+        if msg.get("type") == "function_call":
+            cid = str(msg.get("call_id") or msg.get("id") or "").strip()
+            if cid:
+                needed.append(cid)
+        if msg.get("type") == "function_call_output":
+            cid = str(msg.get("call_id") or "").strip()
+            if cid:
+                have.add(cid)
+    missing = [cid for cid in needed if cid not in have]
+    if not missing:
+        return messages
+    out = list(messages)
+    for cid in missing:
+        out.append(
+            {
+                "role": "tool",
+                "tool_call_id": cid,
+                "content": "（无结果）",
+            }
+        )
+    return out
+
+
+def _responses_parts(parts: object) -> object:
+    """responses 协议的 content 类型名和 completions 不同,逐个转换。"""
+    if not isinstance(parts, list):
+        return parts
+    out: list = []
+    for part in parts:
+        if not isinstance(part, dict):
+            out.append(part)
+            continue
+        typ = str(part.get("type") or "")
+        if typ == "text":
+            out.append({"type": "input_text", "text": str(part.get("text") or "")})
+        elif typ == "image_url":
+            url = part.get("image_url")
+            if isinstance(url, dict):
+                url = url.get("url")
+            out.append({"type": "input_image", "image_url": url})
+        else:
+            out.append(part)
+    return out
+
+
+def _responses_input(messages: list[dict]):
+    """responses:每个 function_call 后面紧跟对应 output,否则会报 No tool output found。"""
+    if (
+        len(messages) == 1
+        and messages[0].get("role") == "user"
+        and not messages[0].get("tool_calls")
+    ):
+        content = messages[0].get("content")
+        if isinstance(content, list):
+            # 带图片的多模态消息:整个消息对象作为 input item
+            return [{"role": "user", "content": _responses_parts(content)}]
+        return content or ""
+    outputs: dict[str, str] = {}
+    for msg in messages:
+        if not isinstance(msg, dict):
+            continue
+        if msg.get("role") == "tool":
+            cid = str(msg.get("tool_call_id") or msg.get("call_id") or "").strip()
+            if cid:
+                outputs[cid] = str(msg.get("content") or "")
+        elif msg.get("type") == "function_call_output":
+            cid = str(msg.get("call_id") or "").strip()
+            if cid:
+                outputs[cid] = str(msg.get("output") or msg.get("content") or "")
+    out: list[dict] = []
+    emitted: set[str] = set()
+
+    def emit_call(call: dict) -> None:
+        cid = _call_id_of(call)
+        if not cid or cid in emitted:
+            return
+        name, arguments = _call_name_args(call)
+        item: dict = {
+            "type": "function_call",
+            "call_id": cid,
+            "name": name,
+            "arguments": arguments,
+        }
+        if call.get("id") and str(call.get("id")) != cid:
+            item["id"] = str(call["id"])
+        out.append(item)
+        out.append(
+            {
+                "type": "function_call_output",
+                "call_id": cid,
+                "output": outputs.get(cid, "（无结果）"),
+            }
+        )
+        emitted.add(cid)
+
+    for msg in messages:
+        if not isinstance(msg, dict):
+            continue
+        if msg.get("role") == "tool" or msg.get("type") == "function_call_output":
+            continue
+        if msg.get("type") == "function_call":
+            emit_call(msg)
+            continue
+        if msg.get("type"):
+            out.append(msg)
+            continue
+        calls = msg.get("tool_calls") or []
+        text = msg.get("content")
+        if calls:
+            if text:
+                out.append({"role": "assistant", "content": text})
+            for call in calls:
+                if isinstance(call, dict):
+                    emit_call(call)
+            continue
+        out.append(
+            {
+                "role": msg.get("role") or "user",
+                "content": _responses_parts(text) if isinstance(text, list) else (text or ""),
+            }
+        )
+    return out
+
+
+class _ToolAcc:
+    def __init__(self) -> None:
+        self.by_index: dict[int, dict[str, str]] = {}
+        self.by_id: dict[str, dict[str, str]] = {}
+        self._item_to_call: dict[str, str] = {}
+
+    def ingest_completions(self, obj: dict) -> None:
+        choices = obj.get("choices")
+        if not isinstance(choices, list) or not choices:
+            return
+        delta = choices[0].get("delta") or {}
+        for item in delta.get("tool_calls") or []:
+            if not isinstance(item, dict):
+                continue
+            idx = int(item.get("index") or 0)
+            slot = self.by_index.setdefault(idx, {"id": "", "name": "", "arguments": ""})
+            if item.get("id"):
+                slot["id"] = str(item["id"])
+            fn = item.get("function") or {}
+            if fn.get("name"):
+                slot["name"] += str(fn["name"])
+            if fn.get("arguments"):
+                slot["arguments"] += str(fn["arguments"])
+
+    def snapshot(self) -> list[dict[str, str]]:
+        """流式中途的工具调用,名字还没到也先给界面。"""
+        rows = list(self.by_index.values()) + list(self.by_id.values())
+        out: list[dict[str, str]] = []
+        seen: set[int] = set()
+        for row in rows:
+            ident = id(row)
+            if ident in seen:
+                continue
+            seen.add(ident)
+            if not (row.get("name") or row.get("arguments")):
+                continue
+            out.append(
+                {
+                    "id": row.get("id") or "",
+                    "name": row.get("name") or "",
+                    "arguments": row.get("arguments") or "",
+                }
+            )
+        return out
+
+    def signature(self) -> tuple:
+        return tuple(
+            (row.get("id"), row.get("name"), len(row.get("arguments") or ""))
+            for row in self.snapshot()
+        )
+
+    def _slot(self, call_id: str) -> dict[str, str] | None:
+        call_id = (call_id or "").strip()
+        if not call_id:
+            return None
+        return self.by_id.setdefault(call_id, {"id": call_id, "name": "", "arguments": ""})
+
+    def ingest_responses(self, obj: dict) -> None:
+        typ = str(obj.get("type") or "")
+        item = obj.get("item")
+        if isinstance(item, dict) and (
+            "function_call" in str(item.get("type") or "") or item.get("name")
+        ):
+            call_id = str(item.get("call_id") or "").strip()
+            item_id = str(item.get("id") or "").strip()
+            if item_id and call_id:
+                self._item_to_call[item_id] = call_id
+            if not call_id:
+                call_id = self._item_to_call.get(item_id, "")
+            if not call_id:
+                call_id = item_id
+            pending = None
+            if item_id and call_id and item_id != call_id:
+                pending = self.by_id.pop(item_id, None)
+            slot = self._slot(call_id)
+            if slot is not None:
+                if pending:
+                    if pending.get("name") and not slot.get("name"):
+                        slot["name"] = pending["name"]
+                    if len(pending.get("arguments") or "") > len(slot.get("arguments") or ""):
+                        slot["arguments"] = pending["arguments"]
+                if item.get("name"):
+                    slot["name"] = str(item["name"])
+                if item.get("arguments"):
+                    slot["arguments"] = str(item["arguments"])
+        if "function_call_arguments" in typ:
+            call_id = str(obj.get("call_id") or "").strip()
+            item_id = str(obj.get("item_id") or "").strip()
+            if not call_id:
+                call_id = self._item_to_call.get(item_id, "")
+            if not call_id:
+                call_id = item_id
+            if item_id and call_id and item_id != call_id:
+                self._item_to_call[item_id] = call_id
+                pending = self.by_id.pop(item_id, None)
+            else:
+                pending = None
+            slot = self._slot(call_id)
+            if slot is None:
+                return
+            if pending:
+                if pending.get("name") and not slot.get("name"):
+                    slot["name"] = pending["name"]
+                if len(pending.get("arguments") or "") > len(slot.get("arguments") or ""):
+                    slot["arguments"] = pending["arguments"]
+            delta = obj.get("delta")
+            if isinstance(delta, str):
+                slot["arguments"] += delta
+            elif isinstance(delta, dict):
+                piece = delta.get("arguments") or delta.get("text") or delta.get("content") or ""
+                if piece:
+                    slot["arguments"] += str(piece)
+            if obj.get("name"):
+                slot["name"] = str(obj["name"])
+            if obj.get("arguments") and "delta" not in typ:
+                slot["arguments"] = str(obj["arguments"])
+
+    def finished(self) -> list[dict[str, str]]:
+        rows = list(self.by_index.values()) + list(self.by_id.values())
+        out = []
+        seen = set()
+        for row in rows:
+            name = (row.get("name") or "").strip()
+            if not name:
+                continue
+            key = row.get("id") or name
+            if key in seen:
+                continue
+            seen.add(key)
+            out.append(
+                {
+                    "id": row.get("id") or key,
+                    "name": name,
+                    "arguments": row.get("arguments") or "{}",
+                }
+            )
+        return out
+
+
+async def stream_completions(
+    session: aiohttp.ClientSession,
+    messages: list[dict],
+    tools: list[dict] | None = None,
+):
+    """旧协议流式:POST /chat/completions, stream=true。"""
+    payload = {
+        "model": MODEL,
+        "messages": ensure_tool_outputs(messages),
+        "max_tokens": MAX_TOKENS,
+        "stream": True,
+        "stream_options": {"include_usage": True},
+    }
+    if tools:
+        payload["tools"] = tools
+        payload["tool_choice"] = "auto"
+    if REASONING_EFFORT:
+        payload["reasoning_effort"] = REASONING_EFFORT
+    acc = _ToolAcc()
+    last_sig = None
+    resp = await _post_stream(session, COMPLETIONS_URL, payload, "completions")
+    async with resp:
+        async for obj in _iter_sse(resp):
+            acc.ingest_completions(obj)
+            for kind, text in _pick_stream_pieces(obj):
+                yield kind, text
+            sig = acc.signature()
+            if sig != last_sig:
+                last_sig = sig
+                snap = acc.snapshot()
+                if snap:
+                    yield "tool_delta", snap
+    calls = acc.finished()
+    if calls:
+        yield "tool_calls", calls
+
+
+async def stream_responses(
+    session: aiohttp.ClientSession,
+    messages: list[dict],
+    tools: list[dict] | None = None,
+):
+    """新协议流式:POST /responses, stream=true。"""
+    payload = {
+        "model": MODEL,
+        "input": _responses_input(ensure_tool_outputs(messages)),
+        "max_output_tokens": MAX_TOKENS,
+        "stream": True,
+    }
+    if tools:
+        payload["tools"] = tools
+    if REASONING_EFFORT:
+        payload["reasoning"] = {"effort": REASONING_EFFORT}
+    acc = _ToolAcc()
+    last_sig = None
+    resp = await _post_stream(session, RESPONSES_URL, payload, "responses")
+    async with resp:
+        async for obj in _iter_sse(resp):
+            acc.ingest_responses(obj)
+            for kind, text in _pick_stream_pieces(obj):
+                yield kind, text
+            sig = acc.signature()
+            if sig != last_sig:
+                last_sig = sig
+                snap = acc.snapshot()
+                if snap:
+                    yield "tool_delta", snap
+    calls = acc.finished()
+    if calls:
+        yield "tool_calls", calls
+
+
+async def ask_stream(prompt: str | list[dict], tools: list[dict] | None = None):
+    """给 TUI 用:一块一块 yield thinking / answer / usage / tool_calls。"""
+    if isinstance(prompt, str):
+        messages = as_messages(prompt)
+    else:
+        messages = list(prompt)
+    if not messages:
+        return
+    timeout = aiohttp.ClientTimeout(total=REQUEST_TIMEOUT)
+    async with aiohttp.ClientSession(timeout=timeout, headers=headers()) as session:
+        if tools:
+            if REQUEST_TYPE == "responses":
+                try:
+                    async for piece in stream_responses(
+                        session, messages, responses_tools_from(tools)
+                    ):
+                        yield piece
+                    return
+                except RuntimeError:
+                    pass
+                async for piece in stream_completions(session, messages, tools):
+                    yield piece
+                return
+            try:
+                async for piece in stream_completions(session, messages, tools):
+                    yield piece
+                return
+            except RuntimeError:
+                pass
+            async for piece in stream_responses(session, messages, responses_tools_from(tools)):
+                yield piece
+            return
+        if REQUEST_TYPE == "responses":
+            try:
+                async for piece in stream_responses(session, messages):
+                    yield piece
+                return
+            except RuntimeError:
+                pass
+        async for piece in stream_completions(session, messages):
+            yield piece
+
+
+def responses_tools_from(openai_tools: list[dict]) -> list[dict]:
+    out = []
+    for item in openai_tools:
+        fn = item.get("function") if item.get("type") == "function" else item
+        if not isinstance(fn, dict):
+            continue
+        name = fn.get("name") or item.get("name")
+        if not name:
+            continue
+        out.append(
+            {
+                "type": "function",
+                "name": name,
+                "description": fn.get("description") or item.get("description") or "",
+                "parameters": fn.get("parameters") or item.get("parameters") or {},
+            }
+        )
+    return out
+
+
+async def ask(prompt: str | list[dict]) -> str:
+    """非流式,给本文件单独测试用。思考和正文拼在一起。"""
+    thinking = []
+    answer = []
+    async for kind, text in ask_stream(prompt):
+        if kind == "thinking":
+            thinking.append(str(text))
+        elif kind == "answer":
+            answer.append(str(text))
+    text = "".join(answer).strip()
+    if not text and thinking:
+        text = "".join(thinking).strip()
+    return text
+
+
+async def main() -> None:
+    if not BASE_URL or not api_key():
+        raise SystemExit("缺少 url,或未在 ~/.lcode/config.json 配置 apiKey(或设 LCODE_API_KEY)")
+
+    print("url   =", BASE_URL)
+    print("协议  =", REQUEST_TYPE)
+    print("模型  =", MODEL)
+    print()
+
+    print("流式:")
+    async for kind, text in ask_stream("只回复一个词: pong"):
+        print(f"  [{kind}] {text!r}")
+    print("通了")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())