usegradient 1.3.1__tar.gz → 1.3.2__tar.gz

{usegradient-1.3.1 → usegradient-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: usegradient
-Version: 1.3.1
+Version: 1.3.2
 Summary: Python SDK for the Gradient agent runtime and observability platform
 Project-URL: Homepage, https://usegradient.dev
 Project-URL: Documentation, https://github.com/use-gradient/gradient/tree/main/sdk/python
@@ -98,7 +98,6 @@ if __name__ == "__main__":
         project=os.getenv("GRADIENT_PROJECT", "my-first-agent"),
         environment=Environment.python(
             python="3.12",
-            packages=["usegradient", "anthropic"],
             env={"ANTHROPIC_API_KEY": os.environ["ANTHROPIC_API_KEY"]},
         ),
     )

{usegradient-1.3.1 → usegradient-1.3.2}/README.md

@@ -71,7 +71,6 @@ if __name__ == "__main__":
         project=os.getenv("GRADIENT_PROJECT", "my-first-agent"),
         environment=Environment.python(
             python="3.12",
-            packages=["usegradient", "anthropic"],
             env={"ANTHROPIC_API_KEY": os.environ["ANTHROPIC_API_KEY"]},
         ),
     )

{usegradient-1.3.1 → usegradient-1.3.2}/examples/sdk_first_agent.py

@@ -34,7 +34,7 @@ if __name__ == "__main__":
         project=os.getenv("GRADIENT_PROJECT", "my-first-agent"),
         environment=Environment.python(
             python="3.12",
-            packages=["usegradient", "anthropic"],
+            # usegradient + anthropic are inferred from imports / Model.CLAUDE_*.
             env={"ANTHROPIC_API_KEY": os.environ["ANTHROPIC_API_KEY"]},
         ),
     )

{usegradient-1.3.1 → usegradient-1.3.2}/gradient_sdk/__init__.py

@@ -10,6 +10,7 @@ from .credentials import (
     save_credentials,
 )
 from .decorators import agent, chain, embedding, llm, retriever, task, tool, trace, trace_context, workflow
+from .dependencies import infer_python_packages
 from .errors import GradientAPIError, GradientAuthError, GradientError
 from .graph import END, START, StateGraph
 from .integrations import generate, run_agent_loop, wrap_anthropic, wrap_openai
