agentkit-sdk-python 0.5.7__tar.gz → 0.5.8__tar.gz

{agentkit_sdk_python-0.5.7/agentkit_sdk_python.egg-info → agentkit_sdk_python-0.5.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentkit-sdk-python
-Version: 0.5.7
+Version: 0.5.8
 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

{agentkit_sdk_python-0.5.7 → agentkit_sdk_python-0.5.8}/agentkit/client/base_service_client.py

@@ -18,7 +18,6 @@ This is the top-level base class for all service clients.
 """
 
 import json
-import logging
 from typing import Any, Dict, Type, TypeVar, Union, Optional
 from dataclasses import dataclass
 
@@ -35,7 +34,6 @@ from agentkit.platform import (
 from agentkit.platform.configuration import Credentials as PlatformCredentials
 from agentkit.platform.provider import CloudProvider
 from agentkit.utils.ve_sign import ensure_x_custom_source_header
-logger = logging.getLogger(__name__)
 
 T = TypeVar("T")
 _CREDENTIAL_ERROR_TOKENS = frozenset(
@@ -306,8 +304,7 @@ class BaseServiceClient(Service):
 
             if not res:
                 raise Exception(f"Empty response from {api_action} request.")
-            # debug level log res
-            logger.debug(f"Response from {api_action} request: {res}")
+
             response_data = json.loads(res)
             metadata = response_data.get("ResponseMetadata", {})
             if metadata.get("Error"):

{agentkit_sdk_python-0.5.7 → agentkit_sdk_python-0.5.8}/agentkit/toolkit/cli/cli_invoke.py

@@ -30,6 +30,26 @@ logger = logging.getLogger(__name__)
 console = Console()
 
 
+def _sanitize_headers_for_display(headers: dict) -> dict:
+    if not isinstance(headers, dict):
+        return {}
+    redacted_keys = {
+        "authorization",
+        "proxy-authorization",
+        "x-api-key",
+        "x-auth-token",
+        "api-key",
+    }
+    out: dict = {}
+    for k, v in headers.items():
+        key = str(k)
+        if key.lower() in redacted_keys:
+            out[key] = "******"
+        else:
+            out[key] = v
+    return out
+
+
 def _extract_text_chunks_from_langchain_event(event: dict) -> list[str]:
     """Extract incremental text chunks from LangChain message_to_dict-style events.
 
@@ -211,7 +231,9 @@ def build_a2a_payload(
 
 
 def invoke_command(
-    config_file: Path = typer.Option("agentkit.yaml", help="Configuration file"),
+    config_file: Optional[Path] = typer.Option(
+        None, "--config-file", 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)"
@@ -219,6 +241,20 @@ def invoke_command(
     headers: str = typer.Option(
         None, "--headers", "-h", help="JSON headers for request (advanced option)"
     ),
+    runtime_id: str = typer.Option(
+        None, "--runtime-id", "-r", help="Runtime ID for direct invocation"
+    ),
+    endpoint: str = typer.Option(
+        None, "--endpoint", "-e", help="Endpoint URL for direct invocation"
+    ),
+    region: str = typer.Option(
+        None, "--region", help="Region for Runtime lookup (used with --runtime-id)"
+    ),
+    a2a: bool = typer.Option(
+        False,
+        "--a2a",
+        help="Force A2A JSON-RPC envelope (direct invocation mode only)",
+    ),
     show_reasoning: bool = typer.Option(
         False,
         "--show-reasoning",
@@ -262,8 +298,28 @@ def invoke_command(
             "[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()
+
+    direct_mode = bool(runtime_id or endpoint)
+    if direct_mode and config_file is not None:
+        console.print(
+            "[red]Error: --config-file cannot be used with --runtime-id/--endpoint.[/red]"
+        )
+        raise typer.Exit(1)
+    if runtime_id and endpoint:
+        console.print(
+            "[red]Error: Cannot specify both --runtime-id and --endpoint.[/red]"
+        )
+        raise typer.Exit(1)
+    if region and not runtime_id:
+        console.print(
+            "[red]Error: --region can only be used together with --runtime-id.[/red]"
+        )
+        raise typer.Exit(1)
+    if a2a and not direct_mode:
+        console.print(
+            "[red]Error: --a2a can only be used with --runtime-id or --endpoint.[/red]"
+        )
+        raise typer.Exit(1)
 
     # Process headers
     default_headers = {
@@ -286,38 +342,100 @@ def invoke_command(
             )
             raise typer.Exit(1)
         final_headers.update(custom_headers)
-        console.print(f"[blue]Using merged headers: {final_headers}[/blue]")
+        console.print(
+            f"[blue]Using merged headers: {_sanitize_headers_for_display(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]"
+            f"[blue]Using default headers: {_sanitize_headers_for_display(final_headers)}[/blue]"
         )
-        final_payload = build_a2a_payload(message, payload, final_headers)
 
     if apikey:
+        if runtime_id:
+            console.print(
+                "[red]Error: --apikey cannot be used together with --runtime-id. "
+                "--runtime-id mode resolves the Runtime and infers its auth type automatically: "
+                "for API Key (key_auth), omit auth flags and the CLI will fetch and inject the API key; "
+                'for JWT/OAuth (custom_jwt), provide an Authorization header via --headers \'{"Authorization":"Bearer <token>"}\'. '
+                "If you want to pass an API key manually, use --endpoint together with --apikey.[/red]"
+            )
+            raise typer.Exit(1)
         final_headers["Authorization"] = f"Bearer {apikey}"
 
+    final_payload = build_standard_payload(message, payload)
+
     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 direct_mode:
+        if endpoint and not apikey and not final_headers.get("Authorization"):
+            console.print(
+                "[red]Error: --endpoint requires --apikey or an Authorization header provided via --headers.[/red]"
+            )
+            raise typer.Exit(1)
+
+        direct_common = {
+            "agent_name": "direct_invoke",
+            "entry_point": "agent.py",
+            "launch_type": "cloud",
+        }
+
+        is_a2a_payload = isinstance(final_payload, dict) and bool(
+            final_payload.get("jsonrpc")
+        )
+        if a2a:
+            final_payload = build_a2a_payload(message, payload, final_headers)
+            is_a2a_payload = True
+
+        if is_a2a_payload:
+            direct_common["agent_type"] = "a2a"
+
+        direct_cloud: dict[str, Any] = {}
+        if region:
+            direct_cloud["region"] = region
+        if runtime_id:
+            direct_cloud["runtime_id"] = runtime_id
+        if endpoint:
+            direct_cloud["runtime_endpoint"] = endpoint
+            if apikey:
+                direct_cloud["runtime_apikey"] = apikey
+            else:
+                direct_cloud["runtime_auth_type"] = "custom_jwt"
+
+        config_dict = {"common": direct_common, "launch_types": {"cloud": direct_cloud}}
+
+        result = executor.execute(
+            payload=final_payload,
+            config_dict=config_dict,
+            headers=final_headers,
+            stream=None,
+        )
+    else:
+        config_path = config_file or Path("agentkit.yaml")
+        config = get_config(config_path=config_path)
+        common_config = config.get_common_config()
+
+        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 is_a2a:
+            console.print(
+                "[cyan]Detected A2A agent type - constructing A2A JSON-RPC envelope[/cyan]"
+            )
+            final_payload = build_a2a_payload(message, payload, final_headers)
+
+        result = executor.execute(
+            payload=final_payload,
+            config_file=str(config_path),
+            headers=final_headers,
+            stream=None,  # Automatically determined by Runner
+        )
 
     if not result.success:
         console.print(f"[red]❌ Invocation failed: {result.error}[/red]")

{agentkit_sdk_python-0.5.7 → agentkit_sdk_python-0.5.8}/agentkit/toolkit/resources/templates/code-pipeline-tos-cr-step.j2

@@ -26,22 +26,24 @@ stages:
                 shell: BASH
             - step: step-c4
               displayName: 镜像构建推送至镜像仓库服务
-              component: build@2.0.0/buildkit-cr@3.0.0
+              component: build@2.0.0/buildkit-cr@5.0.0
               inputs:
+                buildParams: ""
                 compression: gzip
                 contextPath: $PROJECT_ROOT_DIR
                 crDomain: $CR_DOMAIN
-                crNamespace: $CR_NAMESPACE
-                crRegion: $CR_REGION
-                crRegistryInstance: $CR_INSTANCE
-                crRepo: $CR_OCI
-                crTag: $CR_TAG
+                namespace: $CR_NAMESPACE
+                region: $CR_REGION
+                registryInstance: $CR_INSTANCE
+                repo: $CR_OCI
+                tag: $CR_TAG
                 disableSSLVerify: true
                 dockerfiles:
                     default:
                         path: $DOCKERFILE_PATH
                 loginCredential: []
                 useCache: false
+                nydusify: true
           outputs:
             - imageOutput_step-c4
           workspace: {}

{agentkit_sdk_python-0.5.7 → agentkit_sdk_python-0.5.8}/agentkit/toolkit/runners/base.py

@@ -17,6 +17,9 @@ from typing import Dict, Any, Optional, Union, Generator, Tuple
 import logging
 import requests
 import json
+import time
+import uuid
+import random
 from urllib.parse import urljoin
 from dataclasses import dataclass
 
@@ -53,6 +56,8 @@ class Runner(ABC):
         """
         self.logger = logging.getLogger(f"{__name__}.{self.__class__.__name__}")
         self.reporter = reporter or SilentReporter()
+        self._backend_detect_cache: Dict[str, Tuple[str, float]] = {}
+        self._backend_detect_cache_ttl_s: int = 120
 
     # ===== Configuration types =====
     @dataclass
@@ -387,6 +392,99 @@ class Runner(ABC):
             or err.startswith("Invocation failed: 405")
         )
 
+    def _normalize_base_endpoint(self, base_endpoint: str) -> str:
+        try:
+            return (base_endpoint or "").rstrip("/")
+        except Exception:
+            return base_endpoint
+
+    def _get_cached_backend(self, base_endpoint: str) -> Optional[str]:
+        key = self._normalize_base_endpoint(base_endpoint)
+        item = self._backend_detect_cache.get(key)
+        if not item:
+            return None
+        kind, ts = item
+        if time.monotonic() - ts > self._backend_detect_cache_ttl_s:
+            try:
+                self._backend_detect_cache.pop(key, None)
+            except Exception:
+                pass
+            return None
+        return kind
+
+    def _set_cached_backend(self, base_endpoint: str, kind: str) -> None:
+        key = self._normalize_base_endpoint(base_endpoint)
+        try:
+            self._backend_detect_cache[key] = (kind, time.monotonic())
+        except Exception:
+            pass
+
+    def _is_a2a_agent_card_response(self, data: Any) -> bool:
+        if not isinstance(data, dict):
+            return False
+        name = data.get("name")
+        if not isinstance(name, str) or not name:
+            return False
+        if isinstance(data.get("capabilities"), dict):
+            return True
+        if isinstance(data.get("skills"), list):
+            return True
+        if isinstance(data.get("endpoints"), (dict, list)):
+            return True
+        if isinstance(data.get("protocol_version"), str) or isinstance(
+            data.get("protocolVersion"), str
+        ):
+            return True
+        return False
+
+    def _detect_a2a_backend(
+        self, base_endpoint: str, headers: Dict[str, str], timeout_s: int = 2
+    ) -> bool:
+        try:
+            base = (base_endpoint.rstrip("/") + "/") if base_endpoint else ""
+            url = urljoin(base, ".well-known/agent-card.json")
+            resp = requests.get(url, headers=headers, timeout=timeout_s)
+            if resp.status_code != 200:
+                return False
+            try:
+                data = resp.json()
+            except Exception:
+                return False
+            return self._is_a2a_agent_card_response(data)
+        except Exception:
+            return False
+
+    def _build_a2a_jsonrpc_payload(
+        self, original_payload: Any, headers: Dict[str, str]
+    ) -> Dict[str, Any]:
+        if isinstance(original_payload, dict) and original_payload.get("jsonrpc"):
+            return original_payload
+
+        text = None
+        if isinstance(original_payload, dict):
+            val = original_payload.get("prompt")
+            if isinstance(val, str):
+                text = val
+        if text is None:
+            try:
+                text = json.dumps(original_payload, ensure_ascii=False)
+            except Exception:
+                text = ""
+
+        return {
+            "jsonrpc": "2.0",
+            "method": "message/stream",
+            "params": {
+                "message": {
+                    "role": "user",
+                    "messageId": str(uuid.uuid4()),
+                    "parts": [{"kind": "text", "text": text or ""}],
+                },
+                "metadata": headers,
+            },
+            "id": random.randint(1, 999999),
+        }
+
     def _post_run_sse(
         self,
         base_endpoint: str,
@@ -435,10 +533,8 @@ class Runner(ABC):
                 timeout=policy.invoke_timeout,
             )
         else:
-            # Non-A2A: detect ADK first
-            if self._detect_adk_backend(
-                ctx.base_endpoint, ctx.headers, timeout_s=policy.detect_timeout
-            ):
+            cached = self._get_cached_backend(ctx.base_endpoint)
+            if cached == "adk":
                 app_name = self._get_adk_app_name(
                     ctx.base_endpoint,
                     ctx.headers,
@@ -465,6 +561,16 @@ class Runner(ABC):
                     adk_payload,
                     timeout_s=policy.sse_timeout,
                 )
+            elif cached == "a2a":
+                a2a_payload = self._build_a2a_jsonrpc_payload(payload, ctx.headers)
+                success, response_data = self._http_post_invoke(
+                    endpoint=self._normalize_base_endpoint(ctx.base_endpoint)
+                    or ctx.base_endpoint,
+                    payload=a2a_payload,
+                    headers=ctx.headers,
+                    stream=None,
+                    timeout=policy.invoke_timeout,
+                )
             else:
                 success, response_data = self._http_post_invoke(
                     endpoint=ctx.invoke_endpoint,
@@ -473,35 +579,58 @@ class Runner(ABC):
                     stream=None,
                     timeout=policy.invoke_timeout,
                 )
-                if not success and self._should_fallback_to_adk(str(response_data)):
-                    app_name = self._get_adk_app_name(
-                        ctx.base_endpoint,
-                        ctx.headers,
-                        preferred_name=ctx.preferred_app_name,
-                        timeout_s=policy.list_apps_timeout,
-                    )
-                    app_name = app_name or "agentkit-app"
-                    user_id = ctx.headers.get("user_id") or "agentkit_user"
-                    session_id = (
-                        ctx.headers.get("session_id") or "agentkit_sample_session"
-                    )
-                    self._ensure_adk_session(
-                        ctx.base_endpoint,
-                        ctx.headers,
-                        app_name,
-                        user_id,
-                        session_id,
-                        timeout_s=policy.session_timeout,
-                    )
-                    adk_payload = self._build_adk_run_sse_payload(
-                        app_name, ctx.headers, payload
-                    )
-                    success, response_data = self._post_run_sse(
-                        ctx.base_endpoint,
-                        ctx.headers,
-                        adk_payload,
-                        timeout_s=policy.sse_timeout,
-                    )
+                if success:
+                    self._set_cached_backend(ctx.base_endpoint, "invoke")
+                elif self._should_fallback_to_adk(str(response_data)):
+                    if self._detect_adk_backend(
+                        ctx.base_endpoint, ctx.headers, timeout_s=policy.detect_timeout
+                    ):
+                        self._set_cached_backend(ctx.base_endpoint, "adk")
+                        app_name = self._get_adk_app_name(
+                            ctx.base_endpoint,
+                            ctx.headers,
+                            preferred_name=ctx.preferred_app_name,
+                            timeout_s=policy.list_apps_timeout,
+                        )
+                        app_name = app_name or "agentkit-app"
+                        user_id = ctx.headers.get("user_id") or "agentkit_user"
+                        session_id = (
+                            ctx.headers.get("session_id") or "agentkit_sample_session"
+                        )
+                        self._ensure_adk_session(
+                            ctx.base_endpoint,
+                            ctx.headers,
+                            app_name,
+                            user_id,
+                            session_id,
+                            timeout_s=policy.session_timeout,
+                        )
+                        adk_payload = self._build_adk_run_sse_payload(
+                            app_name, ctx.headers, payload
+                        )
+                        success, response_data = self._post_run_sse(
+                            ctx.base_endpoint,
+                            ctx.headers,
+                            adk_payload,
+                            timeout_s=policy.sse_timeout,
+                        )
+                    elif self._detect_a2a_backend(
+                        ctx.base_endpoint, ctx.headers, timeout_s=policy.detect_timeout
+                    ):
+                        self._set_cached_backend(ctx.base_endpoint, "a2a")
+                        a2a_payload = self._build_a2a_jsonrpc_payload(
+                            payload, ctx.headers
+                        )
+                        success, response_data = self._http_post_invoke(
+                            endpoint=self._normalize_base_endpoint(ctx.base_endpoint)
+                            or ctx.base_endpoint,
+                            payload=a2a_payload,
+                            headers=ctx.headers,
+                            stream=None,
+                            timeout=policy.invoke_timeout,
+                        )
+                    else:
+                        self._set_cached_backend(ctx.base_endpoint, "unknown")
 
         is_streaming = hasattr(response_data, "__iter__") and not isinstance(
             response_data, (dict, str, list, bytes)

{agentkit_sdk_python-0.5.7 → agentkit_sdk_python-0.5.8}/agentkit/toolkit/runners/ve_agentkit.py

@@ -416,7 +416,8 @@ class VeAgentkitRuntimeRunner(Runner):
         """
         try:
             runner_config = config
-            is_jwt_auth = runner_config.runtime_auth_type == AUTH_TYPE_CUSTOM_JWT
+            effective_auth_type = runner_config.runtime_auth_type
+            is_jwt_auth = effective_auth_type == AUTH_TYPE_CUSTOM_JWT
 
             # Get Runtime endpoint and API key
             endpoint = runner_config.runtime_endpoint
@@ -455,6 +456,14 @@ class VeAgentkitRuntimeRunner(Runner):
                             error_code=ErrorCode.RESOURCE_NOT_FOUND,
                         )
                     raise e
+
+                authorizer = getattr(runtime, "authorizer_configuration", None)
+                if authorizer and getattr(authorizer, "custom_jwt_authorizer", None):
+                    effective_auth_type = AUTH_TYPE_CUSTOM_JWT
+                elif authorizer and getattr(authorizer, "key_auth", None):
+                    effective_auth_type = AUTH_TYPE_KEY_AUTH
+                is_jwt_auth = effective_auth_type == AUTH_TYPE_CUSTOM_JWT
+
                 endpoint = self.get_public_endpoint_of_runtime(runtime)
 
                 # Only fetch API key for key_auth mode
@@ -468,7 +477,7 @@ class VeAgentkitRuntimeRunner(Runner):
                 # Validate based on auth type
                 if not endpoint:
                     error_msg = "Failed to obtain Runtime endpoint. The 'agentkit invoke' command only supports public network endpoints."
-                    logger.error(f"{error_msg}, runtime: {runtime}")
+                    logger.error(error_msg)
                     return InvokeResult(
                         success=False,
                         error=error_msg,
@@ -476,7 +485,7 @@ class VeAgentkitRuntimeRunner(Runner):
                     )
                 if not is_jwt_auth and not api_key:
                     error_msg = "Failed to obtain Runtime API key."
-                    logger.error(f"{error_msg}, runtime: {runtime}")
+                    logger.error(error_msg)
                     return InvokeResult(
                         success=False,
                         error=error_msg,

{agentkit_sdk_python-0.5.7 → agentkit_sdk_python-0.5.8}/agentkit/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-VERSION = "0.5.7"
+VERSION = "0.5.8"

{agentkit_sdk_python-0.5.7 → agentkit_sdk_python-0.5.8/agentkit_sdk_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentkit-sdk-python
-Version: 0.5.7
+Version: 0.5.8
 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

{agentkit_sdk_python-0.5.7 → agentkit_sdk_python-0.5.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentkit-sdk-python"
-version = "0.5.7"
+version = "0.5.8"
 description = "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."
 readme = "README.md"
 requires-python = ">=3.10"