agentkit-sdk-python 0.6.2__tar.gz → 0.6.3__tar.gz

{agentkit_sdk_python-0.6.2 → agentkit_sdk_python-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentkit-sdk-python
-Version: 0.6.2
+Version: 0.6.3
 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.6.2 → agentkit_sdk_python-0.6.3}/agentkit/platform/configuration.py

@@ -536,16 +536,23 @@ class VolcConfiguration:
         """
         Resolves region for a specific service.
         Priority:
-        1. Service-specific environment variable: VOLCENGINE_{SERVICE}_REGION
-        2. Service-specific config file: services.{service}.region
-        3. Logical region mapping: region_policy.rules.{logical_region}.{service}
-        4. Global environment variable: VOLCENGINE_REGION
-        5. Global config file: volcengine.region
-        6. Default: DEFAULT_REGION
+        1. Explicitly passed in constructor
+        2. Service-specific environment variable: VOLCENGINE_{SERVICE}_REGION
+        3. Service-specific config file: services.{service}.region
+        4. Logical region mapping: region_policy.rules.{logical_region}.{service}
+        5. Global environment variable: VOLCENGINE_REGION
+        6. Global config file: volcengine.region
+        7. Default: DEFAULT_REGION
         """
         key_lower = service_key.lower()
         key_upper = service_key.upper()
 
+        if self._region:
+            mapped_region = self._get_mapped_region(self._region, service_key)
+            if mapped_region:
+                return mapped_region
+            return self._region
+
         if self._provider == CloudProvider.BYTEPLUS:
             svc_region = os.getenv(f"BYTEPLUS_{key_upper}_REGION")
         else:

{agentkit_sdk_python-0.6.2 → agentkit_sdk_python-0.6.3}/agentkit/toolkit/cli/sandbox/cli_create.py

@@ -23,6 +23,7 @@ from typing import Optional
 
 import typer
 