@@ -103,6 +104,7 @@ __all__ = [
     "generate",
     "get_tracer",
     "infer_parameters",
+    "infer_python_packages",
     "init",
     "llm",
     "load_credentials",

usegradient-1.3.2/gradient_sdk/dependencies.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import ast
+import sys
+from pathlib import Path
+from typing import Iterable
+
+# Top-level import name -> PyPI distribution name.
+# Unlisted third-party imports default to the import name itself.
+IMPORT_TO_PACKAGE: dict[str, str | None] = {
+    "dotenv": "python-dotenv",
+    "gradient_sdk": "usegradient",
+    "PIL": "Pillow",
+    "cv2": "opencv-python",
+    "sklearn": "scikit-learn",
+    "yaml": "PyYAML",
+    "bs4": "beautifulsoup4",
+    "attr": "attrs",
+    "serial": "pyserial",
+    "jwt": "PyJWT",
+    "Crypto": "pycryptodome",
+    "OpenSSL": "pyOpenSSL",
+    "dateutil": "python-dateutil",
+    "skimage": "scikit-image",
+    "gi": None,  # system/bindings package; not pip-installable in the usual way
+    "cairo": None,
+}
+
+
+def infer_python_packages(
+    entrypoint: str | Path,
+    *,
+    source_root: str | Path | None = None,
+    explicit: Iterable[str] | None = None,
+) -> list[str]:
+    """Infer pip packages from imports in ``entrypoint`` and local modules it uses.
+
+    Stdlib and local project modules are skipped. Known import renames
+    (for example ``dotenv`` -> ``python-dotenv``) are applied. Explicit packages
+    are always kept and appear first.
+    """
+
+    entry = Path(entrypoint).resolve()
+    root = Path(source_root or entry.parent).resolve()
+    explicit_packages = _normalize_packages(explicit or [])
+    if not entry.exists():
+        return explicit_packages
+
+    local_names = _local_module_names(root)
+    stdlib = set(sys.stdlib_module_names)
+    top_level_imports: set[str] = set()
+    provider_packages: set[str] = set()
+    queued: list[Path] = [entry]
+    seen_files: set[Path] = set()
+
+    while queued:
+        path = queued.pop()
+        if path in seen_files or not path.is_file():
+            continue
+        seen_files.add(path)
+        provider_packages.update(_infer_provider_packages(path))
+        for module_name, level in _iter_import_modules(path):
+            if level > 0:
+                local_path = _resolve_relative_import(path, root, module_name, level)
+                if local_path is not None:
+                    queued.append(local_path)
+                continue
+            if not module_name:
+                continue
+            top = module_name.split(".", 1)[0]
+            top_level_imports.add(top)
+            # Known third-party/SDK imports should not be scanned as local source,
+            # even if a same-named directory exists in the source root (monorepo).
+            if top in IMPORT_TO_PACKAGE:
+                continue
+            if top in local_names:
+                queued.extend(_local_module_files(root, module_name))
+
+    inferred: list[str] = []
+    seen: set[str] = set(explicit_packages)
+    for name in sorted(top_level_imports | provider_packages):
+        if name in stdlib:
+            continue
+        if name in IMPORT_TO_PACKAGE:
+            package = IMPORT_TO_PACKAGE[name]
+        elif name in {"anthropic", "openai"}:
+            package = name
+        elif name in local_names:
+            continue
+        else:
+            package = name
+        if not package or package in seen:
+            continue
+        seen.add(package)
+        inferred.append(package)
+
+    return [*explicit_packages, *inferred]
+
+
+def merge_python_packages(
+    *,
+    entrypoint: str | Path | None,
+    source_root: str | Path,
+    explicit: Iterable[str] | None = None,
+) -> list[str]:
+    if entrypoint:
+        return infer_python_packages(
+            entrypoint,
+            source_root=source_root,
+            explicit=explicit,
+        )
+    return _normalize_packages(explicit or [])
+
+
+def _normalize_packages(packages: Iterable[str]) -> list[str]:
+    result: list[str] = []
+    seen: set[str] = set()
+    for item in packages:
+        name = str(item).strip()
+        if not name or name in seen:
+            continue
+        seen.add(name)
+        result.append(name)
+    return result
+
+
+def _local_module_names(root: Path) -> set[str]:
+    names: set[str] = set()
+    if not root.is_dir():
+        return names
+    for child in root.iterdir():
+        if child.name.startswith("."):
+            continue
+        if child.is_file() and child.suffix == ".py" and child.name != "__init__.py":
+            names.add(child.stem)
+        elif child.is_dir() and not child.name.startswith("__"):
+            if (child / "__init__.py").exists() or any(child.rglob("*.py")):
+                names.add(child.name)
+    return names
+
+
+def _local_module_files(root: Path, module_name: str) -> list[Path]:
+    parts = module_name.split(".")
+    base = root.joinpath(*parts)
+    candidates = [
+        Path(f"{base}.py"),
+        base / "__init__.py",
+    ]
+    return [path.resolve() for path in candidates if path.is_file()]
+
+
+def _resolve_relative_import(
+    current_file: Path,
+    root: Path,
+    module_name: str | None,
+    level: int,
+) -> Path | None:
+    current_dir = current_file.parent
+    # level=1 means current package; climb level-1 parents for package context
+    package_dir = current_dir
+    for _ in range(max(level - 1, 0)):
+        package_dir = package_dir.parent
+    if module_name:
+        target = package_dir.joinpath(*module_name.split("."))
+    else:
+        target = package_dir
+    for candidate in (Path(f"{target}.py"), target / "__init__.py"):
+        try:
+            resolved = candidate.resolve()
+            resolved.relative_to(root)
+        except Exception:
+            continue
+        if resolved.is_file():
+            return resolved
+    return None
+
+
+def _iter_import_modules(path: Path) -> list[tuple[str | None, int]]:
+    try:
+        tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+    except (OSError, SyntaxError):
+        return []
+
+    found: list[tuple[str | None, int]] = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                found.append((alias.name, 0))
+        elif isinstance(node, ast.ImportFrom):
+            found.append((node.module, int(node.level or 0)))
+    return found
+
+
+def _infer_provider_packages(path: Path) -> set[str]:
+    """Detect provider SDKs referenced via model ids/enums without direct imports."""
+
+    try:
+        tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+    except (OSError, SyntaxError):
+        return set()
+
+    found: set[str] = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Constant) and isinstance(node.value, str):
+            if node.value.startswith("anthropic:"):
+                found.add("anthropic")
+            elif node.value.startswith("openai:"):
+                found.add("openai")
+        elif isinstance(node, ast.Attribute) and isinstance(node.value, ast.Name):
+            if node.value.id != "Model":
+                continue
+            attr = node.attr.upper()
+            if attr.startswith("CLAUDE"):
+                found.add("anthropic")
+            elif attr.startswith("GPT"):
+                found.add("openai")
+    return found

