agentkit-sdk-python 0.8.4__tar.gz → 0.8.6__tar.gz

{agentkit_sdk_python-0.8.4 → agentkit_sdk_python-0.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentkit-sdk-python
-Version: 0.8.4
+Version: 0.8.6
 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.8.4 → agentkit_sdk_python-0.8.6}/agentkit/frameworks/model_replacement.py

@@ -7,10 +7,12 @@ import logging
 import os
 from typing import Any
 
-
 logger = logging.getLogger(__name__)
 ARK_DEFAULT_BASE_URL = "https://ark.cn-beijing.volces.com/api/v3"
+VEADK_SOURCE_HEADER = "veadk-source"
+VEADK_SOURCE_VALUE = "veadk"
 _DISABLED_VALUES = {"0", "false", "off", "none", "disabled"}
+_HEADER_PATCH_MARKER = "__agentkit_veadk_source_header__"
 _MODEL_PARAM_KEYS = {
     "frequency_penalty",
     "max_tokens",
@@ -49,6 +51,55 @@ def _replacement_enabled() -> bool:
     return value not in _DISABLED_VALUES
 
 
+def _merge_veadk_source_header(headers: Any = None) -> dict[str, Any]:
+    merged = {
+        key: value
+        for key, value in dict(headers or {}).items()
+        if key.lower() != VEADK_SOURCE_HEADER
+    }
+    merged[VEADK_SOURCE_HEADER] = VEADK_SOURCE_VALUE
+    return merged
+
+
+def _header_kwarg_model_cls(base_cls: type[Any], header_kwarg: str) -> type[Any]:
+    if getattr(base_cls, _HEADER_PATCH_MARKER, False):
+        return base_cls
+
+    class AgentKitHeaderModel(base_cls):
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
+            kwargs[header_kwarg] = _merge_veadk_source_header(kwargs.get(header_kwarg))
+            super().__init__(*args, **kwargs)
+
+    AgentKitHeaderModel.__name__ = base_cls.__name__
+    AgentKitHeaderModel.__qualname__ = base_cls.__qualname__
+    AgentKitHeaderModel.__module__ = base_cls.__module__
+    setattr(AgentKitHeaderModel, _HEADER_PATCH_MARKER, True)
+    return AgentKitHeaderModel
+
+
+def _openai_client_args_model_cls(base_cls: type[Any]) -> type[Any]:
+    if getattr(base_cls, _HEADER_PATCH_MARKER, False):
+        return base_cls
+
+    class AgentKitHeaderModel(base_cls):
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
+            if args or kwargs.get("client") is not None:
+                super().__init__(*args, **kwargs)
+                return
+            client_args = dict(kwargs.get("client_args") or {})
+            client_args["default_headers"] = _merge_veadk_source_header(
+                client_args.get("default_headers")
+            )
+            kwargs["client_args"] = client_args
+            super().__init__(*args, **kwargs)
+
+    AgentKitHeaderModel.__name__ = base_cls.__name__
+    AgentKitHeaderModel.__qualname__ = base_cls.__qualname__
+    AgentKitHeaderModel.__module__ = base_cls.__module__
+    setattr(AgentKitHeaderModel, _HEADER_PATCH_MARKER, True)
+    return AgentKitHeaderModel
+
+
 def _replacement_model_config(config: dict[str, Any]) -> dict[str, Any]:
     model_id = _target_model_id()
     if not model_id:
@@ -90,6 +141,7 @@ def _agentkit_openai_model_cls() -> type[Any]:
                 client_args={
                     "base_url": _target_base_url(),
                     "api_key": api_key,
+                    "default_headers": _merge_veadk_source_header(),
                 },
                 **_replacement_model_config(kwargs),
             )
@@ -101,7 +153,7 @@ def _agentkit_openai_model_cls() -> type[Any]:
 def _patch_model_attr(module_name: str, attr: str, replacement: type[Any]) -> bool:
     try:
         module = importlib.import_module(module_name)
-    except Exception:
+    except Exception:  # noqa: BLE001 - optional framework imports are best effort
         return False
     if hasattr(module, attr):
         setattr(module, attr, replacement)
