agentkit-sdk-python 0.6.5__py3-none-any.whl → 0.7.1__py3-none-any.whl

agentkit/auth/model_login.py

@@ -0,0 +1,360 @@
+# 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.
+
+"""Bring a user's *own* third-party model subscription into the sandbox.
+
+Many foreign models (ChatGPT/Codex, Claude Code) are used via a JWT obtained by an
+interactive SSO login, not a static API key. A user who subscribed to one of those
+plans wants the **sandbox's** codex to run on *their* subscription.
+
+The agentkit UserPool does not (and need not) federate with OpenAI/Anthropic. Codex
+already supports SSO **locally**; in the sandbox it is "remote", so the agreed design
+is dead simple and is what this module implements:
+
+    1. The user runs the provider's native SSO **on their PC** (``codex login`` for
+       Codex/ChatGPT, ``claude`` for Claude Code). That writes the provider's native
+       credential file:
+           Codex   ->  $CODEX_HOME/auth.json   (default ~/.codex/auth.json)
+           Claude  ->  ~/.claude/.credentials.json   (or the macOS Keychain)
+    2. We read that file verbatim and inject it into the **same native path inside
+       the user's private sandbox** — so the sandbox's codex finds its token exactly
+       where it natively looks. No proxy, no federation: the sandbox refreshes the
+       token itself against the provider, just like a local install would.
+
+This module is pure (stdlib only) and side-effect-light so it is unit-testable; the
+network/forwarding lives in the CLI layer (``cli_accesscontrol.py``).
+"""
+
+from __future__ import annotations
+
+import base64
+import datetime
+import json
+import os
+import re
+import sys
+from pathlib import Path
+from typing import Callable, Optional
+
+# ── Codex / ChatGPT facts ────────────────────────────────────────────────────
+CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann"  # codex CLI's public OAuth client (the id_token aud)
+CODEX_OAUTH_NAMESPACE = "https://api.openai.com/auth"  # claim namespace holding the ChatGPT plan
+DEFAULT_SANDBOX_CODEX_HOME = "/home/gem/.codex"  # informational; the shell resolves ${CODEX_HOME:-$HOME/.codex}
+CODEX_INJECT_MARKER = "AGENTKIT_CODEX_INJECTED"
+CLAUDE_INJECT_MARKER = "AGENTKIT_CLAUDE_INJECTED"
+CLAUDE_KEYCHAIN_SERVICE = "Claude Code-credentials"
+
+PROVIDERS = ("codex", "claude")
+
+
+class ModelLoginError(RuntimeError):
+    """A user-facing failure resolving or injecting a model subscription token."""
+
+
+# ── small helpers ────────────────────────────────────────────────────────────
+def b64(data: str | bytes) -> str:
+    """Standard base64 (single line, no newlines) — safe to embed in a shell ``printf``."""
+    if isinstance(data, str):
+        data = data.encode("utf-8")
+    return base64.b64encode(data).decode("ascii")
+
+
+def _iso(epoch_seconds: int) -> str:
+    return datetime.datetime.fromtimestamp(epoch_seconds, tz=datetime.timezone.utc).isoformat()
+
+
+def decode_jwt_claims(jwt: str) -> dict:
+    """Decode (NOT verify) a JWT's payload claims. We only read non-secret metadata."""
+    parts = (jwt or "").split(".")
+    if len(parts) < 2:
+        raise ModelLoginError("malformed JWT")
+    seg = parts[1]
+    try:
+        return json.loads(base64.urlsafe_b64decode(seg + "=" * (-len(seg) % 4)))
+    except Exception as exc:  # noqa: BLE001
+        raise ModelLoginError(f"cannot decode JWT claims: {exc}") from exc
+
+
+# ── Codex (ChatGPT) ──────────────────────────────────────────────────────────
+def codex_home_path(explicit: Optional[str] = None) -> Path:
+    """Resolve the LOCAL codex home: --codex-home > $CODEX_HOME > ~/.codex."""
+    if explicit:
+        return Path(explicit).expanduser()
+    env = os.environ.get("CODEX_HOME")
+    if env:
+        return Path(env).expanduser()
+    return Path.home() / ".codex"
+
+
+def read_codex_auth(path: str | Path) -> dict:
+    p = Path(path)
+    try:
+        data = json.loads(p.read_text(encoding="utf-8"))
+    except FileNotFoundError as exc:
+        raise ModelLoginError(f"codex auth file not found: {p}") from exc
+    except (json.JSONDecodeError, OSError) as exc:
+        raise ModelLoginError(f"cannot read codex auth file {p}: {exc}") from exc
+    if not isinstance(data, dict):
+        raise ModelLoginError(f"codex auth file {p} is not a JSON object")
+    return data
+
+
+def validate_codex_auth(data: dict) -> None:
+    """A usable codex auth has ChatGPT tokens (SSO) or an API key."""
+    tokens = data.get("tokens")
+    has_tokens = isinstance(tokens, dict) and bool(tokens.get("id_token") or tokens.get("access_token"))
+    has_key = bool(data.get("OPENAI_API_KEY"))
+    if not (has_tokens or has_key):
+        raise ModelLoginError(
+            "codex auth.json has neither ChatGPT tokens nor an API key — run `codex login` first"
+        )
+
+
+def codex_auth_summary(data: dict) -> dict:
+    """A redacted, secret-free summary (provider, plan, account, expiry) for display."""
+    tokens = data.get("tokens") or {}
+    summary: dict = {
+        "provider": "codex (ChatGPT)",
+        "auth_mode": data.get("auth_mode") or ("chatgpt" if tokens else "apikey"),
+        "has_refresh_token": bool(tokens.get("refresh_token")),
+        "account_id": tokens.get("account_id"),
+    }
+    idt = tokens.get("id_token")
+    if idt:
+        try:
+            claims = decode_jwt_claims(idt)
+        except ModelLoginError:
+            claims = {}
+        ns = claims.get(CODEX_OAUTH_NAMESPACE) or {}
+        summary["email"] = claims.get("email")
+        summary["plan"] = ns.get("chatgpt_plan_type")
+        summary["chatgpt_account_id"] = ns.get("chatgpt_account_id") or summary.get("account_id")
+        exp = claims.get("exp")
+        if isinstance(exp, int):
+            summary["id_token_expires"] = _iso(exp)
+            summary["id_token_expired"] = exp < int(datetime.datetime.now(datetime.timezone.utc).timestamp())
+    return {k: v for k, v in summary.items() if v is not None}
+
+
+def run_codex_login(
+    *, codex_home: Optional[Path] = None, codex_bin: str = "codex", timeout: int = 300
+) -> None:
+    """Trigger codex's native local SSO (opens a browser) so it writes a fresh auth.json."""
+    import subprocess
+
+    env = dict(os.environ)
+    if codex_home:
+        env["CODEX_HOME"] = str(codex_home)
+    try:
+        subprocess.run([codex_bin, "login"], env=env, timeout=timeout, check=True)  # noqa: S603
+    except FileNotFoundError as exc:
+        raise ModelLoginError(
+            f"`{codex_bin}` not found on PATH — install the Codex CLI and run `codex login`, "
+            f"or pass --auth-file <path-to-your-auth.json>"
+        ) from exc
+    except subprocess.CalledProcessError as exc:
+        raise ModelLoginError(f"`codex login` failed (exit {exc.returncode})") from exc
+    except subprocess.TimeoutExpired as exc:
+        raise ModelLoginError("`codex login` timed out") from exc
+
+
+def resolve_local_codex_auth(
+    *,
+    codex_home: Optional[str] = None,
+    auth_file: Optional[str] = None,
+    allow_login: bool = True,
+    login_timeout: int = 300,
+    login_runner: Optional[Callable[..., None]] = None,
+) -> tuple[Path, dict]:
+    """Return ``(path, data)`` of a usable LOCAL codex auth, running `codex login` if needed."""
+    if auth_file:
+        path = Path(auth_file).expanduser()
+        if not path.exists():
+            raise ModelLoginError(f"--auth-file not found: {path}")
+        data = read_codex_auth(path)
+        validate_codex_auth(data)
+        return path, data
+
+    home = codex_home_path(codex_home)
+    path = home / "auth.json"
+    if not path.exists():
+        if not allow_login:
+            raise ModelLoginError(
+                f"no codex auth at {path} — run `codex login` (or pass --auth-file / --no-login off)"
+            )
+        (login_runner or run_codex_login)(codex_home=home, timeout=login_timeout)
+        if not path.exists():
+            raise ModelLoginError(f"`codex login` finished but {path} is still missing")
+    data = read_codex_auth(path)
+    validate_codex_auth(data)
+    return path, data
+
+
+# ── Codex config.toml: switch the sandbox codex to the ChatGPT subscription ──
+_TOP_MODEL_PIN = re.compile(r"^\s*(model|model_provider|review_model)\s*=")
+_AUTH_METHOD = re.compile(r"^\s*preferred_auth_method\s*=")
+_TABLE_HEADER = re.compile(r"^\s*\[")
+
+
+def rewrite_codex_config_for_chatgpt(toml_text: str) -> str:
+    """Switch an existing codex config.toml to ChatGPT-subscription auth, preserving everything else.
+
+    The sandbox's default config pins a custom ``model_provider``/``model`` to a Volcengine Ark
+    endpoint that authenticates with an API key (``env_key``); in that mode codex never looks at the
+    injected ChatGPT token. To use the subscription we:
+      * drop the top-level ``model`` / ``model_provider`` / ``review_model`` pins, so codex falls back
+        to its built-in ``openai`` provider and the subscription's default model, and
+      * force ``preferred_auth_method = "chatgpt"`` so the OAuth token wins over any stray API key.
+    Tables (``[tui]``, ``[projects.*]``, ``[mcp_servers.*]``, ``[model_providers.*]``) and other
+    top-level keys (approval_policy, sandbox_mode, model_reasoning_effort, …) are kept verbatim.
+    """
+    out: list[str] = []
+    seen_table = False
+    for line in toml_text.splitlines():
+        if _TABLE_HEADER.match(line):
+            seen_table = True
+        if _AUTH_METHOD.match(line):
+            continue  # re-added at the top
+        if not seen_table and _TOP_MODEL_PIN.match(line):
+            continue
+        out.append(line)
+    body = "\n".join(out).strip("\n")
+    return 'preferred_auth_method = "chatgpt"\n' + (body + "\n" if body else "")
+
+
+def minimal_chatgpt_codex_config() -> str:
+    """A config.toml for a sandbox that has no codex config yet — ChatGPT auth, headless-friendly."""
+    return "\n".join(
+        [
+            'preferred_auth_method = "chatgpt"',
+            'approval_policy = "never"',
+            'sandbox_mode = "danger-full-access"',
+            "",
+            '[projects."/home/gem"]',
+            'trust_level = "trusted"',
+            "",
+        ]
+    )
+
+
+def read_codex_config_command() -> str:
+    """Shell command that prints the sandbox's current codex config.toml (empty if none)."""
+    return 'cat "${CODEX_HOME:-$HOME/.codex}/config.toml" 2>/dev/null || true'
+
+
+def build_codex_injection_command(*, auth_json: str, config_toml: Optional[str] = None) -> str:
+    """A single POSIX-sh command that writes auth.json (and optionally config.toml) into the
+    sandbox's native codex home (``${CODEX_HOME:-$HOME/.codex}``), 0600, and prints a marker."""
+    lines = [
+        "set -e",
+        'CH="${CODEX_HOME:-$HOME/.codex}"',
+        'mkdir -p "$CH"',
+        "umask 077",
+        f"printf %s '{b64(auth_json)}' | base64 -d > \"$CH/auth.json\"",
+        'chmod 600 "$CH/auth.json"',
+    ]
+    if config_toml is not None:
+        lines.append(f"printf %s '{b64(config_toml)}' | base64 -d > \"$CH/config.toml\"")
+    lines.append(f'echo "{CODEX_INJECT_MARKER} $CH"')
+    return "\n".join(lines)
+
+
+# ── Claude Code ──────────────────────────────────────────────────────────────
+def claude_creds_path(explicit: Optional[str] = None) -> Path:
+    if explicit:
+        return Path(explicit).expanduser()
+    return Path.home() / ".claude" / ".credentials.json"
+
+
+def _read_macos_keychain(service: str) -> Optional[str]:
+    import subprocess
+
+    try:
+        out = subprocess.run(  # noqa: S603
+            ["security", "find-generic-password", "-s", service, "-w"],  # noqa: S607
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+    except (FileNotFoundError, OSError, subprocess.TimeoutExpired):
+        return None
+    if out.returncode != 0:
+        return None
+    return (out.stdout or "").strip() or None
+
+
+def read_claude_creds(*, creds_file: Optional[str] = None, allow_keychain: bool = True) -> dict:
+    """Read Claude Code subscription creds from the file, or the macOS Keychain as a fallback."""
+    path = claude_creds_path(creds_file)
+    if path.exists():
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError) as exc:
+            raise ModelLoginError(f"cannot read {path}: {exc}") from exc
+    elif creds_file:
+        raise ModelLoginError(f"--auth-file not found: {path}")
+    elif allow_keychain and sys.platform == "darwin":
+        raw = _read_macos_keychain(CLAUDE_KEYCHAIN_SERVICE)
+        if not raw:
+            raise ModelLoginError(
+                "no Claude Code credentials in ~/.claude/.credentials.json or the macOS Keychain — "
+                "run `claude` and log in with your subscription first"
+            )
+        try:
+            data = json.loads(raw)
+        except json.JSONDecodeError as exc:
+            raise ModelLoginError("Claude Keychain entry is not valid JSON") from exc
+    else:
+        raise ModelLoginError(
+            "no Claude Code credentials at ~/.claude/.credentials.json — "
+            "run `claude` and log in with your subscription first"
+        )
+    if not isinstance(data, dict):
+        raise ModelLoginError("Claude credentials file is not a JSON object")
+    return data
+
+
+def validate_claude_creds(data: dict) -> None:
+    oauth = data.get("claudeAiOauth")
+    if not (isinstance(oauth, dict) and oauth.get("accessToken")):
+        raise ModelLoginError("Claude credentials missing claudeAiOauth.accessToken")
+
+
+def claude_creds_summary(data: dict) -> dict:
+    oauth = data.get("claudeAiOauth") or {}
+    summary: dict = {
+        "provider": "claude (Claude Code)",
+        "subscription": oauth.get("subscriptionType"),
+        "scopes": oauth.get("scopes"),
+        "has_refresh_token": bool(oauth.get("refreshToken")),
+    }
+    exp = oauth.get("expiresAt")
+    if isinstance(exp, (int, float)):
+        summary["access_token_expires"] = _iso(int(exp / 1000))  # Claude stores epoch milliseconds
+    return {k: v for k, v in summary.items() if v is not None}
+
+
+def build_claude_injection_command(*, creds_json: str) -> str:
+    """A single POSIX-sh command that writes Claude Code creds into ``$HOME/.claude``, 0600."""
+    return "\n".join(
+        [
+            "set -e",
+            'CD="$HOME/.claude"',
+            'mkdir -p "$CD"',
+            "umask 077",
+            f"printf %s '{b64(creds_json)}' | base64 -d > \"$CD/.credentials.json\"",
+            'chmod 600 "$CD/.credentials.json"',
+            f'echo "{CLAUDE_INJECT_MARKER} $CD"',
+        ]
+    )