{usegradient-1.3.1 → usegradient-1.3.2}/gradient_sdk/integrations/agent.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import json
-from typing import Any, Literal
+from typing import Any, Literal, Mapping
 
 from ..tools import Tool, execute_tool_calls
 from ..tracing import get_tracer
@@ -218,16 +218,15 @@ def _generate_anthropic(
         from anthropic import Anthropic
 
         client = Anthropic()
-    if isinstance(messages, str):
-        anthropic_messages = [{"role": "user", "content": messages}]
-    else:
-        anthropic_messages = messages
+    system, anthropic_messages = _anthropic_messages(messages)
     payload: dict[str, Any] = {
         "model": model,
         "max_tokens": kwargs.pop("max_tokens", 1024),
         "messages": anthropic_messages,
         **kwargs,
     }
+    if system:
+        payload["system"] = system
     if tools:
         payload["tools"] = [tool.to_anthropic() for tool in tools]
     response = client.messages.create(**payload)
@@ -257,6 +256,98 @@ def _generate_anthropic(
     }
 
 
+def _anthropic_messages(
+    messages: list[dict[str, Any]] | str,
+) -> tuple[str | None, list[dict[str, Any]]]:
+    """Convert chat-style messages into Anthropic Messages API shape.
+
+    Anthropic rejects role=system entries in ``messages`` and expects the
+    initial system prompt in the top-level ``system`` parameter instead.
+    """
+
+    if isinstance(messages, str):
+        return None, [{"role": "user", "content": messages}]
+
+    system_parts: list[str] = []
+    converted: list[dict[str, Any]] = []
+    for message in messages:
+        role = str(message.get("role") or "user")
+        content = message.get("content", "")
+        if role == "system":
+            text = _message_text(content)
+            if text:
+                system_parts.append(text)
+            continue
+        if role == "tool":
+            converted.append(
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "tool_result",
+                            "tool_use_id": message.get("tool_call_id") or message.get("id"),
+                            "content": _message_text(content),
+                        }
+                    ],
+                }
+            )
+            continue
+        if role == "assistant" and message.get("tool_calls"):
+            blocks: list[dict[str, Any]] = []
+            text = _message_text(content)
+            if text:
+                blocks.append({"type": "text", "text": text})
+            for call in message.get("tool_calls") or []:
+                arguments = call.get("arguments", call.get("input", {}))
+                if isinstance(arguments, str):
+                    try:
+                        arguments = json.loads(arguments)
+                    except json.JSONDecodeError:
+                        arguments = {"raw": arguments}
+                blocks.append(
+                    {
+                        "type": "tool_use",
+                        "id": call.get("id"),
+                        "name": call.get("name", ""),
+                        "input": arguments if isinstance(arguments, dict) else {"value": arguments},
+                    }
+                )
+            converted.append({"role": "assistant", "content": blocks or text})
+            continue
+        if role not in {"user", "assistant"}:
+            role = "user"
+        converted.append({"role": role, "content": content})
+
+    if not converted:
+        converted = [{"role": "user", "content": ""}]
+    return ("\n\n".join(system_parts) if system_parts else None), converted
+
+
+def _message_text(content: Any) -> str:
+    if content is None:
+        return ""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts: list[str] = []
+        for item in content:
+            if isinstance(item, Mapping):
+                text = item.get("text")
+                if text:
+                    parts.append(str(text))
+                else:
+                    parts.append(json.dumps(item, default=str))
+            else:
+                parts.append(str(item))
+        return "".join(parts)
+    if isinstance(content, Mapping):
+        text = content.get("text")
+        if text is not None:
+            return str(text)
+        return json.dumps(content, default=str)
+    return str(content)
+
+
 def _get(value: Any, key: str, default: Any = None) -> Any:
     if isinstance(value, dict):
         return value.get(key, default)

