mirror of
https://github.com/Sea-Haven-Industries/open-swe.git
synced 2026-09-30 15:03:16 +00:00
209132d355
* wip(rebuild): core reliability spine
- remove PR-babysitting (ci_autofix + ci_monitor graph + webhook wiring)
- dispatch core: agent/dispatch.py with multitask_strategy=interrupt +
durability=sync + completion webhook; reroute all webhook + plan triggers;
drop the racy in-process lock + is_thread_active busy-check
- completion webhook: agent/completion.py + /webhooks/run-complete loopback
route for failure/timeout replies (idempotent)
Co-authored-by: open-swe[bot]
* feat(rebuild): async tools, reconcile, shared http timeouts, assembly tuning
Parallel batch on top of the reliability spine:
- async-ify all 24 tools (drop asyncio.run; requests->httpx); re-implement the
http_request/fetch_url SSRF + DNS-rebinding defense httpx-natively and harden
the IP check to 'not is_global' (+ IPv4-mapped unwrap)
- reconcile.py: stale pending-run sweep (threads.search -> per-thread runs.list
-> cancel_many), wired into the scheduler graph via task='reconcile'
- shared DEFAULT_HTTP_TIMEOUT (agent/utils/http.py) on every bare
httpx.AsyncClient() across utils/dashboard/webapp/middleware
- run budget: MODEL_CALL_RECURSION_LIMIT 5000->250
- fix stale OpenAI->Anthropic fallback id (claude-opus-4-5 -> 4-8)
- drop redundant custom repair middleware (deepagents auto-adds PatchToolCalls)
- confirm tool-result eviction + summarization auto-wired via backend
- slim system prompt ~8% (full harness-profile rewrite deferred)
Co-authored-by: open-swe[bot]
* feat(rebuild): harness-profile prompt + split webhooks out of webapp
- prompt.py: own the system prompt via a registered harness profile
(OPEN_SWE_SHARED_BASE, kept neutral so the read-only reviewer/analyzer that
share it stay safe), registered across all 4 providers; per-thread values
stay in construct_system_prompt. Assembled main-agent prompt ~6.8k -> ~3.1k
tokens (~55% smaller); de-duped PR/commit/suite/force-push guidance; dropped
ALL-CAPS markers.
- webapp.py 3325 -> 1890 LOC: moved 14 per-source handlers into
agent/webhooks/{linear,slack,github}.py; webapp re-exports them for the
routes + tests; moved handlers reach shared helpers via the webapp namespace
to preserve the test suite's monkeypatch targets.
Full suite: 1168 passing, lint clean.
Co-authored-by: open-swe[bot]
* Restore MODEL_CALL_RECURSION_LIMIT to 5000 for long-running tasks
Reverts the 250 cap from the run-budget change — long-running tasks legitimately
need many model calls. The notify_step_limit_reached safety net still fires if a
run does hit the cap, so runs end with a signal either way.
Co-authored-by: open-swe[bot]
* fix: address PR review (auth, SSRF, interrupted status, redirect headers)
- completion.py: drop `interrupted` from failure statuses — with
multitask_strategy=interrupt a follow-up ends the prior run as interrupted,
which is healthy, not a failure to report. [open-swe]
- /webhooks/run-complete: shared-secret auth — dispatch appends ?token= when
RUN_COMPLETE_WEBHOOK_SECRET is set; route verifies via hmac.compare_digest.
[corridor-security]
- SSRF: extract the URL validator to agent/utils/url_safety.py and apply it
before server-side image fetches in multimodal.fetch_image_block.
[corridor-security]
- http_request: preserve caller headers/extensions across redirect hops instead
of dropping them on the first hop. [open-swe]
Co-authored-by: open-swe[bot]
* chore: remove REBUILD_PLAN.md (planning doc, not needed in the repo)
Co-authored-by: open-swe[bot]
* fix: fail closed on run-complete webhook auth when secret unset
Corridor follow-up: verify_run_complete_token returns False (not True) when
RUN_COMPLETE_WEBHOOK_SECRET is unset, so the public route is never
unauthenticated. Logs a startup warning when the secret is absent, and dispatch
skips registering the webhook when there's no secret (no rejected callbacks).
Co-authored-by: open-swe[bot]
---------
Co-authored-by: open-swe[bot] <open-swe@users.noreply.github.com>
243 lines
8 KiB
Python
243 lines
8 KiB
Python
from __future__ import annotations
|
|
|
|
import importlib
|
|
from datetime import UTC, datetime
|
|
from typing import Any
|
|
|
|
import pytest
|
|
|
|
wakeup_tool = importlib.import_module("agent.tools.schedule_thread_wakeup")
|
|
|
|
|
|
def _config(**overrides: Any) -> dict[str, Any]:
|
|
base: dict[str, Any] = {
|
|
"configurable": {
|
|
"thread_id": "test-thread-123",
|
|
"source": "slack",
|
|
"repo": {"owner": "langchain-ai", "name": "open-swe"},
|
|
"slack_thread": {"channel_id": "C1", "thread_ts": "1.0"},
|
|
"github_login": "johannes117",
|
|
"user_email": "johannes@example.com",
|
|
}
|
|
}
|
|
base["configurable"].update(overrides)
|
|
return base
|
|
|
|
|
|
async def test_schedule_thread_wakeup_rejects_zero_delay(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
monkeypatch.setattr(wakeup_tool, "get_config", _config)
|
|
result = await wakeup_tool.schedule_thread_wakeup(0)
|
|
assert result["success"] is False
|
|
assert "positive" in result["error"].lower()
|
|
|
|
|
|
async def test_schedule_thread_wakeup_rejects_negative_delay(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
monkeypatch.setattr(wakeup_tool, "get_config", _config)
|
|
result = await wakeup_tool.schedule_thread_wakeup(-5)
|
|
assert result["success"] is False
|
|
|
|
|
|
async def test_schedule_thread_wakeup_rejects_delay_over_24h(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
monkeypatch.setattr(wakeup_tool, "get_config", _config)
|
|
result = await wakeup_tool.schedule_thread_wakeup(1441)
|
|
assert result["success"] is False
|
|
assert "1440" in result["error"]
|
|
|
|
|
|
async def test_schedule_thread_wakeup_rejects_missing_thread_id(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
monkeypatch.setattr(
|
|
wakeup_tool,
|
|
"get_config",
|
|
lambda: {"configurable": {"source": "slack"}},
|
|
)
|
|
result = await wakeup_tool.schedule_thread_wakeup(5)
|
|
assert result["success"] is False
|
|
assert "thread_id" in result["error"].lower()
|
|
|
|
|
|
async def test_schedule_thread_wakeup_creates_cron(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
captured: dict[str, Any] = {}
|
|
|
|
async def fake_create_wakeup_cron(
|
|
*,
|
|
thread_id: str,
|
|
fire_time: datetime,
|
|
prompt: str,
|
|
configurable: dict[str, Any],
|
|
) -> dict[str, Any]:
|
|
captured.update(
|
|
{
|
|
"thread_id": thread_id,
|
|
"fire_time": fire_time,
|
|
"prompt": prompt,
|
|
"configurable": configurable,
|
|
}
|
|
)
|
|
return {
|
|
"success": True,
|
|
"cron_id": "cron-abc",
|
|
"scheduled_for": fire_time.isoformat(),
|
|
"thread_id": thread_id,
|
|
}
|
|
|
|
monkeypatch.setattr(wakeup_tool, "get_config", _config)
|
|
monkeypatch.setattr(wakeup_tool, "_create_wakeup_cron", fake_create_wakeup_cron)
|
|
|
|
result = await wakeup_tool.schedule_thread_wakeup(10, prompt="Check CI status")
|
|
|
|
assert result["success"] is True
|
|
assert result["cron_id"] == "cron-abc"
|
|
assert result["thread_id"] == "test-thread-123"
|
|
assert captured["thread_id"] == "test-thread-123"
|
|
assert captured["prompt"] == "Check CI status"
|
|
assert captured["configurable"]["thread_id"] == "test-thread-123"
|
|
assert captured["configurable"]["source"] == "slack"
|
|
assert captured["configurable"]["repo"] == {"owner": "langchain-ai", "name": "open-swe"}
|
|
assert captured["configurable"]["slack_thread"] == {"channel_id": "C1", "thread_ts": "1.0"}
|
|
assert captured["configurable"]["github_login"] == "johannes117"
|
|
|
|
now = datetime.now(UTC)
|
|
delay = (captured["fire_time"] - now).total_seconds()
|
|
assert delay >= 600
|
|
assert delay < 660
|
|
assert captured["fire_time"].second == 0
|
|
assert captured["fire_time"].microsecond == 0
|
|
|
|
|
|
async def test_schedule_thread_wakeup_uses_default_prompt_when_none(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
captured: dict[str, Any] = {}
|
|
|
|
async def fake_create_wakeup_cron(
|
|
*,
|
|
thread_id: str,
|
|
fire_time: datetime,
|
|
prompt: str,
|
|
configurable: dict[str, Any],
|
|
) -> dict[str, Any]:
|
|
captured["prompt"] = prompt
|
|
return {"success": True, "cron_id": "cron-1", "scheduled_for": "", "thread_id": thread_id}
|
|
|
|
monkeypatch.setattr(wakeup_tool, "get_config", _config)
|
|
monkeypatch.setattr(wakeup_tool, "_create_wakeup_cron", fake_create_wakeup_cron)
|
|
|
|
result = await wakeup_tool.schedule_thread_wakeup(5)
|
|
assert result["success"] is True
|
|
assert "automated re-trigger" in captured["prompt"].lower()
|
|
|
|
|
|
async def test_schedule_thread_wakeup_uses_default_prompt_when_blank(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
captured: dict[str, Any] = {}
|
|
|
|
async def fake_create_wakeup_cron(
|
|
*,
|
|
thread_id: str,
|
|
fire_time: datetime,
|
|
prompt: str,
|
|
configurable: dict[str, Any],
|
|
) -> dict[str, Any]:
|
|
captured["prompt"] = prompt
|
|
return {"success": True, "cron_id": "cron-1", "scheduled_for": "", "thread_id": thread_id}
|
|
|
|
monkeypatch.setattr(wakeup_tool, "get_config", _config)
|
|
monkeypatch.setattr(wakeup_tool, "_create_wakeup_cron", fake_create_wakeup_cron)
|
|
|
|
result = await wakeup_tool.schedule_thread_wakeup(5, prompt=" ")
|
|
assert result["success"] is True
|
|
assert "automated re-trigger" in captured["prompt"].lower()
|
|
|
|
|
|
async def test_schedule_thread_wakeup_returns_error_on_exception(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
async def fake_create_wakeup_cron(
|
|
*,
|
|
thread_id: str,
|
|
fire_time: datetime,
|
|
prompt: str,
|
|
configurable: dict[str, Any],
|
|
) -> dict[str, Any]:
|
|
raise RuntimeError("connection refused")
|
|
|
|
monkeypatch.setattr(wakeup_tool, "get_config", _config)
|
|
monkeypatch.setattr(wakeup_tool, "_create_wakeup_cron", fake_create_wakeup_cron)
|
|
|
|
result = await wakeup_tool.schedule_thread_wakeup(5)
|
|
assert result["success"] is False
|
|
assert "connection refused" in result["error"]
|
|
|
|
|
|
async def test_schedule_thread_wakeup_does_not_pass_none_configurable_keys(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
captured: dict[str, Any] = {}
|
|
|
|
async def fake_create_wakeup_cron(
|
|
*,
|
|
thread_id: str,
|
|
fire_time: datetime,
|
|
prompt: str,
|
|
configurable: dict[str, Any],
|
|
) -> dict[str, Any]:
|
|
captured["configurable"] = configurable
|
|
return {"success": True, "cron_id": "cron-1", "scheduled_for": "", "thread_id": thread_id}
|
|
|
|
monkeypatch.setattr(wakeup_tool, "get_config", _config)
|
|
monkeypatch.setattr(wakeup_tool, "_create_wakeup_cron", fake_create_wakeup_cron)
|
|
|
|
result = await wakeup_tool.schedule_thread_wakeup(5)
|
|
assert result["success"] is True
|
|
cfg = captured["configurable"]
|
|
assert "linear_issue" not in cfg
|
|
assert "schedule_id" not in cfg
|
|
assert cfg["thread_id"] == "test-thread-123"
|
|
|
|
|
|
def test_ceil_to_next_minute_keeps_exact_minute() -> None:
|
|
value = datetime(2025, 1, 15, 14, 30, tzinfo=UTC)
|
|
assert wakeup_tool._ceil_to_next_minute(value) == value
|
|
|
|
|
|
def test_ceil_to_next_minute_rounds_up_with_seconds() -> None:
|
|
value = datetime(2025, 1, 15, 14, 30, 59, 123, tzinfo=UTC)
|
|
assert wakeup_tool._ceil_to_next_minute(value) == value.replace(
|
|
minute=31, second=0, microsecond=0
|
|
)
|
|
|
|
|
|
def test_ceil_to_next_minute_handles_day_boundary() -> None:
|
|
value = datetime(2025, 1, 31, 23, 59, 59, tzinfo=UTC)
|
|
assert wakeup_tool._ceil_to_next_minute(value) == value.replace(
|
|
year=2025, month=2, day=1, hour=0, minute=0, second=0
|
|
)
|
|
|
|
|
|
def test_build_one_shot_cron_format() -> None:
|
|
fire_time = datetime(2025, 1, 15, 14, 30, tzinfo=UTC)
|
|
cron = wakeup_tool._build_one_shot_cron(fire_time)
|
|
parts = cron.split(" ")
|
|
assert len(parts) == 5
|
|
assert parts[0] == "30"
|
|
assert parts[1] == "14"
|
|
assert parts[2] == "15"
|
|
assert parts[3] == "1"
|
|
assert parts[4] == "*"
|
|
|
|
|
|
def test_build_one_shot_cron_handles_month_boundary() -> None:
|
|
fire_time = datetime(2025, 12, 31, 23, 59, tzinfo=UTC)
|
|
cron = wakeup_tool._build_one_shot_cron(fire_time)
|
|
parts = cron.split(" ")
|
|
assert parts[0] == "59"
|
|
assert parts[1] == "23"
|
|
assert parts[2] == "31"
|
|
assert parts[3] == "12"
|