+from agentkit.platform import VolcConfiguration
 from agentkit.sdk.tools.client import AgentkitToolsClient
 from agentkit.sdk.tools import types as tools_types
 from agentkit.toolkit.cli.sandbox.model_config import (
@@ -31,13 +32,16 @@ from agentkit.toolkit.cli.sandbox.model_config import (
     CODE_ENV_HOME,
     CODEX_CONFIG_TOML_ENV,
     CODEX_MODEL_CATALOG_JSON_ENV,
-    DEFAULT_ANTHROPIC_BASE_URL,
-    DEFAULT_MODEL_BASE_URL,
-    DEFAULT_MODEL_NAME,
+    DEFAULT_MODEL_PROVIDER,
+    ModelProviderType,
     MODEL_API_KEY_ENV,
     MODEL_API_KEY_ENV_KEYS,
     MODEL_BASE_URL_ENV_KEYS,
     MODEL_NAME_ENV_KEYS,
+    MODEL_PROVIDER_ENV,
+    get_model_provider_config,
+    normalize_model_provider,
+    resolve_model_name,
     build_codex_config_toml as _shared_build_codex_config_toml,
     build_codex_model_catalog_json as _shared_build_codex_model_catalog_json,
 )
@@ -50,7 +54,6 @@ from agentkit.toolkit.volcengine.services.tos_service import (
 )
 from agentkit.utils.misc import generate_apikey_name, generate_random_id
 
-DEFAULT_CREATE_TOOL_REGION = "cn-beijing"
 SANDBOX_REGION_ENV = "AGENTKIT_SANDBOX_REGION"
 SANDBOX_TOS_REGION_ENV = "AGENTKIT_SANDBOX_TOS_REGION"
 DEFAULT_CREATE_TOOL_TYPE = "CodeEnv"
@@ -64,17 +67,22 @@ DISABLED_SERVICE_ENV_KEYS = (
     "DISABLE_CODE_SERVER",
     "DISABLE_NODEJS_REPL",
 )
+BROWSER_EXTRA_ARGS_ENV = "BROWSER_EXTRA_ARGS"
+DEFAULT_BROWSER_EXTRA_ARGS = (
+    "--enable-unsafe-swiftshader --use-gl=angle "
+    "--use-angle=swiftshader-webgl --ignore-gpu-blocklist"
+)
 TOOL_READY_STATUS = "Ready"
 TOOL_FAILED_STATUSES = {"Error", "Failed", "CreateFailed", "Deleting", "Deleted"}
 TOOL_WAIT_INTERVAL_SECONDS = 5
 TOOL_WAIT_TIMEOUT_SECONDS = 600
 
 
-def _resolve_region(env_var_name: str) -> str:
+def _resolve_region(env_var_name: str, service_key: str) -> str:
     env_region = (os.getenv(env_var_name) or "").strip()
     if env_region:
         return env_region
-    return DEFAULT_CREATE_TOOL_REGION
+    return VolcConfiguration().get_service_endpoint(service_key).region
 
 
 def _generate_tool_name(tool_type: str) -> str:
@@ -118,17 +126,24 @@ def _append_tool_envs(
     )
 
 
-def _build_codex_config_toml(model_name: str) -> str:
-    return _shared_build_codex_config_toml(model_name)
+def _build_codex_config_toml(
+    model_name: str,
+    model_provider: str | ModelProviderType | None = None,
+) -> str:
+    return _shared_build_codex_config_toml(model_name, model_provider)
 
 
-def _build_codex_model_catalog_json(model_name: str) -> str:
-    return _shared_build_codex_model_catalog_json(model_name)
+def _build_codex_model_catalog_json(
+    model_name: str,
+    model_provider: str | ModelProviderType | None = None,
+) -> str:
+    return _shared_build_codex_model_catalog_json(model_name, model_provider)
 
 
 def _append_code_env_tool_envs(
     envs: list[tools_types.EnvsItemForCreateTool],
     model_name: str,
+    model_provider: str | ModelProviderType | None,
 ) -> None:
     envs.extend(
         [
@@ -146,11 +161,11 @@ def _append_code_env_tool_envs(
             ),
             tools_types.EnvsItemForCreateTool(
                 Key=CODEX_CONFIG_TOML_ENV,
-                Value=_build_codex_config_toml(model_name),
+                Value=_build_codex_config_toml(model_name, model_provider),
             ),
             tools_types.EnvsItemForCreateTool(
                 Key=CODEX_MODEL_CATALOG_JSON_ENV,
-                Value=_build_codex_model_catalog_json(model_name),
+                Value=_build_codex_model_catalog_json(model_name, model_provider),
             ),
         ]
     )
@@ -161,25 +176,30 @@ def _build_tool_model_envs(
     tool_type: str,
     model_name: Optional[str] = None,
     model_api_key: Optional[str] = None,
+    model_provider: str | ModelProviderType | None = DEFAULT_MODEL_PROVIDER,
 ) -> list[tools_types.EnvsItemForCreateTool] | None:
     envs: list[tools_types.EnvsItemForCreateTool] = []
-    resolved_model_name = (model_name or "").strip() or DEFAULT_MODEL_NAME
+    provider_config = get_model_provider_config(model_provider)
+    resolved_model_provider = normalize_model_provider(model_provider)
+    resolved_model_name = resolve_model_name(model_name, model_provider)
     resolved_model_api_key = model_api_key or os.getenv(MODEL_API_KEY_ENV)
+    _append_tool_envs(envs, (MODEL_PROVIDER_ENV,), resolved_model_provider)
     _append_tool_envs(envs, MODEL_NAME_ENV_KEYS, resolved_model_name)
     _append_tool_envs(envs, MODEL_API_KEY_ENV_KEYS, resolved_model_api_key)
     _append_tool_envs(
         envs,
         MODEL_BASE_URL_ENV_KEYS,
-        DEFAULT_MODEL_BASE_URL,
+        provider_config.model_base_url,
     )
     _append_tool_envs(
         envs,
         ANTHROPIC_BASE_URL_ENV_KEYS,
-        DEFAULT_ANTHROPIC_BASE_URL,
+        provider_config.anthropic_base_url,
     )
     _append_tool_envs(envs, DISABLED_SERVICE_ENV_KEYS, "true")
+    _append_tool_envs(envs, (BROWSER_EXTRA_ARGS_ENV,), DEFAULT_BROWSER_EXTRA_ARGS)
     if tool_type.strip() == DEFAULT_CREATE_TOOL_TYPE:
-        _append_code_env_tool_envs(envs, resolved_model_name)
+        _append_code_env_tool_envs(envs, resolved_model_name, model_provider)
     return envs or None
 
 
@@ -192,6 +212,7 @@ def _build_create_tool_request(
     cpu: int = DEFAULT_CPU,
     model_name: Optional[str] = None,
     model_api_key: Optional[str] = None,
+    model_provider: str | ModelProviderType | None = DEFAULT_MODEL_PROVIDER,
 ) -> tools_types.CreateToolRequest:
     resolved_tool_type = tool_type.strip() or DEFAULT_CREATE_TOOL_TYPE
     resolved_name = (name or "").strip() or _generate_tool_name(resolved_tool_type)
@@ -218,6 +239,7 @@ def _build_create_tool_request(
             tool_type=resolved_tool_type,
             model_name=model_name,
             model_api_key=model_api_key,
+            model_provider=model_provider,
         ),
     )
 