{usegradient-1.3.1 → usegradient-1.3.2}/gradient_sdk/runtime.py

@@ -9,6 +9,7 @@ import io
 import json
 import os
 import posixpath
+import shlex
 import sys
 import tarfile
 import time
@@ -17,6 +18,7 @@ from pathlib import Path
 from typing import Any, Callable, Iterable, Mapping
 
 from .client import GradientClient
+from .dependencies import merge_python_packages
 from .errors import GradientAPIError
 
 DEFAULT_EXCLUDES = [
@@ -677,10 +679,19 @@ class Gradient:
             source.duration_ms,
         )
 
+        packages = self._python_packages_for_source(source)
+        environment_spec = self._environment_spec(packages=packages)
+        if packages and self.environment.runtime == "python":
+            self._stage(
+                "dependencies",
+                "ready",
+                f"Resolved packages: {', '.join(packages)}",
+            )
+
         t0 = time.perf_counter()
         resolved = self.client.resolve_environment(
             project=self.project,
-            environment=self.environment.to_spec(),
+            environment=environment_spec,
             source=source.manifest,
         )
         timings["resolve_environment_ms"] = _elapsed_ms(t0)
@@ -698,7 +709,11 @@ class Gradient:
         t0 = time.perf_counter()
         traced = self.client.create_traced_machine(
             template,
-            machine_template=_with_source_bundle(template, source),
+            machine_template=_with_source_bundle(
+                template,
+                source,
+                extra_env=self.environment.env,
+            ),
             trace_mode=trace_policy.trace_mode,
             capture_policy=trace_policy.capture_policy(),
             metadata={
@@ -709,6 +724,7 @@ class Gradient:
                 "target": source.target_ref,
                 "trace_preset": trace_policy.preset,
                 "sdk_surface": "Gradient.run",
+                "packages": packages,
             },
             wait=True,
             wait_timeout_seconds=wait_timeout_seconds,
@@ -724,49 +740,40 @@ class Gradient:
             timings["upload_source_ms"] = 0
             self._stage("upload", "ready", "Mounted source bundle when the machine was created")
 
-            setup_command = env_version.get("setup_command")
-            if setup_command and self.environment.install_at_runtime:
-                t0 = time.perf_counter()
-                setup = self._exec_machine_with_retry(
-                    machine_id,
-                    command=["sh", "-lc", f"cd /workspace && {setup_command}"],
-                    timeout_seconds=run_timeout_seconds,
-                    trace=False,
-                    stage="dependencies",
-                )
-                timings["runtime_setup_ms"] = _elapsed_ms(t0)
-                self._stage(
-                    "dependencies",
-                    "ready" if setup.exit_code == 0 else "failed",
-                    "Runtime dependency setup completed" if setup.exit_code == 0 else setup.stderr,
-                    timings["runtime_setup_ms"],
-                )
-                if setup.exit_code != 0:
-                    raise RuntimeError(setup.stderr or setup.stdout)
-            else:
-                self._stage("dependencies", "cached", "Skipped runtime install; using cached environment image", cached=True)
+            python_bin = self._prepare_remote_python(
+                machine_id=machine_id,
+                packages=packages,
+                setup_command=env_version.get("setup_command"),
+                run_timeout_seconds=run_timeout_seconds,
+                timings=timings,
+            )
 
             payload = base64.b64encode(json.dumps(input).encode("utf-8")).decode("ascii")
             remote_code = _remote_bootstrap(source.target_ref, payload)
             t0 = time.perf_counter()
             result = self._exec_machine_with_retry(
                 machine_id,
-                command=["python", "-c", remote_code],
+                command=[python_bin, "-c", remote_code],
                 timeout_seconds=run_timeout_seconds,
                 trace=trace_policy.trace_exec,
                 watch=list(watch or ["/workspace"]),
                 stage="run",
             )
             timings["remote_run_ms"] = _elapsed_ms(t0)
+            failure_detail = _compact_output(result.stderr or result.stdout)
             self._stage(
                 "run",
                 "ready" if result.exit_code == 0 else "failed",
-                f"Remote agent exited with {result.exit_code}",
+                (
+                    f"Remote agent exited with {result.exit_code}"
+                    if result.exit_code == 0 or not failure_detail
+                    else f"Remote agent exited with {result.exit_code}: {failure_detail}"
+                ),
                 timings["remote_run_ms"],
             )
 
             timings["total_ms"] = _elapsed_ms(overall)
-            return RunHandle(
+            handle = RunHandle(
                 run_id=run_id,
                 machine_id=machine_id,
                 environment_version_id=str(env_version["id"]),
@@ -781,6 +788,13 @@ class Gradient:
                 client=self.client,
                 input=input,
             )
+            if result.exit_code != 0:
+                detail = (result.stderr or result.stdout or "").strip()
+                raise RuntimeError(
+                    detail
+                    or f"Remote agent exited with {result.exit_code}. Trace: {handle.trace_url}"
+                )
+            return handle
         finally:
             if not keep_machine:
                 t0 = time.perf_counter()
@@ -831,10 +845,13 @@ class Gradient:
             source.duration_ms,
         )
 
+        packages = self._python_packages_for_source(source)
+        environment_spec = self._environment_spec(packages=packages)
+
         t0 = time.perf_counter()
         resolved = self.client.resolve_environment(
             project=self.project,
-            environment=self.environment.to_spec(),
+            environment=environment_spec,
             source=source.manifest,
         )
         timings["resolve_environment_ms"] = _elapsed_ms(t0)
@@ -856,6 +873,7 @@ class Gradient:
                 env_version["machine_template"],
                 source,
                 service_code=_remote_service_bootstrap(source.target_ref),
+                extra_env=self.environment.env,
             ),
             environment_version_id=str(env_version["id"]),
             trace_mode=trace_policy.trace_mode,
