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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentkit-sdk-python
-Version: 0.3.3
+Version: 0.4.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.3.3 → agentkit_sdk_python-0.4.1}/agentkit/toolkit/builders/ve_pipeline.py

@@ -715,6 +715,7 @@ class VeCPCRBuilder(Builder):
             from agentkit.toolkit.volcengine.services.tos_service import (
                 TOSService,
                 TOSServiceConfig,
+                tos,
             )
 
             # Handle bucket configuration with auto-creation support
@@ -742,55 +743,95 @@ class VeCPCRBuilder(Builder):
 
             tos_service = TOSService(tos_config)
 
-            # Check if bucket exists and create if necessary
-            self.reporter.info(f"Checking TOS bucket existence: {bucket_name}")
-            if not tos_service.bucket_exists():
-                # Case 2: Bucket doesn't exist, create it
-                self.reporter.warning(
-                    f"TOS bucket does not exist, creating: {bucket_name}"
-                )
+            # Two-step safety check:
+            # 1) Ensure the bucket exists and is accessible.
+            # 2) Verify the bucket is owned by the current account via ListBuckets before uploading.
+            import time
 
-                if not tos_service.create_bucket():
-                    error_msg = f"Failed to create TOS bucket: {bucket_name}"
-                    self.reporter.error(error_msg)
-                    logger.error(error_msg)
-                    raise Exception(error_msg)
+            created_in_this_run = False
 
-                self.reporter.success(f"TOS bucket created successfully: {bucket_name}")
+            # Step 1: ensure bucket exists / accessible
+            if auto_created_bucket:
+                self.reporter.info(
+                    f"Creating auto-generated TOS bucket in current account: {bucket_name}"
+                )
 
-                # Verify bucket creation with retry logic (eventual consistency)
-                self.reporter.info(f"Verifying TOS bucket creation: {bucket_name}")
-                import time
+                # Very low probability: name collision. Retry with a new generated name.
+                max_attempts = 3
+                for attempt in range(1, max_attempts + 1):
+                    tos_service.config.bucket = bucket_name
+                    try:
+                        tos_service.create_bucket()
+                        created_in_this_run = True
+                        break
+                    except tos.exceptions.TosServerError as e:
+                        if e.status_code == 409 and attempt < max_attempts:
+                            bucket_name = TOSService.generate_bucket_name()
+                            self.reporter.warning(
+                                "Auto-generated bucket name already taken, retrying with a new name "
+                                f"(attempt {attempt + 1}/{max_attempts}): {bucket_name}"
+                            )
+                            continue
+                        raise
+            else:
+                # User-specified bucket: if not accessible/existing, attempt to create.
+                self.reporter.info(f"Checking TOS bucket accessibility: {bucket_name}")
+                if not tos_service.bucket_exists():
+                    self.reporter.warning(
+                        f"TOS bucket '{bucket_name}' is not accessible or does not exist, attempting to create it..."
+                    )
+                    try:
+                        tos_service.create_bucket()
+                        created_in_this_run = True
+                    except tos.exceptions.TosServerError as e:
+                        if e.status_code == 409:
+                            # The bucket name is already taken (possibly by another account).
+                            # Ownership verification in step 2 will block the upload.
+                            pass
+                        else:
+                            raise
 
-                start_time = time.time()
-                timeout = 30  # 30 second timeout
-                check_interval = 2  # Check every 2 seconds
+            # Step 2: verify bucket ownership via ListBuckets
+            self.reporter.info(f"Verifying TOS bucket ownership: {bucket_name}")
 
