sbxloop-worker 0.2.0__tar.gz → 0.4.0__tar.gz

{sbxloop_worker-0.2.0 → sbxloop_worker-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sbxloop-worker
-Version: 0.2.0
+Version: 0.4.0
 Summary: In-sandbox worker runtime for sbxloop (protocol models, agent backends, job runner)
 Project-URL: Homepage, https://github.com/brettbergin/sbxloop
 Project-URL: Repository, https://github.com/brettbergin/sbxloop

{sbxloop_worker-0.2.0 → sbxloop_worker-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sbxloop-worker"
-version = "0.2.0"
+version = "0.4.0"
 description = "In-sandbox worker runtime for sbxloop (protocol models, agent backends, job runner)"
 readme = "README.md"
 requires-python = ">=3.11"

{sbxloop_worker-0.2.0 → sbxloop_worker-0.4.0}/src/sbxloop_worker/__init__.py

@@ -5,6 +5,6 @@ models, the agent backends (GitHub Copilot SDK), and the job runner invoked
 via ``python -m sbxloop_worker``.
 """
 
-__version__ = "0.2.0"
+__version__ = "0.4.0"
 
 __all__ = ["__version__"]

{sbxloop_worker-0.2.0 → sbxloop_worker-0.4.0}/src/sbxloop_worker/__main__.py

@@ -65,6 +65,7 @@ def main(argv: list[str] | None = None) -> int:
     run.add_argument("--result", required=True, type=Path)
     run.add_argument("--heartbeat", type=float, default=15.0)
     run.add_argument("--env-file", type=Path, default=DEFAULT_ENV_FILE)
+    run.add_argument("--cwd", type=Path, default=None)
     args = parser.parse_args(argv)
 
     apply_env_file(args.env_file)
@@ -76,6 +77,18 @@ def main(argv: list[str] | None = None) -> int:
         print(f"sbxloop_worker: invalid job file {args.job}: {exc}", file=sys.stderr)
         return 64
 
+    if args.cwd is not None:
+        # Run the whole worker in the job's working directory so agent
+        # sessions (which inherit the process cwd) and shell commands both
+        # execute in the run workspace. Overwrite job.cwd with the resolved
+        # value so shell.check keeps its single code path.
+        try:
+            os.chdir(args.cwd)
+        except OSError as exc:
+            print(f"sbxloop_worker: cannot chdir to {args.cwd}: {exc}", file=sys.stderr)
+            return 64
+        job = job.model_copy(update={"cwd": str(Path.cwd())})
+
     try:
         JobRunner(
             job,

{sbxloop_worker-0.2.0 → sbxloop_worker-0.4.0}/src/sbxloop_worker/backends/copilot.py

@@ -17,6 +17,7 @@ from unit coverage accordingly.
 from __future__ import annotations
 
 import asyncio
+import json
 import os
 from typing import Any
 
@@ -52,6 +53,59 @@ def _auth_diagnostic() -> str:
     )
 
 
+# Transcript-facing clips: the event stream is telemetry, not the artifact
+# channel, so payloads are bounded aggressively.
+TOOL_ARGS_CLIP = 400
+TOOL_OUTPUT_CLIP = 1_000
+
+
+def _tool_args(arguments: Any) -> str | None:
+    """The tool's arguments as one displayable string (best-effort).
+
+    ``ToolExecutionStartData.arguments`` is typed ``Any`` by the SDK: shell
+    tools carry ``{"command": ...}``-shaped dicts, others arbitrary JSON.
+    Prefer the human-relevant fields, fall back to compact JSON.
+    """
+    if arguments is None:
+        return None
+    if isinstance(arguments, dict):
+        for key in ("command", "cmd", "input", "query", "path"):
+            value = arguments.get(key)
+            if isinstance(value, str) and value.strip():
+                return value[:TOOL_ARGS_CLIP]
+        try:
+            return json.dumps(arguments, separators=(",", ":"))[:TOOL_ARGS_CLIP]
+        except (TypeError, ValueError):
+            return str(arguments)[:TOOL_ARGS_CLIP]
+    text = str(arguments)
+    return text[:TOOL_ARGS_CLIP] if text.strip() else None
+
+
+def _tool_exit_code(data: Any) -> int | None:
+    """Shell exit code from a ToolExecutionComplete, when present.
+
+    Shell completions carry a ShellExit entry in ``result.contents``
+    (verified against github-copilot-sdk: ``exit_code: int``).
+    """
+    result = getattr(data, "result", None)
+    for entry in getattr(result, "contents", None) or []:
+        code = getattr(entry, "exit_code", None)
+        if isinstance(code, int):
+            return code
+    return None
+
+
+def _tool_output(data: Any) -> str | None:
+    """A bounded tail of the tool's output, for transcript display."""
+    result = getattr(data, "result", None)
+    content = getattr(result, "content", None)
+    if not content and result is not None:
+        content = getattr(result, "detailed_content", None)
+    if not isinstance(content, str) or not content.strip():
+        return None
+    return content[-TOOL_OUTPUT_CLIP:]
+
+
 class CopilotBackend:
     name = "copilot"
 
@@ -75,6 +129,9 @@ class CopilotBackend:
 
         usage = Usage()
         final_text: list[str] = []
+        # tool_call_id -> tool name, so completion events can name the tool
+        # (the SDK's Complete event carries only the call id).
+        tool_names: dict[str, str] = {}
 
         def on_event(event: Any) -> None:
             nonlocal usage
@@ -91,18 +148,25 @@ class CopilotBackend:
                     final_text.append(content)
                 emit(EventTypes.AGENT_MESSAGE, content=content)
             elif type_name.startswith("ToolExecutionStart"):
+                tool = getattr(data, "tool_name", None) or getattr(data, "toolName", None)
+                call_id = getattr(data, "tool_call_id", None) or getattr(data, "toolCallId", None)
+                if tool and call_id:
+                    tool_names[str(call_id)] = str(tool)
                 emit(
                     EventTypes.AGENT_TOOL_START,
-                    tool=getattr(data, "tool_name", None) or getattr(data, "toolName", None),
-                    tool_call_id=getattr(data, "tool_call_id", None)
-                    or getattr(data, "toolCallId", None),
+                    tool=tool,
+                    tool_call_id=call_id,
+                    args=_tool_args(getattr(data, "arguments", None)),
                 )
             elif type_name.startswith("ToolExecutionComplete"):
+                call_id = getattr(data, "tool_call_id", None) or getattr(data, "toolCallId", None)
                 emit(
                     EventTypes.AGENT_TOOL_END,
-                    tool_call_id=getattr(data, "tool_call_id", None)
-                    or getattr(data, "toolCallId", None),
+                    tool_call_id=call_id,
+                    tool=tool_names.get(str(call_id)),
                     success=getattr(data, "success", None),
+                    exit_code=_tool_exit_code(data),
+                    output=_tool_output(data),
                 )
             elif type_name == "AssistantUsageData":
                 sample = Usage(
@@ -142,6 +206,21 @@ class CopilotBackend:
             kwargs["model"] = job.model
         if job.system_message:
             kwargs["system_message"] = {"mode": "append", "content": job.system_message}
+        if job.cwd:
+            # Belt-and-braces alongside the worker-level chdir; the kwarg
+            # name is unverified against the SDK (e2e-validated), so an
+            # unsupported signature must not fail the session.
+            kwargs["working_directory"] = job.cwd
+        try:
+            return await self._open(client, job, kwargs)
+        except TypeError:
+            if "working_directory" not in kwargs:
+                raise
+            del kwargs["working_directory"]
+            return await self._open(client, job, kwargs)
+
+    @staticmethod
+    async def _open(client: Any, job: JobRequest, kwargs: dict[str, Any]) -> Any:
         if job.resume_session_id:
             return await client.resume_session(job.resume_session_id, **kwargs)
         return await client.create_session(**kwargs)

{sbxloop_worker-0.2.0 → sbxloop_worker-0.4.0}/src/sbxloop_worker/backends/echo.py

@@ -7,7 +7,11 @@ multi-job engine tests can script an entire run.
 
 Response object shape (all fields optional):
 ``{"text": str, "json": dict|list, "session_id": str, "sleep_s": float,
-"events": [{"type": str, "data": {...}}], "fail": str}``
+"events": [{"type": str, "data": {...}}], "fail": str,
+"files": {"relative/path": "content"}}``
+
+``files`` are written relative to the worker process cwd — modelling an
+executor that produces artifacts in the run workspace.
 """
 
 from __future__ import annotations
@@ -73,6 +77,10 @@ class EchoBackend:
             raise RuntimeError(str(response["fail"]))
         if sleep_s := float(response.get("sleep_s", 0)):
             time.sleep(sleep_s)
+        for relative, content in response.get("files", {}).items():
+            target = Path.cwd() / relative
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_text(str(content))
         for scripted_event in response.get("events", []):
             emit(scripted_event["type"], **scripted_event.get("data", {}))
         text = str(response.get("text", ""))

{sbxloop_worker-0.2.0 → sbxloop_worker-0.4.0}/src/sbxloop_worker/protocol.py

@@ -92,6 +92,10 @@ class JobRequest(ProtocolModel):
 
     # kind == "shell.check"
     argv: list[str] | None = None
+
+    # agent.session + shell.check: in-sandbox working directory. The worker
+    # process chdirs here (via --cwd) so agent sessions and shell commands
+    # run in the run's canonical workspace.
     cwd: str | None = None
 
     # kind == "github.op"