agentkit-sdk-python 0.3.2__tar.gz → 0.3.3__tar.gz

{agentkit_sdk_python-0.3.2/agentkit_sdk_python.egg-info → agentkit_sdk_python-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentkit-sdk-python
-Version: 0.3.2
+Version: 0.3.3
 Summary: Python SDK for transforming any AI agent into a production-ready application. Framework-agnostic primitives for runtime, memory, authentication, and tools with volcengine-managed infrastructure.
 Author-email: Xiangrui Cheng <innsdcc@gmail.com>, Yumeng Bao <baoyumeng.123@gmail.com>, Yaozheng Fang <fangyozheng@gmail.com>, Guodong Li <cu.eric.lee@gmail.com>
 License:                                  Apache License
@@ -237,6 +237,7 @@ Requires-Dist: jinja2
 Requires-Dist: tos>=2.8.7
 Requires-Dist: volcengine
 Requires-Dist: pyfiglet>=1.0.2
+Requires-Dist: typing_extensions>=4.12
 Requires-Dist: pyreadline3; sys_platform == "win32"
 Provides-Extra: extensions
 Provides-Extra: toolkit

{agentkit_sdk_python-0.3.2 → agentkit_sdk_python-0.3.3}/agentkit/apps/a2a_app/a2a_app.py

@@ -17,7 +17,8 @@ import os
 import uvicorn
 import inspect
 
-from typing import Callable, override
+from typing import Callable
+from typing_extensions import override
 from a2a.server.agent_execution import AgentExecutor
 from a2a.server.agent_execution.context import RequestContext
 from a2a.server.apps import A2AStarletteApplication

{agentkit_sdk_python-0.3.2 → agentkit_sdk_python-0.3.3}/agentkit/apps/agent_server_app/agent_server_app.py

@@ -15,7 +15,7 @@
 import json
 import logging
 from contextlib import asynccontextmanager
-from typing import override
+from typing_extensions import override
 
 import uvicorn
 from fastapi import FastAPI, HTTPException, Request

{agentkit_sdk_python-0.3.2 → agentkit_sdk_python-0.3.3}/agentkit/apps/mcp_app/mcp_app.py

@@ -17,7 +17,8 @@ import inspect
 import logging
 import os
 from functools import wraps
-from typing import Any, Callable, override
+from typing import Any, Callable
+from typing_extensions import override
 
 from fastmcp import FastMCP
 from fastmcp.server.server import Transport

{agentkit_sdk_python-0.3.2 → agentkit_sdk_python-0.3.3}/agentkit/apps/simple_app/simple_app.py

@@ -14,7 +14,8 @@
 
 import inspect
 import logging
-from typing import Callable, override
+from typing import Callable
+from typing_extensions import override
 
 import uvicorn
 from starlette.applications import Starlette

{agentkit_sdk_python-0.3.2 → agentkit_sdk_python-0.3.3}/agentkit/apps/simple_app/simple_app_handlers.py

@@ -19,7 +19,8 @@ import threading
 import time
 import uuid
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Optional, override
+from typing import Any, Callable, Optional
+from typing_extensions import override
 
 from starlette.requests import Request
 from starlette.responses import JSONResponse, Response, StreamingResponse

{agentkit_sdk_python-0.3.2 → agentkit_sdk_python-0.3.3}/agentkit/toolkit/cli/cli_config.py

@@ -319,6 +319,25 @@ def _interactive_config(config_file: Optional[str] = None):
         console.print(f"[red]❌ Unknown launch type: {strategy_name}[/red]")
         raise typer.Exit(1)
 
+    # When disabling strict region restrictions, default show global region
+    try:
+        from agentkit.toolkit.config.global_config import get_global_config
+
+        global_conf = get_global_config()
+        disabled = bool(
+            getattr(global_conf.defaults, "disable_region_strict_restrictions", False)
+        )
+        if disabled and isinstance(current_strategy_config_dict, dict):
+            global_region = (global_conf.region or "").strip()
+            if global_region:
+                if "region" in current_strategy_config_dict:
+                    if not current_strategy_config_dict.get("region"):
+                        current_strategy_config_dict["region"] = global_region
+                else:
+                    current_strategy_config_dict["region"] = global_region
+    except Exception:
+        pass
+
     # Generate new strategy config
     strategy_config = generate_config_from_dataclass(
         config_class, current_strategy_config_dict
@@ -472,6 +491,8 @@ def _show_global_config():
     console.print(
         f"  Region:     [yellow]{config.region or '[dim](not set)[/dim]'}[/yellow]"
     )
+    if config.defaults.disable_region_strict_restrictions:
+        console.print("  Disable Region Restrictions: [yellow]True[/yellow]")
     console.print()
 
     # Display Volcengine credentials
@@ -581,22 +602,9 @@ def _set_global_field(field_value: str):
                 )
             config_dict[section][field] = clean_value
         elif field == "cr_public_endpoint_check":
-            clean_value = value.strip().lower() if value is not None else None
-            if clean_value == "":
-                clean_value = None
-            if clean_value is None:
-                config_dict[section][field] = None
-            else:
-                truthy = {"true", "1", "yes", "y"}
-                falsy = {"false", "0", "no", "n"}
-                if clean_value in truthy:
-                    config_dict[section][field] = True
-                elif clean_value in falsy:
-                    config_dict[section][field] = False
-                else:
-                    raise AttributeError(
-                        f"Invalid boolean value for cr_public_endpoint_check: {value}"
-                    )
+            _set_bool_field(config_dict[section], field, value)
+        elif field == "disable_region_strict_restrictions":
+            _set_bool_field(config_dict[section], field, value)
         elif field == "iam_role_policies":
             # Simple list parsing for CLI convenience
             if not value:
@@ -631,3 +639,22 @@ def _set_global_field(field_value: str):
     except Exception as e:
         console.print(f"[red]❌ Failed to set config: {e}[/red]")
         raise typer.Exit(code=1)
+
+
+def _set_bool_field(target_dict: dict, field: str, value: str):
+    """Helper to set boolean field from string value."""
+    clean_value = value.strip().lower() if value is not None else None
+    if clean_value == "":
+        clean_value = None
+
+    if clean_value is None:
+        target_dict[field] = None
+    else:
+        truthy = {"true", "1", "yes", "y"}
+        falsy = {"false", "0", "no", "n"}
+        if clean_value in truthy:
+            target_dict[field] = True
+        elif clean_value in falsy:
+            target_dict[field] = False
+        else:
+            raise AttributeError(f"Invalid boolean value for {field}: {value}")

agentkit_sdk_python-0.3.3/agentkit/toolkit/cli/cli_invoke.py

@@ -0,0 +1,452 @@
+# Copyright (c) 2025 Beijing Volcano Engine Technology Co., Ltd. and/or its affiliates.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""AgentKit CLI - Invoke command implementation."""
+
+from pathlib import Path
+from typing import Optional, Any
+import json
+import typer
+from rich.console import Console
+import time
+import random
+import uuid
+from agentkit.toolkit.config import get_config
+import logging
+
+# Note: Avoid importing heavy packages at the top to keep CLI startup fast
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+def _extract_text_chunks_from_langchain_event(event: dict) -> list[str]:
+    """Extract incremental text chunks from LangChain message_to_dict-style events.
+
+    Expected shape (example):
+        {"type": "AIMessageChunk", "data": {"content": "今天", ...}}
+    """
+    if not isinstance(event, dict):
+        return []
+
+    event_type = event.get("type")
+    data = event.get("data")
+    if not isinstance(event_type, str) or not isinstance(data, dict):
+        return []
+
+    # Most common streaming types: AIMessageChunk / HumanMessageChunk / ToolMessageChunk
+    if not (
+        event_type.endswith("MessageChunk")
+        or event_type in {"AIMessage", "HumanMessage", "ToolMessage"}
+    ):
+        return []
+
+    content = data.get("content")
+    if content is None:
+        return []
+
+    # content can be a string, or a multimodal list like:
+    #   [{"type":"text","text":"..."}, ...]
+    if isinstance(content, str):
+        return [content] if content else []
+    if isinstance(content, list):
+        chunks: list[str] = []
+        for item in content:
+            if isinstance(item, str) and item:
+                chunks.append(item)
+            elif isinstance(item, dict):
+                text = item.get("text")
+                if isinstance(text, str) and text:
+                    chunks.append(text)
+        return chunks
+
+    return []
+
+
+def _extract_reasoning_chunks_from_langchain_event(event: dict) -> list[str]:
+    """Extract incremental reasoning chunks from LangChain events.
+
+    LangChain emit reasoning in:
+        event['data']['additional_kwargs']['reasoning_content']
+    while leaving event['data']['content'] empty.
+    """
+    if not isinstance(event, dict):
+        return []
+
+    event_type = event.get("type")
+    data = event.get("data")
+    if not isinstance(event_type, str) or not isinstance(data, dict):
+        return []
+
+    if not (
+        event_type.endswith("MessageChunk")
+        or event_type in {"AIMessage", "HumanMessage", "ToolMessage"}
+    ):
+        return []
+
+    additional_kwargs = data.get("additional_kwargs")
+    if not isinstance(additional_kwargs, dict):
+        return []
+
+    reasoning = additional_kwargs.get("reasoning_content")
+    if isinstance(reasoning, str):
+        return [reasoning] if reasoning else []
+    return []
+
+
+def _extract_text_chunks_from_adk_event(event: dict) -> list[str]:
+    """Extract incremental text chunks from Google ADK/AgentKit streaming events."""
+    if not isinstance(event, dict):
+        return []
+
+    parts: list[Any] = []
+    if isinstance(event.get("parts"), list):
+        parts = event.get("parts", [])
+    elif isinstance(event.get("message"), dict):
+        parts = event["message"].get("parts", [])
+    elif isinstance(event.get("content"), dict):
+        parts = event["content"].get("parts", [])
+    elif isinstance(event.get("status"), dict):
+        role = event["status"].get("message", {}).get("role")
+        if role == "agent":
+            parts = event["status"].get("message", {}).get("parts", [])
+
+    if not isinstance(parts, list) or not parts:
+        return []
+
+    chunks: list[str] = []
+    for part in parts:
+        text: Optional[str] = None
+        if isinstance(part, dict) and "text" in part:
+            val = part.get("text")
+            text = val if isinstance(val, str) else None
+        elif isinstance(part, str):
+            text = part
+        if text:
+            chunks.append(text)
+    return chunks
+
+
+def _normalize_stream_event(event: Any) -> Optional[dict]:
+    """Normalize an event yielded by InvokeResult.stream() to a dict.
+
+    - Runner normally yields dict (already JSON-decoded).
+    - CLI keeps a fallback path for raw SSE strings ("data: {...}").
+    """
+    if isinstance(event, dict):
+        return event
+    if isinstance(event, str):
+        s = event.strip()
+        if not s.startswith("data: "):
+            return None
+        json_str = s[6:].strip()
+        if not json_str:
+            return None
+        try:
+            parsed = json.loads(json_str)
+            return parsed if isinstance(parsed, dict) else None
+        except json.JSONDecodeError:
+            return None
+    return None
+
+
+def build_standard_payload(message: Optional[str], payload: Optional[str]) -> dict:
+    if message:
+        return {"prompt": message}
+    else:
+        try:
+            parsed = json.loads(payload) if isinstance(payload, str) else payload
+            console.print(f"[blue]Using custom payload: {parsed}[/blue]")
+            return parsed
+        except json.JSONDecodeError as e:
+            console.print(f"[red]Error: Invalid JSON payload: {e}[/red]")
+            raise typer.Exit(1)
+
+
+def build_a2a_payload(
+    message: Optional[str], payload: Optional[str], headers: dict
+) -> dict:
+    parsed = None
+    if payload:
+        try:
+            parsed = json.loads(payload) if isinstance(payload, str) else payload
+        except json.JSONDecodeError:
+            parsed = None
+
+    if isinstance(parsed, dict) and parsed.get("jsonrpc"):
+        console.print("[blue]Using provided JSON-RPC payload for A2A[/blue]")
+        return parsed
+
+    if message:
+        text = message
+    elif parsed is not None:
+        text = json.dumps(parsed, ensure_ascii=False)
+    else:
+        text = payload if payload else ""
+
+    a2a = {
+        "jsonrpc": "2.0",
+        "method": "message/stream",
+        "params": {
+            "message": {
+                "role": "user",
+                "messageId": str(uuid.uuid4()),
+                "parts": [{"kind": "text", "text": text}],
+            },
+            "metadata": headers,
+        },
+        "id": random.randint(1, 999999),
+    }
+    return a2a
+
+
+def invoke_command(
+    config_file: Path = typer.Option("agentkit.yaml", help="Configuration file"),
+    message: str = typer.Argument(None, help="Simple message to send to agent"),
+    payload: str = typer.Option(
+        None, "--payload", "-p", help="JSON payload to send (advanced option)"
+    ),
+    headers: str = typer.Option(
+        None, "--headers", "-h", help="JSON headers for request (advanced option)"
+    ),
+    show_reasoning: bool = typer.Option(
+        False,
+        "--show-reasoning",
+        help="Print LangChain reasoning_content (if present) during streaming",
+    ),
+    raw: bool = typer.Option(
+        False,
+        "--raw",
+        help="Print raw streaming events (and raw JSON response) for debugging",
+    ),
+    apikey: str = typer.Option(
+        None, "--apikey", "-ak", help="API key for authentication"
+    ),
+) -> Any:
+    """Send a test request to deployed Agent.
+
+    Examples:
+        # Simple message
+        agentkit invoke "What is the weather today?"
+
+        # Custom payload
+        agentkit invoke --payload '{"prompt": "What is the weather in Hangzhou?"}'
+
+        # With custom headers
+        agentkit invoke --payload '{"prompt": "What is the weather in Hangzhou?"}' --headers '{"user_id": "test123"}'
+    """
+    from agentkit.toolkit.executors import InvokeExecutor
+    from agentkit.toolkit.cli.console_reporter import ConsoleReporter
+
+    console.print("[cyan]Invoking agent...[/cyan]")
+
+    # Validate parameters: message and payload cannot be provided simultaneously
+    if message and payload:
+        console.print(
+            "[red]Error: Cannot specify both message and payload. Use either message or --payload.[/red]"
+        )
+        raise typer.Exit(1)
+    # Validate parameters: must provide either message or payload
+    if not message and not payload:
+        console.print(
+            "[red]Error: Must provide either a message or --payload option.[/red]"
+        )
+        raise typer.Exit(1)
+    config = get_config(config_path=config_file)
+    common_config = config.get_common_config()
+
+    # Process headers
+    default_headers = {
+        "user_id": "agentkit_user",
+        "session_id": "agentkit_sample_session",
+    }
+    final_headers = default_headers.copy()
+
+    if headers:
+        try:
+            custom_headers = (
+                json.loads(headers) if isinstance(headers, str) else headers
+            )
+        except json.JSONDecodeError as e:
+            console.print(f"[red]Error: Invalid JSON headers: {e}[/red]")
+            raise typer.Exit(1)
+        if not isinstance(custom_headers, dict):
+            console.print(
+                '[red]Error: --headers must be a JSON object (e.g. \'{"user_id": "u1"}\').[/red]'
+            )
+            raise typer.Exit(1)
+        final_headers.update(custom_headers)
+        console.print(f"[blue]Using merged headers: {final_headers}[/blue]")
+    else:
+        console.print(f"[blue]Using default headers: {final_headers}[/blue]")
+
+    final_payload = build_standard_payload(message, payload)
+    agent_type = getattr(common_config, "agent_type", "") or getattr(
+        common_config, "template_type", ""
+    )
+    is_a2a = isinstance(agent_type, str) and "a2a" in agent_type.lower()
+
+    # If it's an A2A Agent, reconstruct payload using A2A constructor
+    if is_a2a:
+        console.print(
+            "[cyan]Detected A2A agent type - constructing A2A JSON-RPC envelope[/cyan]"
+        )
+        final_payload = build_a2a_payload(message, payload, final_headers)
+
+    if apikey:
+        final_headers["Authorization"] = f"Bearer {apikey}"
+
+    from agentkit.toolkit.context import ExecutionContext
+
+    reporter = ConsoleReporter()
+    ExecutionContext.set_reporter(reporter)
+
+    executor = InvokeExecutor(reporter=reporter)
+    result = executor.execute(
+        payload=final_payload,
+        config_file=str(config_file),
+        headers=final_headers,
+        stream=None,  # Automatically determined by Runner
+    )
+
+    if not result.success:
+        console.print(f"[red]❌ Invocation failed: {result.error}[/red]")
+        raise typer.Exit(1)
+    console.print("[green]✅ Invocation successful[/green]")
+
+    # Get response
+    response = result.response
+
+    # Handle streaming response (generator)
+    if result.is_streaming:
+        console.print("[cyan]📡 Streaming response detected...[/cyan]\n")
+        if raw:
+            console.print(
+                "[yellow]Raw mode enabled: printing raw stream events[/yellow]\n"
+            )
+        result_list = []
+        complete_text = []
+        printed_reasoning_header = False
+        printed_answer_header = False
+        printed_hidden_reasoning_hint = False
+        printed_heartbeat = False
+        last_heartbeat_ts = time.monotonic()
+
+        for event in result.stream():
+            result_list.append(event)
+
+            if raw:
+                # Print the event as received (before normalization), to help debugging.
+                if isinstance(event, dict):
+                    console.print(json.dumps(event, ensure_ascii=False))
+                elif isinstance(event, str):
+                    console.print(event.rstrip("\n"))
+                else:
+                    console.print(repr(event))
+
+            normalized = _normalize_stream_event(event)
+            if normalized is None:
+                continue
+
+            # Handle A2A JSON-RPC wrapper (unwrap to the underlying result payload)
+            if normalized.get("jsonrpc") and "result" in normalized:
+                result_payload = normalized.get("result")
+                normalized = result_payload if isinstance(result_payload, dict) else {}
+
+            # Keep existing partial-event behavior for ADK style streams.
+            # (LangChain message events typically don't carry this field.)
+            if not normalized.get("partial", True):
+                logger.info("Partial event: %s", normalized)
+                continue
+
+            # In raw mode, we still keep termination/error handling, but skip
+            # extracted text printing to avoid mixing structured debug output.
+            if not raw:
+                # LangChain: reasoning_content
+                reasoning_chunks = _extract_reasoning_chunks_from_langchain_event(
+                    normalized
+                )
+                if reasoning_chunks:
+                    if show_reasoning:
+                        if not printed_reasoning_header:
+                            console.print("[cyan]🧠 Reasoning:[/cyan]")
+                            printed_reasoning_header = True
+                        for text in reasoning_chunks:
+                            console.print(text, end="", style="yellow")
+                    else:
+                        # Default behavior: do not print reasoning, but keep the CLI responsive
+                        # with a one-time hint and a periodic heartbeat.
+                        if not printed_hidden_reasoning_hint:
+                            console.print(
+                                "[cyan]🤔 Model is thinking... (use --show-reasoning to view)[/cyan]"
+                            )
+                            printed_hidden_reasoning_hint = True
+                        now = time.monotonic()
+                        if now - last_heartbeat_ts >= 1.5:
+                            console.print(".", end="", style="cyan")
+                            printed_heartbeat = True
+                            last_heartbeat_ts = now
+
+                # Extract and print incremental answer text chunks
+                text_chunks: list[str] = []
+                text_chunks.extend(
+                    _extract_text_chunks_from_langchain_event(normalized)
+                )
+                if not text_chunks:
+                    text_chunks.extend(_extract_text_chunks_from_adk_event(normalized))
+
+                if text_chunks:
+                    # If we printed a hidden reasoning hint / heartbeat dots, separate answer on a new line.
+                    if printed_hidden_reasoning_hint or printed_heartbeat:
+                        console.print("")
+                        printed_hidden_reasoning_hint = False
+                        printed_heartbeat = False
+                    if printed_reasoning_header and not printed_answer_header:
+                        console.print("\n[cyan]📝 Answer:[/cyan]")
+                        printed_answer_header = True
+                    for text in text_chunks:
+                        complete_text.append(text)
+                        console.print(text, end="", style="green")
+
+            # Display error information in event (if any)
+            if "error" in normalized:
+                console.print(f"\n[red]Error: {normalized['error']}[/red]")
+
+            # Handle status updates (e.g., final flag or completed status)
+            if normalized.get("final") is True:
+                break
+
+            status = normalized.get("status")
+            if isinstance(status, dict) and status.get("state") == "completed":
+                console.print("\n[cyan]Status indicates completed[/cyan]")
+                break
+
+        # Display complete response (commented out for now)
+        # if complete_text:
+        #     console.print("\n\n[cyan]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/cyan]")
+        #     console.print(f"[cyan]📝 Complete response:[/cyan] {''.join(complete_text)}")
+        console.print("")  # Line break
+
+        return str(result_list)
+
+    # Handle non-streaming response
+    console.print("[cyan]📝 Response:[/cyan]")
+    if isinstance(response, dict):
+        if raw:
+            console.print(json.dumps(response, ensure_ascii=False))
+        else:
+            console.print(json.dumps(response, indent=2, ensure_ascii=False))
+    else:
+        console.print(response)
+
+    return str(response)

{agentkit_sdk_python-0.3.2 → agentkit_sdk_python-0.3.3}/agentkit/toolkit/cli/interactive_config.py

@@ -107,6 +107,7 @@ class AutoPromptGenerator:
             dict: self._handle_dict,
             Dict: self._handle_dict,
         }
