agentkit-sdk-python 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

agentkit/toolkit/cli/sandbox/__init__.py

@@ -17,13 +17,17 @@
 from agentkit.toolkit.cli.sandbox.cli import sandbox_app
 from agentkit.toolkit.cli.sandbox.cli_create import create_command
 from agentkit.toolkit.cli.sandbox.cli_exec import exec_command
+from agentkit.toolkit.cli.sandbox.cli_file import file_command
 from agentkit.toolkit.cli.sandbox.cli_get import get_command
 from agentkit.toolkit.cli.sandbox.cli_shell import shell_command
+from agentkit.toolkit.cli.sandbox.cli_web import web_command
 
 __all__ = [
     "create_command",
     "exec_command",
+    "file_command",
     "get_command",
     "sandbox_app",
     "shell_command",
+    "web_command",
 ]

agentkit/toolkit/cli/sandbox/cli.py

@@ -20,8 +20,10 @@ import typer
 
 from agentkit.toolkit.cli.sandbox.cli_create import create_command
 from agentkit.toolkit.cli.sandbox.cli_exec import exec_command
+from agentkit.toolkit.cli.sandbox.cli_file import file_command
 from agentkit.toolkit.cli.sandbox.cli_get import get_command
 from agentkit.toolkit.cli.sandbox.cli_shell import shell_command