@@ -896,27 +914,13 @@ class Gradient:
             timings["upload_source_ms"] = 0
             self._stage("upload", "ready", "Mounted deployment source bundle at machine creation")
 
-            setup_command = env_version.get("setup_command")
-            if setup_command and self.environment.install_at_runtime:
-                t0 = time.perf_counter()
-                setup = self._exec_machine_with_retry(
-                    machine_id,
-                    command=["sh", "-lc", f"cd /workspace && {setup_command}"],
-                    timeout_seconds=run_timeout_seconds,
-                    trace=False,
-                    stage="dependencies",
-                )
-                timings["runtime_setup_ms"] = _elapsed_ms(t0)
-                self._stage(
-                    "dependencies",
-                    "ready" if setup.exit_code == 0 else "failed",
-                    "Runtime dependency setup completed" if setup.exit_code == 0 else setup.stderr,
-                    timings["runtime_setup_ms"],
-                )
-                if setup.exit_code != 0:
-                    raise RuntimeError(setup.stderr or setup.stdout)
-            else:
-                self._stage("dependencies", "cached", "Skipped runtime install; using cached environment image", cached=True)
+            python_bin = self._prepare_remote_python(
+                machine_id=machine_id,
+                packages=packages,
+                setup_command=env_version.get("setup_command"),
+                run_timeout_seconds=run_timeout_seconds,
+                timings=timings,
+            )
 
             t0 = time.perf_counter()
             started = self._exec_machine_with_retry(
@@ -924,7 +928,7 @@ class Gradient:
                 command=[
                     "sh",
                     "-lc",
-                    "cd /workspace && nohup python -u /tmp/gradient-service.py >/tmp/gradient-service.log 2>&1 &",
+                    f"cd /workspace && nohup {shlex.quote(python_bin)} -u /tmp/gradient-service.py >/tmp/gradient-service.log 2>&1 &",
                 ],
                 timeout_seconds=30,
                 trace=trace_policy.trace_exec,
@@ -1009,6 +1013,89 @@ class Gradient:
             return _InstrumentedRunnable(target)
         return target
 
+    def _python_packages_for_source(self, source: SourceBundle) -> list[str]:
+        if self.environment.runtime != "python":
+            return list(self.environment.packages)
+        entrypoint = (
+            (self.source_root / source.entrypoint).resolve()
+            if source.entrypoint
+            else None
+        )
+        return merge_python_packages(
+            entrypoint=entrypoint,
+            source_root=self.source_root,
+            explicit=self.environment.packages,
+        )
+
+    def _environment_spec(self, *, packages: list[str] | None = None) -> dict[str, Any]:
+        spec = self.environment.to_spec()
+        if packages is not None:
+            spec["packages"] = list(packages)
+        return spec
+
+    def _prepare_remote_python(
+        self,
+        *,
+        machine_id: str,
+        packages: list[str],
+        setup_command: str | None,
+        run_timeout_seconds: int,
+        timings: dict[str, int],
+    ) -> str:
+        if self.environment.runtime == "python" and packages:
+            command = _python_venv_install_command(packages)
+            t0 = time.perf_counter()
+            setup = self._exec_machine_with_retry(
+                machine_id,
+                command=["sh", "-lc", command],
+                timeout_seconds=run_timeout_seconds,
+                trace=False,
+                stage="dependencies",
+            )
+            timings["runtime_setup_ms"] = _elapsed_ms(t0)
+            detail = _compact_output(setup.stderr or setup.stdout)
+            self._stage(
+                "dependencies",
+                "ready" if setup.exit_code == 0 else "failed",
+                (
+                    f"Installed {len(packages)} package(s) into remote venv"
+                    if setup.exit_code == 0
+                    else detail or "Remote dependency install failed"
+                ),
+                timings["runtime_setup_ms"],
+            )
+            if setup.exit_code != 0:
+                raise RuntimeError(detail or setup.stderr or setup.stdout or "Remote dependency install failed")
+            return "/tmp/gradient-venv/bin/python"
+
+        if setup_command and self.environment.install_at_runtime:
+            t0 = time.perf_counter()
+            setup = self._exec_machine_with_retry(
+                machine_id,
+                command=["sh", "-lc", f"cd /workspace && {setup_command}"],
+                timeout_seconds=run_timeout_seconds,
+                trace=False,
+                stage="dependencies",
+            )
+            timings["runtime_setup_ms"] = _elapsed_ms(t0)
+            self._stage(
+                "dependencies",
+                "ready" if setup.exit_code == 0 else "failed",
+                "Runtime dependency setup completed" if setup.exit_code == 0 else setup.stderr,
+                timings["runtime_setup_ms"],
+            )
+            if setup.exit_code != 0:
+                raise RuntimeError(setup.stderr or setup.stdout)
+            return "python"
+
+        self._stage(
+            "dependencies",
+            "cached",
+            "Skipped runtime install; using cached environment image",
+            cached=True,
+        )
+        return "python"
+
     def _exec_machine_with_retry(
         self,
         machine_id: str,
@@ -1133,10 +1220,13 @@ def _with_source_bundle(
     source: SourceBundle,
     *,
     service_code: str | None = None,
+    extra_env: Mapping[str, str] | None = None,
 ) -> dict[str, Any]:
     result = copy.deepcopy(dict(template))
     config = dict(result.get("config") or {})
     env = dict(config.get("env") or {})
+    if extra_env:
+        env.update({key: str(value) for key, value in extra_env.items() if value is not None})
     env["GRADIENT_SOURCE_ARCHIVE_B64"] = source.archive_b64
     init_steps = [
         "rm -rf /workspace",
@@ -1258,7 +1348,14 @@ def _find_global_object_ref(root: Path, target: Any) -> tuple[str, str] | None:
             continue
         for name, value in vars(module).items():
             if value is target and not name.startswith("_"):
-                return entrypoint, f"{module.__name__}:{name}"
+                module_name = module.__name__
+                if module_name == "__main__":
+                    module_name = (
+                        entrypoint[:-3].replace("/", ".")
+                        if entrypoint.endswith(".py")
+                        else entrypoint.replace("/", ".")
+                    )
+                return entrypoint, f"{module_name}:{name}"
     return None
 
 
@@ -1406,6 +1503,22 @@ def _elapsed_ms(started: float) -> int:
     return int((time.perf_counter() - started) * 1000)
 
 
+def _compact_output(value: str | None, *, limit: int = 500) -> str:
+    text = " ".join(str(value or "").split())
+    if len(text) <= limit:
+        return text
+    return text[: limit - 3] + "..."
+
+
+def _python_venv_install_command(packages: list[str]) -> str:
+    quoted = " ".join(shlex.quote(package) for package in packages)
+    return (
+        "python -m venv /tmp/gradient-venv && "
+        "/tmp/gradient-venv/bin/pip install --upgrade pip && "
+        f"/tmp/gradient-venv/bin/pip install --no-cache-dir {quoted}"
+    )
+
+
 def _stable_hash(value: Any) -> str:
     return hashlib.sha256(
         json.dumps(value, sort_keys=True, separators=(",", ":"), default=str).encode("utf-8")

{usegradient-1.3.1 → usegradient-1.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "usegradient"
-version = "1.3.1"
+version = "1.3.2"
 description = "Python SDK for the Gradient agent runtime and observability platform"
 readme = "README.md"
 requires-python = ">=3.11"

{usegradient-1.3.1 → usegradient-1.3.2}/tests/test_agent.py

@@ -138,11 +138,18 @@ class AgentTests(unittest.TestCase):
         class Client:
             messages = Messages()
 
-        run = Agent(Model.CLAUDE_HAIKU_4_5, client=Client())
+        run = Agent(
+            Model.CLAUDE_HAIKU_4_5,
+            client=Client(),
+            instructions="You are a helpful assistant.",
+        )
         result = run.run("hello")
 
         self.assertEqual(result.text, "anthropic response")
         self.assertEqual(calls[0]["model"], "claude-haiku-4-5")
+        self.assertEqual(calls[0]["system"], "You are a helpful assistant.")
+        self.assertEqual(calls[0]["messages"][0]["role"], "user")
+        self.assertTrue(all(message["role"] != "system" for message in calls[0]["messages"]))
         self.assertIn("messages", calls[0])
 
     def test_global_agent_can_be_packaged_as_runtime_target(self):

usegradient-1.3.2/tests/test_dependencies.py

@@ -0,0 +1,71 @@
+import tempfile
+import unittest
+from pathlib import Path
+
+from gradient_sdk.dependencies import infer_python_packages
+
+
+class DependencyInferenceTests(unittest.TestCase):
+    def test_infers_third_party_imports_and_keeps_explicit_packages(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            entry = root / "agent.py"
+            entry.write_text(
+                "\n".join(
+                    [
+                        "import os",
+                        "from dotenv import load_dotenv",
+                        "from gradient_sdk import Agent",
+                        "import anthropic",
+                        "from helper import value",
+                        "",
+                        "load_dotenv()",
+                        "value = value",
+                    ]
+                ),
+                encoding="utf-8",
+            )
+            (root / "helper.py").write_text("value = 1\n", encoding="utf-8")
+
+            packages = infer_python_packages(
+                entry,
+                source_root=root,
+                explicit=["anthropic"],
+            )
+
+        self.assertEqual(packages, ["anthropic", "python-dotenv", "usegradient"])
+
+    def test_infers_provider_from_model_enum(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            entry = root / "agent.py"
+            entry.write_text(
+                "\n".join(
+                    [
+                        "from gradient_sdk import Agent, Model",
+                        "agent = Agent(Model.CLAUDE_HAIKU_4_5)",
+                    ]
+                ),
+                encoding="utf-8",
+            )
+            packages = infer_python_packages(entry, source_root=root)
+
+        self.assertEqual(packages, ["anthropic", "usegradient"])
+
+    def test_follows_local_relative_imports(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            pkg = root / "app"
+            pkg.mkdir()
+            (pkg / "__init__.py").write_text("", encoding="utf-8")
+            (pkg / "tools.py").write_text("import requests\n", encoding="utf-8")
+            entry = pkg / "agent.py"
+            entry.write_text("from .tools import *\nimport json\n", encoding="utf-8")
+
+            packages = infer_python_packages(entry, source_root=root)
+
+        self.assertEqual(packages, ["requests"])
+
+
+if __name__ == "__main__":
+    unittest.main()

{usegradient-1.3.1 → usegradient-1.3.2}/tests/test_runtime.py

@@ -127,7 +127,9 @@ class FakeClient:
 
     def exec_machine(self, machine_id, command, **kwargs):
         self.calls.append(("exec_machine", machine_id, command, kwargs))
-        if command[:2] == ["python", "-c"]:
+        if command[:2] == ["sh", "-lc"] and "gradient-venv" in command[2]:
+            return ExecResult(stdout="installed\n")
+        if len(command) >= 2 and command[1] == "-c":
             return ExecResult(stdout='{"ok": true}\n')
         return ExecResult(stdout="ok\n")
 
@@ -211,10 +213,19 @@ class RuntimeTests(unittest.TestCase):
         run_exec = next(
             call
             for call in client.calls
-            if call[0] == "exec_machine" and call[2][:2] == ["python", "-c"]
+            if call[0] == "exec_machine" and len(call[2]) >= 2 and call[2][1] == "-c"
         )
         self.assertTrue(run_exec[3]["trace"])
         self.assertEqual(run_exec[3]["watch"], ["/workspace"])
+        self.assertTrue(run_exec[2][0].endswith("python"))
+        resolve_call = next(call for call in client.calls if call[0] == "resolve_environment")
+        self.assertIn("usegradient", resolve_call[1]["environment"]["packages"])
+        setup_calls = [
+            call
+            for call in client.calls
+            if call[0] == "exec_machine" and call[2][:2] == ["sh", "-lc"] and "gradient-venv" in call[2][2]
+        ]
+        self.assertEqual(len(setup_calls), 1)
 
     def test_gradient_build_returns_v1_handle(self):
         client = FakeClient()
@@ -250,7 +261,7 @@ class RuntimeTests(unittest.TestCase):
         run_exec = next(
             call
             for call in client.calls
-            if call[0] == "exec_machine" and call[2][:2] == ["python", "-c"]
+            if call[0] == "exec_machine" and len(call[2]) >= 2 and call[2][1] == "-c"
         )
         self.assertFalse(run_exec[3]["trace"])
 
@@ -320,7 +331,9 @@ class RuntimeTests(unittest.TestCase):
                     "Fly API 412 POST ... exec request failed: EOF",
                     response_body='{"error":"failed_precondition: exec request failed: EOF"}',
                 )
-            if command[:2] == ["python", "-c"]:
+            if command[:2] == ["sh", "-lc"] and "gradient-venv" in command[2]:
+                return ExecResult(stdout="installed\n")
+            if len(command) >= 2 and command[1] == "-c":
                 return ExecResult(stdout='{"ok": true}\n')
             return ExecResult(stdout="ok\n")
 
@@ -355,7 +368,9 @@ class RuntimeTests(unittest.TestCase):
                     "Fly API 412 POST ... machine not running",
                     response_body='{"error":"failed_precondition: machine not running"}',
                 )
-            if command[:2] == ["python", "-c"]:
+            if command[:2] == ["sh", "-lc"] and "gradient-venv" in command[2]:
+                return ExecResult(stdout="installed\n")
+            if len(command) >= 2 and command[1] == "-c":
                 return ExecResult(stdout='{"ok": true}\n')
             return ExecResult(stdout="ok\n")
 
@@ -391,10 +406,13 @@ class RuntimeTests(unittest.TestCase):
         serve_exec = next(
             call
             for call in client.calls
-            if call[0] == "exec_machine" and call[2][:2] == ["sh", "-lc"]
+            if call[0] == "exec_machine"
+            and call[2][:2] == ["sh", "-lc"]
+            and "gradient-service.py" in call[2][2]
         )
         self.assertTrue(serve_exec[3]["trace"])
         self.assertEqual(serve_exec[3]["watch"], ["/workspace"])
+        self.assertIn("/tmp/gradient-venv/bin/python", serve_exec[2][2])
 
         stopped = deployment.stop()
         self.assertEqual(stopped.status, "stopped")