@@ -329,9 +351,11 @@ def create_tool(
     cpu: int = DEFAULT_CPU,
     model_name: Optional[str] = None,
     model_api_key: Optional[str] = None,
+    model_provider: str | ModelProviderType | None = DEFAULT_MODEL_PROVIDER,
 ) -> dict[str, object]:
-    region = _resolve_region(SANDBOX_REGION_ENV)
-    tos_region = _resolve_region(SANDBOX_TOS_REGION_ENV)
+    resolved_model_provider = normalize_model_provider(model_provider)
+    region = _resolve_region(SANDBOX_REGION_ENV, "agentkit")
+    tos_region = _resolve_region(SANDBOX_TOS_REGION_ENV, "tos")
     request = _build_create_tool_request(
         tool_type=tool_type,
         name=tool_name,
@@ -340,6 +364,7 @@ def create_tool(
         cpu=cpu,
         model_name=model_name,
         model_api_key=model_api_key,
+        model_provider=resolved_model_provider,
     )
     client = AgentkitToolsClient(
         region=region,
@@ -354,6 +379,7 @@ def create_tool(
         "tool_type": final_tool.tool_type or request.tool_type,
         "name": final_tool.name or request.name,
         "status": final_tool.status or TOOL_READY_STATUS,
+        "model_provider": resolved_model_provider,
     }
 
 
@@ -398,6 +424,11 @@ def create_command(
             "and ANTHROPIC_AUTH_TOKEN when creating a tool."
         ),
     ),
+    model_provider: ModelProviderType = typer.Option(
+        ModelProviderType.MODEL_SQUARE,
+        "--model-provider",
+        help="Model provider to use for base URLs, defaults, and model catalog.",
+    ),
 ) -> None:
     """Create an AgentKit Tool with optional TOS mount."""
     try:
@@ -408,6 +439,7 @@ def create_command(
             cpu=cpu,
             model_name=model_name,
             model_api_key=model_api_key,
+            model_provider=model_provider.value,
         )
         save_tool_result(str(result["tool_type"]), result)
     except (typer.Abort, typer.Exit):

{agentkit_sdk_python-0.6.2 → agentkit_sdk_python-0.6.3}/agentkit/toolkit/cli/sandbox/cli_exec.py

@@ -31,6 +31,7 @@ from typing import Iterator, Optional
 
 import typer
 