+        self.current_dataclass_type = None
 
     def _safe_input(self, prompt_text, default: str = "") -> str:
         """Safe input method that protects prompt text from being deleted by Backspace.
@@ -175,6 +176,7 @@ class AutoPromptGenerator:
     def generate_config(
         self, dataclass_type: type, existing_config: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
+        self.current_dataclass_type = dataclass_type
         if not is_dataclass(dataclass_type):
             raise ValueError(f"{dataclass_type} must be a dataclass")
 
@@ -270,6 +272,7 @@ class AutoPromptGenerator:
             if not isinstance(value, type(MISSING)):
                 filtered_config[key] = value
 
+        self.current_dataclass_type = None
         return filtered_config
 
     def _prompt_for_field(
@@ -326,7 +329,35 @@ class AutoPromptGenerator:
             default = None
 
         choices = metadata.get("choices")
-        if choices:
+        # Allow free region input when global defaults disable strict restrictions
+        allow_free_region = False
+        try:
+            from agentkit.toolkit.config.global_config import get_global_config
+
+            global_conf = get_global_config()
+            disabled = bool(
+                getattr(
+                    global_conf.defaults, "disable_region_strict_restrictions", False
+                )
+            )
+            if disabled and name == "region":
+                # Limit to Cloud/Hybrid strategy types only
+                try:
+                    from agentkit.toolkit.config.strategy_configs import (
+                        CloudStrategyConfig,
+                        HybridStrategyConfig,
+                    )
+
+                    allow_free_region = self.current_dataclass_type in (
+                        CloudStrategyConfig,
+                        HybridStrategyConfig,
+                    )
+                except Exception:
+                    allow_free_region = False
+        except Exception:
+            allow_free_region = False
+
+        if choices and not allow_free_region:
             return self._handle_choice_selection(
                 description, default, choices, metadata, current, total
             )
@@ -830,8 +861,8 @@ class AutoPromptGenerator:
         # Add environment variable hints (if description contains 'env')
         if "env" in description.lower():
             console.print("Common environment variables:")
+            console.print("  - MODEL_AGENT_NAME=your_model_name")
             console.print("  - MODEL_AGENT_API_KEY=your_api_key")
-            console.print("  - DEBUG=true")
             console.print("  - LOG_LEVEL=info")
 
         console.print("Input format: KEY=VALUE")