+from agentkit.toolkit.cli.sandbox.cli_web import web_command
 
 sandbox_app = typer.Typer(
     name="sandbox",
@@ -31,6 +33,13 @@ sandbox_app = typer.Typer(
 
 sandbox_app.command(name="create")(create_command)
 sandbox_app.command(name="get")(get_command)
-sandbox_app.command(name="exec")(exec_command)
-sandbox_app.command(name="shell")(shell_command)
-
+sandbox_app.command(
+    name="exec",
+    context_settings={"allow_extra_args": True},
+)(exec_command)
+sandbox_app.command(
+    name="shell",
+    context_settings={"allow_extra_args": True},
+)(shell_command)
+sandbox_app.command(name="web")(web_command)
+sandbox_app.add_typer(file_command, name="file")

agentkit/toolkit/cli/sandbox/cli_create.py

@@ -16,6 +16,7 @@
 
 from __future__ import annotations
 
+import json
 import os
 import re
 import time
@@ -45,7 +46,19 @@ SANDBOX_TOS_REGION_ENV = "AGENTKIT_SANDBOX_TOS_REGION"
 DEFAULT_CREATE_TOOL_TYPE = "CodeEnv"
 DEFAULT_TOS_BUCKET_PATH = "/sandbox-session/default/default"
 DEFAULT_TOS_LOCAL_PATH = "/home/gem"
+CODE_ENV_HOME = "/home/gem"
+CODE_ENV_CODEX_HOME = "/home/gem/.codex"
+CODEX_MODEL_CATALOG_PATH = f"{CODE_ENV_CODEX_HOME}/model-catalog.json"
 DEFAULT_MODEL_NAME = "deepseek-v4-flash-260425"
+DEFAULT_MODEL_NAME_LIST = (
+    DEFAULT_MODEL_NAME,
+    "deepseek-v4-pro-260425",
+    "doubao-seed-2-0-pro-260215",
+)
+DEFAULT_MODEL_CONTEXT_WINDOW = 1000000
+MODEL_CONTEXT_WINDOW_OVERRIDES = {
+    "doubao-seed-2-0-pro-260215": 256000,
+}
 DEFAULT_MODEL_BASE_URL = "https://ark.cn-beijing.volces.com/api/v3"
 DEFAULT_ANTHROPIC_BASE_URL = "https://ark.cn-beijing.volces.com/api/compatible"
 MODEL_BASE_URL_ENV_KEYS = (
@@ -57,8 +70,6 @@ ANTHROPIC_BASE_URL_ENV_KEYS = ("ANTHROPIC_BASE_URL",)
 DISABLED_SERVICE_ENV_KEYS = (
     "DISABLE_JUPYTER",
     "DISABLE_CODE_SERVER",
-    "DISABLE_BROWSER",
-    "DISABLE_VNC",
     "DISABLE_NODEJS_REPL",
 )
 TOOL_READY_STATUS = "Ready"
@@ -98,13 +109,134 @@ def _append_tool_envs(
         return
 
     envs.extend(
-        tools_types.EnvsItemForCreateTool(key=key, value=resolved)
+        tools_types.EnvsItemForCreateTool(Key=key, Value=resolved)
         for key in keys
     )
 
 
+def _toml_quote(value: str) -> str:
+    return json.dumps(value, ensure_ascii=False)
+
+
+def _build_codex_config_toml(model_name: str) -> str:
+    quoted_model = _toml_quote(model_name)
+    return "\n".join(
+        [
+            'model_provider = "codex"',
+            f"model = {quoted_model}",
+            f"review_model = {quoted_model}",
+            'approval_policy = "never"',
+            'sandbox_mode = "danger-full-access"',
+            'model_reasoning_effort = "medium"',
+            'personality = "pragmatic"',
+            "check_for_update_on_startup = false",
+            'web_search = "disabled"',
+            f"model_catalog_json = {_toml_quote(CODEX_MODEL_CATALOG_PATH)}",
+            "",
+            "[model_providers.codex]",
+            'name = "codex"',
+            f"base_url = {_toml_quote(DEFAULT_MODEL_BASE_URL)}",
+            'wire_api = "responses"',
+            'env_key = "CODEX_API_KEY"',
+            "",
+            "[tui]",
+            "show_tooltips = false",
+            "",
+            '[projects."/home/gem"]',
+            'trust_level = "trusted"',
+            "",
+        ]
+    )
+
+
+def _build_model_catalog_item(model_name: str, max_context_window: int) -> dict:
+    return {
+        "slug": model_name,
+        "display_name": model_name,
+        "supported_reasoning_levels": [
+            {
+                "effort": "low",
+                "description": "Fast responses with lighter reasoning",
+            },
+            {
+                "effort": "medium",
+                "description": "Balances speed and reasoning depth",
+            },
+            {
+                "effort": "high",
+                "description": "Greater reasoning depth",
+            },
+        ],
+        "max_context_window": max_context_window,
+        "shell_type": "shell_command",
+        "visibility": "list",
+        "supported_in_api": True,
+        "priority": 100,
+        "base_instructions": "",
+        "supports_reasoning_summaries": True,
+        "support_verbosity": False,
+        "truncation_policy": {"mode": "tokens", "limit": 10000},
+        "supports_parallel_tool_calls": False,
+        "experimental_supported_tools": [],
+    }
+
+
+def _model_catalog_context_window(model_name: str) -> int:
+    return MODEL_CONTEXT_WINDOW_OVERRIDES.get(
+        model_name,
+        DEFAULT_MODEL_CONTEXT_WINDOW,
+    )
+
+
+def _build_codex_model_catalog_json(model_name: str) -> str:
+    deduped_model_names = list(
+        dict.fromkeys((model_name, *DEFAULT_MODEL_NAME_LIST))
+    )
+    payload = {
+        "models": [
+            _build_model_catalog_item(
+                name,
+                _model_catalog_context_window(name),
+            )
+            for name in deduped_model_names
+        ]
+    }
+    return json.dumps(payload, ensure_ascii=False, indent=2)
+
+
+def _append_code_env_tool_envs(
+    envs: list[tools_types.EnvsItemForCreateTool],
+    model_name: str,
+) -> None:
+    envs.extend(
+        [
+            tools_types.EnvsItemForCreateTool(
+                Key="OPENCODE_DISABLE_AUTOUPDATE",
+                Value="1",
+            ),
+            tools_types.EnvsItemForCreateTool(
+                Key="HOME",
+                Value=CODE_ENV_HOME,
+            ),
+            tools_types.EnvsItemForCreateTool(
+                Key="CODEX_HOME",
+                Value=CODE_ENV_CODEX_HOME,
+            ),
+            tools_types.EnvsItemForCreateTool(
+                Key="CODEX_CONFIG_TOML",
+                Value=_build_codex_config_toml(model_name),
+            ),
+            tools_types.EnvsItemForCreateTool(
+                Key="CODEX_MODEL_CATALOG_JSON",
+                Value=_build_codex_model_catalog_json(model_name),
+            ),
+        ]
+    )
+
+
 def _build_tool_model_envs(
     *,
+    tool_type: str,
     model_name: Optional[str] = None,
     model_api_key: Optional[str] = None,
 ) -> list[tools_types.EnvsItemForCreateTool] | None:
@@ -124,6 +256,8 @@ def _build_tool_model_envs(
         DEFAULT_ANTHROPIC_BASE_URL,
     )
     _append_tool_envs(envs, DISABLED_SERVICE_ENV_KEYS, "true")
+    if tool_type.strip() == DEFAULT_CREATE_TOOL_TYPE:
+        _append_code_env_tool_envs(envs, resolved_model_name)
     return envs or None
 
 
@@ -141,20 +275,21 @@ def _build_create_tool_request(
     tos_mount_config = _build_tos_mount_config(tos_bucket, tos_region)
 
     return tools_types.CreateToolRequest(
-        name=resolved_name,
-        tool_type=resolved_tool_type,
-        authorizer_configuration=tools_types.AuthorizerForCreateTool(
-            key_auth=tools_types.AuthorizerKeyAuthForCreateTool(
-                api_key_name=generate_apikey_name(),
-                api_key_location="Header",
+        Name=resolved_name,
+        ToolType=resolved_tool_type,
+        AuthorizerConfiguration=tools_types.AuthorizerForCreateTool(
+            KeyAuth=tools_types.AuthorizerKeyAuthForCreateTool(
+                ApiKeyName=generate_apikey_name(),
+                ApiKeyLocation="Header",
             )
         ),
-        network_configuration=tools_types.NetworkForCreateTool(
-            enable_public_network=True,
-            enable_private_network=False,
+        NetworkConfiguration=tools_types.NetworkForCreateTool(
+            EnablePublicNetwork=True,
+            EnablePrivateNetwork=False,
         ),
-        tos_mount_config=tos_mount_config,
-        envs=_build_tool_model_envs(
+        TosMountConfig=tos_mount_config,
+        Envs=_build_tool_model_envs(
+            tool_type=resolved_tool_type,
             model_name=model_name,
             model_api_key=model_api_key,
         ),
@@ -183,18 +318,18 @@ def _to_create_tool_tos_mount_config(
     mount_config: TOSMountConfig,
 ) -> tools_types.TosMountForCreateTool:
     return tools_types.TosMountForCreateTool(
-        enable_tos=True,
-        credentials=tools_types.TosMountCredentialsForCreateTool(
-            access_key_id=mount_config.credentials.access_key_id,
-            secret_access_key=mount_config.credentials.secret_access_key,
+        EnableTos=True,
+        Credentials=tools_types.TosMountCredentialsForCreateTool(
+            AccessKeyId=mount_config.credentials.access_key_id,
+            SecretAccessKey=mount_config.credentials.secret_access_key,
         ),
-        mount_points=[
+        MountPoints=[
             tools_types.TosMountMountPointsItemForCreateTool(
-                bucket_name=mount.bucket_name,
-                bucket_path=mount.bucket_path,
-                endpoint=mount.endpoint,
-                local_mount_path=mount.local_mount_path,
-                read_only=mount.read_only,
+                BucketName=mount.bucket_name,
+                BucketPath=mount.bucket_path,
+                Endpoint=mount.endpoint,
+                LocalMountPath=mount.local_mount_path,
+                ReadOnly=mount.read_only,
             )
             for mount in mount_config.mount_points
         ],
@@ -238,7 +373,7 @@ def _wait_for_tool_ready(
     last_status = None
 
     while True:
-        response = client.get_tool(tools_types.GetToolRequest(tool_id=tool_id))
+        response = client.get_tool(tools_types.GetToolRequest(ToolId=tool_id))
         status = response.status or ""
         if status != last_status:
             typer.echo(f"工具状态：{status or 'Unknown'}")

agentkit/toolkit/cli/sandbox/cli_exec.py

@@ -26,10 +26,21 @@ import termios
 import threading
 import tty
 from contextlib import contextmanager
+from pathlib import Path
 from typing import Iterator, Optional
 
 import typer
 
+from agentkit.toolkit.cli.sandbox.cli_file import (
+    _build_remote_extract_command,
+    _create_upload_archive,
+    _create_sources_upload_archive,
+    _exec_shell_command,
+    _new_remote_archive_path,
+    _normalize_workspace,
+    _resolve_sandbox_path,
+    _upload_remote_file,
+)
 from agentkit.toolkit.cli.sandbox.session_create import (
     SANDBOX_TOOL_ID_ENV,
     build_model_envs,
@@ -46,6 +57,7 @@ from agentkit.toolkit.cli.sandbox.utils import (
 DETACH_SEQUENCE = b"\x1d"
 DETACH_HINT = "Ctrl-]"
 LOCAL_EXIT_COMMANDS = {"exit", "exit()"}
+DEFAULT_EXEC_WORKSPACE = "/home/gem"
 
 
 def _terminal_size() -> dict[str, int]:
@@ -232,10 +244,95 @@ def _connect_terminal(
             signal.signal(sigwinch, previous_sigwinch)
 
 
+def _resolve_exec_dst_dir(
+    *,
+    workspace: Optional[str],
+    dst_dir: Optional[str],
+) -> str:
+    resolved_workspace = _normalize_workspace(workspace) or DEFAULT_EXEC_WORKSPACE
+    raw_dst_dir = (dst_dir or "").strip()
+    if not raw_dst_dir:
+        return resolved_workspace
+    if raw_dst_dir.startswith("/"):
+        error("--dst-dir must be relative to --workspace")
+    return _resolve_sandbox_path(
+        raw_dst_dir,
+        workspace=resolved_workspace,
+        option_name="--dst-dir",
+    )
+
+
+def _resolve_exec_upload_sources(src_dirs: list[Path]) -> list[Path]:
+    resolved_sources = []
+    seen_names: set[str] = set()
+    for src_dir in src_dirs:
+        if not src_dir.exists():
+            error(f"Source path not found: {src_dir}")
+        if not src_dir.is_dir() and not src_dir.is_file():
+            error(f"Source path is not a file or directory: {src_dir}")
+        if src_dir.name in seen_names:
+            error(f"Duplicate source name: {src_dir.name}")
+        seen_names.add(src_dir.name)
+        resolved_sources.append(src_dir)
+    return resolved_sources
+
+
+def _collect_exec_upload_sources(
+    ctx: typer.Context,
+    src_dir: Optional[Path],
+) -> list[Path]:
+    src_dirs = [Path(value) for value in ctx.args]
+    if src_dirs and not src_dir:
+        error("Additional source paths require --src-dir")
+    if src_dir:
+        src_dirs.insert(0, src_dir)
+    return src_dirs
+
+
+def _upload_source_before_exec(
+    session: dict[str, object],
+    *,
+    workspace: Optional[str],
+    src_dirs: list[Path],
+    dst_dir: Optional[str],
+) -> str:
+    resolved_dst_dir = _resolve_exec_dst_dir(
+        workspace=workspace,
+        dst_dir=dst_dir,
+    )
+    resolved_sources = _resolve_exec_upload_sources(src_dirs)
+    if len(resolved_sources) == 1 and resolved_sources[0].is_dir():
+        archive_path = _create_upload_archive(
+            upload_dir=resolved_sources[0],
+            upload_files=[],
+        )
+    else:
+        archive_path = _create_sources_upload_archive(resolved_sources)
+    remote_archive_path = _new_remote_archive_path("agentkit-upload")
+    try:
+        _upload_remote_file(
+            session,
+            local_path=archive_path,
+            remote_path=remote_archive_path,
+        )
+        _exec_shell_command(
+            session,
+            _build_remote_extract_command(
+                archive_path=remote_archive_path,
+                dst_dir=resolved_dst_dir,
+            ),
+        )
+    finally:
+        archive_path.unlink(missing_ok=True)
+    return resolved_dst_dir
+
+
 def exec_command(
+    ctx: typer.Context,
     session_id: Optional[str] = typer.Option(
         None,
         "--session-id",
+        "--sid",
         help=(
             "Sandbox session ID. Defaults to a generated UUID and creates "
             "a sandbox session when needed."
@@ -264,6 +361,29 @@ def exec_command(
         "--shell-id",
         help="Existing shell terminal ID to connect to.",
     ),
+    workspace: str = typer.Option(
+        DEFAULT_EXEC_WORKSPACE,
+        "--workspace",
+        help=(
+            "Sandbox workspace root. Relative --dst-dir values are "
+            "resolved inside this directory."
+        ),
+    ),
+    src_dir: Optional[Path] = typer.Option(
+        None,
+        "--src-dir",
+        help=(
+            "Local file or directory to upload before opening the exec session."
+        ),
+    ),
+    dst_dir: Optional[str] = typer.Option(
+        None,
+        "--dst-dir",
+        help=(
+            "Relative sandbox destination directory for --src-dir. Defaults "
+            "to --workspace."
+        ),
+    ),
     model_name: Optional[str] = typer.Option(
         None,
         "--model-name",
@@ -301,6 +421,20 @@ def exec_command(
     if not isinstance(session_id, str) or not session_id:
         error("Sandbox session missing session_id")
 
+    try:
+        src_dirs = _collect_exec_upload_sources(ctx, src_dir)
+        if src_dirs:
+            _upload_source_before_exec(
+                session,
+                workspace=workspace,
+                src_dirs=src_dirs,
+                dst_dir=dst_dir,
+            )
+    except typer.Exit:
+        raise
+    except Exception as exc:
+        error(str(exc))
+
     ws_url = build_terminal_ws_url(session.get("endpoint"), shell_id=shell_id)
     initial_command = command