+from agentkit.sdk.tools.client import AgentkitToolsClient
 from agentkit.toolkit.cli.sandbox.cli_file import (
     _build_remote_extract_command,
     _create_upload_archive,
@@ -46,11 +47,18 @@ from agentkit.toolkit.cli.sandbox.session_create import (
     build_model_envs,
     ensure_sandbox_session,
 )
-from agentkit.toolkit.cli.sandbox.tool_resolve import SandboxToolType
+from agentkit.toolkit.cli.sandbox.git_config import apply_git_config_to_session
+from agentkit.toolkit.cli.sandbox.model_config import ModelProviderType
+from agentkit.toolkit.cli.sandbox.tool_resolve import (
+    SandboxToolType,
+    find_tool_model_provider,
+    get_remote_tool_model_provider,
+)
 from agentkit.toolkit.cli.sandbox.utils import (
     add_session_terminal_shell_id,
     build_terminal_ws_url,
     error,
+    find_session_result,
     remove_session_terminal_shell_id,
 )
 
@@ -327,6 +335,48 @@ def _upload_source_before_exec(
     return resolved_dst_dir
 
 
+def _resolve_exec_model_provider(
+    *,
+    session_id: Optional[str],
+    tool_id: Optional[str],
+    tool_type: SandboxToolType,
+    model_name: Optional[str],
+    model_provider: Optional[ModelProviderType],
+) -> str | ModelProviderType | None:
+    if model_provider or not (model_name or "").strip():
+        return model_provider
+
+    resolved_tool_id = (tool_id or "").strip()
+    if not resolved_tool_id and session_id:
+        existing = find_session_result(session_id)
+        if existing:
+            existing_tool_id = existing.get("tool_id")
+            if isinstance(existing_tool_id, str):
+                resolved_tool_id = existing_tool_id.strip()
+
+    if not resolved_tool_id:
+        return None
+
+    cached_model_provider = find_tool_model_provider(
+        tool_id=resolved_tool_id,
+        tool_type=tool_type,
+    )
+    if cached_model_provider:
+        return cached_model_provider
+
+    if not (tool_id or "").strip():
+        return None
+
+    try:
+        return get_remote_tool_model_provider(
+            AgentkitToolsClient(),
+            resolved_tool_id,
+            tool_type=tool_type,
+        )
+    except Exception:
+        return None
+
+
 def exec_command(
     ctx: typer.Context,
     session_id: Optional[str] = typer.Option(
@@ -357,11 +407,6 @@ def exec_command(
             "Omit this option to connect without an initial command."
         ),
     ),
-    shell_id: Optional[str] = typer.Option(
-        None,
-        "--shell-id",
-        help="Existing shell terminal ID to connect to.",
-    ),
     workspace: str = typer.Option(
         DEFAULT_EXEC_WORKSPACE,
         "--workspace",
@@ -385,6 +430,14 @@ def exec_command(
             "to --workspace."
         ),
     ),
+    git_config: Optional[str] = typer.Option(
+        None,
+        "--git-config",
+        help=(
+            "Git identity source. Use 'local' to read local git config, or "
+            "provide an INI/TOML/JSON file path with user.name and user.email."
+        ),
+    ),
     model_name: Optional[str] = typer.Option(
         None,
         "--model-name",
@@ -401,9 +454,24 @@ def exec_command(
             "and ANTHROPIC_AUTH_TOKEN when creating a sandbox session."
         ),
     ),
+    model_provider: Optional[ModelProviderType] = typer.Option(
+        None,
+        "--model-provider",
+        help=(
+            "Model provider to use for base URLs, defaults, and model catalog "
+            "when creating a sandbox session."
+        ),
+    ),
 ) -> None:
     """Open a streaming sandbox exec session. Press Ctrl-] or type exit/exit()."""
     try:
+        resolved_model_provider = _resolve_exec_model_provider(
+            session_id=session_id,
+            tool_id=tool_id,
+            tool_type=tool_type,
+            model_name=model_name,
+            model_provider=model_provider,
+        )
         session = ensure_sandbox_session(
             session_id=session_id,
             tool_id=tool_id,
@@ -411,6 +479,7 @@ def exec_command(
             envs=build_model_envs(
                 model_name=model_name,
                 model_api_key=model_api_key,
+                model_provider=resolved_model_provider,
                 include_codex_config=tool_type == SandboxToolType.CODE_ENV,
             ),
         )
@@ -437,9 +506,6 @@ def exec_command(
     except Exception as exc:
         error(str(exc))
 
-    ws_url = build_terminal_ws_url(session.get("endpoint"), shell_id=shell_id)
-    initial_command = command
-
     cleanup_shell_ids: list[str] = []
     cleanup_shell_ids_lock = threading.Lock()
 
@@ -448,9 +514,18 @@ def exec_command(
             if remote_shell_id not in cleanup_shell_ids:
                 cleanup_shell_ids.append(remote_shell_id)
 
-    if shell_id:
-        add_session_terminal_shell_id(session_id, shell_id)
-        remember_cleanup_shell_id(shell_id)
+    try:
+        apply_git_config_to_session(
+            session,
+            git_config,
+        )
+    except typer.Exit:
+        raise
+    except Exception as exc:
+        error(str(exc))
+
+    ws_url = build_terminal_ws_url(session.get("endpoint"))
+    initial_command = command
 
     def on_shell_id(remote_shell_id: str) -> None:
         add_session_terminal_shell_id(session_id, remote_shell_id)

{agentkit_sdk_python-0.6.2 → agentkit_sdk_python-0.6.3}/agentkit/toolkit/cli/sandbox/cli_file.py

@@ -193,11 +193,13 @@ def _exec_shell_command(
     session: dict[str, object],
     command: str,
     *,
+    shell_id: str = "",
+    exec_dir: str = "",
     quiet_errors: bool = False,
 ) -> dict[str, object]:
     response = requests.post(
         build_exec_url(session.get("endpoint")),
-        json={"id": "", "exec_dir": "", "command": command},
+        json={"id": shell_id, "exec_dir": exec_dir, "command": command},
         timeout=SANDBOX_EXEC_TIMEOUT_SECONDS,
     )
     payload = _json_response(response, "shell exec")

{agentkit_sdk_python-0.6.2 → agentkit_sdk_python-0.6.3}/agentkit/toolkit/cli/sandbox/cli_shell.py

@@ -31,6 +31,7 @@ from agentkit.toolkit.cli.sandbox.session_create import (
     SANDBOX_TOOL_ID_ENV,
     ensure_sandbox_session,
 )
+from agentkit.toolkit.cli.sandbox.git_config import apply_git_config_to_session
 from agentkit.toolkit.cli.sandbox.tool_resolve import SandboxToolType
 from agentkit.toolkit.cli.sandbox.utils import (
     SANDBOX_EXEC_TIMEOUT_SECONDS,
@@ -73,11 +74,6 @@ def shell_command(
         "--exec-dir",
         help="Execution directory.",
     ),
-    shell_id: Optional[str] = typer.Option(
-        None,
-        "--shell-id",
-        help="Shell terminal ID for re-entering an existing shell.",
-    ),
     workspace: str = typer.Option(
         DEFAULT_EXEC_WORKSPACE,
         "--workspace",
@@ -101,6 +97,14 @@ def shell_command(
             "to --workspace."
         ),
     ),
+    git_config: Optional[str] = typer.Option(
+        None,
+        "--git-config",
+        help=(
+            "Git identity source. Use 'local' to read local git config, or "
+            "provide an INI/TOML/JSON file path with user.name and user.email."
+        ),
+    ),
 ) -> None:
     """Execute a command in a sandbox shell."""
     try:
@@ -128,9 +132,19 @@ def shell_command(
     except Exception as exc:
         error(str(exc))
 
+    try:
+        apply_git_config_to_session(
+            session,
+            git_config,
+        )
+    except typer.Exit:
+        raise
+    except Exception as exc:
+        error(str(exc))
+
     url = build_exec_url(session.get("endpoint"))
     body = {
-        "id": shell_id or "",
+        "id": "",
         "exec_dir": exec_dir or "",
         "command": command,
     }

{agentkit_sdk_python-0.6.2 → agentkit_sdk_python-0.6.3}/agentkit/toolkit/cli/sandbox/cli_web.py

@@ -21,37 +21,28 @@ from typing import Optional
 
 import typer
 
-from agentkit.sdk.tools.client import AgentkitToolsClient
-from agentkit.toolkit.cli.sandbox.session_create import SANDBOX_TOOL_ID_ENV
-from agentkit.toolkit.cli.sandbox.session_sync import sync_remote_sessions
+from agentkit.toolkit.cli.sandbox.session_create import (
+    SANDBOX_TOOL_ID_ENV,
+    ensure_sandbox_session_with_status,
+)
 from agentkit.toolkit.cli.sandbox.tool_resolve import SandboxToolType
 from agentkit.toolkit.cli.sandbox.utils import (
     build_web_url,
     echo_json,
     error,
-    find_session_result,
 )
 
 
-def _resolve_existing_session(
+def _resolve_web_session(
     *,
     session_id: str,
     tool_id: Optional[str],
-) -> dict[str, object]:
-    client = AgentkitToolsClient()
-    resolved_tool_id = sync_remote_sessions(
+) -> tuple[dict[str, object], bool]:
+    return ensure_sandbox_session_with_status(
         session_id=session_id,
         tool_id=tool_id,
-        tool_type=SandboxToolType.CODE_ENV,
-        client=client,
-        env_var_name=SANDBOX_TOOL_ID_ENV,
+        tool_type=SandboxToolType.CODE_ENV.value,
     )
-    result = find_session_result(session_id)
-    if result is None:
-        error(f"Sandbox session not found: {session_id}")
-    if resolved_tool_id and result.get("tool_id") != resolved_tool_id:
-        error(f"Sandbox session not found: {session_id}")
-    return result
 
 
 def web_command(
@@ -71,7 +62,7 @@ def web_command(
 ) -> None:
     """Return the browser URL for a sandbox session."""
     try:
-        session = _resolve_existing_session(
+        session, is_new = _resolve_web_session(
             session_id=session_id,
             tool_id=tool_id,
         )
@@ -92,5 +83,6 @@ def web_command(
             "url": url,
             "tool_id": session.get("tool_id"),
             "session_id": resolved_session_id,
+            "is_new": is_new,
         }
     )