agentkit-sdk-python 0.2.2__tar.gz → 0.3.1__tar.gz

{agentkit_sdk_python-0.2.2/agentkit_sdk_python.egg-info → agentkit_sdk_python-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentkit-sdk-python
-Version: 0.2.2
+Version: 0.3.1
 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.2.2 → agentkit_sdk_python-0.3.1}/agentkit/apps/agent_server_app/agent_server_app.py

@@ -12,15 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import json
+import logging
+from contextlib import asynccontextmanager
 from typing import override
 
 import uvicorn
-import json
-from fastapi import Request
-from fastapi import HTTPException
+from fastapi import FastAPI, HTTPException, Request
 from fastapi.responses import StreamingResponse
-from opentelemetry import trace
+from google.adk.a2a.utils.agent_to_a2a import to_a2a
 from google.adk.agents.base_agent import BaseAgent
+from google.adk.agents.run_config import RunConfig, StreamingMode
 from google.adk.artifacts.in_memory_artifact_service import (
     InMemoryArtifactService,
 )
@@ -35,15 +37,20 @@ from google.adk.evaluation.local_eval_set_results_manager import (
 from google.adk.evaluation.local_eval_sets_manager import LocalEvalSetsManager
 from google.adk.memory.in_memory_memory_service import InMemoryMemoryService
 from google.adk.sessions.base_session_service import BaseSessionService
-from google.adk.agents.run_config import RunConfig, StreamingMode
 from google.adk.utils.context_utils import Aclosing
 from google.genai import types
+from opentelemetry import trace
 from veadk import Agent
 from veadk.memory.short_term_memory import ShortTermMemory
+from veadk.runner import Runner
 
-from agentkit.apps.base_app import BaseAgentkitApp
+from agentkit.apps.agent_server_app.middleware import (
+    AgentkitTelemetryHTTPMiddleware,
+)
 from agentkit.apps.agent_server_app.telemetry import telemetry
-from agentkit.apps.agent_server_app.middleware import AgentkitTelemetryHTTPMiddleware
+from agentkit.apps.base_app import BaseAgentkitApp
+
+logger = logging.getLogger(__name__)
 
 
 class AgentKitAgentLoader(BaseAgentLoader):
@@ -63,7 +70,9 @@ class AgentKitAgentLoader(BaseAgentLoader):
 
 class AgentkitAgentServerApp(BaseAgentkitApp):
     def __init__(
-        self, agent: BaseAgent, short_term_memory: BaseSessionService | ShortTermMemory
+        self,
+        agent: BaseAgent,
+        short_term_memory: BaseSessionService | ShortTermMemory,
     ) -> None:
         super().__init__()
 
@@ -88,7 +97,20 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
             agents_dir=".",
         )
 
-        self.app = self.server.get_fast_api_app()
+        runner = Runner(agent=agent)
+        _a2a_server_app = to_a2a(agent=agent, runner=runner)
+
+        @asynccontextmanager
+        async def lifespan(app: FastAPI):
+            # trigger A2A server app startup
+            logger.info("Triggering A2A server app startup within API server...")
+            for handler in _a2a_server_app.router.on_startup:
+                await handler()
+            yield
+
+        self.app = self.server.get_fast_api_app(lifespan=lifespan)
+
+        self.app.mount("/", _a2a_server_app)
 
         # Attach ASGI middleware for unified telemetry across all routes
         self.app.add_middleware(AgentkitTelemetryHTTPMiddleware)
@@ -171,7 +193,9 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
                     pass
                 except Exception as e:
                     yield f'data: {{"error": "{str(e)}"}}\n\n'
