synth-ai 0.2.9.dev7__py3-none-any.whl → 0.2.10__py3-none-any.whl

examples/swe/task_app/hosted/envs/mini_swe/policy.py

@@ -0,0 +1,355 @@
+from __future__ import annotations
+
+import json
+import logging
+import re
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+from jinja2 import StrictUndefined, Template
+from minisweagent.agents.default import FormatError
+
+from .shared import (
+    DEFAULT_ACTION_TEMPLATE,
+    DEFAULT_INSTANCE_TEMPLATE,
+    DEFAULT_SYSTEM_TEMPLATE,
+)
+from .tools import RUN_COMMAND_TOOL, SUBMIT_TOOL, TOOLS_SCHEMA
+
+logger = logging.getLogger(__name__)
+
+COMMAND_PATTERN = re.compile(r"```(?:bash)?\s*\n(.*?)\n```", re.DOTALL)
+
+
+def _render_template(source: str, **kwargs: Any) -> str:
+    return Template(source, undefined=StrictUndefined).render(**kwargs)
+
+
+@dataclass
+class MiniSwePolicyConfig:
+    system_template: str = DEFAULT_SYSTEM_TEMPLATE
+    instance_template: str = DEFAULT_INSTANCE_TEMPLATE
+    action_template: str = DEFAULT_ACTION_TEMPLATE
+    model: str | None = None
+    temperature: float | None = None
+    top_p: float | None = None
+    max_completion_tokens: int | None = None
+    tool_choice: str = "required"
+    use_tools: bool = True
+    step_limit: int = 0
+    cost_limit: float = 3.0
+    extra_template_vars: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_payload(cls, payload: dict[str, Any]) -> MiniSwePolicyConfig:
+        base = MiniSwePolicyConfig()
+        for key in (
+            "system_template",
+            "instance_template",
+            "action_template",
+            "model",
+            "temperature",
+            "top_p",
+            "max_completion_tokens",
+            "tool_choice",
+            "use_tools",
+            "step_limit",
+            "cost_limit",
+        ):
+            if key in payload:
+                setattr(base, key, payload[key])
+        extra = payload.get("extra_template_vars") or {}
+        if isinstance(extra, dict):
+            base.extra_template_vars = dict(extra)
+        return base
+
+
+class MiniSwePolicy:
+    """Mini-SWE policy that mirrors the default agent prompt loop."""
+
+    name = "swe-mini"
+
+    def __init__(self, *, inference_url: str | None = None, model: str | None = None) -> None:
+        self.inference_url = inference_url
+        self.config = MiniSwePolicyConfig(model=model)
+        self.system_template = Template(self.config.system_template, undefined=StrictUndefined)
+        self.instance_template = Template(self.config.instance_template, undefined=StrictUndefined)
+        self.action_template = Template(self.config.action_template, undefined=StrictUndefined)
+
+        self.messages: list[dict[str, Any]] = []
+        self.turn_index = 0
+        self.history_messages: list[dict[str, Any]] = []
+        self.trajectory_history: list[dict[str, Any]] = []
+        self.task: dict[str, Any] | None = None
+        self.template_vars: dict[str, Any] = {}
+
+    async def initialize(self, payload: dict[str, Any]) -> None:
+        cfg = MiniSwePolicyConfig.from_payload(payload or {})
+        self.config = cfg
+        self.system_template = Template(cfg.system_template, undefined=StrictUndefined)
+        self.instance_template = Template(cfg.instance_template, undefined=StrictUndefined)
+        self.action_template = Template(cfg.action_template, undefined=StrictUndefined)
+        if cfg.model:
+            self.config.model = cfg.model
+        self.template_vars = dict(cfg.extra_template_vars or {})
+        logger.info("Mini-swe policy initialized with model=%s", self.config.model)
+        self._reset_state()
+
+    def _reset_state(self) -> None:
+        self.messages = []
+        self.history_messages = []
+        self.trajectory_history = []
+        self.turn_index = 0
+
+    def _append_user(self, content: str) -> None:
+        msg = {"role": "user", "content": content}
+        self.messages.append(msg)
+        self.history_messages.append(msg)
+        self.turn_index += 1
+
+    def _append_assistant(self, content: str) -> None:
+        msg = {"role": "assistant", "content": content}
+        self.messages.append(msg)
+        self.history_messages.append(msg)
+
+    def _apply_previous_cycle(self, metadata: dict[str, Any] | None) -> None:
+        if not metadata:
+            return
+        prev_tool_calls = metadata.get("prev_tool_calls")
+        prev_response = metadata.get("prev_inference_response")
+        prev_env_result = metadata.get("prev_env_result")
+        prev_assistant_text = metadata.get("prev_assistant_text")
+
+        if prev_assistant_text:
+            self._append_assistant(prev_assistant_text)
+        elif prev_response:
+            text = self._extract_response_text(prev_response)
+            if text:
+                self._append_assistant(text)
+
+        if prev_tool_calls or prev_env_result:
+            record = {
+                "turn": self.turn_index,
+                "tool_calls": prev_tool_calls,
+                "env_result": prev_env_result,
+            }
+            self.trajectory_history.append(record)
+
+    def _ensure_task_context(self, observation: dict[str, Any] | None) -> None:
+        if self.task is not None:
+            return
+        task = (observation or {}).get("task") or {}
+        self.task = dict(task)
+        render_vars = dict(self.template_vars)
+        render_vars.setdefault("task", task)
+        render_vars.setdefault("problem_statement", task.get("problem_statement", ""))
+        render_vars.setdefault("instructions", task.get("instructions", ""))
+        render_vars.setdefault("metadata", task.get("metadata", {}))
+        rendered_system = self.system_template.render(**render_vars)
+        rendered_user = self.instance_template.render(**render_vars)
+        self.messages.append({"role": "system", "content": rendered_system})
+        self.history_messages.append({"role": "system", "content": rendered_system})
+        self._append_user(rendered_user)
+
+    def _render_action_observation(self, observation: dict[str, Any]) -> str:
+        last = observation.get("last") or {}
+        output = {
+            "stdout": last.get("stdout", ""),
+            "returncode": last.get("returncode", 0),
+        }
+        template_input = {"output": output, "observation": observation}
+        return self.action_template.render(**template_input)
+
+    def _extract_response_text(self, response: dict[str, Any]) -> str:
+        try:
+            choices = response.get("choices") or []
+            for choice in choices:
+                msg = choice.get("message") or {}
+                content = msg.get("content")
+                if isinstance(content, str):
+                    return content
+                if isinstance(content, list):
+                    parts = []
+                    for entry in content:
+                        if isinstance(entry, dict):
+                            txt = entry.get("text") or entry.get("content")
+                            if isinstance(txt, str):
+                                parts.append(txt)
+                    if parts:
+                        return "".join(parts)
+        except Exception:
+            pass
+        return ""
+
+    def _build_inference_request(self) -> dict[str, Any]:
+        payload: dict[str, Any] = {"messages": self.messages}
+        if self.config.model:
+            payload["model"] = self.config.model
+        if self.config.temperature is not None:
+            payload["temperature"] = self.config.temperature
+        if self.config.top_p is not None:
+            payload["top_p"] = self.config.top_p
+        if self.config.max_completion_tokens is not None:
+            payload["max_completion_tokens"] = self.config.max_completion_tokens
+        if self.config.use_tools:
+            model_name = str(self.config.model or "").lower()
+            if "gpt-5" in model_name:
+                # GPT-5 models insist on a single tool; keep run_command to avoid shim calls.
+                tool_list: list[dict[str, Any]] = [RUN_COMMAND_TOOL]
+                payload["tools"] = tool_list
+                payload["tool_choice"] = {
+                    "type": "function",
+                    "function": {"name": "run_command"},
+                }
+                payload["parallel_tool_calls"] = False
+            else:
+                # Groq/Qwen and other OpenAI-compatible models handle both tools under auto mode.
+                tool_list = [RUN_COMMAND_TOOL, SUBMIT_TOOL]
+                payload["tools"] = tool_list
+                payload["tool_choice"] = "auto"
+                payload["parallel_tool_calls"] = False
+        return payload
+
+    async def step(
+        self,
+        observation_text: str,
+        state: dict[str, Any] | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+        raw_observation: dict[str, Any] | None = None
+        if metadata is not None:
+            candidate = metadata.get("raw_observation")
+            if isinstance(candidate, dict):
+                raw_observation = candidate
+
+        self._ensure_task_context(raw_observation)
+        self._apply_previous_cycle(metadata)
+
+        message_text = observation_text or ""
+        if raw_observation and raw_observation.get("last"):
+            rendered = self._render_action_observation(raw_observation)
+            message_text = f"{message_text}\n\n{rendered}" if message_text else rendered
+        elif not message_text:
+            message_text = (
+                "Observation: repository ready. Begin by inspecting files and planning next steps."
+            )
+
+        self._append_user(message_text)
+
+        inference_request = self._build_inference_request()
+        meta = {
+            "inference_request": inference_request,
+            "turn_index": self.turn_index,
+            "history_len": len(self.history_messages),
+            "tool_schema": TOOLS_SCHEMA,
+        }
+        if self.inference_url:
+            meta["inference_url"] = self.inference_url
+
+        return [], meta
+
+    @staticmethod
+    def _parse_command_from_text(text: str) -> str:
+        matches = COMMAND_PATTERN.findall(text or "")
+        if len(matches) != 1:
+            raise FormatError(
+                "Please provide exactly one bash command enclosed in a single ```bash``` block."
+            )
+        command = matches[0].strip()
+        if not command:
+            raise FormatError("Command block was empty. Provide a valid shell command.")
+        return command
+
+    def parse_response_to_tool_calls(
+        self,
+        response: dict[str, Any],
+        use_tools: bool = True,
+    ) -> list[dict[str, Any]]:
+        if use_tools:
+            # Prefer structured tool calls if available.
+            for choice in response.get("choices", []):
+                msg = choice.get("message") or {}
+                tool_calls = msg.get("tool_calls")
+                if tool_calls:
+                    parsed: list[dict[str, Any]] = []
+                    for tool in tool_calls:
+                        if not isinstance(tool, dict):
+                            continue
+                        name = tool.get("name")
+                        args = tool.get("arguments")
+                        if "function" in tool:
+                            name = tool["function"].get("name")
+                            args = tool["function"].get("arguments")
+                        if isinstance(args, str):
+                            try:
+                                args = json.loads(args)
+                            except json.JSONDecodeError:
+                                args = {"command": args}
+                        parsed.append({"tool_name": name, "arguments": args})
+                    if parsed:
+                        return parsed
+
+        text = self._extract_response_text(response)
+        if not text:
+            logger.warning("Model response missing content; defaulting to echo NOOP")
+            return [{"tool_name": "run_command", "arguments": {"command": "echo NOOP"}}]
+
+        try:
+            command = self._parse_command_from_text(text)
+        except FormatError as err:
+            logger.warning("Format error parsing command: %s; defaulting to echo NOOP", err)
+            return [{"tool_name": "run_command", "arguments": {"command": "echo NOOP"}}]
+
+        return [{"tool_name": "run_command", "arguments": {"command": command}}]
+
+    def state_dict(self) -> dict[str, Any]:
+        return {
+            "config": asdict(self.config),
+            "messages": self.messages,
+            "history_messages": self.history_messages,
+            "trajectory_history": self.trajectory_history,
+            "turn_index": self.turn_index,
+            "task": self.task,
+            "template_vars": self.template_vars,
+        }
+
+    def load_state_dict(self, state: dict[str, Any]) -> None:
+        self.config = MiniSwePolicyConfig.from_payload(state.get("config", {}))
+        self.system_template = Template(
+            self.config.system_template, undefined=StrictUndefined
+        )
+        self.instance_template = Template(
+            self.config.instance_template, undefined=StrictUndefined
+        )
+        self.action_template = Template(self.config.action_template, undefined=StrictUndefined)
+        self.messages = state.get("messages", [])
+        self.history_messages = state.get("history_messages", [])
+        self.trajectory_history = state.get("trajectory_history", [])
+        self.turn_index = int(state.get("turn_index", 0))
+        self.task = state.get("task")
+        self.template_vars = state.get("template_vars", {})
+
+    async def serialize(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "config": asdict(self.config),
+            "state": self.state_dict(),
+        }
+
+    @classmethod
+    async def deserialize(cls, payload: dict[str, Any]) -> MiniSwePolicy:
+        config = payload.get("config") or {}
+        state = payload.get("state") or {}
+        policy = cls(
+            inference_url=config.get("inference_url"),
+            model=config.get("model"),
+        )
+        await policy.initialize(config)
+        policy.load_state_dict(state)
+        return policy
+
+    async def terminate(self) -> None:
+        return None
+
+
+__all__ = ["MiniSwePolicy"]

examples/swe/task_app/hosted/envs/mini_swe/shared.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import json
+import textwrap
+from typing import Any
+
+DEFAULT_SYSTEM_TEMPLATE = textwrap.dedent(
+    """\
+    You are a helpful assistant that can interact with a software repository by issuing shell commands.
+    Follow the workflow and formatting guidelines exactly. Every response MUST contain a THOUGHT section
+    and exactly one bash command enclosed in a single ```bash``` block.
+    """
+)
+
+DEFAULT_INSTANCE_TEMPLATE = textwrap.dedent(
+    """\
+    Please solve this task:
+
+    {{problem_statement}}
+
+    {{instructions}}
+
+    Remember:
+    - Explain your reasoning in a THOUGHT section before the command.
+    - Provide exactly one bash command wrapped in ```bash``` fences.
+    - Use non-interactive flags and prefer deterministic tooling.
+    - To finish, run `echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT && git add -A && git diff --cached`.
+    """
+)
+
+DEFAULT_ACTION_TEMPLATE = textwrap.dedent(
+    """\
+    <returncode>{{ output.returncode }}</returncode>
+    {% if output.stdout | length < 10000 %}
+    <output>
+    {{ output.stdout }}
+    </output>
+    {% else %}
+    <warning>Output truncated ({{ output.stdout | length }} characters)</warning>
+    <output_head>{{ output.stdout[:5000] }}</output_head>
+    <output_tail>{{ output.stdout[-5000:] }}</output_tail>
+    {% endif %}
+    """
+)
+
+
+def summarise_history(history: list[dict[str, Any]], limit: int = 5) -> list[dict[str, Any]]:
+    """Return the most recent command history entries, truncated for transport."""
+
+    def _truncate(text: str, max_len: int = 4000) -> str:
+        if len(text) <= max_len:
+            return text
+        head = text[: max_len // 2]
+        tail = text[-max_len // 2 :]
+        return f"{head}\n... [truncated {len(text) - max_len} chars] ...\n{tail}"
+
+    trimmed: list[dict[str, Any]] = []
+    for item in history[-limit:]:
+        trimmed.append(
+            {
+                "command": item.get("command"),
+                "returncode": item.get("returncode"),
+                "stdout": _truncate(item.get("stdout", "")),
+                "duration": item.get("duration"),
+            }
+        )
+    return trimmed
+
+
+def format_observation(observation: dict[str, Any]) -> str:
+    """Simple pretty-printer used by tracing/logging."""
+
+    last = observation.get("last")
+    task = observation.get("task", {})
+    summary = {
+        "instance_id": task.get("instance_id"),
+        "step": observation.get("step_idx"),
+        "submitted": bool(observation.get("submitted")),
+        "last_command": (last or {}).get("command"),
+        "returncode": (last or {}).get("returncode"),
+    }
+    return json.dumps(summary, indent=2, sort_keys=True)
+

examples/swe/task_app/hosted/envs/mini_swe/tools.py

@@ -0,0 +1,96 @@
+"""Tool schema for mini-SWE command execution."""
+
+from __future__ import annotations
+
+RUN_COMMAND_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "run_command",
+        "description": (
+            "Execute a bash command inside the task workspace. Use this for all shell "
+            "operations including editing files, running tests, and submitting results."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "command": {
+                    "type": "string",
+                    "description": "The bash command to execute. Must be non-empty.",
+                },
+                "timeout": {
+                    "type": "integer",
+                    "minimum": 1,
+                    "maximum": 600,
+                    "description": (
+                        "Optional timeout (seconds) for the command. Defaults to the environment "
+                        "timeout if omitted."
+                    ),
+                },
+            },
+            "required": ["command"],
+            "additionalProperties": False,
+        },
+    },
+}
+
+SUBMIT_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "submit_patch",
+        "description": (
+            "Finish the task and submit the final patch. Call this once you believe the "
+            "fix is complete and tests pass."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "command": {
+                    "type": "string",
+                    "description": (
+                        "Optional submission command. Defaults to "
+                        "`echo COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT && git add -A && git diff --cached` "
+                        "if omitted."
+                    ),
+                }
+            },
+            "required": [],
+            "additionalProperties": False,
+        },
+    },
+}
+
+TOOLS_SCHEMA = [RUN_COMMAND_TOOL, SUBMIT_TOOL]
+
+# Compatibility: some OpenAI reasoning models (e.g., gpt-5) insist on calling
+# a generic function (e.g., 'interact' or 'interact_many'). Provide stubs so
+# vendor requests do not 400 on unknown function names; the policy will map
+# these calls to concrete environment tools.
+COMPAT_INTERACT_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "interact",
+        "description": "Compatibility shim for models that call a generic 'interact' tool.",
+        "parameters": {
+            "type": "object",
+            "properties": {},
+            "additionalProperties": True,
+        },
+    },
+}
+
+COMPAT_INTERACT_MANY_TOOL = {
+    "type": "function",
+    "function": {
+        "name": "interact_many",
+        "description": "Compatibility shim for models that call 'interact_many'.",
+        "parameters": {
+            "type": "object",
+            "properties": {},
+            "additionalProperties": True,
+        },
+    },
+}
+
+# Append compatibility tools last so preferred tools remain first in the list
+TOOLS_SCHEMA.extend([COMPAT_INTERACT_TOOL, COMPAT_INTERACT_MANY_TOOL])
+