agentkit-sdk-python 0.8.0__tar.gz → 0.8.2__tar.gz

{agentkit_sdk_python-0.8.0 → agentkit_sdk_python-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentkit-sdk-python
-Version: 0.8.0
+Version: 0.8.2
 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
@@ -217,7 +217,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: a2a-sdk>=0.3.7
+Requires-Dist: a2a-sdk<1.0.0,>=0.3.15
 Requires-Dist: fastapi>=0.117.1
 Requires-Dist: fastmcp>=2.12.3
 Requires-Dist: opentelemetry-api<=1.37.0,>=1.32.1
@@ -226,7 +226,7 @@ Requires-Dist: opentelemetry-exporter-otlp-proto-grpc<=1.37.0,>=1.32.1
 Requires-Dist: opentelemetry-sdk<=1.37.0,>=1.32.1
 Requires-Dist: pydantic>=2.11.9
 Requires-Dist: requests>=2.32.5
-Requires-Dist: PyJWT>=2.10.1
+Requires-Dist: PyJWT[crypto]>=2.10.1
 Requires-Dist: uvicorn>=0.37.0
 Requires-Dist: pyyaml
 Requires-Dist: tomli>=2.0.1; python_version < "3.11"
@@ -245,6 +245,8 @@ Requires-Dist: pyreadline3; sys_platform == "win32"
 Provides-Extra: extensions
 Provides-Extra: toolkit
 Provides-Extra: dev
+Provides-Extra: identity-runtime
+Requires-Dist: google-adk<3.0.0,>=1.18.0; extra == "identity-runtime"
 Provides-Extra: langchain
 Requires-Dist: langchain; extra == "langchain"
 Provides-Extra: langgraph

{agentkit_sdk_python-0.8.0 → agentkit_sdk_python-0.8.2}/agentkit/apps/agent_server_app/agent_server_app.py

@@ -12,12 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import inspect
 import json
 import logging
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import uvicorn
 from fastapi import FastAPI, HTTPException, Request
@@ -59,6 +61,15 @@ except ImportError:  # pragma: no cover - default migration path avoids veadk.
 from agentkit.apps.agent_server_app.middleware import (
     AgentkitTelemetryHTTPMiddleware,
 )
+from agentkit.apps.agent_server_app.credential_service import (
+    AgentkitCredentialService,
+)
+from agentkit.apps.agent_server_app.inbound_auth_adapter import (
+    InboundAuthCaptureMiddleware,
+    build_a2a_inbound_auth_executor_factory,
+    save_inbound_auth,
+)
+from agentkit.apps.auth.inbound import redact_inbound_auth_headers
 from agentkit.apps.agent_server_app.origin import (
     add_cors_compat_middleware,
     adk_supports_regex_origins,
@@ -69,6 +80,15 @@ from agentkit.apps.agent_server_app.origin import (
 from agentkit.apps.agent_server_app.telemetry import telemetry
 from agentkit.apps.base_app import BaseAgentkitApp
 
+if TYPE_CHECKING:
+    from agentkit_identity import IdentityRuntimeConfig, RuntimeIdentity
+else:
+    # Avoid eagerly importing the bundled security module for ordinary
+    # AgentServer startup. Construction imports and validates the concrete
+    # classes before Identity mode can be enabled.
+    IdentityRuntimeConfig = Any
+    RuntimeIdentity = Any
+
 logger = logging.getLogger(__name__)
 
 
@@ -120,6 +140,10 @@ def _create_a2a_runner(
             short_term_memory=short_term_memory
             if _is_veadk_short_term_memory(short_term_memory)
             else None,
+            app_name=root_agent.name,
+            session_service=session_service,
+            memory_service=memory_service,
+            credential_service=credential_service,
         )
     return Runner(
         agent=root_agent,
@@ -199,6 +223,21 @@ class AgentKitAgentLoader(BaseAgentLoader):
 
 
 class AgentkitAgentServerApp(BaseAgentkitApp):
+    def _request_identity_context(self) -> Any | None:
+        # Older integrations and focused unit-test doubles predate the
+        # ``runtime_identity`` attribute. Treat an absent attribute exactly as
+        # the existing identity-disabled mode. A real identity-enabled server
+        # always sets the attribute during construction and still fails closed
+        # below when request context binding is unavailable.
+        if getattr(self, "runtime_identity", None) is None:
+            return None
+        identity_current = getattr(self, "_identity_current", None)
+        if identity_current is None:
+            raise RuntimeError("Agent Identity Runtime is not initialized")
+        # Identity-enabled handlers must never fall back to a caller-owned
+        # user_id if middleware composition or context binding is broken.
+        return identity_current(required=True)
+
     def __init__(
         self,
         agent: BaseAgent | App | None = None,
@@ -207,8 +246,12 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
         app: App | None = None,
         allow_origins: list[str] | None = None,
         allow_origin_regex: str | list[str] | None = None,
+        enable_auth: bool = False,
+        identity: IdentityRuntimeConfig | RuntimeIdentity | None = None,
+        identity_health_routes: tuple[str, ...] = (),
     ) -> None:
         super().__init__()
+        self._enable_auth_enabled = enable_auth
 
         if app is not None and agent is not None:
             raise TypeError("Only one of 'agent' or 'app' can be provided.")
@@ -222,7 +265,9 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
         memory_service = _resolve_memory_service(root_agent)
 
         _artifact_service = InMemoryArtifactService()
-        _credential_service = InMemoryCredentialService()
+        _credential_service = (
+            AgentkitCredentialService() if enable_auth else InMemoryCredentialService()
+        )
 
         _eval_sets_manager = LocalEvalSetsManager(agents_dir=".")
         _eval_set_results_manager = LocalEvalSetResultsManager(agents_dir=".")
@@ -246,14 +291,21 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
             artifact_service=_artifact_service,
             credential_service=_credential_service,
         )
-        _a2a_server_app = to_a2a(agent=root_agent, runner=runner)
+        to_a2a_kwargs: dict[str, Any] = {"agent": root_agent, "runner": runner}
+        if enable_auth:
+            to_a2a_kwargs["agent_executor_factory"] = (
+                build_a2a_inbound_auth_executor_factory(
+                    runner=runner,
+                    app_name=root_agent.name,
+                    credential_service=_credential_service,
+                )
+            )
+        _a2a_server_app = to_a2a(**to_a2a_kwargs)
 
         @asynccontextmanager
         async def lifespan(app: FastAPI):
             # trigger A2A server app startup
-            logger.info(
-                "Triggering A2A server app lifespan within API server..."
-            )
+            logger.info("Triggering A2A server app lifespan within API server...")
             async with _run_a2a_app_lifespan(_a2a_server_app):
                 yield
 
@@ -285,16 +337,56 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
 
         self.app = get_fast_api_app(**get_fast_api_app_kwargs)
 
+        identity_middleware_type = None
+        identity_current = None
+        if identity is None:
+            self.runtime_identity = None
+        else:
+            # Identity is an opt-in security feature. Import it only when
+            # configured, but fail closed if the bundled module is broken.
+            from agentkit.identity import (
+                AgentIdentityMiddleware,
+                IdentityRuntimeConfig,
+                RuntimeIdentity,
+                current_identity,
+            )
+
+            if isinstance(identity, IdentityRuntimeConfig):
+                self.runtime_identity = RuntimeIdentity(identity)
+            elif isinstance(identity, RuntimeIdentity):
+                self.runtime_identity = identity
+            else:
+                raise TypeError(
+                    "identity must be an IdentityRuntimeConfig, "
+                    "RuntimeIdentity, or None"
+                )
+            identity_middleware_type = AgentIdentityMiddleware
+            identity_current = current_identity
+        self._identity_current = identity_current
+
         if needs_cors_compat_middleware:
             add_cors_compat_middleware(self.app, resolved_allow_origins)
 
         @self.app.post("/run_sse")
-        async def run_agent_sse(req: RunAgentRequest) -> StreamingResponse:
+        async def run_agent_sse(
+            req: RunAgentRequest, request: Request
+        ) -> StreamingResponse:
             logger.info("Overriding run_agent_sse endpoint...")
+            identity_context = AgentkitAgentServerApp._request_identity_context(self)
+            effective_user_id = (
+                identity_context.user_sub if identity_context else req.user_id
+            )
+            if getattr(self, "_enable_auth_enabled", False):
+                await save_inbound_auth(
+                    request=request,
+                    app_name=req.app_name,
+                    user_id=effective_user_id,
+                    credential_service=self.server.credential_service,
+                )
             # SSE endpoint
             session = await self.server.session_service.get_session(
                 app_name=req.app_name,
-                user_id=req.user_id,
+                user_id=effective_user_id,
                 session_id=req.session_id,
             )
             if not session:
@@ -306,6 +398,7 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
 
             # Convert the events to properly formatted SSE
             async def event_generator():
+                error_payload = None
                 try:
                     stream_mode = (
                         StreamingMode.SSE if req.streaming else StreamingMode.NONE
@@ -313,7 +406,7 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
                     runner = await self.server.get_runner_async(req.app_name)
                     async with Aclosing(
                         runner.run_async(
-                            user_id=req.user_id,
+                            user_id=effective_user_id,
                             session_id=req.session_id,
                             new_message=req.new_message,
                             state_delta=req.state_delta,
@@ -351,11 +444,23 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
                                 )
                                 yield f"data: {sse_event}\n\n"
                 except Exception as e:
-                    logger.exception("Error in event_generator: %s", e)
-                    telemetry.trace_agent_server_finish(
-                        path="/run_sse", func_result="", exception=e
-                    )
-                    yield f"data: {json.dumps({'error': str(e)})}\n\n"
+                    if getattr(self, "runtime_identity", None) is not None:
+                        safe_error = RuntimeError("agent execution failed")
+                        logger.error("Agent execution failed in identity mode")
+                        telemetry.trace_agent_server_finish(
+                            path="/run_sse", func_result="", exception=safe_error
+                        )
+                        error_payload = 'data: {"error":"agent execution failed"}\n\n'
+                    else:
+                        logger.exception("Error in event_generator: %s", e)
+                        telemetry.trace_agent_server_finish(
+                            path="/run_sse", func_result="", exception=e
+                        )
+                        error_payload = f"data: {json.dumps({'error': str(e)})}\n\n"
+                if error_payload is not None:
+                    # Yield only after the caught exception variable and its
+                    # traceback have left scope in identity mode.
+                    yield error_payload
                 # Returns a streaming response with the proper media type for SSE
 
             return StreamingResponse(
@@ -377,17 +482,27 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
         # Attach ASGI middleware for unified telemetry across all routes
         self.app.add_middleware(AgentkitTelemetryHTTPMiddleware)
 
+        if self.runtime_identity is not None:
+            # Added after telemetry so identity is the outermost middleware:
+            # invalid requests fail before Agent/ADK code and the child scope no
+            # longer contains the Authorization header.
+            if identity_middleware_type is None:
+                raise RuntimeError("Agent Identity middleware is not initialized")
+            self.app.add_middleware(
+                identity_middleware_type,
+                identity=self.runtime_identity,
+                public_health_routes=identity_health_routes,
+            )
+        if enable_auth:
+            self.app.add_middleware(InboundAuthCaptureMiddleware)
+
         async def _invoke_compat(request: Request):
             # Use current request span from middleware for telemetry
             span = trace.get_current_span()
 
             # Extract headers (fallback keys supported)
             headers = request.headers
-            telemetry_headers = {
-                k: v
-                for k, v in dict(headers).items()
-                if k.lower() not in {"authorization", "token"}
-            }
+            telemetry_headers = redact_inbound_auth_headers(dict(headers))
             # trace request attributes on current span
             telemetry.trace_agent_server(
                 func_name="_invoke_compat",
@@ -396,7 +511,12 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
                 text="",
             )
 
-            user_id = headers.get("user_id") or "agentkit_user"
+            identity_context = AgentkitAgentServerApp._request_identity_context(self)
+            user_id = (
+                identity_context.user_sub
+                if identity_context
+                else headers.get("user_id") or "agentkit_user"
+            )
             session_id = headers.get("session_id") or ""
 
             # Determine app_name from loader
@@ -410,6 +530,13 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
                 )
                 raise exception
             app_name = app_names[0]
+            if getattr(self, "_enable_auth_enabled", False):
+                await save_inbound_auth(
+                    request=request,
+                    app_name=app_name,
+                    user_id=user_id,
+                    credential_service=self.server.credential_service,
+                )
 
             # Parse payload and convert to ADK Content
             try:
@@ -442,6 +569,7 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
                 )
 
             async def event_generator():
+                error_payload = None
                 try:
                     runner = await self.server.get_runner_async(app_name)
                     async with Aclosing(
@@ -449,9 +577,7 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
                             user_id=user_id,
                             session_id=session_id,
                             new_message=content,
-                            run_config=RunConfig(
-                                streaming_mode=StreamingMode.SSE
-                            ),
+                            run_config=RunConfig(streaming_mode=StreamingMode.SSE),
                         )
                     ) as agen:
                         async for event in agen:
@@ -465,10 +591,22 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
                     # finish span on successful end of stream handled by middleware
                     pass
                 except Exception as e:
-                    telemetry.trace_agent_server_finish(
-                        path="/invoke", func_result="", exception=e
-                    )
-                    yield f'data: {{"error": "{str(e)}"}}\n\n'
+                    if getattr(self, "runtime_identity", None) is not None:
+                        safe_error = RuntimeError("agent execution failed")
+                        logger.error("Agent execution failed in identity mode")
+                        telemetry.trace_agent_server_finish(
+                            path="/invoke", func_result="", exception=safe_error
+                        )
+                        error_payload = 'data: {"error":"agent execution failed"}\n\n'
+                    else:
+                        telemetry.trace_agent_server_finish(
+                            path="/invoke", func_result="", exception=e
+                        )
+                        error_payload = f'data: {{"error": "{str(e)}"}}\n\n'
+                if error_payload is not None:
+                    # The identity path never suspends while retaining the
+                    # original exception or its credential-bearing traceback.
+                    yield error_payload
 
             return StreamingResponse(
                 event_generator(),
@@ -483,8 +621,11 @@ class AgentkitAgentServerApp(BaseAgentkitApp):
         # Compatibility route for AgentKit CLI invoke
         self.app.add_api_route("/invoke", _invoke_compat, methods=["POST"])
 
-        # Mount A2A server app last to avoid shadowing API routes like `/invoke`.
-        self.app.mount("/", _a2a_server_app)
+        # V1 identity mode does not expose A2A: its payload/session ownership is
+        # not yet bound to the verified OIDC subject. Fail closed instead of
+        # presenting authentication as multi-tenant authorization.
+        if self.runtime_identity is None:
+            self.app.mount("/", _a2a_server_app)
 
     def run(self, host: str, port: int = 8000) -> None:
         """Run the app with Uvicorn server."""

agentkit_sdk_python-0.8.2/agentkit/apps/agent_server_app/credential_service.py

@@ -0,0 +1,92 @@
+# Copyright (c) 2026 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 Any
+
+from google.adk.auth.auth_credential import AuthCredential
+from google.adk.auth.credential_service.base_credential_service import (
+    BaseCredentialService,
+)
+
+
+class AgentkitCredentialService(BaseCredentialService):
+    """AgentKit-owned ADK credential service with a direct write API."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._credentials: dict[str, dict[str, dict[str, AuthCredential]]] = {}
+
+    async def load_credential(
+        self,
+        auth_config: Any,
+        callback_context: Any,
+    ) -> AuthCredential | None:
+        app_name, user_id = self._resolve_context(callback_context)
+        credential_key = self._resolve_credential_key(auth_config)
+        if credential_key is None:
+            return None
+        return await self.get_credential(
+            app_name=app_name,
+            user_id=user_id,
+            credential_key=credential_key,
+        )
+
+    async def save_credential(
+        self,
+        auth_config: Any,
+        callback_context: Any,
+    ) -> None:
+        app_name, user_id = self._resolve_context(callback_context)
+        credential_key = self._resolve_credential_key(auth_config)
+        credential = getattr(auth_config, "exchanged_auth_credential", None)
+        if credential_key and credential is not None:
+            await self.set_credential(
+                app_name=app_name,
+                user_id=user_id,
+                credential_key=credential_key,
+                credential=credential,
+            )
+
+    async def set_credential(
+        self,
+        app_name: str,
+        user_id: str,
+        credential_key: str,
+        credential: AuthCredential,
+    ) -> None:
+        self._credentials.setdefault(app_name, {})
+        self._credentials[app_name].setdefault(user_id, {})
+        self._credentials[app_name][user_id][credential_key] = credential
+
+    async def get_credential(
+        self,
+        app_name: str,
+        user_id: str,
+        credential_key: str,
+    ) -> AuthCredential | None:
+        return self._credentials.get(app_name, {}).get(user_id, {}).get(credential_key)
+
+    def _resolve_context(self, callback_context: Any) -> tuple[str, str]:
+        invocation_context = getattr(callback_context, "_invocation_context", None)
+        if invocation_context is None:
+            invocation_context = getattr(callback_context, "invocation_context", None)
+        return invocation_context.app_name, invocation_context.user_id
+
+    def _resolve_credential_key(self, auth_config: Any) -> str | None:
+        credential_key = getattr(auth_config, "credential_key", None)
+        if credential_key is None and hasattr(auth_config, "get_credential_key"):
+            credential_key = auth_config.get_credential_key()
+        return credential_key

agentkit_sdk_python-0.8.2/agentkit/apps/agent_server_app/inbound_auth.py

@@ -0,0 +1,43 @@
+# Copyright (c) 2026 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.
+
+"""Compatibility imports for AgentServer inbound-auth helpers."""
+
+from agentkit.apps.agent_server_app.inbound_auth_adapter import (
+    inbound_tokens_to_adk_credentials,
+    save_inbound_auth,
+)
+from agentkit.apps.auth.inbound import (
+    AUTHORIZATION_HEADER,
+    INBOUND_AUTH_CREDENTIAL_KEY,
+    TIP_TOKEN_CREDENTIAL_KEY,
+    TIP_TOKEN_HEADER,
+    InboundAuthTokens,
+    extract_inbound_auth,
+    redact_inbound_auth_headers,
+    strip_bearer,
+)
+
+__all__ = [
+    "AUTHORIZATION_HEADER",
+    "INBOUND_AUTH_CREDENTIAL_KEY",
+    "TIP_TOKEN_CREDENTIAL_KEY",
+    "TIP_TOKEN_HEADER",
+    "InboundAuthTokens",
+    "extract_inbound_auth",
+    "inbound_tokens_to_adk_credentials",
+    "redact_inbound_auth_headers",
+    "save_inbound_auth",
+    "strip_bearer",
+]