-                while time.time() - start_time < timeout:
-                    if tos_service.bucket_exists():
-                        self.reporter.success(
-                            f"TOS bucket verification successful: {bucket_name}"
-                        )
-                        break
-                    else:
-                        self.reporter.info(
-                            f"Waiting for TOS bucket to be ready... ({time.time() - start_time:.1f}s)"
-                        )
-                        time.sleep(check_interval)
-                else:
-                    # Timeout occurred
-                    error_msg = f"TOS bucket creation verification timeout ({timeout}s): {bucket_name}"
+            def check_owned() -> bool:
+                try:
+                    return tos_service.bucket_is_owned(bucket_name)
+                except Exception as e:
+                    error_msg = (
+                        "Failed to determine TOS bucket ownership via ListBuckets. "
+                        "Upload has been blocked for security reasons. "
+                        "Please ensure your credentials have TOS ListBuckets permission, or set 'tos_bucket: Auto'."
+                    )
                     self.reporter.error(error_msg)
-                    logger.error(error_msg)
+                    logger.error(f"Bucket ownership check failed: {str(e)}")
                     raise Exception(error_msg)
 
-                # Notify user if their configured bucket didn't exist and was auto-created
-                if config.tos_bucket and config.tos_bucket != AUTO_CREATE_VE:
-                    self.reporter.info(
-                        f"Note: Your configured bucket '{config.tos_bucket}' did not exist, auto-created new bucket '{bucket_name}'"
-                    )
+            if created_in_this_run:
+                # ListBuckets may be eventually consistent shortly after creation.
+                timeout_s = 10
+                interval_s = 2
+                deadline = time.time() + timeout_s
+                owned = False
+                while time.time() < deadline:
+                    owned = check_owned()
+                    if owned:
+                        break
+                    time.sleep(interval_s)
             else:
-                self.reporter.success(f"TOS bucket exists: {bucket_name}")
+                owned = check_owned()
+
+            if not owned:
+                error_msg = (
+                    f"Security notice: The configured TOS bucket '{bucket_name}' is not owned by the current account. "
+                    "To prevent uploading your source code to a bucket you do not own (which could leak secrets), this upload has been blocked. "
+                    "Please choose a bucket owned by your account, use 'agentkit config --tos_bucket <your-bucket-name>' to set it."
+                )
+                raise Exception(error_msg)
+
+            self.reporter.success(
+                f"TOS bucket ownership verified for current account: {bucket_name}"
+            )
 
             # Update config with auto-generated bucket name if applicable
             if auto_created_bucket:

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

@@ -155,6 +155,52 @@ def config_command(
         "--runtime_jwt_allowed_clients",
         help="Allowed OAuth2 client IDs when runtime_auth_type is custom_jwt (can be used multiple times)",
     ),
