inspect-ai 0.3.49__py3-none-any.whl → 0.3.51__py3-none-any.whl

inspect_ai/solver/_task_state.py

@@ -273,6 +273,10 @@ class TaskState:
         """Set limit on total messages allowed per conversation."""
         self._message_limit = messages
 
+        from inspect_ai.log._samples import set_active_sample_message_limit
+
+        set_active_sample_message_limit(messages)
+
     @property
     def token_limit(self) -> int | None:
         """Limit on total tokens allowed per conversation."""
@@ -283,11 +287,24 @@ class TaskState:
         """Set limit on total tokens allowed per conversation."""
         self._token_limit = tokens
 
+        from inspect_ai.log._samples import set_active_sample_token_limit
+
+        set_active_sample_token_limit(tokens)
+
+    @property
+    def token_usage(self) -> int:
+        """Total tokens used for the current sample."""
+        return sample_total_tokens()
+
     @property
     def completed(self) -> bool:
         """Is the task completed."""
+        # update messages
+        from inspect_ai.log._samples import set_active_sample_total_messages
         from inspect_ai.log._transcript import SampleLimitEvent, transcript
 
+        set_active_sample_total_messages(len(self.messages))
+
         if self._completed:
             return True
         elif self.message_limit and len(self.messages) >= self.message_limit:
@@ -302,7 +319,7 @@ class TaskState:
                     )
                 )
             return True
-        elif self.token_limit and sample_total_tokens() >= self.token_limit:
+        elif self.token_limit and self.token_usage >= self.token_limit:
             # log if this is the first time we hit this
             if not self._token_limit_exceeded:
                 self._token_limit_exceeded = True

inspect_ai/solver/_use_tools.py