agentkit/client/base_service_client.py

@@ -18,9 +18,12 @@ This is the top-level base class for all service clients.
 """
 
 import json
+import os
 from typing import Any, Dict, Type, TypeVar, Union, Optional
 from dataclasses import dataclass
 
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
 from volcengine.ApiInfo import ApiInfo
 from volcengine.base.Service import Service
 from volcengine.Credentials import Credentials as VolcCredentials
@@ -174,6 +177,41 @@ class BaseServiceClient(Service):
         if self.session_token:
             self.set_session_token(self.session_token)
 
+        self._install_retry_adapter()
+
+    def _install_retry_adapter(self) -> None:
+        """Retry transient overload responses (429/503) and connection failures
+        with exponential backoff on the shared ``Service`` session.
+
+        Scoped to cases that mean the request was not processed, so
+        non-idempotent ``Create*`` actions are never double-executed: read
+        timeouts are not retried (``read=0``) and only 429/503 are status-
+        retried. Honors ``Retry-After``. Disabled with AGENTKIT_HTTP_RETRIES=0.
+        """
+        try:
+            retries = max(0, int(os.getenv("AGENTKIT_HTTP_RETRIES", "2")))
+        except ValueError:
+            retries = 2
+        if retries <= 0:
+            return
+        session = getattr(self, "session", None)
+        if session is None:
+            return
+        retry = Retry(
+            total=retries,
+            connect=retries,
+            read=0,
+            status=retries,
+            status_forcelist=(429, 503),
+            allowed_methods=None,  # OpenAPI calls are POST; gate by status only
+            backoff_factor=0.5,
+            respect_retry_after_header=True,
+            raise_on_status=False,
+        )
+        adapter = HTTPAdapter(max_retries=retry)
+        session.mount("https://", adapter)
+        session.mount("http://", adapter)
+
     def _should_auto_refresh_vefaas_credentials(self) -> bool:
         if self._explicit_credentials:
             return False

agentkit/toolkit/cli/cli_add.py

@@ -26,6 +26,7 @@ auth block), serialized as a layered JSON document::
       "tools": ["web_search"],
       "skills": [],
       "system_prompt": "You are a helpful assistant.",
+      "description": "A helpful assistant.",
       "runtime": "adk",
       "knowledgebase": {"type": "viking", "project": "...", "region": "..."},
       "long_term_memory": {"type": ""},
@@ -42,7 +43,7 @@ import os
 import re
 from pathlib import Path
 from typing import Any, Optional
-from urllib.parse import parse_qs, urlparse
+from urllib.parse import parse_qs, urlparse, urlunparse
 
 import typer
 from rich.console import Console
@@ -74,6 +75,10 @@ _REGISTRY_QUERY_KEYS = {
 _REGISTRY_INT_KEYS = {"top_k"}
 _REGISTER_NETWORK_TYPES = {"public", "private"}
 _REGISTER_DEFAULT_VERSION = "2025-10-30"
+_DEFAULT_A2A_REGISTRY_URI = (
+    "agentkit://a2a-registry?"
+    "space_name=Default&region=cn-beijing&endpoint=https://open.volcengineapi.com/"
+)
 
 
 class _A2ARegisterError(Exception):
@@ -96,6 +101,17 @@ def _is_blank(value: object) -> bool:
     return value is None or value == "" or value == [] or value == {}
 
 
+def _derive_agent_name(harness_name: str) -> str:
+    """ADK agent name derived from a harness name.
+
+    Must mirror veadk's ``harness_app/utils.py::agent_name_from_harness``.
+    """
+    name = re.sub(r"[^0-9A-Za-z_]", "_", harness_name or "")
+    if not name or name[0].isdigit():
+        name = f"_{name}"
+    return f"{name}_" if name == "user" else name
+
+
 def _prune(data: dict) -> None:
     """Drop unset fields so the file holds only what is configured.
 