+    # Runtime bindings (resource associations)
+    memory_id: Optional[str] = typer.Option(
+        None,
+        "--memory_id",
+        "--runtime_binding_memory_id",
+        help="Bind Runtime to a Memory collection ID (cloud/hybrid only)",
+    ),
+    knowledge_id: Optional[str] = typer.Option(
+        None,
+        "--knowledge_id",
+        "--runtime_binding_knowledge_id",
+        help="Bind Runtime to a Knowledge ID (cloud/hybrid only)",
+    ),
+    tool_id: Optional[str] = typer.Option(
+        None,
+        "--tool_id",
+        "--runtime_binding_tool_id",
+        help="Bind Runtime to a Tool ID (cloud/hybrid only)",
+    ),
+    mcp_toolset_id: Optional[str] = typer.Option(
+        None,
+        "--mcp_toolset_id",
+        "--runtime_binding_mcp_toolset_id",
+        help="Bind Runtime to an MCP Toolset ID (cloud/hybrid only)",
+    ),
+    # Runtime network configuration (advanced, CreateRuntime only)
+    runtime_network_mode: Optional[str] = typer.Option(
+        None,
+        "--runtime_network_mode",
+        "--runtime-network-mode",
+        help="Runtime network mode (cloud/hybrid, CreateRuntime only): public/private/both",
+    ),
+    runtime_vpc_id: Optional[str] = typer.Option(
+        None,
+        "--runtime_vpc_id",
+        "--runtime-vpc-id",
+        help="Runtime VPC ID (cloud/hybrid, CreateRuntime only; required for private/both)",
+    ),
+    runtime_subnet_ids: Optional[List[str]] = typer.Option(
+        None,
+        "--runtime_subnet_ids",
+        "--runtime_subnet_id",
+        "--runtime-subnet-id",
+        "--runtime-subnet-ids",
+        help="Runtime subnet ID (repeatable; cloud/hybrid, CreateRuntime only)",
+    ),
 ):
     """Configure AgentKit (supports interactive and non-interactive modes).
     
@@ -254,6 +300,13 @@ def config_command(
             runtime_auth_type=runtime_auth_type,
             runtime_jwt_discovery_url=runtime_jwt_discovery_url,
             runtime_jwt_allowed_clients=runtime_jwt_allowed_clients,
+            memory_id=memory_id,
+            knowledge_id=knowledge_id,
+            tool_id=tool_id,
+            mcp_toolset_id=mcp_toolset_id,
+            runtime_network_mode=runtime_network_mode,
+            runtime_vpc_id=runtime_vpc_id,
+            runtime_subnet_ids=runtime_subnet_ids,
         )
 
         has_cli_params = ConfigParamHandler.has_cli_params(cli_params)

{agentkit_sdk_python-0.3.3 → agentkit_sdk_python-0.4.1}/agentkit/toolkit/cli/cli_runtime.py

@@ -57,6 +57,9 @@ def create_runtime_command(
         None, "--knowledge-id", help="Knowledge ID"
     ),
     tool_id: Optional[str] = typer.Option(None, "--tool-id", help="Tool ID"),
+    mcp_toolset_id: Optional[str] = typer.Option(
+        None, "--mcp-toolset-id", help="MCP Toolset ID"
+    ),
     model_agent_name: Optional[str] = typer.Option(
         None, "--model-agent-name", help="Model agent name"
     ),
@@ -169,6 +172,7 @@ def create_runtime_command(
                 memory_id=memory_id,
                 knowledge_id=knowledge_id,
                 tool_id=tool_id,
+                mcp_toolset_id=mcp_toolset_id,
                 model_agent_name=model_agent_name,
                 authorizer_configuration=authorizer,
                 network_configuration=network,
@@ -233,6 +237,9 @@ def update_runtime_command(
         None, "--knowledge-id", help="Knowledge ID"
     ),
     tool_id: Optional[str] = typer.Option(None, "--tool-id", help="Tool ID"),
+    mcp_toolset_id: Optional[str] = typer.Option(
+        None, "--mcp-toolset-id", help="MCP Toolset ID"
+    ),
     envs_json: Optional[str] = typer.Option(
         None, "--envs-json", help="JSON array of envs [{Key,Value}]"
     ),
@@ -278,6 +285,7 @@ def update_runtime_command(
                 memory_id=memory_id,
                 knowledge_id=knowledge_id,
                 tool_id=tool_id,
+                mcp_toolset_id=mcp_toolset_id,
                 envs=envs,
                 tags=tags,
             )

{agentkit_sdk_python-0.3.3 → agentkit_sdk_python-0.4.1}/agentkit/toolkit/config/config.py

@@ -362,10 +362,22 @@ class AgentkitConfigManager:
         self._save_config()
 
     def _filter_config_values(self, config: Dict[str, Any]) -> Dict[str, Any]:
-        """Filter empty and meaningless values from configuration."""
+        """Filter empty and meaningless values from configuration.
+
+        Note: Some config sections intentionally use empty values to represent
+        explicit user intent. For example, `runtime_bindings` may use empty
+        strings ("")/null to indicate unbinding.
+        """
         filtered = {}
 
         for key, value in config.items():
+            # Keep runtime_bindings as-is. It may contain empty strings / null to
+            # explicitly represent "no binding" / "unbind" semantics.
+            if key == "runtime_bindings" and isinstance(value, dict):
+                if value:
+                    filtered[key] = value
+                continue
+
             if value == "" or value is None:
                 continue
 

{agentkit_sdk_python-0.3.3 → agentkit_sdk_python-0.4.1}/agentkit/toolkit/config/config_handler.py

@@ -63,6 +63,21 @@ class ConfigParamHandler:
 
         return result
 
+    @staticmethod
+    def parse_id_list(values: Optional[List[str]]) -> List[str]:
+        """Parse repeatable IDs, supporting comma-separated values."""
+        if not values:
+            return []
+        result: List[str] = []
+        for item in values:
+            if item is None:
+                continue
+            for part in str(item).split(","):
+                part = part.strip()
+                if part:
+                    result.append(part)
+        return result
+
     @staticmethod
     def collect_cli_params(
         agent_name: Optional[str],
@@ -88,6 +103,13 @@ class ConfigParamHandler:
         runtime_auth_type: Optional[str],
         runtime_jwt_discovery_url: Optional[str],
         runtime_jwt_allowed_clients: Optional[List[str]],
+        memory_id: Optional[str],
+        knowledge_id: Optional[str],
+        tool_id: Optional[str],
+        mcp_toolset_id: Optional[str],
+        runtime_network_mode: Optional[str],
+        runtime_vpc_id: Optional[str],
+        runtime_subnet_ids: Optional[List[str]],
     ) -> Dict[str, Any]:
         """Collect all CLI parameters.
 