@@ -109,6 +161,49 @@ def _patch_model_attr(module_name: str, attr: str, replacement: type[Any]) -> bo
     return False
 
 
+def _patch_langchain_model_headers() -> bool:
+    try:
+        module = importlib.import_module("langchain_openai.chat_models.base")
+        replacement = _header_kwarg_model_cls(module.ChatOpenAI, "default_headers")
+    except Exception:  # noqa: BLE001 - optional framework imports are best effort
+        return False
+
+    patched = False
+    for module_name in (
+        "langchain_openai",
+        "langchain_openai.chat_models",
+        "langchain_openai.chat_models.base",
+    ):
+        patched = _patch_model_attr(module_name, "ChatOpenAI", replacement) or patched
+    return patched
+
+
+def _patch_adk_model_headers() -> bool:
+    try:
+        module = importlib.import_module("google.adk.models.lite_llm")
+        replacement = _header_kwarg_model_cls(module.LiteLlm, "extra_headers")
+    except Exception:  # noqa: BLE001 - optional framework imports are best effort
+        return False
+
+    patched = False
+    for module_name in ("google.adk.models", "google.adk.models.lite_llm"):
+        patched = _patch_model_attr(module_name, "LiteLlm", replacement) or patched
+    return patched
+
+
+def _patch_strands_openai_model_headers() -> bool:
+    try:
+        module = importlib.import_module("strands.models.openai")
+        replacement = _openai_client_args_model_cls(module.OpenAIModel)
+    except Exception:  # noqa: BLE001 - optional framework imports are best effort
+        return False
+
+    patched = False
+    for module_name in ("strands.models", "strands.models.openai"):
+        patched = _patch_model_attr(module_name, "OpenAIModel", replacement) or patched
+    return patched
+
+
 def _apply_env_aliases() -> bool:
     changed = False
     model_id = _target_model_id()
@@ -138,7 +233,7 @@ def _apply_env_aliases() -> bool:
 def _patch_strands_model_classes() -> bool:
     try:
         replacement = _agentkit_openai_model_cls()
-    except Exception:
+    except Exception:  # noqa: BLE001 - optional framework imports are best effort
         return False
 
     patched = False
@@ -155,21 +250,33 @@ def apply_agentkit_model_replacement() -> bool:
     """Apply explicit target-model replacement for generated migration wrappers.
 
     The helper intentionally stays low-intrusion: it normalizes common model
-    environment variables and patches only stable Strands Bedrock/Anthropic
-    model classes before user code constructs them. It does not rewrite project
-    source code or chase framework-specific model SDK constructor details.
+    environment variables and patches stable framework model constructors before
+    user code constructs them. It does not rewrite project source code or patch
+    global HTTP/OpenAI clients.
     """
 
     if not _replacement_enabled():
         logger.info("AgentKit model replacement disabled by ARK_MODEL_REPLACEMENT.")
         return False
     env_changed = _apply_env_aliases()
+    langchain_headers_patched = _patch_langchain_model_headers()
+    adk_headers_patched = _patch_adk_model_headers()
+    strands_headers_patched = _patch_strands_openai_model_headers()
     patched = _patch_strands_model_classes()
     logger.info(
-        "AgentKit model replacement enabled: env_aliases=%s strands_model_patch=%s target_model_configured=%s base_url_configured=%s",
+        "AgentKit model replacement enabled: env_aliases=%s langchain_headers=%s adk_headers=%s strands_headers=%s strands_model_patch=%s target_model_configured=%s base_url_configured=%s",
         env_changed,
+        langchain_headers_patched,
+        adk_headers_patched,
+        strands_headers_patched,
         patched,
         bool(_target_model_id()),
         bool(_target_base_url()),
     )
-    return env_changed or patched
+    return (
+        env_changed
+        or langchain_headers_patched
+        or adk_headers_patched
+        or strands_headers_patched
+        or patched
+    )

{agentkit_sdk_python-0.8.4 → agentkit_sdk_python-0.8.6}/agentkit/sdk/tools/types.py