-                    telemetry.trace_agent_server_finish(func_result="", exception=e)
+                    telemetry.trace_agent_server_finish(
+                        path="/invoke", func_result="", exception=e
+                    )
 
             return StreamingResponse(
                 event_generator(),

{agentkit_sdk_python-0.2.2 → agentkit_sdk_python-0.3.1}/agentkit/client/base_agentkit_client.py

@@ -20,7 +20,6 @@ Provides common initialization and API invocation logic.
 from typing import Any, Dict, Union, Optional
 
 from agentkit.client.base_service_client import BaseServiceClient, ApiConfig
-from agentkit.utils.ve_sign import get_volc_agentkit_host_info, get_volc_agentkit_scheme
 
 
 class BaseAgentkitClient(BaseServiceClient):
@@ -60,30 +59,15 @@ class BaseAgentkitClient(BaseServiceClient):
             service_name: Service name for logging (e.g., 'knowledge', 'memory')
         """
         super().__init__(
+            service="agentkit",
             access_key=access_key,
             secret_key=secret_key,
             region=region,
             session_token=session_token,
             service_name=service_name,
-            credential_env_prefix="AGENTKIT",
             header=header,
         )
 
-    def _get_service_config(self) -> Dict[str, str]:
-        """
-        Get AgentKit service configuration.
-
-        Returns:
-            Dictionary with host, api_version, and service
-        """
-        host, api_version, service = get_volc_agentkit_host_info()
-        return {
-            "host": host,
-            "api_version": api_version,
-            "service": service,
-            "scheme": get_volc_agentkit_scheme(),
-        }
-
     def _get(self, api_action: str, params: Dict[str, Any] = None) -> str:
         """Legacy method for GET requests."""
         try:

{agentkit_sdk_python-0.2.2 → agentkit_sdk_python-0.3.1}/agentkit/client/base_iam_client.py

@@ -20,7 +20,6 @@ Uses the same volcengine.base.Service approach as AgentKit services.
 from typing import Dict, Union
 
 from agentkit.client.base_service_client import BaseServiceClient, ApiConfig
-from agentkit.utils.ve_sign import get_volc_iam_host_scheme
 
 
 class BaseIAMClient(BaseServiceClient):
@@ -64,25 +63,10 @@ class BaseIAMClient(BaseServiceClient):
             service_name: Service name for logging
         """
         super().__init__(
+            service="iam",
             access_key=access_key,
             secret_key=secret_key,
             region=region,
             session_token=session_token,
             service_name=service_name,
-            credential_env_prefix="IAM",
         )
-
-    def _get_service_config(self) -> Dict[str, str]:
-        """
-        Get IAM service configuration.
-
-        Returns:
-            Dictionary with host, api_version, and service
-        """
-        host, scheme = get_volc_iam_host_scheme()
-        return {
-            "host": host or self.IAM_HOST,
-            "api_version": self.IAM_API_VERSION,
-            "service": self.IAM_SERVICE_CODE,
-            "scheme": scheme,
-        }

{agentkit_sdk_python-0.2.2 → agentkit_sdk_python-0.3.1}/agentkit/client/base_service_client.py

@@ -26,10 +26,12 @@ from volcengine.base.Service import Service
 from volcengine.Credentials import Credentials
 from volcengine.ServiceInfo import ServiceInfo
 
-from agentkit.utils.ve_sign import (
-    get_volc_ak_sk_region,
-    ensure_x_custom_source_header,
+from agentkit.platform import (
+    VolcConfiguration,
+    resolve_credentials,
+    resolve_endpoint,
 )
+from agentkit.utils.ve_sign import ensure_x_custom_source_header
 
 T = TypeVar("T")
 
@@ -62,7 +64,6 @@ class BaseServiceClient(Service):
 
     Subclasses should:
     1. Override API_ACTIONS with their API action configurations
-    2. Implement _get_service_config() to provide service-specific configuration
     """
 
     # Subclasses should override this with their API action configurations
@@ -70,42 +71,53 @@ class BaseServiceClient(Service):
 
     def __init__(
         self,
+        service: str,
         access_key: str = "",
         secret_key: str = "",
         region: str = "",
         session_token: str = "",
         service_name: str = "",
-        credential_env_prefix: str = "",
+        platform_config: Optional[VolcConfiguration] = None,
         header: Optional[Dict[str, Any]] = None,
     ) -> None:
         """
         Initialize the service client.
 
         Args:
+            service: Logical service name for signing and endpoint resolution
             access_key: Volcengine access key
             secret_key: Volcengine secret key
-            region: Volcengine region
+            region: Volcengine region override for endpoint
             session_token: Optional session token
             service_name: Service name for logging
-            credential_env_prefix: Environment variable prefix for credentials (e.g., 'AGENTKIT', 'IAM')
+            platform_config: Optional platform-level configuration overrides
         """
-        # Validate and get credentials
-        if not any([access_key, secret_key, region]):
-            access_key, secret_key, region = get_volc_ak_sk_region(
-                credential_env_prefix
-            )
-        else:
-            if not all([access_key, secret_key, region]):
-                raise ValueError(
-                    f"Error creating {service_name} instance: "
-                    "missing access key, secret key or region"
-                )
+        if platform_config is None:
+            platform_config = VolcConfiguration()
+
+        creds = resolve_credentials(
+            service=service,
+            explicit_access_key=access_key or None,
+            explicit_secret_key=secret_key or None,
+            platform_config=platform_config,
+        )
+
+        ep = resolve_endpoint(
+            service=service,
+            region=region or None,
+            platform_config=platform_config,
+        )
+
+        self.access_key = creds.access_key
+        self.secret_key = creds.secret_key
+        self.session_token = creds.session_token
+
+        self.host = ep.host
+        self.region = ep.region
+        self.service = ep.service
+        self.scheme = ep.scheme
+        self.api_version = ep.api_version
 
-        # Store credentials and service info
-        self.access_key = access_key
-        self.secret_key = secret_key
-        self.region = region
-        self.session_token = session_token
         self.service_name = service_name
 
         if header is None:
@@ -116,14 +128,6 @@ class BaseServiceClient(Service):
                 effective_header = {"Accept": "application/json", **effective_header}
 
         effective_header = ensure_x_custom_source_header(effective_header)
-
-        # Get service-specific configuration from subclass
-        config = self._get_service_config()
-        self.host = config["host"]
-        self.api_version = config["api_version"]
-        self.service = config["service"]
-        self.scheme = config.get("scheme", "https")
-
         # Create ServiceInfo
         self.service_info = ServiceInfo(
             host=self.host,
@@ -145,20 +149,9 @@ class BaseServiceClient(Service):
 
         # Initialize parent Service class
         Service.__init__(self, service_info=self.service_info, api_info=self.api_info)
-
-    def _get_service_config(self) -> Dict[str, str]:
-        """
-        Get service-specific configuration.
-
-        Subclasses must override this method to provide:
-        - host: API endpoint host
-        - api_version: API version string
-        - service: Service name for signing
-
-        Returns:
-            Dictionary with 'host', 'api_version', and 'service' keys
-        """
-        raise NotImplementedError("Subclasses must implement _get_service_config()")
+        # need setting ak/sk after initializing Service to avoid volcengine SDK bugs
+        self.set_ak(self.access_key)
+        self.set_sk(self.secret_key)
 
     def _build_api_info(self) -> Dict[str, ApiInfo]:
         """

agentkit_sdk_python-0.3.1/agentkit/platform/__init__.py

@@ -0,0 +1,89 @@
+# 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.
+
+from __future__ import annotations
+
+from typing import Optional
+
+from agentkit.platform.configuration import VolcConfiguration, Endpoint, Credentials
+from agentkit.platform.constants import DEFAULT_REGION_RULES
+
+__all__ = [
+    "VolcConfiguration",
+    "Endpoint",
+    "Credentials",
+    "resolve_endpoint",
+    "resolve_credentials",
+    "DEFAULT_REGION_RULES",
+]
+
+# Backward compatibility wrappers
+
+
+def resolve_endpoint(
+    service: str,
+    *,
+    region: Optional[str] = None,
+    platform_config: Optional[VolcConfiguration] = None,
+) -> Endpoint:
+    """
+    Resolves the endpoint for a service.
+
+    Args:
+        service: Service identifier (e.g. 'agentkit', 'cr')
+        region: Explicit region override
+        platform_config: Optional configuration object. If provided, 'region' arg overrides config.
+    """
+    # If region is provided explicitly, it should override the config's region.
+    # We can achieve this by creating a new ephemeral config or just letting VolcConfiguration handle it?
+    # Since VolcConfiguration is immutable-ish, we can just instantiate one if needed.
+
+    if platform_config:
+        # If explicit region is passed, it overrides the config's region for this call
+        if region and region != platform_config.region:
+            # Create a temporary lightweight clone with new region, keeping creds
+            # Or more simply, VolcConfiguration handles service-specific region overrides internally
+            # but here 'region' is a global override for this call.
+            # Let's create a new config merging both.
+            cfg = VolcConfiguration(
+                region=region,
+                access_key=platform_config._ak,
+                secret_key=platform_config._sk,
+            )
+        else:
+            cfg = platform_config
+    else:
+        cfg = VolcConfiguration(region=region)
+
+    return cfg.get_service_endpoint(service)
+
+
+def resolve_credentials(
+    service: str,
+    *,
+    explicit_access_key: Optional[str] = None,
+    explicit_secret_key: Optional[str] = None,
+    platform_config: Optional[VolcConfiguration] = None,
+) -> Credentials:
+    """
+    Resolves credentials for a service.
+    """
+    # 1. Explicit args take absolute precedence
+    if explicit_access_key and explicit_secret_key:
+        return Credentials(
+            access_key=explicit_access_key, secret_key=explicit_secret_key
+        )
+
+    cfg = platform_config or VolcConfiguration()
+    return cfg.get_service_credentials(service)