@@ -158,6 +180,32 @@ class ConfigParamHandler:
             strategy_params["runtime_role_name"] = runtime_role_name
         if runtime_apikey_name is not None:
             strategy_params["runtime_apikey_name"] = runtime_apikey_name
+
+        # Runtime bindings (resource associations)
+        runtime_bindings: Dict[str, Any] = {}
+        if memory_id is not None:
+            runtime_bindings["memory_id"] = memory_id
+        if knowledge_id is not None:
+            runtime_bindings["knowledge_id"] = knowledge_id
+        if tool_id is not None:
+            runtime_bindings["tool_id"] = tool_id
+        if mcp_toolset_id is not None:
+            runtime_bindings["mcp_toolset_id"] = mcp_toolset_id
+        if runtime_bindings:
+            strategy_params["runtime_bindings"] = runtime_bindings
+
+        # Runtime network configuration (advanced, CreateRuntime only)
+        runtime_network: Dict[str, Any] = {}
+        if runtime_network_mode is not None:
+            runtime_network["mode"] = runtime_network_mode.strip().lower()
+        if runtime_vpc_id is not None:
+            runtime_network["vpc_id"] = runtime_vpc_id
+        if runtime_subnet_ids is not None:
+            runtime_network["subnet_ids"] = ConfigParamHandler.parse_id_list(
+                runtime_subnet_ids
+            )
+        if runtime_network:
+            strategy_params["runtime_network"] = runtime_network
         if runtime_auth_type is not None:
             strategy_params["runtime_auth_type"] = runtime_auth_type
         if runtime_jwt_discovery_url is not None:
@@ -241,6 +289,20 @@ class NonInteractiveConfigHandler:
                         new_strategy_config["runtime_envs"] = existing_envs
                     else:
                         new_strategy_config["runtime_envs"] = value
+                elif key == "runtime_bindings" and isinstance(value, dict):
+                    existing_bindings = new_strategy_config.get("runtime_bindings", {})
+                    if isinstance(existing_bindings, dict):
+                        existing_bindings.update(value)
+                        new_strategy_config["runtime_bindings"] = existing_bindings
+                    else:
+                        new_strategy_config["runtime_bindings"] = value
+                elif key == "runtime_network" and isinstance(value, dict):
+                    existing_network = new_strategy_config.get("runtime_network", {})
+                    if isinstance(existing_network, dict):
+                        existing_network.update(value)
+                        new_strategy_config["runtime_network"] = existing_network
+                    else:
+                        new_strategy_config["runtime_network"] = value
                 else:
                     new_strategy_config[key] = value
 