@@ -17,6 +17,7 @@
 
 from __future__ import annotations
 
+from enum import Enum
 from typing import Optional
 from pydantic import BaseModel, Field
 
@@ -28,6 +29,11 @@ class ToolsBaseModel(BaseModel):
 
 
 # Data Types
+class CredentialType(str, Enum):
+    TOS_CREDENTIAL_TYPE_ACCESS_KEY = "TOS_CREDENTIAL_TYPE_ACCESS_KEY"
+    TOS_CREDENTIAL_TYPE_IAM_ROLE = "TOS_CREDENTIAL_TYPE_IAM_ROLE"
+
+
 class AssociatedRuntimesForGetTool(ToolsBaseModel):
     id: Optional[str] = Field(default=None, alias="Id")
     name: Optional[str] = Field(default=None, alias="Name")
@@ -204,6 +210,9 @@ class TosMountConfigForGetTool(ToolsBaseModel):
     credentials: Optional[CredentialsForGetTool] = Field(
         default=None, alias="Credentials"
     )
+    credential_type: Optional[CredentialType] = Field(
+        default=None, alias="CredentialType"
+    )
     enable_tos: Optional[bool] = Field(default=None, alias="EnableTos")
     mount_points: Optional[list[MountPointsForGetTool]] = Field(
         default=None, alias="MountPoints"
@@ -348,6 +357,9 @@ class TosMountForCreateTool(ToolsBaseModel):
     credentials: Optional[TosMountCredentialsForCreateTool] = Field(
         default=None, alias="Credentials"
     )
+    credential_type: Optional[CredentialType] = Field(
+        default=None, alias="CredentialType"
+    )
     mount_points: Optional[list[TosMountMountPointsItemForCreateTool]] = Field(
         default=None, alias="MountPoints"
     )
@@ -678,6 +690,9 @@ class TosMountForUpdateTool(ToolsBaseModel):
     credentials: Optional[TosMountCredentialsForUpdateTool] = Field(
         default=None, alias="Credentials"
     )
+    credential_type: Optional[CredentialType] = Field(
+        default=None, alias="CredentialType"
+    )
     mount_points: Optional[list[TosMountMountPointsItemForUpdateTool]] = Field(
         default=None, alias="MountPoints"
     )

{agentkit_sdk_python-0.8.4 → agentkit_sdk_python-0.8.6}/agentkit/toolkit/cli/cli_tools.py

@@ -329,6 +329,10 @@ def update_tool_command(
         client = AgentkitToolsClient(region=(region or "").strip())
         if json_body:
             payload = json.loads(json_body)
+            if not isinstance(payload, dict):
+                raise ValueError("--json must contain a JSON object")
+            payload.pop("tool_id", None)
+            payload["ToolId"] = tool_id.strip()
         else:
             payload = tools_types.UpdateToolRequest(
                 tool_id=tool_id, description=description

{agentkit_sdk_python-0.8.4 → agentkit_sdk_python-0.8.6}/agentkit/toolkit/cli/sandbox/cli_create.py

@@ -56,8 +56,10 @@ from agentkit.toolkit.cli.sandbox.model_config import (
 )
 from agentkit.toolkit.cli.sandbox.tool_resolve import save_tool_result_if_resolvable
 from agentkit.toolkit.cli.sandbox.tos_config import (
+    DEFAULT_TOS_CREDENTIAL_TYPE,
     DEFAULT_TOS_LOCAL_PATH,
     build_create_tool_tos_mount_config,
+    normalize_tos_credential_type,
 )
 from agentkit.toolkit.cli.sandbox.sandbox_client import error
 from agentkit.toolkit.volcengine.services.tos_service import (
@@ -206,6 +208,7 @@ def _build_create_tool_request(
     tos_bucket: Optional[str],
     tos_region: str,
     tos_mount_path: str = DEFAULT_TOS_LOCAL_PATH,
+    tos_credential_type: str | tools_types.CredentialType | None = None,
     cpu: int = DEFAULT_CPU,
     model_name: Optional[str] = None,
     model_api_key: Optional[str] = None,
@@ -228,6 +231,16 @@ def _build_create_tool_request(
     is_private_tool = resolved_tool_type == PRIVATE_TOOL_TYPE
     if is_private_tool and not (image_url or "").strip():
         error("--image-url is required when --tool-type Private")
+    resolved_tos_credential_type = normalize_tos_credential_type(
+        tos_credential_type
+    )
+    if (
+        is_private_tool
+        and (tos_bucket or "").strip()
+        and resolved_tos_credential_type
+        == tools_types.CredentialType.TOS_CREDENTIAL_TYPE_IAM_ROLE
+    ):
+        error("TOS IAM Role mounting is only supported for Built-in Tools")
     command = PRIVATE_TOOL_COMMAND if is_private_tool else None
     port = PRIVATE_TOOL_PORT if is_private_tool else None
     envs = (
@@ -256,6 +269,7 @@ def _build_create_tool_request(
         tos_bucket,
         tos_region,
         local_mount_path=tos_mount_path,
+        credential_type=resolved_tos_credential_type,
         tos_service_cls=TOSService,
         tos_service_config_cls=TOSServiceConfig,
     )
@@ -451,6 +465,7 @@ def create_tool(
     tool_name: Optional[str] = None,
     tos_bucket: Optional[str] = None,
     tos_mount_path: str = DEFAULT_TOS_LOCAL_PATH,
+    tos_credential_type: str | tools_types.CredentialType | None = None,
     cpu: int = DEFAULT_CPU,
     model_name: Optional[str] = None,
     model_api_key: Optional[str] = None,
@@ -508,6 +523,7 @@ def create_tool(
         tos_bucket=tos_bucket,
         tos_region=tos_region,
         tos_mount_path=tos_mount_path,
+        tos_credential_type=tos_credential_type,
         cpu=cpu,
         model_name=model_name,
         model_api_key=model_api_key,
@@ -571,6 +587,15 @@ def create_command(
             f"Defaults to {DEFAULT_TOS_LOCAL_PATH} when omitted."
         ),
     ),
+    tos_credential_type: Optional[str] = typer.Option(
+        None,
+        "--tos-credential-type",
+        help=(
+            "TOS mount authentication: access-key or iam-role. "
+            "IAM Role is only supported for Built-in Tools. "
+            "Defaults to access-key."
+        ),
+    ),
     cpu: int = typer.Option(
         DEFAULT_CPU,
         "--cpu",
@@ -672,6 +697,13 @@ def create_command(
         tos_mount = config_default_if_unprovided(
             ctx, "tos_mount", "tos-mount", tos_mount, data=config_defaults
         )
+        tos_credential_type = config_default_if_unprovided(
+            ctx,
+            "tos_credential_type",
+            "tos-credential-type",
+            tos_credential_type,
+            data=config_defaults,
+        )
         cpu = config_default_if_unprovided(
             ctx,
             "cpu",
@@ -777,6 +809,11 @@ def create_command(
         )
         if tos_mount is not None and not (tos_bucket or "").strip():
             error("--tos-mount requires --tos-bucket")
+        if (
+            tos_credential_type is not None
+            and not (tos_bucket or "").strip()
+        ):
+            error("--tos-credential-type requires --tos-bucket")
         model_provider_was_provided = param_was_provided(ctx, "model_provider")
         model_base_url_was_provided = param_was_provided(ctx, "model_base_url")
         result = create_tool(
@@ -784,6 +821,9 @@ def create_command(
             tool_name=tool_name,
             tos_bucket=tos_bucket,
             tos_mount_path=tos_mount or DEFAULT_TOS_LOCAL_PATH,
+            tos_credential_type=(
+                tos_credential_type or DEFAULT_TOS_CREDENTIAL_TYPE
+            ),
             cpu=cpu,
             model_name=model_name,
             model_api_key=model_api_key,

{agentkit_sdk_python-0.8.4 → agentkit_sdk_python-0.8.6}/agentkit/toolkit/cli/sandbox/config_store.py

@@ -157,6 +157,11 @@ CONFIG_KEY_SPECS: dict[str, ConfigKeySpec] = {
     "cpu": ConfigKeySpec(("tool", "cpu"), _int_value, VALID_CPU_VALUES),
     "tos-bucket": ConfigKeySpec(("tool", "tos_bucket"), _str_value),
     "tos-mount": ConfigKeySpec(("tool", "tos_mount"), _str_value),
+    "tos-credential-type": ConfigKeySpec(
+        ("tool", "tos_credential_type"),
+        _str_value,
+        ("access-key", "iam-role"),
+    ),
     "role-name": ConfigKeySpec(("tool", "role_name"), _str_value),
     "enable-snapshot": ConfigKeySpec(("tool", "enable_snapshot"), _bool_value),
     "websearch-apikey": ConfigKeySpec(("tool", "websearch_apikey"), _str_value),

{agentkit_sdk_python-0.8.4 → agentkit_sdk_python-0.8.6}/agentkit/toolkit/cli/sandbox/tos_config.py

@@ -29,6 +29,35 @@ from agentkit.toolkit.volcengine.services.tos_service import (
 DEFAULT_TOS_BUCKET_PATH = "/sandbox-session/default/default"
 DEFAULT_TOS_LOCAL_PATH = "/home/gem/workspace"
 DEFAULT_SANDBOX_WORKSPACE = "/home/gem"
+DEFAULT_TOS_CREDENTIAL_TYPE = (
+    tools_types.CredentialType.TOS_CREDENTIAL_TYPE_ACCESS_KEY
+)
+
+
+def normalize_tos_credential_type(
+    value: str | tools_types.CredentialType | None,
+) -> tools_types.CredentialType:
+    if isinstance(value, tools_types.CredentialType):
+        return value
+
+    normalized = (value or "").strip().upper().replace("-", "_")
+    aliases = {
+        "": DEFAULT_TOS_CREDENTIAL_TYPE,
+        "ACCESS_KEY": tools_types.CredentialType.TOS_CREDENTIAL_TYPE_ACCESS_KEY,
+        "TOS_CREDENTIAL_TYPE_ACCESS_KEY": (
+            tools_types.CredentialType.TOS_CREDENTIAL_TYPE_ACCESS_KEY
+        ),
+        "IAM_ROLE": tools_types.CredentialType.TOS_CREDENTIAL_TYPE_IAM_ROLE,
+        "TOS_CREDENTIAL_TYPE_IAM_ROLE": (
+            tools_types.CredentialType.TOS_CREDENTIAL_TYPE_IAM_ROLE
+        ),
+    }
+    credential_type = aliases.get(normalized)
+    if credential_type is None:
+        error(
+            "--tos-credential-type must be one of: access-key, iam-role"
+        )
+    return credential_type
 
 
 def resolve_tos_bucket(tos_bucket: Optional[str]) -> str:
@@ -50,6 +79,7 @@ def build_create_tool_tos_mount_config(
     region: str,
     *,
     local_mount_path: str = DEFAULT_TOS_LOCAL_PATH,
+    credential_type: str | tools_types.CredentialType | None = None,
     tos_service_cls=TOSService,
     tos_service_config_cls=TOSServiceConfig,
 ) -> tools_types.TosMountForCreateTool | None:
@@ -58,6 +88,25 @@ def build_create_tool_tos_mount_config(
 
     resolved_bucket = resolve_tos_bucket(tos_bucket)
     resolved_local_mount_path = resolve_tos_mount_path(local_mount_path)
+    resolved_credential_type = normalize_tos_credential_type(credential_type)
+    if (
+        resolved_credential_type
+        == tools_types.CredentialType.TOS_CREDENTIAL_TYPE_IAM_ROLE
+    ):
+        return tools_types.TosMountForCreateTool(
+            EnableTos=True,
+            CredentialType=resolved_credential_type,
+            MountPoints=[
+                tools_types.TosMountMountPointsItemForCreateTool(
+                    BucketName=resolved_bucket,
+                    BucketPath=DEFAULT_TOS_BUCKET_PATH,
+                    Endpoint=TOSService.build_mount_endpoint(region),
+                    LocalMountPath=resolved_local_mount_path,
+                    ReadOnly=False,
+                )
+            ],
+        )
+
     service = tos_service_cls(
         tos_service_config_cls(
             bucket=resolved_bucket,
@@ -76,6 +125,9 @@ def to_create_tool_tos_mount_config(
 ) -> tools_types.TosMountForCreateTool:
     return tools_types.TosMountForCreateTool(
         EnableTos=True,
+        CredentialType=(
+            tools_types.CredentialType.TOS_CREDENTIAL_TYPE_ACCESS_KEY
+        ),
         Credentials=tools_types.TosMountCredentialsForCreateTool(
             AccessKeyId=mount_config.credentials.access_key_id,
             SecretAccessKey=mount_config.credentials.secret_access_key,

{agentkit_sdk_python-0.8.4 → agentkit_sdk_python-0.8.6}/agentkit/toolkit/executors/init_executor.py

@@ -131,13 +131,19 @@ TEMPLATES = {
 }
 
 
-# `.env.example` written into a harness directory. Carries only the Volcengine
-# deploy credentials; copy to `.env` and fill in the AK/SK before deploying.
+# `.env.example` written into a harness directory. Copy it to `.env` and fill in
+# the credential pair for the selected cloud provider before deploying.
 _HARNESS_ENV_EXAMPLE = """\
 # Volcengine credentials for harness deploy. Copy this file to `.env` and fill in.
 VOLCENGINE_ACCESS_KEY=
 VOLCENGINE_SECRET_KEY=
 # VOLCENGINE_REGION=cn-beijing
+
+# BytePlus credentials (uncomment these lines and set CLOUD_PROVIDER=byteplus).
+# CLOUD_PROVIDER=byteplus
+# BYTEPLUS_ACCESS_KEY=
+# BYTEPLUS_SECRET_KEY=
+# BYTEPLUS_REGION=ap-southeast-1
 """
 
 # Container image for the harness server. The base image's apt mirror is an

{agentkit_sdk_python-0.8.4 → agentkit_sdk_python-0.8.6}/agentkit/toolkit/harness/config_builder.py

@@ -23,6 +23,7 @@ def build_agentkit_config(
     envs: Dict[str, str],
     auth: Optional[Dict[str, Any]] = None,
     runtime_id: str = "Auto",
+    cloud_provider: Optional[str] = None,
 ) -> Dict[str, Any]:
     """Build the cloud AgentKit launch config dict (auto-provision).
 
@@ -37,7 +38,8 @@ def build_agentkit_config(
 
     When ``auth`` (a normalized ``{discovery_url, allowed_ids}`` block) is given,
     the runtime is gated by OAuth2/JWT (``custom_jwt``); otherwise it keeps the
-    default API-key auth (``key_auth``).
+    default API-key auth (``key_auth``). ``cloud_provider`` pins the generated
+    launch config to the same provider used to resolve credentials and region.
     """
     cloud: Dict[str, Any] = {
         "region": region,
@@ -64,16 +66,20 @@ def build_agentkit_config(
         cloud["runtime_apikey_name"] = "Auto"
         cloud["runtime_apikey"] = "Auto"
         cloud["runtime_jwt_allowed_clients"] = []
+    common: Dict[str, Any] = {
+        "agent_name": runtime_name,
+        "entry_point": "app.py",
+        "description": "Harness Server - VeADK",
+        "language": "Python",
+        "language_version": "3.12",
+        "runtime_envs": envs,
+        "launch_type": "cloud",
+    }
+    if cloud_provider:
+        common["cloud_provider"] = cloud_provider
+
     return {
-        "common": {
-            "agent_name": runtime_name,
-            "entry_point": "app.py",
-            "description": "Harness Server - VeADK",
-            "language": "Python",
-            "language_version": "3.12",
-            "runtime_envs": envs,
-            "launch_type": "cloud",
-        },
+        "common": common,
         "launch_types": {"cloud": cloud},
         "docker_build": {},
     }