zai-adk-python-preview 0.1.2__tar.gz → 0.1.4__tar.gz

{zai_adk_python_preview-0.1.2 → zai_adk_python_preview-0.1.4}/.gitignore

@@ -217,4 +217,7 @@ __marimo__/
 
 # Streamlit
 .streamlit/secrets.toml
-./tmp/
+./tmp/
+# Claude Code / OMC
+.claude/
+.omc/

zai_adk_python_preview-0.1.4/.gitlab-ci.yml

@@ -0,0 +1,10 @@
+stages:
+  - build
+  - test
+
+include:
+  # 代码 review 检测
+  - project: 'zhangpeipei/ci'
+    file: '/ci-ap-check.yml'
+    ref: 'main'
+

{zai_adk_python_preview-0.1.2 → zai_adk_python_preview-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zai-adk-python-preview
-Version: 0.1.2
+Version: 0.1.4
 Summary: A Python SDK for building AI agents with LLM integration
 Project-URL: Homepage, https://github.com/zai-adk-python/zai-adk-python
 Project-URL: Documentation, https://github.com/zai-adk-python/zai-adk-python#readme
@@ -139,6 +139,51 @@ async for event in agent.query_stream("Help me with a task"):
             print(f"[Final]: {text}")
 ```
 
+### True Token Streaming
+
+Enable real-time token-by-token streaming from the LLM with `stream=True`:
+
+```python
+from zai_adk.agent import TextChunkEvent, ThinkingChunkEvent, FinalResponseEvent
+
+async for event in agent.query_stream("Explain quantum computing", stream=True):
+    match event:
+        case ThinkingChunkEvent(content=delta):
+            print(delta, end="", flush=True)   # thinking token delta
+        case TextChunkEvent(content=delta):
+            print(delta, end="", flush=True)   # text token delta
+        case FinalResponseEvent(content=text):
+            print(f"\nDone: {text}")
+```
+
+**Key differences from default (`stream=False`):**
+
+| | `stream=False` (default) | `stream=True` |
+|---|---|---|
+| First token latency | Waits for full response | Streams immediately |
+| Event types | `TextEvent` (complete text) | `TextChunkEvent` per token + `TextEvent` (complete) |
+| Thinking | `ThinkingEvent` (complete) | `ThinkingChunkEvent` per token + `ThinkingEvent` (complete) |
+| Backward compat | — | Fully compatible, same tool execution flow |
+
+**Enable extended thinking (GLM, DeepSeek):**
+
+```python
+from zai_adk.llm.openai.chat import ChatOpenAI
+
+llm = ChatOpenAI(
+    model="glm-5.1",
+    thinking={"type": "enabled"},  # enable reasoning output
+)
+agent = Agent(llm=llm, tools=[])
+
+async for event in agent.query_stream("Think carefully: 9.11 vs 9.8", stream=True):
+    match event:
+        case ThinkingChunkEvent(content=delta):
+            print(f"[think] {delta}", end="", flush=True)
+        case TextChunkEvent(content=delta):
+            print(delta, end="", flush=True)
+```
+
 ### Sandboxed File Operations
 
 ```python

{zai_adk_python_preview-0.1.2 → zai_adk_python_preview-0.1.4}/README.md

@@ -89,6 +89,51 @@ async for event in agent.query_stream("Help me with a task"):
             print(f"[Final]: {text}")
 ```
 
+### True Token Streaming
+
+Enable real-time token-by-token streaming from the LLM with `stream=True`:
+
+```python
+from zai_adk.agent import TextChunkEvent, ThinkingChunkEvent, FinalResponseEvent
+
+async for event in agent.query_stream("Explain quantum computing", stream=True):
+    match event:
+        case ThinkingChunkEvent(content=delta):
+            print(delta, end="", flush=True)   # thinking token delta
+        case TextChunkEvent(content=delta):
+            print(delta, end="", flush=True)   # text token delta
+        case FinalResponseEvent(content=text):
+            print(f"\nDone: {text}")
+```
+
+**Key differences from default (`stream=False`):**
+
+| | `stream=False` (default) | `stream=True` |
+|---|---|---|
+| First token latency | Waits for full response | Streams immediately |
+| Event types | `TextEvent` (complete text) | `TextChunkEvent` per token + `TextEvent` (complete) |
+| Thinking | `ThinkingEvent` (complete) | `ThinkingChunkEvent` per token + `ThinkingEvent` (complete) |
+| Backward compat | — | Fully compatible, same tool execution flow |
+
+**Enable extended thinking (GLM, DeepSeek):**
+
+```python
+from zai_adk.llm.openai.chat import ChatOpenAI
+
+llm = ChatOpenAI(
+    model="glm-5.1",
+    thinking={"type": "enabled"},  # enable reasoning output
+)
+agent = Agent(llm=llm, tools=[])
+
+async for event in agent.query_stream("Think carefully: 9.11 vs 9.8", stream=True):
+    match event:
+        case ThinkingChunkEvent(content=delta):
+            print(f"[think] {delta}", end="", flush=True)
+        case TextChunkEvent(content=delta):
+            print(delta, end="", flush=True)
+```
+
 ### Sandboxed File Operations
 
 ```python

zai_adk_python_preview-0.1.4/examples/test_streaming.py

@@ -0,0 +1,110 @@
+"""Quick manual test for true streaming vs pseudo-streaming.
+
+Usage:
+    uv run python -m examples.test_streaming
+
+Compare the output of stream=False vs stream=True:
+- stream=False: you wait several seconds, then see the full text at once
+- stream=True: you see text appear token-by-token in real time
+"""
+
+import asyncio
+import time
+
+from zai_adk import Agent
+from zai_adk.llm.openai.chat import ChatOpenAI
+
+
+async def test_stream_false():
+    """Default behavior — collect full response then yield."""
+    llm = ChatOpenAI(
+        model="glm-4.7",
+        temperature=0.3,
+        max_completion_tokens=256,
+    )
+    agent = Agent(llm=llm, tools=[])
+
+    print("=" * 60)
+    print("stream=False (pseudo-streaming)")
+    print("=" * 60)
+
+    start = time.time()
+    async for event in agent.query_stream("用一句话介绍什么是量子计算"):
+        if hasattr(event, "content") and event.content:
+            elapsed = time.time() - start
+            print(f"  [{elapsed:.2f}s] {type(event).__name__}: {event.content[:80]}")
+    print()
+
+
+async def test_stream_true():
+    """True streaming — token by token."""
+    llm = ChatOpenAI(
+        model="glm-4.7",
+        temperature=0.3,
+        max_completion_tokens=256,
+    )
+    agent = Agent(llm=llm, tools=[])
+
+    print("=" * 60)
+    print("stream=True (true streaming)")
+    print("=" * 60)
+
+    start = time.time()
+    full_text = []
+    async for event in agent.query_stream("用一句话介绍什么是量子计算", stream=True):
+        match event:
+            case _ if hasattr(event, "content") and isinstance(event.content, str) and event.content:
+                elapsed = time.time() - start
+                type_name = type(event).__name__
+                if type_name == "TextChunkEvent":
+                    print(event.content, end="", flush=True)
+                    full_text.append(event.content)
+                else:
+                    print(f"\n  [{elapsed:.2f}s] {type_name}: {event.content[:80]}")
+    print(f"\n  Full text length: {len(''.join(full_text))} chars")
+    print()
+
+
+async def test_stream_with_tools():
+    """True streaming with tool calls."""
+    from zai_adk.tools.builtin import bash
+
+    llm = ChatOpenAI(
+        model="glm-4.7",
+        temperature=0.3,
+        max_completion_tokens=256,
+    )
+    agent = Agent(llm=llm, tools=[bash])
+
+    print("=" * 60)
+    print("stream=True with tool calls")
+    print("=" * 60)
+
+    start = time.time()
+    async for event in agent.query_stream("列出当前目录下的 Python 文件", stream=True):
+        match event:
+            case _ if hasattr(event, "content") and isinstance(event.content, str) and event.content:
+                type_name = type(event).__name__
+                if type_name == "TextChunkEvent":
+                    print(event.content, end="", flush=True)
+                else:
+                    elapsed = time.time() - start
+                    print(f"\n  [{elapsed:.2f}s] {type_name}: {event.content[:80]}")
+    print("\n")
+
+
+if __name__ == "__main__":
+    import os
+
+    if not os.getenv("OPENAI_API_KEY") and not os.getenv("OPENAI_BASE_URL"):
+        print("Please set OPENAI_API_KEY or OPENAI_BASE_URL in .env")
+        exit(1)
+
+    print("\n>>> Test 1: Pseudo-streaming (default)")
+    asyncio.run(test_stream_false())
+
+    print("\n>>> Test 2: True streaming")
+    asyncio.run(test_stream_true())
+
+    print("\n>>> Test 3: True streaming with tools")
+    asyncio.run(test_stream_with_tools())

zai_adk_python_preview-0.1.4/examples/test_streaming_real.py

@@ -0,0 +1,450 @@
+"""
+True streaming real API test — covers text, tools, and skills.
+
+Usage:
+    # Edit .env with your API credentials, then:
+    uv run python -m examples.test_streaming_real
+
+    # Or set env vars directly:
+    OPENAI_API_KEY=your-key OPENAI_BASE_URL=https://... uv run python -m examples.test_streaming_real
+"""
+
+import asyncio
+import os
+import sys
+import time
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+from zai_adk import Agent
+from zai_adk.agent.events import (
+    FinalResponseEvent,
+    TextChunkEvent,
+    TextEvent,
+    ThinkingChunkEvent,
+    ToolCallEvent,
+    ToolResultEvent,
+)
+from zai_adk.llm.openai.chat import ChatOpenAI
+from zai_adk.sandbox import SandboxConfig
+from zai_adk.tools.builtin import bash, fs_read, fs_write, fs_glob, fs_grep
+from zai_adk.tools.decorator import tool
+
+
+# ─── Custom tools ───────────────────────────────────────────────────────────
+
+@tool("Calculate the result of a math expression")
+async def calculator(expression: str) -> str:
+    """Safely evaluate a math expression."""
+    import ast
+    import operator
+
+    ops = {
+        ast.Add: operator.add, ast.Sub: operator.sub,
+        ast.Mult: operator.mul, ast.Div: operator.truediv,
+        ast.Pow: operator.pow, ast.USub: operator.neg,
+    }
+
+    def _eval(node):
+        if isinstance(node, ast.Constant):
+            return node.value
+        if isinstance(node, ast.UnaryOp):
+            return ops[type(node.op)](_eval(node.operand))
+        if isinstance(node, ast.BinOp):
+            return ops[type(node.op)](_eval(node.left), _eval(node.right))
+        raise ValueError(f"Unsupported: {type(node).__name__}")
+
+    try:
+        result = _eval(ast.parse(expression, mode="eval").body)
+        return str(result)
+    except Exception as e:
+        return f"Error: {e}"
+
+
+@tool("Get the current time")
+async def get_time() -> str:
+    from datetime import datetime
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+
+# ─── LLM setup ─────────────────────────────────────────────────────────────
+
+def create_llm(thinking: bool = False):
+    api_key = os.getenv("OPENAI_API_KEY")
+    base_url = os.getenv("OPENAI_BASE_URL")
+    model = os.getenv("OPENAI_MODEL", "glm-4.7")
+
+    if not api_key and not base_url:
+        print("ERROR: Set OPENAI_API_KEY or OPENAI_BASE_URL in .env or environment")
+        sys.exit(1)
+
+    return ChatOpenAI(
+        model=model,
+        api_key=api_key,
+        base_url=base_url,
+        temperature=0.3,
+        max_completion_tokens=2048,
+        thinking={"type": "enabled"} if thinking else None,
+    )
+
+
+# ─── Color helpers ──────────────────────────────────────────────────────────
+
+class C:
+    """ANSI colors for terminal output."""
+    BOLD = "\033[1m"
+    DIM = "\033[2m"
+    CYAN = "\033[36m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    RED = "\033[31m"
+    RESET = "\033[0m"
+
+
+def header(title: str):
+    print(f"\n{'=' * 70}")
+    print(f"  {C.BOLD}{C.CYAN}{title}{C.RESET}")
+    print(f"{'=' * 70}\n")
+
+
+# ─── Test cases ─────────────────────────────────────────────────────────────
+
+async def test_1_text_only_streaming():
+    """Test 1: Pure text streaming — compare stream=False vs stream=True."""
+    header("Test 1: Text-only streaming comparison")
+    tools = []
+    prompt = "用三句话解释什么是大语言模型(LLM)。"
+
+    # --- stream=False (pseudo-streaming) ---
+    agent = Agent(llm=create_llm(), tools=tools)
+    print(f"  {C.DIM}[stream=False] Waiting for full response...{C.RESET}")
+    start = time.time()
+    first_token_time = None
+    async for event in agent.query_stream(prompt, stream=False):
+        if isinstance(event, TextEvent):
+            first_token_time = time.time() - start
+            print(f"  {C.GREEN}TextEvent (full): {event.content[:60]}...{C.RESET}")
+        elif isinstance(event, FinalResponseEvent):
+            total_time = time.time() - start
+            print(f"  {C.DIM}First token: {first_token_time:.2f}s | Total: {total_time:.2f}s{C.RESET}")
+
+    # --- stream=True (true streaming) ---
+    agent = Agent(llm=create_llm(), tools=tools)
+    print(f"\n  {C.DIM}[stream=True] Streaming token by token...{C.RESET}")
+    start = time.time()
+    first_chunk_time = None
+    chunk_count = 0
+    full_text = []
+    print(f"  {C.YELLOW}", end="", flush=True)
+    async for event in agent.query_stream(prompt, stream=True):
+        if isinstance(event, TextChunkEvent):
+            if first_chunk_time is None:
+                first_chunk_time = time.time() - start
+            chunk_count += 1
+            full_text.append(event.content)
+            print(event.content, end="", flush=True)
+        elif isinstance(event, TextEvent):
+            pass  # complete text, already printed via chunks
+        elif isinstance(event, FinalResponseEvent):
+            total_time = time.time() - start
+            print(f"{C.RESET}")
+            print(f"  {C.DIM}Chunks: {chunk_count} | First token: {first_chunk_time:.2f}s | Total: {total_time:.2f}s{C.RESET}")
+            print(f"  {C.DIM}Full text: {''.join(full_text)[:80]}...{C.RESET}")
+
+
+async def test_2_builtin_tools():
+    """Test 2: Streaming with built-in tools (bash, fs_glob, fs_read)."""
+    header("Test 2: Streaming with built-in tools")
+    workspace = str(Path(__file__).parent.parent)  # project root
+    tools = [bash, fs_glob, fs_read]
+    prompt = f"列出 {workspace}/zai_adk/llm/ 目录下的所有 Python 文件，并读取 base.py 的前 5 行。"
+
+    agent = Agent(
+        llm=create_llm(),
+        tools=tools,
+        sandbox=SandboxConfig(kind="local", work_dir=workspace),
+    )
+
+    print(f"  {C.DIM}Prompt: {prompt}{C.RESET}\n")
+    start = time.time()
+    async for event in agent.query_stream(prompt, stream=True):
+        match event:
+            case TextChunkEvent(content=delta):
+                print(f"{C.YELLOW}{delta}{C.RESET}", end="", flush=True)
+            case TextEvent():
+                pass
+            case ToolCallEvent(tool=name, args=args):
+                print(f"\n  {C.BLUE}>> Tool call: {name}({args}){C.RESET}")
+            case ToolResultEvent(tool=name, result=result):
+                preview = result[:150].replace("\n", "\\n")
+                print(f"  {C.GREEN}<< {name}: {preview}...{C.RESET}")
+            case FinalResponseEvent():
+                elapsed = time.time() - start
+                print(f"\n  {C.DIM}Completed in {elapsed:.2f}s{C.RESET}")
+
+
+async def test_3_custom_tools():
+    """Test 3: Streaming with custom tools (calculator, get_time)."""
+    header("Test 3: Streaming with custom tools")
+    tools = [calculator, get_time]
+    prompt = "现在几点了？然后帮我算一下 (1234 + 5678) * 3 的结果。"
+
+    agent = Agent(llm=create_llm(), tools=tools)
+
+    print(f"  {C.DIM}Prompt: {prompt}{C.RESET}\n")
+    async for event in agent.query_stream(prompt, stream=True):
+        match event:
+            case TextChunkEvent(content=delta):
+                print(f"{C.YELLOW}{delta}{C.RESET}", end="", flush=True)
+            case TextEvent():
+                pass
+            case ToolCallEvent(tool=name, args=args):
+                print(f"\n  {C.BLUE}>> Tool call: {name}({args}){C.RESET}")
+            case ToolResultEvent(tool=name, result=result):
+                print(f"  {C.GREEN}<< {name}: {result}{C.RESET}")
+            case FinalResponseEvent():
+                print()
+
+
+async def test_4_multi_tool_workflow():
+    """Test 4: Complex workflow — write file, read it back, search content."""
+    header("Test 4: Multi-tool workflow (write → read → grep)")
+    workspace = str(Path(__file__).parent)
+    tools = [fs_write, fs_read, fs_grep, bash]
+
+    agent = Agent(
+        llm=create_llm(),
+        tools=tools,
+        sandbox=SandboxConfig(kind="local", work_dir=workspace),
+    )
+
+    prompt = (
+        "请完成以下任务：\n"
+        "1. 在当前目录创建一个文件 test_stream_data.txt，内容是 3 种编程语言的简介（每行一个）\n"
+        "2. 读取这个文件确认内容正确\n"
+        "3. 搜索文件中包含 Python 的行"
+    )
+
+    print(f"  {C.DIM}Prompt: {prompt[:80]}...{C.RESET}\n")
+    tool_calls = 0
+    async for event in agent.query_stream(prompt, stream=True):
+        match event:
+            case TextChunkEvent(content=delta):
+                print(f"{C.YELLOW}{delta}{C.RESET}", end="", flush=True)
+            case TextEvent():
+                pass
+            case ToolCallEvent(tool=name, args=args):
+                tool_calls += 1
+                args_str = str(args)
+                if len(args_str) > 80:
+                    args_str = args_str[:77] + "..."
+                print(f"\n  {C.BLUE}[{tool_calls}] >> {name}({args_str}){C.RESET}")
+            case ToolResultEvent(tool=name, result=result):
+                preview = result[:120].replace("\n", "\\n")
+                print(f"  {C.GREEN}   << {name}: {preview}{C.RESET}")
+            case FinalResponseEvent():
+                print(f"\n  {C.DIM}Total tool calls: {tool_calls}{C.RESET}")
+
+    # Cleanup
+    data_file = Path(workspace) / "test_stream_data.txt"
+    if data_file.exists():
+        data_file.unlink()
+        print(f"  {C.DIM}Cleaned up test_stream_data.txt{C.RESET}")
+
+
+async def test_5_skills():
+    """Test 5: Streaming with skills — create a skill and use it."""
+    header("Test 5: Streaming with skills")
+
+    # Create a temporary skills directory with a skill
+    workspace = str(Path(__file__).parent)
+    skills_dir = Path(workspace) / "_test_skills"
+    skills_dir.mkdir(exist_ok=True)
+
+    # Create a code-review skill
+    review_skill_dir = skills_dir / "code-review"
+    review_skill_dir.mkdir(exist_ok=True)
+    (review_skill_dir / "SKILL.md").write_text("""\
+---
+name: code-review
+description: Review code for bugs, security issues, and best practices
+---
+
+# Code Review Skill
+
+When reviewing code:
+1. Check for security vulnerabilities (SQL injection, XSS, etc.)
+2. Check for error handling issues
+3. Check for performance problems
+4. Check for code style and readability
+5. Provide specific suggestions for improvement
+""")
+
+    # Create a git-commit skill
+    commit_skill_dir = skills_dir / "git-commit"
+    commit_skill_dir.mkdir(exist_ok=True)
+    (commit_skill_dir / "SKILL.md").write_text("""\
+---
+name: git-commit
+description: Generate conventional commit messages following project conventions
+---
+
+# Git Commit Skill
+
+Generate commit messages following the Conventional Commits specification:
+- feat: New features
+- fix: Bug fixes
+- docs: Documentation changes
+- refactor: Code refactoring
+- test: Test additions/changes
+- chore: Build/tooling changes
+""")
+
+    tools = [bash, fs_read]
+    agent = Agent(
+        llm=create_llm(),
+        tools=tools,
+        skills_dir=str(skills_dir),
+        sandbox=SandboxConfig(kind="local", work_dir=str(Path(__file__).parent.parent)),
+    )
+
+    # Must call async_initialize to load skills
+    await agent.async_initialize()
+
+    print(f"  {C.DIM}Loaded skills: {[s.name for s in agent._skills_manager.list()]}{C.RESET}")
+    print(f"  {C.DIM}System prompt includes skills metadata: {'skills' in (agent.system_prompt or '').lower()}{C.RESET}\n")
+
+    prompt = "请列出所有可用的 skills，然后用 code-review skill 来审查以下代码的安全性: def query(user_input): return db.execute(f'SELECT * FROM users WHERE name={user_input}')"
+
+    async for event in agent.query_stream(prompt, stream=True):
+        match event:
+            case TextChunkEvent(content=delta):
+                print(f"{C.YELLOW}{delta}{C.RESET}", end="", flush=True)
+            case TextEvent():
+                pass
+            case ToolCallEvent(tool=name, args=args):
+                args_str = str(args)
+                if len(args_str) > 80:
+                    args_str = args_str[:77] + "..."
+                print(f"\n  {C.BLUE}>> {name}({args_str}){C.RESET}")
+            case ToolResultEvent(tool=name, result=result):
+                preview = result[:120].replace("\n", "\\n")
+                print(f"  {C.GREEN}   << {name}: {preview}{C.RESET}")
+            case FinalResponseEvent():
+                print()
+
+    # Cleanup
+    import shutil
+    if skills_dir.exists():
+        shutil.rmtree(skills_dir)
+        print(f"  {C.DIM}Cleaned up _test_skills/{C.RESET}")
+
+
+async def test_6_thinking_streaming():
+    """Test 6: Thinking content streaming (if model supports extended thinking)."""
+    header("Test 6: Thinking streaming")
+    tools = []
+    prompt = "9.11 和 9.8 哪个更大？请仔细思考后再回答。"
+
+    agent = Agent(llm=create_llm(thinking=True), tools=tools)
+
+    print(f"  {C.DIM}Prompt: {prompt}{C.RESET}")
+    thinking_chunks = 0
+    text_chunks = 0
+    thinking_parts: list[str] = []
+    in_thinking = False
+    in_response = False
+
+    async for event in agent.query_stream(prompt, stream=True):
+        match event:
+            case ThinkingChunkEvent(content=delta):
+                thinking_chunks += 1
+                thinking_parts.append(delta)
+                if not in_thinking:
+                    in_thinking = True
+                    print(f"\n  {C.BOLD}{C.MAGENTA}[Thinking]{C.RESET} ", end="", flush=True)
+                print(f"{C.MAGENTA}{delta}{C.RESET}", end="", flush=True)
+            case TextChunkEvent(content=delta):
+                if in_thinking:
+                    in_thinking = False
+                    print()  # end thinking line
+                    print(f"\n  {C.BOLD}{C.YELLOW}[Response]{C.RESET} ", end="", flush=True)
+                    in_response = True
+                text_chunks += 1
+                print(f"{C.YELLOW}{delta}{C.RESET}", end="", flush=True)
+            case TextEvent():
+                pass
+            case FinalResponseEvent():
+                if in_response or in_thinking:
+                    print()
+                thinking_text = "".join(thinking_parts)
+                print(f"\n  {C.DIM}{'─' * 50}{C.RESET}")
+                print(f"  {C.BOLD}Stats:{C.RESET}")
+                print(f"    Thinking: {C.MAGENTA}{thinking_chunks} chunks{C.RESET} ({len(thinking_text)} chars)")
+                print(f"    Text:     {C.YELLOW}{text_chunks} chunks{C.RESET}")
+                print(f"  {C.DIM}{'─' * 50}{C.RESET}")
+
+
+# ─── Main ───────────────────────────────────────────────────────────────────
+
+TESTS = [
+    ("1", "Text-only streaming comparison", test_1_text_only_streaming),
+    ("2", "Built-in tools (bash, fs_glob, fs_read)", test_2_builtin_tools),
+    ("3", "Custom tools (calculator, get_time)", test_3_custom_tools),
+    ("4", "Multi-tool workflow (write→read→grep)", test_4_multi_tool_workflow),
+    ("5", "Skills (code-review, git-commit)", test_5_skills),
+    ("6", "Thinking streaming", test_6_thinking_streaming),
+]
+
+
+async def run_all():
+    for _, desc, test_fn in TESTS:
+        try:
+            await test_fn()
+        except Exception as e:
+            print(f"\n  {C.RED}FAILED: {e}{C.RESET}")
+            import traceback
+            traceback.print_exc()
+
+    print(f"\n{'=' * 70}")
+    print(f"  {C.BOLD}{C.GREEN}All tests completed.{C.RESET}")
+    print(f"{'=' * 70}\n")
+
+
+async def run_one(choice: str):
+    for key, desc, test_fn in TESTS:
+        if key == choice:
+            print(f"\n  Running: {C.BOLD}{desc}{C.RESET}\n")
+            try:
+                await test_fn()
+            except Exception as e:
+                print(f"\n  {C.RED}FAILED: {e}{C.RESET}")
+                import traceback
+                traceback.print_exc()
+            return
+    print(f"  {C.RED}Unknown test: {choice}{C.RESET}")
+
+
+if __name__ == "__main__":
+    print(f"\n{C.BOLD}zai-adk True Streaming Test Suite{C.RESET}")
+    print(f"  Model: {os.getenv('OPENAI_MODEL', 'glm-4.7')}")
+    print(f"  Base URL: {os.getenv('OPENAI_BASE_URL', '(default)')}")
+
+    if len(sys.argv) > 1:
+        choice = sys.argv[1]
+        if choice in ("all", "a"):
+            asyncio.run(run_all())
+        else:
+            asyncio.run(run_one(choice))
+    else:
+        print(f"\n  Usage: python -m examples.test_streaming_real [test_number|all]")
+        print(f"\n  Available tests:")
+        for key, desc, _ in TESTS:
+            print(f"    {C.BOLD}{key}{C.RESET}  {desc}")
+        print(f"    {C.BOLD}all{C.RESET}  Run all tests")
+        print()