{agentkit_sdk_python-0.3.3 → agentkit_sdk_python-0.4.1}/agentkit/toolkit/config/strategy_configs.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import Dict, List
+from typing import Any, Dict, List, Optional
 from .dataclass_utils import AutoSerializableMixin
 from .constants import (
     AUTH_TYPE_CUSTOM_JWT,
@@ -307,6 +307,25 @@ class HybridStrategyConfig(AutoSerializableMixin):
             "icon": "🔧",
         },
     )
+
+    runtime_bindings: Dict[str, Optional[str]] = field(
+        default_factory=dict,
+        metadata={
+            "hidden": True,
+            "description": "Runtime associated resource IDs (memory_id/knowledge_id/tool_id/mcp_toolset_id)",
+            "examples": "{memory_id: mem-xxx, knowledge_id: kb-xxx, tool_id: tool-xxx, mcp_toolset_id: mcp-ts-xxx}",
+            "icon": "🔗",
+        },
+    )
+
+    runtime_network: Dict[str, Any] = field(
+        default_factory=dict,
+        metadata={
+            "hidden": True,
+            "description": "Runtime network configuration (advanced, CreateRuntime only)",
+            "examples": "{mode: private, vpc_id: vpc-xxx, subnet_ids: [subnet-aaa, subnet-bbb]}",
+        },
+    )
     _config_metadata = {
         "name": "Hybrid Strategy Configuration",
         "welcome_message": "Welcome to AgentKit Hybrid Deployment Mode Configuration Wizard",
@@ -554,6 +573,25 @@ class CloudStrategyConfig(AutoSerializableMixin):
         },
     )
 
+    runtime_bindings: Dict[str, Optional[str]] = field(
+        default_factory=dict,
+        metadata={
+            "hidden": True,
+            "description": "Runtime associated resource IDs (memory_id/knowledge_id/tool_id/mcp_toolset_id)",
+            "examples": "{memory_id: mem-xxx, knowledge_id: kb-xxx, tool_id: tool-xxx, mcp_toolset_id: mcp-ts-xxx}",
+            "icon": "🔗",
+        },
+    )
+
+    runtime_network: Dict[str, Any] = field(
+        default_factory=dict,
+        metadata={
+            "hidden": True,
+            "description": "Runtime network configuration (advanced, CreateRuntime only)",
+            "examples": "{mode: private, vpc_id: vpc-xxx, subnet_ids: [subnet-aaa, subnet-bbb]}",
+        },
+    )
+
     # Deployment metadata
     build_timestamp: str = field(
         default="", metadata={"system": True, "description": "Timestamp of image build"}

{agentkit_sdk_python-0.3.3 → agentkit_sdk_python-0.4.1}/agentkit/toolkit/runners/ve_agentkit.py

@@ -91,6 +91,22 @@ class VeAgentkitRunnerConfig(AutoSerializableMixin):
         default_factory=dict, metadata={"description": "Runtime environment variables"}
     )
 
+    # Runtime bindings (resource associations)
+    runtime_bindings: Dict[str, Optional[str]] = field(
+        default_factory=dict,
+        metadata={
+            "description": "Runtime associated resources: memory_id/knowledge_id/tool_id/mcp_toolset_id",
+        },
+    )
+
+    # Runtime network configuration (advanced, CreateRuntime only)
+    runtime_network: Dict[str, Any] = field(
+        default_factory=dict,
+        metadata={
+            "description": "Runtime network configuration (advanced, CreateRuntime only)",
+        },
+    )
+
     # Authentication configuration
     runtime_auth_type: str = field(
         default=AUTH_TYPE_KEY_AUTH,
@@ -451,7 +467,7 @@ class VeAgentkitRuntimeRunner(Runner):
 
                 # Validate based on auth type
                 if not endpoint:
-                    error_msg = "Failed to obtain Runtime endpoint."
+                    error_msg = "Failed to obtain Runtime endpoint. The 'agentkit invoke' command only supports public network endpoints."
                     logger.error(f"{error_msg}, runtime: {runtime}")
                     return InvokeResult(
                         success=False,
@@ -604,6 +620,65 @@ class VeAgentkitRuntimeRunner(Runner):
                 )
             )
 