@@ -142,9 +158,16 @@ def _parse_registry_int(key: str, value: object) -> object:
         raise ValueError(f"Registry param `{key}` must be an integer, got {value!r}.") from exc
 
 
+def _expand_default_registry_uri(value: str) -> str:
+    raw = value.strip()
+    if raw.lower() == "default":
+        return _DEFAULT_A2A_REGISTRY_URI
+    return raw
+
+
 def _parse_registry_uri(value: str) -> dict:
     """Parse the supported AgentKit A2A registry URI into a spec section."""
-    raw = value.strip()
+    raw = _expand_default_registry_uri(value)
     if raw.lower() == "disabled":
         return {"type": ""}
 
@@ -157,7 +180,7 @@ def _parse_registry_uri(value: str) -> dict:
         raise ValueError(
             "Unsupported registry URI. Currently only "
             "`agentkit://a2a-registry?space_id=xxx&top_k=3` or "
-            "`disabled` is supported."
+            "`default` / `disabled` is supported."
         )
 
     query = {
@@ -211,8 +234,13 @@ def _apply_registry_config(
         section = {}
 
     if registry is not None:
-        section.update(_parse_registry_uri(registry))
+        parsed_registry = _parse_registry_uri(registry)
+        if parsed_registry.get("space_name") and "space_id" not in parsed_registry:
+            section.pop("space_id", None)
+        section.update(parsed_registry)
 
+    if registry_space_name is not None:
+        section.pop("space_id", None)
     _set_registry_value(section, "space_id", registry_space_id)
     _set_registry_value(section, "space_name", registry_space_name)
     _set_registry_value(section, "top_k", registry_top_k)
@@ -253,6 +281,16 @@ def _apply_registry_config(
         )
 
     data["registry"] = section
+    if section.get("type") == "agentkit_a2a":
+        resolved_endpoint, resolved_region = _resolve_agentkit_openapi_target(
+            endpoint=str(section["endpoint"]) if section.get("endpoint") else None,
+            region=str(section["region"]) if section.get("region") else None,
+        )
+        _enable_a2a_space_intent(
+            str(section["space_id"]),
+            endpoint=resolved_endpoint,
+            region=resolved_region,
+        )
 
 
 def _load_spec(path: Path) -> dict:
@@ -294,6 +332,30 @@ def _default_agentkit_endpoint(region: str) -> str:
     return f"https://agentkit.{region}.volcengineapi.com/"
 
 
+def _resolve_agentkit_openapi_target(
+    *,
+    endpoint: Optional[str],
+    region: Optional[str],
+) -> tuple[str, str]:
+    resolved_region = (
+        region
+        or os.getenv("AGENTKIT_REGION")
+        or os.getenv("VOLCENGINE_REGION")
+        or "cn-beijing"
+    )
+    resolved_endpoint = endpoint or _default_agentkit_endpoint(str(resolved_region))
+    parsed = urlparse(resolved_endpoint)
+    if (
+        parsed.scheme
+        and parsed.netloc
+        and (parsed.query or parsed.params or parsed.fragment)
+    ):
+        resolved_endpoint = urlunparse(
+            (parsed.scheme, parsed.netloc, parsed.path or "/", "", "", "")
+        )
+    return resolved_endpoint, str(resolved_region)
+
+
 def _request_id(response: dict[str, Any]) -> str | None:
     return (response.get("ResponseMetadata") or {}).get("RequestId")
 
@@ -374,6 +436,25 @@ def _agentkit_post(
     return data, duration_ms
 
 
+def _enable_a2a_space_intent(
+    space_id: str,
+    *,
+    endpoint: str,
+    region: str,
+) -> dict[str, Any]:
+    response, request_duration_ms = _agentkit_post(
+        endpoint=endpoint,
+        version=_REGISTER_DEFAULT_VERSION,
+        region=region,
+        action="UpdateA2aSpace",
+        body={"Id": space_id, "IntentEnabled": True},
+    )
+    return {
+        "request_id": _request_id(response),
+        "request_duration_ms": request_duration_ms,
+    }
+
+
 def _resolve_a2a_space_id_by_name(
     space_name: str,
     *,
@@ -587,6 +668,12 @@ def harness_command(
     system_prompt: Optional[str] = typer.Option(
         None, "--system-prompt", help="Agent system prompt / instruction."
     ),
+    description: Optional[str] = typer.Option(
+        None,
+        "--description",
+        "--desc",
+        help="Agent description (used at agent init, e.g. for A2A discovery).",
+    ),
     model_name: Optional[str] = typer.Option(
         None, "--model-name", help="Reasoning model name."
     ),
@@ -612,7 +699,10 @@ def harness_command(
     registry: Optional[str] = typer.Option(
         None,
         "--registry",
-        help='AgentKit A2A registry URI, e.g. "agentkit://a2a-registry?space_id=xxx&top_k=3".',
+        help=(
+            'AgentKit A2A registry URI, "default", or "disabled", e.g. '
+            '"agentkit://a2a-registry?space_id=xxx&top_k=3".'
+        ),
     ),
     registry_space_id: Optional[str] = typer.Option(
         None, "--registry-space-id", help="AgentKit A2A SpaceId."
@@ -790,6 +880,13 @@ def harness_command(
         )
         raise typer.Exit(1)
 
+    agent_name = _derive_agent_name(name)
+    if agent_name != name:
+        console.print(
+            f"[yellow]ℹ Once deployed, the agent will be named "
+            f"'{agent_name}' instead of '{name}'.[/yellow]"
+        )
+
     _validate_choice("--runtime", runtime, _RUNTIMES)
     _validate_choice("--knowledgebase-type", knowledgebase_type, _KNOWLEDGEBASE_TYPES)
     _validate_choice(
@@ -820,6 +917,8 @@ def harness_command(
         data["model"]["name"] = model_name
     if system_prompt is not None:
         data["system_prompt"] = system_prompt
+    if description is not None:
+        data["description"] = description
     if runtime is not None:
         data["runtime"] = runtime
     if structured_tool_calls is not None:
@@ -904,7 +1003,9 @@ def harness_command(
             registry_region,
         )
     except _A2ARegisterError as exc:
-        console.print(f"[red]Error: failed to resolve A2A space name: {exc.message}[/red]")
+        console.print(
+            f"[red]Error: failed to configure A2A registry: {exc.message}[/red]"
+        )
         if exc.diagnostics:
             console.print(json.dumps(exc.diagnostics, ensure_ascii=False, indent=2))
         raise typer.Exit(1) from exc

agentkit/toolkit/cli/cli_invoke.py

@@ -662,6 +662,7 @@ def _parse_harness_registry_override(value: Optional[str]) -> dict[str, Any]:
     """Parse ``--registry`` into one-time harness registry overrides.
 
     Supported forms:
+    - default (Default space in cn-beijing via https://open.volcengineapi.com/)
     - agentkit://a2a-registry?space_id=xxx&top_k=3&region=cn-beijing
     - https://... (treated as registry_endpoint; recognized query params are
       also extracted when present)
@@ -673,6 +674,9 @@ def _parse_harness_registry_override(value: Optional[str]) -> dict[str, Any]:
     if not raw:
         return {}
 
+    from agentkit.toolkit.cli.cli_add import _expand_default_registry_uri
+
+    raw = _expand_default_registry_uri(raw)
     parsed = urlparse(raw)
     overrides: dict[str, Any] = {}
 
@@ -686,14 +690,16 @@ def _parse_harness_registry_override(value: Optional[str]) -> dict[str, Any]:
         if parsed.netloc != "a2a-registry" or parsed.path not in {"", "/"}:
             raise ValueError(
                 "Unsupported registry URI. Use "
-                '`agentkit://a2a-registry?space_id=xxx&top_k=3` or an http(s) URL.'
+                '`default`, `agentkit://a2a-registry?space_id=xxx&top_k=3`, '
+                "or an http(s) URL."
             )
     elif parsed.scheme in {"http", "https"}:
         overrides["registry_endpoint"] = raw
     else:
         raise ValueError(
             "Unsupported registry value. Use "
-            '`agentkit://a2a-registry?space_id=xxx&top_k=3` or an http(s) URL.'
+            '`default`, `agentkit://a2a-registry?space_id=xxx&top_k=3`, '
+            "or an http(s) URL."
         )
 
     unknown = sorted(set(query) - set(_INVOKE_REGISTRY_QUERY_ALIASES))
@@ -786,6 +792,23 @@ def _merge_harness_registry_overrides(
     return overrides
 
 
+def _enable_harness_registry_intent(overrides: dict[str, Any]) -> None:
+    space_id = overrides.get("registry_space_id")
+    if not space_id:
+        return
+
+    from agentkit.toolkit.cli.cli_add import (
+        _enable_a2a_space_intent,
+        _resolve_agentkit_openapi_target,
+    )
+
+    endpoint, region = _resolve_agentkit_openapi_target(
+        endpoint=overrides.get("registry_endpoint"),
+        region=overrides.get("registry_region"),
+    )
+    _enable_a2a_space_intent(str(space_id), endpoint=endpoint, region=region)
+
+
 # Fixed ADK app name for the run_sse path. The harness loader serves its single
 # agent under any app name, so a stable constant keeps the CLI decoupled from the
 # deployed HARNESS_NAME.
@@ -998,7 +1021,8 @@ def harness_command(
         "--registry",
         help=(
             "Override A2A registry for this invocation. Accepts "
-            "`agentkit://a2a-registry?space_id=xxx&top_k=3` or an http(s) URL."
+            "`default`, `agentkit://a2a-registry?space_id=xxx&top_k=3`, "
+            "or an http(s) URL."
         ),
     ),
     registry_top_k: int = typer.Option(
@@ -1066,8 +1090,9 @@ def harness_command(
             registry_endpoint=registry_endpoint,
             registry_region=registry_region,
         )
+        _enable_harness_registry_intent(registry_overrides)
     except _A2ARegisterError as e:
-        console.print(f"[red]Error: failed to resolve A2A space name: {e}[/red]")
+        console.print(f"[red]Error: failed to configure A2A registry: {e}[/red]")
         raise typer.Exit(1)
     except ValueError as e:
         console.print(f"[red]Error: {e}[/red]")

agentkit/toolkit/cli/sandbox/cli.py

@@ -22,6 +22,7 @@ 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_model_login import codex_login_command
 from agentkit.toolkit.cli.sandbox.cli_mount import mount_command
 from agentkit.toolkit.cli.sandbox.cli_run import run_command
 from agentkit.toolkit.cli.sandbox.cli_shell import shell_command
@@ -46,4 +47,6 @@ sandbox_app.command(
     context_settings={"allow_extra_args": True},
 )(shell_command)
 sandbox_app.command(name="web")(web_command)
+sandbox_app.command(name="codex-login")(codex_login_command)
+sandbox_app.command(name="model-login")(codex_login_command)  # provider-agnostic alias
 sandbox_app.add_typer(file_command, name="file")

agentkit/toolkit/cli/sandbox/cli_model_login.py

@@ -0,0 +1,238 @@
+# 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.
+
+"""`agentkit sandbox codex-login` — bring your own model subscription into a sandbox.
+
+Codex/ChatGPT and Claude Code are used via a JWT obtained by an interactive SSO login, not a
+static API key. Codex supports that SSO **locally**; in the sandbox it is remote. So instead of
+federating the platform UserPool with OpenAI/Anthropic, this command:
+
+  1. reads the provider's native credential the local SSO already produced
+     (``$CODEX_HOME/auth.json`` for Codex, ``~/.claude/.credentials.json`` for Claude Code), and
+  2. injects it into the **same native path inside the sandbox session**, so the sandbox's codex
+     finds its token exactly where it natively looks.
+
+The sandbox refreshes the token itself against the provider, just like a local install would. The
+heavy lifting (resolve / validate / redact / config rewrite / build the injection command) lives in
+``agentkit.auth.model_login``; this file is only the sandbox-session transport + CLI surface.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Optional
+
+import typer
+
+from agentkit.toolkit.cli.sandbox.cli_file import _exec_shell_command
+from agentkit.toolkit.cli.sandbox.session_create import (
+    SANDBOX_TOOL_ID_ENV,
+    ensure_sandbox_session,
+)
+from agentkit.toolkit.cli.sandbox.tool_resolve import SandboxToolType
+from agentkit.toolkit.cli.sandbox.sandbox_client import error
+
+
+def _shell_output(payload: dict) -> str:
+    data = payload.get("data")
+    if isinstance(data, dict):
+        out = data.get("output")
+        if isinstance(out, str):
+            return out
+    return ""
+
+
+def _redact_inject(cmd: str) -> str:
+    """Redact the base64 token blob in an injection command (for --dry-run display)."""
+    return re.sub(
+        r"printf %s '([A-Za-z0-9+/=]+)'",
+        lambda m: f"printf %s '<base64 {len(m.group(1))} bytes — redacted>'",
+        cmd,
+    )
+
+
+def codex_login_command(
+    session_id: Optional[str] = typer.Option(
+        None,
+        "--session-id",
+        "--sid",
+        "-s",
+        help=(
+            "Sandbox session to inject into. Defaults to a new session; reuse the printed id "
+            "with `agentkit sandbox exec --sid <id>`."
+        ),
+    ),
+    provider: str = typer.Option(
+        "codex",
+        "--provider",
+        "-p",
+        help="Subscription to bring in: codex (ChatGPT) or claude (Claude Code).",
+    ),
+    auth_file: Optional[str] = typer.Option(
+        None,
+        "--auth-file",
+        help=(
+            "Use a specific local credential file (codex auth.json / claude .credentials.json) "
+            "instead of running the local SSO."
+        ),
+    ),
+    codex_home: Optional[str] = typer.Option(
+        None,
+        "--codex-home",
+        help="Local codex home (default $CODEX_HOME or ~/.codex).",
+    ),
+    login: bool = typer.Option(
+        True,
+        "--login/--no-login",
+        help="If no local credential exists, trigger `codex login` (browser SSO) once.",
+    ),
+    keep_model_config: bool = typer.Option(
+        False,
+        "--keep-model-config",
+        help="Only inject the token; do not switch the sandbox codex config to subscription auth.",
+    ),
+    tool_id: Optional[str] = typer.Option(
+        None,
+        "--tool-id",
+        help=f"Sandbox tool ID. Defaults to {SANDBOX_TOOL_ID_ENV}.",
+    ),
+    tool_type: SandboxToolType = typer.Option(
+        SandboxToolType.CODE_ENV,
+        "--tool-type",
+        help="Sandbox tool type to resolve when --tool-id is omitted.",
+    ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="Resolve the local credential and print what would be injected (token redacted); no session.",
+    ),
+) -> None:
+    """Inject your own ChatGPT/Codex or Claude Code subscription token into a sandbox session.
+
+    Run the provider's local SSO once (codex supports it locally), then this injects the native
+    token into the sandbox's native location so the sandbox codex runs on your subscription.
+    """
+    from agentkit.auth import model_login as ml
+
+    provider = (provider or "codex").lower()
+    if provider not in ml.PROVIDERS:
+        error(f"unknown provider: {provider} (supported: {', '.join(ml.PROVIDERS)})")
+
+    # 1) resolve the LOCAL native credential (runs the provider's local SSO if needed)
+    try:
+        if provider == "codex":
+            src, data = ml.resolve_local_codex_auth(
+                codex_home=codex_home, auth_file=auth_file, allow_login=login
+            )
+            summary = ml.codex_auth_summary(data)
+        else:  # claude
+            data = ml.read_claude_creds(creds_file=auth_file)
+            ml.validate_claude_creds(data)
+            src = ml.claude_creds_path(auth_file)
+            summary = ml.claude_creds_summary(data)
+    except ml.ModelLoginError as exc:
+        error(str(exc))
+
+    typer.secho(f"\nLocal credential: {src}", fg=typer.colors.CYAN, err=True)
+    typer.echo(json.dumps(summary, indent=2, ensure_ascii=False))
+    if summary.get("id_token_expired") and not summary.get("has_refresh_token"):
+        typer.secho(
+            "  warning: token expired and has no refresh_token — re-run `codex login` locally first.",
+            fg=typer.colors.YELLOW,
+            err=True,
+        )
+
+    payload = json.dumps(data, ensure_ascii=False)
+
+    # 2) build the injection (codex also switches its config to subscription auth unless --keep-model-config)
+    if provider == "codex":
+        if dry_run:
+            typer.secho("\n— dry-run: read current sandbox codex config (read-only) —", fg=typer.colors.CYAN, err=True)
+            typer.secho(f"  $ {ml.read_codex_config_command()}", err=True)
+            cmd = ml.build_codex_injection_command(
+                auth_json=payload,
+                config_toml=None if keep_model_config else ml.minimal_chatgpt_codex_config(),
+            )
+            typer.secho("\n— dry-run: would inject (token redacted) —", fg=typer.colors.CYAN, err=True)
+            typer.secho(_redact_inject(cmd), err=True)
+            raise typer.Exit(0)
+        marker = ml.CODEX_INJECT_MARKER
+    else:  # claude
+        cmd = ml.build_claude_injection_command(creds_json=payload)
+        marker = ml.CLAUDE_INJECT_MARKER
+        if dry_run:
+            typer.secho("\n— dry-run: would inject (token redacted) —", fg=typer.colors.CYAN, err=True)
+            typer.secho(_redact_inject(cmd), err=True)
+            raise typer.Exit(0)
+
+    # 3) ensure the sandbox session, then inject over its shell-exec endpoint
+    try:
+        session = ensure_sandbox_session(
+            session_id=session_id,
+            tool_id=tool_id,
+            tool_type=tool_type.value,
+        )
+    except typer.Exit:
+        raise
+    except Exception as exc:  # noqa: BLE001
+        error(str(exc))
+
+    sid = session.get("session_id")
+    if not isinstance(sid, str) or not sid:
+        error("sandbox session missing session_id")
+
+    if provider == "codex":
+        new_cfg = None
+        if not keep_model_config:
+            cur = _shell_output(
+                _exec_shell_command(session, ml.read_codex_config_command(), quiet_errors=True)
+            )
+            new_cfg = (
+                ml.rewrite_codex_config_for_chatgpt(cur)
+                if cur.strip()
+                else ml.minimal_chatgpt_codex_config()
+            )
+        cmd = ml.build_codex_injection_command(auth_json=payload, config_toml=new_cfg)
+
+    out = _shell_output(_exec_shell_command(session, cmd))
+    if marker not in out:
+        error(f"injection did not confirm (marker missing). sandbox output: {out[:200]}")
+    where = out.split(marker, 1)[1].strip() or "<sandbox>"
+
+    typer.secho(
+        f"\n✓ injected your {summary.get('provider', provider)} subscription into {where}",
+        fg=typer.colors.GREEN,
+        bold=True,
+        err=True,
+    )
+    typer.secho(f"  session: {sid}", fg=typer.colors.CYAN, err=True)
+    if provider == "codex":
+        typer.secho(
+            f'  next:  agentkit sandbox exec --sid {sid} --command "codex"   # codex runs on your subscription',
+            fg=typer.colors.CYAN,
+            err=True,
+        )
+        if not keep_model_config:
+            typer.secho(
+                "  (switched the sandbox codex config to ChatGPT subscription auth; keep it with --keep-model-config)",
+                fg=typer.colors.BRIGHT_BLACK,
+                err=True,
+            )
+    typer.secho(
+        "  note: the token is refreshed by codex/claude inside the sandbox; re-inject if the session is recreated.",
+        fg=typer.colors.BRIGHT_BLACK,
+        err=True,
+    )
+    typer.echo(json.dumps({"injected": True, "provider": provider, "session_id": sid, "path": where}, ensure_ascii=False))

agentkit/toolkit/runners/ve_agentkit.py

@@ -585,8 +585,11 @@ class VeAgentkitRuntimeRunner(Runner):
                     f"Generated role name: {config.runtime_role_name}"
                 )
 
-            # Generate API key name if not provided
-            if (
+            # Generate API key name if not provided. Skipped for custom_jwt: the
+            # gateway authorizes via JWT and never uses an API key (see
+            # _build_authorizer_config_for_create), so generating one here only
+            # produced a misleading "Generated API key name" line.
+            if config.runtime_auth_type != AUTH_TYPE_CUSTOM_JWT and (
                 config.runtime_apikey_name == AUTO_CREATE_VE
                 or not config.runtime_apikey_name
             ):

agentkit/utils/ve_sign.py

@@ -31,6 +31,7 @@ import hashlib
 import hmac
 import os
 import platform
+import time
 import requests
 from urllib.parse import quote
 
@@ -46,6 +47,79 @@ Scheme = "https"
 MAX_X_CUSTOM_SOURCE_LENGTH = 256
 
 
+# Transient-failure handling for signed OpenAPI calls. Historically this used a
+# single timeout-less ``requests.request`` — a stalled connection could hang
+# forever, and a transient overload (429/503) or connection error failed the
+# call outright with no retry. Both are now bounded and conservatively retried.
+# Tunable via env; AGENTKIT_HTTP_RETRIES=0 disables retries.
+_RETRYABLE_STATUS = frozenset({429, 503})
+
+
+def _http_timeout() -> float:
+    try:
+        return max(1.0, float(os.getenv("AGENTKIT_HTTP_TIMEOUT", "30")))
+    except ValueError:
+        return 30.0
+
+
+def _http_retries() -> int:
+    try:
+        return max(0, int(os.getenv("AGENTKIT_HTTP_RETRIES", "2")))
+    except ValueError:
+        return 2
+
+
+def _backoff_seconds(attempt: int) -> float:
+    return min(8.0, 0.5 * (2**attempt))
+
+
+def _retry_after_seconds(resp: requests.Response) -> float | None:
+    raw = resp.headers.get("Retry-After")
+    if not raw:
+        return None
+    try:
+        return max(0.0, float(raw))
+    except ValueError:
+        return None
+
+
+def _signed_request(method, url, headers, params, data) -> requests.Response:
+    """Issue a signed HTTP request with a bounded timeout and conservative
+    transient-retry.
+
+    Only retries failures that almost certainly mean the request was not
+    processed — connection errors (incl. connect timeouts) and HTTP 429/503 —
+    so non-idempotent ``Create*`` actions are never double-executed. Read
+    timeouts and other 5xx are surfaced, not retried. Honors ``Retry-After``.
+    """
+    retries = _http_retries()
+    timeout = _http_timeout()
+    resp: requests.Response | None = None
+    for attempt in range(retries + 1):
+        try:
+            resp = requests.request(
+                method=method,
+                url=url,
+                headers=headers,
+                params=params,
+                data=data,
+                timeout=timeout,
+            )
+        except requests.ConnectionError:
+            # Not delivered (connection failed/reset before completion), so a
+            # retry cannot double-execute the request.
+            if attempt < retries:
+                time.sleep(_backoff_seconds(attempt))
+                continue
+            raise
+        if resp.status_code in _RETRYABLE_STATUS and attempt < retries:
+            time.sleep(_retry_after_seconds(resp) or _backoff_seconds(attempt))
+            continue
+        return resp
+    assert resp is not None  # loop always returns or raises before here
+    return resp
+
+
 def _get_os_tag() -> str:
     system = platform.system().lower()
     if "linux" in system:
@@ -221,7 +295,7 @@ def request(method, date, query, header, ak, sk, action, body):
     header = {**header, **sign_result}
     # header = {**header, **{"X-Security-Token": SessionToken}}
     # 第六步：将 Signature 签名写入 HTTP Header 中，并发送 HTTP 请求。
-    r = requests.request(
+    r = _signed_request(
         method=method,
         url=f"{Scheme}://{request_param['host']}{request_param['path']}",
         headers=header,

agentkit/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-VERSION = "0.6.5"
+VERSION = "0.7.1"

{agentkit_sdk_python-0.6.5.dist-info → agentkit_sdk_python-0.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentkit-sdk-python
-Version: 0.6.5
+Version: 0.7.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.6.5.dist-info → agentkit_sdk_python-0.7.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 agentkit/__init__.py,sha256=l27ZMDslc3VhmmnPZJyrqVvTDoZ0LqhCtM5hw0caHcU,1021
-agentkit/version.py,sha256=-8u8ma3ZjT78npvdx0yb_H-M501lF15MhCY0uJyY6CU,653
+agentkit/version.py,sha256=x8YYWLWsVZRn9Iz6baPWEWckXHw3be6Y347X-_UiPLU,653
 agentkit/apps/__init__.py,sha256=-oXTjxV3gejpJ8pffTUcUAXw0LfxKCYZJk-_hIJhtLM,1921
 agentkit/apps/base_app.py,sha256=3hZZExL1wyTGWveJEZZoqXN086MzmkVS_WU1vyulIWg,754
 agentkit/apps/utils.py,sha256=IzimIDmT6FS6PV9MLimPh46mq5zT-EjVmnYPxBdyEq0,1934
@@ -25,6 +25,7 @@ agentkit/auth/_sigv4.py,sha256=yAbFD57g3cBvCkGTVJap0BCakQeukyR_FlzMDYZdTkw,3375
 agentkit/auth/admin.py,sha256=U9rvVFx1rD5dsSrL0eQVPezBVI9vhaSrdc6QkM7jVKY,23393
 agentkit/auth/credential_hosting.py,sha256=lFFYseYHkqCUsv1djtK3EFR1XvESmw6l1Zgu1CcwIa8,24280
 agentkit/auth/errors.py,sha256=ZD5y1bxt_5oYs31dy3G1xRDHQSFVqxVaAxXdohg4948,1401
+agentkit/auth/model_login.py,sha256=mdESwhfB5KotRaDuBf3ihcJckOMERDwDda1SySFUxsI,15387
 agentkit/auth/oauth.py,sha256=vbFRJpmlQXxcKRjHk2LIDLs1I3hsVrWTvLRnDA8XNN4,8812
 agentkit/auth/profile.py,sha256=gJpPj1ivpjRdH3MnjB2ICN4fYVaQlkt9DreJqkOze0Y,5656
 agentkit/auth/providers.py,sha256=zcOjEryJvuUctnRl3_Uae6HdZ8hGc0NVX4Lp3Y_2W68,3041
@@ -37,7 +38,7 @@ agentkit/auth/sts.py,sha256=mHcC4XJg9kwcX-Qt3_Ez88QnAOHkV7b_XRIIs3XznSM,5277
 agentkit/client/__init__.py,sha256=WHKgNGkpYsJp0xD20drYcxAMDclwDqrfURqxEVv0V1Y,1053
 agentkit/client/base_agentkit_client.py,sha256=OELc-y1aT-G2scAsS7p8gO4L4y9lA1ZqfDTLMt2Ajvc,2688
 agentkit/client/base_iam_client.py,sha256=F3ggcZjt14CAcgDYpncF2XGr1zTGnhaOzqEJl4NGHwU,2432
-agentkit/client/base_service_client.py,sha256=5PDivEpamjCkNDWZmkswqGEd7u1FjbFpLwPMeLXOy7k,11816
+agentkit/client/base_service_client.py,sha256=lUb2aDFp9E-mCmCjOlCGkA0D_ziBuciiv-QEmKgK2-o,13234
 agentkit/platform/__init__.py,sha256=XD1YoXWJPpLGrP410Tb_psPFKR3LUo3-47UlqayUumo,3464
 agentkit/platform/configuration.py,sha256=LbnEaZT17FNuxa1yQWpG7ol3_D--EUj-AFgGddrmkzs,23347
 agentkit/platform/console_urls.py,sha256=JcnjwyuxN5c4RuXcPevsxy6aInurVFtchqbibJBqjSk,1125
@@ -81,7 +82,7 @@ agentkit/toolkit/builders/ve_pipeline.py,sha256=n2ZbjqkSBKv5oOsqD-E0SpC5NeP2Impr
 agentkit/toolkit/cli/__init__.py,sha256=pkSabKw7_ai4NOo56pXKL40EcaxIDh6HYxPXOY7qWbo,634
 agentkit/toolkit/cli/__main__.py,sha256=arwJ1gHkaaoQAXb0ezo_FeyxiMqVy0FXujB2WOX_ohU,775
 agentkit/toolkit/cli/cli.py,sha256=PFe6axB5f2Ox10azlf2Ditb1rXeVVMI5BbX46Cnu33k,4769
-agentkit/toolkit/cli/cli_add.py,sha256=1yP5zyErRJa4RfYKcI-OaPlyIaLHg62nHk87aEaKzPY,36505
+agentkit/toolkit/cli/cli_add.py,sha256=aLyvN9Vcjis_KLhy92uuPi7e8ltFdHjwFOb-nME7CV0,39730
 agentkit/toolkit/cli/cli_auth.py,sha256=eislIHxafJovjDSQai8zfO4zcd502-U5oJYelnPFKgQ,26445
 agentkit/toolkit/cli/cli_build.py,sha256=gtRBPJfm6Z4y37ISC_CiGwEkMhD4fD7IQi1H6Lzc2Yo,2984
 agentkit/toolkit/cli/cli_config.py,sha256=cb-QGXNvm8kQiaii4vjfCwt6Y9oukiZFSgHp1Y8Ovuk,29096
@@ -89,7 +90,7 @@ agentkit/toolkit/cli/cli_delete.py,sha256=Q6utRf5ak1fHF_Bm73weWgiiQA3Oz3iWzl5ij5
 agentkit/toolkit/cli/cli_deploy.py,sha256=B912gRSpgLFBCLF8w8lD1J_jP5-PvpT_Zjblx-0yees,7066
 agentkit/toolkit/cli/cli_destroy.py,sha256=QpH7cctsaIFd2io6hhEeKnCjxK7DbE7AnFsecWL5BxY,1797
 agentkit/toolkit/cli/cli_init.py,sha256=feuypfgggXj6_0ZP4TEQ3rIZOuYRVUxXwvpdq9nsOY0,17911
-agentkit/toolkit/cli/cli_invoke.py,sha256=6fvL0yprSHHfj04vD2uA6AS27ouvpD33QIjgREZz01k,45204
+agentkit/toolkit/cli/cli_invoke.py,sha256=sLaCXXoOeTPzECZFtNCV8EIlIQPQZsaih2s5rocz2h8,46082
 agentkit/toolkit/cli/cli_knowledge.py,sha256=J3pcJs01tWJAMp79nFnX5pU6AEZK7XVCZtyPRLKkfUI,25142
 agentkit/toolkit/cli/cli_launch.py,sha256=vkhjTBcxteVGwxtkDXKQxDjqTsFyDPx0SZcKL-zkPMg,3774
 agentkit/toolkit/cli/cli_list.py,sha256=KBqSRMaiO6Frej_ZvTV4_ODWgMVdHzJtsl63K43Y3hY,14256
@@ -106,11 +107,12 @@ agentkit/toolkit/cli/console_reporter.py,sha256=ta9GFUDkPEFfGeANDsza5bZdVXidqhHI
 agentkit/toolkit/cli/interactive_config.py,sha256=y5g5aNMJuX2tHUuu2pvacOssx3O3oqs0u_g0ZinyP1c,46133
 agentkit/toolkit/cli/utils.py,sha256=THEzN0Nln0sA3luIc9seP_oczBMDsHJAV6nlBhsWroI,8693
 agentkit/toolkit/cli/sandbox/__init__.py,sha256=8xnyvQUEVlMNQjoFf6drRqGL03Kdw8tVHEq2aMaUK2Y,1351
-agentkit/toolkit/cli/sandbox/cli.py,sha256=73obe5G-LOa1b7p5lwMgIy19pta7FZSS9m_fTDmb-tY,1863
+agentkit/toolkit/cli/sandbox/cli.py,sha256=UukUNxsDmyQ66QQjM-a8W0l6BuVqgb1bbesEU3P3RD4,2089
 agentkit/toolkit/cli/sandbox/cli_create.py,sha256=_3yPBnfJ9igDbQAkeag7oksWEw2Hz-s0GftzKD6jSKc,14403
 agentkit/toolkit/cli/sandbox/cli_exec.py,sha256=m70Po9ybYL_ZAskpceNamQgtg3QvlNoAjyQPqHOdbb0,17479
 agentkit/toolkit/cli/sandbox/cli_file.py,sha256=AXNV0qPlWY_GS6InKkVTQ9cMSSkdiOIxC2dfAHED-Fk,28715
 agentkit/toolkit/cli/sandbox/cli_get.py,sha256=sbdCXIzR6L3vUHZvwaC19GWbOJQixR37zDONIRdNhzo,3218
+agentkit/toolkit/cli/sandbox/cli_model_login.py,sha256=Y-pBu0onNdZ9lPP0rKQT6ZG3PEmeILzIl4-wbcbwtLA,9351
 agentkit/toolkit/cli/sandbox/cli_mount.py,sha256=ZKjEOifPvRHhqdMXlTMqc1ZtW0TSjdfJuJ0yzl6F0PY,11215
 agentkit/toolkit/cli/sandbox/cli_run.py,sha256=7TTRssT1CNGIC-8JRGtPazRJZDX_9WM-MhIgVR_sZ-g,11414
 agentkit/toolkit/cli/sandbox/cli_shell.py,sha256=PniGXNmw4PoZRiB0P29jryra_aFtpuCwJgv5vlxfFeU,4642
@@ -191,7 +193,7 @@ agentkit/toolkit/resources/wrappers/wrapper_stream.py.jinja2,sha256=V5KeODA426nN
 agentkit/toolkit/runners/__init__.py,sha256=c-PuCvGFpIQrYC_W9qp2ZztgTSH2AVgxSEgkXMqJKZM,1829
 agentkit/toolkit/runners/base.py,sha256=GosKJUUVa1V85y9bhoT8SZthp5sV7KEfvn9gzL1MkoQ,29426
 agentkit/toolkit/runners/local_docker.py,sha256=YQTFcxB_PxIx_7SXleODBBBRCY9GuAgpkYQLCm8M8KA,28825
-agentkit/toolkit/runners/ve_agentkit.py,sha256=xf9UXMLIHZ-hVo3GD6v2PnjBuCH0g07ZTMBaI3grHKk,55206
+agentkit/toolkit/runners/ve_agentkit.py,sha256=jIhb9ycgZMJxxxw9XKKyC5U2ZwTV-ArGsaJsQ4VHOWM,55507
 agentkit/toolkit/sdk/__init__.py,sha256=SK_ElW74IiT2WRhDIJhL0xhpAk4C8xHI7ZUCnGgW2hs,2735
 agentkit/toolkit/sdk/builder.py,sha256=tI-uawiJ_BYVH5FbDxVWJIXC-56rM4eUzX2o7M4pkMI,4225
 agentkit/toolkit/sdk/client.py,sha256=EbGhgcWgc50Z39AeXnvtip2r5fH_qx9YhM2CXOwlR_8,18136
@@ -227,10 +229,10 @@ agentkit/utils/logging_config.py,sha256=419kWZ1YWAoejdSRm71XOWjCZ9aghhelweL8bj2n
 agentkit/utils/misc.py,sha256=FXMlcupj3KzxfJvMYFp0uTQk3FRMx8FiEXkYiy-UQ8w,3437
 agentkit/utils/request.py,sha256=IVoat3EavR9rQ_fXi0eA2rZPCJ9lVZAXXn7uIIX6bY4,1614
 agentkit/utils/template_utils.py,sha256=Qjg9V6dEpjAd_yYezIIPwuDsDeeMmp6XTMn5ZECifNc,6336
-agentkit/utils/ve_sign.py,sha256=nrYiS2bYncvWKQVpVMzwYwPDfkA0OJS7LO9l_wfW0xc,9310
-agentkit_sdk_python-0.6.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-agentkit_sdk_python-0.6.5.dist-info/METADATA,sha256=-cvLyYEu2KfEUXw6UkEhVrbRr7_Ud-IiQYTurDxz3q4,19462
-agentkit_sdk_python-0.6.5.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-agentkit_sdk_python-0.6.5.dist-info/entry_points.txt,sha256=fhzZUsvsLXeB4mPaa0SBQiTBqFT404uDAKPaePAOUAE,58
-agentkit_sdk_python-0.6.5.dist-info/top_level.txt,sha256=ipy8JF-QQ-V0C1oRFLxsyaW8zwrasfJ-zjAh9vgOc7U,9
-agentkit_sdk_python-0.6.5.dist-info/RECORD,,
+agentkit/utils/ve_sign.py,sha256=Vk_ku0t2665CaR2iPndoNWudifVa0cYnpl4ZXqEojBY,11832
+agentkit_sdk_python-0.7.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+agentkit_sdk_python-0.7.1.dist-info/METADATA,sha256=1r6tYfTNDy2zpM5UC8ZJ3iI9NuZ6VwJ3-EXr9MkSg2I,19462
+agentkit_sdk_python-0.7.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+agentkit_sdk_python-0.7.1.dist-info/entry_points.txt,sha256=fhzZUsvsLXeB4mPaa0SBQiTBqFT404uDAKPaePAOUAE,58
+agentkit_sdk_python-0.7.1.dist-info/top_level.txt,sha256=ipy8JF-QQ-V0C1oRFLxsyaW8zwrasfJ-zjAh9vgOc7U,9
+agentkit_sdk_python-0.7.1.dist-info/RECORD,,