@@ -9,6 +9,7 @@ from ._task_state import TaskState
 def use_tools(
     *tools: Tool | list[Tool],
     tool_choice: ToolChoice | None = "auto",
+    append: bool = False,
 ) -> Solver:
     """
     Inject tools into the task state to be used in generate().
@@ -20,6 +21,9 @@ def use_tools(
         tool_choice (ToolChoice | None): Directive indicating which
           tools the model should use. If `None` is passed, then no
           change to `tool_choice` is made.
+        append (bool): If `True`, then the passed-in tools are appended
+            to the existing tools; otherwise any existing tools are
+            replaced (the default)
 
     Returns:
         A solver that injects the tools and tool_choice into the task state.
@@ -42,7 +46,11 @@ def use_tools(
             else:
                 add_tool(tool)
         if len(tools_update) > 0:
-            state.tools = tools_update
+            if append:
+                existing_tools = state.tools
+                state.tools = existing_tools + tools_update
+            else:
+                state.tools = tools_update
 
         # set tool choice if specified
         if tool_choice is not None:

inspect_ai/tool/_tool_def.py

@@ -190,8 +190,8 @@ def tool_def_fields(tool: Tool) -> ToolDefFields:
                 f"{context} not provided for parameter '{param_name}' of tool function '{name}'."
             )
 
-        if param.type == "null":
-            raise_not_provided_error("Type annotation")
+        if param.type is None and not param.anyOf and not param.enum:
+            raise_not_provided_error("Unsupported type or type annotation")
         elif not param.description:
             raise_not_provided_error("Description")
 

inspect_ai/tool/_tool_info.py

@@ -1,4 +1,6 @@
 import inspect
+import types
+import typing
 from dataclasses import is_dataclass
 from typing import (
     Any,
@@ -139,12 +141,18 @@ def parse_type(type_hint: Type[Any]) -> ToolParam:
             return ToolParam(type="string")
         elif type_hint is bool:
             return ToolParam(type="boolean")
+        elif type_hint is list:
+            return ToolParam(type="array", items=ToolParam())
+        elif type_hint is dict:
+            return ToolParam(type="object", additionalProperties=ToolParam())
         elif (
             is_dataclass(type_hint)
             or is_typeddict(type_hint)
             or (isinstance(type_hint, type) and issubclass(type_hint, BaseModel))
         ):
             return parse_object(type_hint)
+        elif type_hint is type(None):
+            return ToolParam(type="null")
         else:
             return ToolParam()
     elif origin is list or origin is List:
@@ -156,10 +164,14 @@ def parse_type(type_hint: Type[Any]) -> ToolParam:
             type="object",
             additionalProperties=parse_type(args[1]) if len(args) > 1 else ToolParam(),
         )
-    elif origin is Union:
+    elif origin is Union or origin is types.UnionType:
         return ToolParam(anyOf=[parse_type(arg) for arg in args])
     elif origin is Optional:
-        return ToolParam(anyOf=[parse_type(args[0]), ToolParam()])
+        return ToolParam(
+            anyOf=[parse_type(arg) for arg in args] + [ToolParam(type="null")]
+        )
+    elif origin is typing.Literal:
+        return ToolParam(enum=list(args))
 
     return ToolParam()  # Default case if we can't determine the type
 

inspect_ai/tool/_tool_params.py

@@ -13,9 +13,10 @@ JSONType = Literal["string", "integer", "number", "boolean", "array", "object",
 class ToolParam(BaseModel):
     """Description of tool parameter in JSON Schema format."""
 
-    type: JSONType = Field(default="null")
+    type: JSONType | None = Field(default=None)
     description: str | None = Field(default=None)
     default: Any = Field(default=None)
+    enum: list[Any] | None = Field(default=None)
     items: Optional["ToolParam"] = Field(default=None)
     properties: dict[str, "ToolParam"] | None = Field(default=None)
     additionalProperties: Optional["ToolParam"] | bool | None = Field(default=None)

inspect_ai/tool/_tools/_execute.py

@@ -75,7 +75,7 @@ def python(timeout: int | None = None, user: str | None = None) -> Tool:
         Use the python function to execute Python code.
 
         The python function will only return you the stdout of the script,
-        oo make sure to use print to see the output.
+        so make sure to use print to see the output.
 
         Args:
           code (str): The python code to execute.

inspect_ai/tool/_tools/_web_browser/_web_browser.py

@@ -373,6 +373,12 @@ async def web_browser_cmd(cmd: str, *args: str) -> str:
             web_at = (
                 str(response.get("web_at")) or "(no web accessiblity tree available)"
             )
+            # Remove base64 data from images.
+            web_at_lines = web_at.split("\n")
+            web_at_lines = [
+                line.partition("data:image/png;base64")[0] for line in web_at_lines
+            ]
+            web_at = "\n".join(web_at_lines)
             store().set(WEB_BROWSER_AT, web_at)
             return web_at
         elif "error" in response:

inspect_ai/util/__init__.py

@@ -1,13 +1,12 @@
 from ._concurrency import concurrency
 from ._console import input_screen
+from ._panel import InputPanel, input_panel
 from ._resource import resource
 from ._sandbox import (
     OutputLimitExceededError,
     SandboxConnection,
-    SandboxConnectionContainer,
-    SandboxConnectionLocal,
-    SandboxConnectionSSH,
     SandboxEnvironment,
+    SandboxEnvironmentConfigType,
     SandboxEnvironmentLimits,
     SandboxEnvironments,
     SandboxEnvironmentSpec,
@@ -29,19 +28,19 @@ from ._trace import trace_enabled, trace_panel
 __all__ = [
     "ExecResult",
     "concurrency",
+    "InputPanel",
+    "input_panel",
     "input_screen",
     "OutputLimitExceededError",
     "resource",
     "subprocess",
     "SandboxEnvironment",
+    "SandboxEnvironmentConfigType",
     "SandboxEnvironmentLimits",
     "SandboxEnvironments",
     "SandboxEnvironmentSpec",
     "SandboxEnvironmentType",
     "SandboxConnection",
-    "SandboxConnectionContainer",
-    "SandboxConnectionLocal",
-    "SandboxConnectionSSH",
     "sandboxenv",
     "sandbox",
     "sandbox_with",

inspect_ai/util/_panel.py

@@ -0,0 +1,91 @@
+from typing import Any, Protocol, TypeVar
+
+from textual.containers import Container
+
+
+class InputPanel(Container):
+    DEFAULT_CLASSES = "task-input-panel"
+
+    class Host(Protocol):
+        def set_title(self, title: str) -> None: ...
+        def activate(self) -> None: ...
+        def deactivate(self) -> None: ...
+        def close(self) -> None: ...
+
+    def __init__(self, title: str, host: Host) -> None:
+        super().__init__()
+        self._title = title
+        self._host = host
+
+    async def __aenter__(self) -> "InputPanel":
+        self.activate()
+        return self
+
+    async def __aexit__(
+        self,
+        *execinfo: Any,
+    ) -> None:
+        self.close()
+
+    @property
+    def title(self) -> str:
+        return self._title
+
+    @title.setter
+    def title(self, title: str) -> None:
+        self._title = title
+        self._host.set_title(title)
+
+    def activate(self) -> None:
+        self._host.activate()
+
+    def deactivate(self) -> None:
+        self._host.deactivate()
+
+    def close(self) -> None:
+        self._host.close()
+
+    def update(self) -> None:
+        """Update method (called periodically e.g. once every second)"""
+        pass
+
+
+TP = TypeVar("TP", bound=InputPanel)
+
+
+async def input_panel(title: str, panel: type[TP]) -> TP:
+    """Create an input panel in the task display.
+
+    There can only be a single instance of an InputPanel with a given
+    'title' running at once. Therefore, if the panel doesn't exist it
+    is created, otherwise a reference to the existing panel is returned.
+
+    Examples:
+        Create/activate an input panel (the panel will remain after
+        the scope exits -- see below for open/close semantics)
+
+        ```python
+        panel = await input_panel("Custom", CustomPanel)
+        panel.activate()
+        ```
+
+        Activate and close an input panel using a context manager:
+
+        ```python
+        async with await input_panel("Custom", CustomPanel) as panel:
+            ...
+        ```
+
+    Args:
+       title (str): Input panel title.
+       panel (type[TP]): Type of panel widget (must derive from `InputPanel`)
+
+    Returns:
+       InputPanel: Instance of widget running in the task display.
+
+    Raises:
+       NotImplementedError: If Inspect is not running in display='full' model.
+    """
+    from inspect_ai._display.core.active import task_screen
+
+    return await task_screen().input_panel(title, panel)

inspect_ai/util/_sandbox/__init__.py

@@ -4,10 +4,8 @@ from .context import sandbox, sandbox_with
 from .docker.docker import DockerSandboxEnvironment  # noqa: F401
 from .environment import (
     SandboxConnection,
-    SandboxConnectionContainer,
-    SandboxConnectionLocal,
-    SandboxConnectionSSH,
     SandboxEnvironment,
+    SandboxEnvironmentConfigType,
     SandboxEnvironments,
     SandboxEnvironmentSpec,
     SandboxEnvironmentType,
@@ -20,14 +18,12 @@ from .service import SandboxService, sandbox_service
 __all__ = [
     "OutputLimitExceededError",
     "SandboxEnvironment",
+    "SandboxEnvironmentConfigType",
     "SandboxEnvironmentLimits",
     "SandboxEnvironments",
     "SandboxEnvironmentSpec",
     "SandboxEnvironmentType",
     "SandboxConnection",
-    "SandboxConnectionContainer",
-    "SandboxConnectionLocal",
-    "SandboxConnectionSSH",
     "sandboxenv",
     "sandbox",
     "sandbox_with",

inspect_ai/util/_sandbox/context.py

@@ -9,6 +9,7 @@ from .environment import (
     SampleInit,
     SandboxConnection,
     SandboxEnvironment,
+    SandboxEnvironmentConfigType,
 )
 from .registry import registry_find_sandboxenv
 
@@ -93,7 +94,7 @@ async def sandbox_connections() -> dict[str, SandboxConnection]:
         for name, environment in environments.items():
             try:
                 connections[name] = await environment.connection()
-            except NotImplementedError:
+            except (NotImplementedError, ConnectionError):
                 pass
         return connections
     else:
@@ -110,7 +111,7 @@ def raise_no_sandbox() -> NoReturn:
 async def init_sandbox_environments_sample(
     type: str,
     task_name: str,
-    config: str | None,
+    config: SandboxEnvironmentConfigType | None,
     files: dict[str, bytes],
     setup: bytes | None,
     metadata: dict[str, Any],
@@ -149,7 +150,7 @@ async def init_sandbox_environments_sample(
 async def cleanup_sandbox_environments_sample(
     type: str,
     task_name: str,
-    config: str | None,
+    config: SandboxEnvironmentConfigType | None,
     environments: dict[str, SandboxEnvironment],
     interrupted: bool,
 ) -> None:

inspect_ai/util/_sandbox/docker/compose.py

@@ -71,9 +71,15 @@ async def compose_down(project: ComposeProject, quiet: bool = True) -> None:
 
 
 async def compose_cp(
-    src: str, dest: str, project: ComposeProject, cwd: str | Path | None = None
+    src: str,
+    dest: str,
+    project: ComposeProject,
+    cwd: str | Path | None = None,
+    output_limit: int | None = None,
 ) -> None:
-    result = await compose_command(["cp", "--", src, dest], project=project, cwd=cwd)
+    result = await compose_command(
+        ["cp", "--", src, dest], project=project, cwd=cwd, output_limit=output_limit
+    )
     if not result.success:
         msg = f"Failed to copy file from '{src}' to '{dest}': {result.stderr}"
         raise RuntimeError(msg)
@@ -149,6 +155,7 @@ async def compose_exec(
     project: ComposeProject,
     timeout: int | None = None,
     input: str | bytes | None = None,
+    output_limit: int | None = None,
 ) -> ExecResult[str]:
     return await compose_command(
         ["exec"] + command,
@@ -156,6 +163,7 @@ async def compose_exec(
         timeout=timeout,
         input=input,
         forward_env=False,
+        output_limit=output_limit,
     )
 
 
@@ -241,6 +249,7 @@ async def compose_command(
     cwd: str | Path | None = None,
     forward_env: bool = True,
     capture_output: bool = True,
+    output_limit: int | None = None,
     ansi: Literal["never", "always", "auto"] | None = None,
 ) -> ExecResult[str]:
     # The base docker compose command
@@ -278,6 +287,7 @@ async def compose_command(
         env=env,
         timeout=timeout,
         capture_output=capture_output,
+        output_limit=output_limit,
     )
     sandbox_log(f"compose command completed: {shlex.join(compose_command)}")
     return result

inspect_ai/util/_sandbox/docker/docker.py

@@ -12,10 +12,14 @@ from inspect_ai.util._subprocess import ExecResult
 
 from ..environment import (
     SandboxConnection,
-    SandboxConnectionContainer,
     SandboxEnvironment,
+    SandboxEnvironmentConfigType,
+)
+from ..limits import (
+    SandboxEnvironmentLimits,
+    verify_exec_result_size,
+    verify_read_file_size,
 )
-from ..limits import verify_exec_result_size, verify_read_file_size
 from ..registry import sandboxenv
 from .cleanup import (
     cli_cleanup,
@@ -51,7 +55,9 @@ class DockerSandboxEnvironment(SandboxEnvironment):
         return CONFIG_FILES + [DOCKERFILE]
 
     @classmethod
-    async def task_init(cls, task_name: str, config: str | None) -> None:
+    async def task_init(
+        cls, task_name: str, config: SandboxEnvironmentConfigType | None
+    ) -> None:
         # validate prereqs
         await validate_prereqs()
 
@@ -98,13 +104,16 @@ class DockerSandboxEnvironment(SandboxEnvironment):
     @override
     @classmethod
     async def sample_init(
-        cls, task_name: str, config: str | None, metadata: dict[str, str]
+        cls,
+        task_name: str,
+        config: SandboxEnvironmentConfigType | None,
+        metadata: dict[str, str],
     ) -> dict[str, SandboxEnvironment]:
         sandbox_log("setup")
 
         # create environment variables for sample metadata
         env: dict[str, str] = {}
-        if config and Path(config).exists():
+        if isinstance(config, str) and Path(config).exists():
             # read the config file
             with open(config, "r") as f:
                 config_text = f.read()
@@ -175,7 +184,7 @@ class DockerSandboxEnvironment(SandboxEnvironment):
     async def sample_cleanup(
         cls,
         task_name: str,
-        config: str | None,
+        config: SandboxEnvironmentConfigType | None,
         environments: dict[str, SandboxEnvironment],
         interrupted: bool,
     ) -> None:
@@ -191,7 +200,7 @@ class DockerSandboxEnvironment(SandboxEnvironment):
 
     @classmethod
     async def task_cleanup(
-        cls, task_name: str, config: str | None, cleanup: bool
+        cls, task_name: str, config: SandboxEnvironmentConfigType | None, cleanup: bool
     ) -> None:
         await project_cleanup_shutdown(cleanup)
 
@@ -241,6 +250,7 @@ class DockerSandboxEnvironment(SandboxEnvironment):
             project=self._project,
             timeout=timeout,
             input=input,
+            output_limit=SandboxEnvironmentLimits.MAX_EXEC_OUTPUT_SIZE,
         )
         verify_exec_result_size(exec_result)
         if exec_result.returncode == 126 and "permission denied" in exec_result.stdout:
@@ -369,6 +379,7 @@ class DockerSandboxEnvironment(SandboxEnvironment):
                     dest=os.path.basename(dest_file),
                     project=self._project,
                     cwd=os.path.dirname(dest_file),
+                    output_limit=SandboxEnvironmentLimits.MAX_READ_FILE_SIZE,
                 )
             except RuntimeError as ex:
                 # extract the message and normalise case
@@ -413,10 +424,9 @@ class DockerSandboxEnvironment(SandboxEnvironment):
 
         # return container login
         if container:
-            return SandboxConnectionContainer(
+            return SandboxConnection(
                 command=f"docker exec -it {container} /bin/bash --login",
                 container=container,
-                working_dir=self._working_dir,
             )
 
         # error (not currently running)

inspect_ai/util/_sandbox/docker/util.py

@@ -7,6 +7,7 @@ from shortuuid import uuid
 
 from inspect_ai._util.constants import SANDBOX
 
+from ..environment import SandboxEnvironmentConfigType
 from .config import (
     COMPOSE_DOCKERFILE_YAML,
     auto_compose_file,
@@ -26,10 +27,17 @@ class ComposeProject:
 
     @classmethod
     async def create(
-        cls, name: str, config: str | None, env: dict[str, str] = {}
+        cls,
+        name: str,
+        config: SandboxEnvironmentConfigType | None,
+        env: dict[str, str] = {},
     ) -> "ComposeProject":
         # resolve config to full path if we have one
-        config_path = Path(config).resolve() if config else None
+        config_path = None
+        if isinstance(config, str):
+            config_path = Path(config).resolve()
+        elif config is not None:
+            raise ValueError(f"Unsupported config type: {type(config)}. Expected str.")
 
         # if its a Dockerfile, then config is the auto-generated .compose.yaml
         if config_path and is_dockerfile(config_path.name):