+    def _build_network_config_for_create(
+        self, config: VeAgentkitRunnerConfig
+    ) -> Optional[runtime_types.NetworkForCreateRuntime]:
+        runtime_network = (
+            config.runtime_network if isinstance(config.runtime_network, dict) else {}
+        )
+        if not runtime_network:
+            return None
+
+        mode = runtime_network.get("mode")
+        vpc_id = runtime_network.get("vpc_id")
+        subnet_ids = runtime_network.get("subnet_ids")
+
+        # Convenience: if vpc_id is provided without an explicit mode, assume private.
+        if mode is None and vpc_id:
+            mode = "private"
+
+        if mode is None:
+            raise ValueError(
+                "runtime_network is configured but 'mode' is missing. "
+                "Valid values: public/private/both."
+            )
+
+        mode = str(mode).strip().lower()
+        if mode not in {"public", "private", "both"}:
+            raise ValueError(
+                f"Invalid runtime_network.mode '{mode}'. Valid values: public/private/both."
+            )
+
+        enable_public = mode in {"public", "both"}
+        enable_private = mode in {"private", "both"}
+
+        vpc_configuration = None
+        if enable_private:
+            vpc_id_str = str(vpc_id or "").strip()
+            if not vpc_id_str:
+                raise ValueError(
+                    "runtime_network.mode requires 'vpc_id' when mode is private/both."
+                )
+
+            parsed_subnet_ids: Optional[List[str]] = None
+            if isinstance(subnet_ids, str):
+                ids = [s.strip() for s in subnet_ids.split(",") if s.strip()]
+                parsed_subnet_ids = ids or None
+            elif isinstance(subnet_ids, list):
+                ids = [str(s).strip() for s in subnet_ids if str(s).strip()]
+                parsed_subnet_ids = ids or None
+
+            vpc_configuration = runtime_types.NetworkVpcForCreateRuntime(
+                vpc_id=vpc_id_str,
+                subnet_ids=parsed_subnet_ids,
+            )
+
+        return runtime_types.NetworkForCreateRuntime(
+            vpc_configuration=vpc_configuration,
+            enable_private_network=enable_private,
+            enable_public_network=enable_public,
+        )
+
     def _create_new_runtime(self, config: VeAgentkitRunnerConfig) -> DeployResult:
         """Create a new Runtime instance.
 
@@ -624,9 +699,22 @@ class VeAgentkitRuntimeRunner(Runner):
                 for k, v in config.runtime_envs.items()
             ]
 
+            bindings = (
+                config.runtime_bindings
+                if isinstance(config.runtime_bindings, dict)
+                else {}
+            )
+            memory_id = bindings.get("memory_id")
+            knowledge_id = bindings.get("knowledge_id")
+            tool_id = bindings.get("tool_id")
+            mcp_toolset_id = bindings.get("mcp_toolset_id")
+
             # Build authorizer configuration based on auth type
             authorizer_config = self._build_authorizer_config_for_create(config)
 
+            # Network configuration is only supported during CreateRuntime.
+            network_configuration = self._build_network_config_for_create(config)
+
             create_request = runtime_types.CreateRuntimeRequest(
                 name=config.runtime_name,
                 description=config.common_config.description
@@ -635,6 +723,13 @@ class VeAgentkitRuntimeRunner(Runner):
                 artifact_type=ARTIFACT_TYPE_DOCKER_IMAGE,
                 artifact_url=config.image_url,
                 role_name=config.runtime_role_name,
+                memory_id=(memory_id if is_valid_config(memory_id) else None),
+                knowledge_id=(knowledge_id if is_valid_config(knowledge_id) else None),
+                tool_id=(tool_id if is_valid_config(tool_id) else None),
+                mcp_toolset_id=(
+                    mcp_toolset_id if is_valid_config(mcp_toolset_id) else None
+                ),
+                network_configuration=network_configuration,
                 envs=envs,
                 project_name=PROJECT_NAME_DEFAULT,
                 authorizer_configuration=authorizer_config,
@@ -985,6 +1080,12 @@ class VeAgentkitRuntimeRunner(Runner):
         try:
             self.reporter.info(f"Updating Runtime: {config.runtime_id}")
 
+            if isinstance(config.runtime_network, dict) and config.runtime_network:
+                self.reporter.warning(
+                    "runtime_network is configured, but network settings only apply when creating a Runtime. "
+                    "UpdateRuntime does not support network_configuration; ignoring runtime_network."
+                )
+
             client = self._get_runtime_client(config.region)
 
             # Get existing Runtime information
@@ -1048,6 +1149,32 @@ class VeAgentkitRuntimeRunner(Runner):
 
             self.reporter.info("Starting Runtime update...")
 
+            def _binding_update_value(key: str) -> Optional[str]:
+                """Translate runtime_bindings into UpdateRuntimeRequest fields.
+
+                Semantics:
+                - key not present: return None (do not send)
+                - value is None: return "" (explicit clear/unbind)
+                - value is "" or whitespace: return "" (explicit clear/unbind)
+                - value is non-empty: return value
+                """
+                if (
+                    not isinstance(config.runtime_bindings, dict)
+                    or key not in config.runtime_bindings
+                ):
+                    return None
+                raw = config.runtime_bindings.get(key)
+                if raw is None:
+                    return ""
+                if isinstance(raw, str) and not raw.strip():
+                    return ""
+                return str(raw)
+
+            memory_id = _binding_update_value("memory_id")
+            knowledge_id = _binding_update_value("knowledge_id")
+            tool_id = _binding_update_value("tool_id")
+            mcp_toolset_id = _binding_update_value("mcp_toolset_id")
+
             envs = [
                 {"Key": str(k), "Value": str(v)} for k, v in config.runtime_envs.items()
             ]
@@ -1056,6 +1183,10 @@ class VeAgentkitRuntimeRunner(Runner):
                     runtime_id=config.runtime_id,
                     artifact_url=config.image_url,
                     description=config.common_config.description,
+                    memory_id=memory_id,
+                    knowledge_id=knowledge_id,
+                    tool_id=tool_id,
+                    mcp_toolset_id=mcp_toolset_id,
                     envs=envs,
                     client_token=generate_client_token(),
                 )

{agentkit_sdk_python-0.3.3 → agentkit_sdk_python-0.4.1}/agentkit/toolkit/strategies/cloud_strategy.py

@@ -338,6 +338,8 @@ class CloudStrategy(Strategy):
             runtime_apikey_name=strategy_config.runtime_apikey_name,
             runtime_endpoint=strategy_config.runtime_endpoint,
             runtime_envs=merged_envs,
+            runtime_bindings=getattr(strategy_config, "runtime_bindings", None) or {},
+            runtime_network=getattr(strategy_config, "runtime_network", None) or {},
             runtime_auth_type=strategy_config.runtime_auth_type,
             runtime_jwt_discovery_url=strategy_config.runtime_jwt_discovery_url,
             runtime_jwt_allowed_clients=strategy_config.runtime_jwt_allowed_clients,

{agentkit_sdk_python-0.3.3 → agentkit_sdk_python-0.4.1}/agentkit/toolkit/strategies/hybrid_strategy.py

@@ -505,6 +505,8 @@ class HybridStrategy(Strategy):
             runtime_apikey_name=strategy_config.runtime_apikey_name,
             runtime_endpoint=strategy_config.runtime_endpoint,
             runtime_envs=merged_envs,
+            runtime_bindings=getattr(strategy_config, "runtime_bindings", None) or {},
+            runtime_network=getattr(strategy_config, "runtime_network", None) or {},
             runtime_auth_type=strategy_config.runtime_auth_type,
             runtime_jwt_discovery_url=strategy_config.runtime_jwt_discovery_url,
             runtime_jwt_allowed_clients=strategy_config.runtime_jwt_allowed_clients,