JiuwenSwarm is an intelligent AI Agent built on openJiuwen. It extends the powerful capabilities of large language models directly to your fingertips through various communication apps you use daily.
Python
import hashlib
import inspect
import json
import logging
import asyncio
from pathlib import Path
from unittest.mock import AsyncMock, patch
import pytest
from openjiuwen.core.runner.callback import get_callback_framework
from openjiuwen.core.runner.callback.events import ToolCallEvents
from jiuwenswarm.agents.harness.common.tools.deepresearch import rewrite_tools as rt
def _document(root: Path, citation_artifacts: dict[str, str] | None = None):
body = "原句。\n"
report = root / "report.md"
# write_bytes: content_sha256 hashes body's exact UTF-8 bytes; text mode
# would translate \n -> \r\n on Windows and break the hash check.
report.write_bytes(body.encode("utf-8"))
snapshot = {
"response_content": body,
"citation_messages": {"code": 0, "msg": "success", "data": []},
"infer_messages": [],
"chart_messages": [],
}
snapshot_bytes = json.dumps(
snapshot, ensure_ascii=False, sort_keys=True, separators=(",", ":")
).encode("utf-8")
snapshot_path = report.with_suffix(".final-result.json")
snapshot_path.write_bytes(snapshot_bytes)
provenance = {
"schema_version": 2,
"document_id": "doc_test",
"revision_id": "rev_parent",
"parent_revision_id": None,
"conversation_id": "C1",
"markdown_path": str(report),
"content_sha256": hashlib.sha256(body.encode()).hexdigest(),
"final_result_path": snapshot_path.name,
"final_result_sha256": hashlib.sha256(snapshot_bytes).hexdigest(),
"created_at": "2026-07-15T00:00:00+00:00",
"operation": {"action": "deepresearch_generate"},
"citations": [],
"inference_manifest": [],
"chart_manifest": [],
"rewrite_history": [],
}
if citation_artifacts is not None:
provenance["citation_artifacts"] = citation_artifacts
report.with_suffix(".provenance.json").write_text(json.dumps(provenance), encoding="utf-8")
return report, provenance
def _selection() -> dict:
selected = "原句。"
selected_bytes = selected.encode("utf-8")
return {
"protocol_version": 2,
"start_byte": 0,
"end_byte": len(selected_bytes),
"selected_text": selected,
"source_sha256": hashlib.sha256(selected_bytes).hexdigest(),
}
def _structured_result(prepared: dict, text: str = "新句。") -> dict:
prepared_unit = prepared["units"][0]
prepared_slot = prepared_unit["slots"][0]
return {
"units": [
{
"unit_id": prepared_unit["unit_id"],
"slots": [{"slot_id": prepared_slot["slot_id"], "text": text}],
}
],
"facts_added": False,
}
_INVOKE_LIFECYCLE_EVENTS = (
ToolCallEvents.TOOL_INVOKE_INPUT,
ToolCallEvents.TOOL_CALL_STARTED,
ToolCallEvents.TOOL_PARSE_STARTED,
ToolCallEvents.TOOL_PARSE_FINISHED,
ToolCallEvents.TOOL_CALL_FINISHED,
ToolCallEvents.TOOL_INVOKE_OUTPUT,
)
_INVOKE_AUDIT_EVENTS = _INVOKE_LIFECYCLE_EVENTS + (
ToolCallEvents.TOOL_CALL_ERROR,
)
async def _invoke_with_event_probe(tool_instance, payload):
framework = get_callback_framework()
observed = []
callbacks = []
for event in _INVOKE_AUDIT_EVENTS:
async def capture(*_args, _event=event, **_kwargs):
observed.append(_event)
framework.register_sync(event, capture, namespace="rewrite-tool-contract-test")
callbacks.append((event, capture))
try:
try:
result = await tool_instance.invoke(payload)
except Exception as exc: # the probe asserts whether errors escape
result = exc
finally:
for event, callback in callbacks:
await framework.unregister(event, callback)
return result, observed
def test_rewrite_tool_schemas_expose_only_protocol_v2_contract():
assert list(inspect.signature(rt.deepresearch_prepare_rewrite._func).parameters) == [
"report_path",
"action",
"selection",
"instruction",
]
assert list(inspect.signature(rt.deepresearch_commit_rewrite._func).parameters) == [
"context_token",
"structured_result",
]
prepare_card = rt.deepresearch_prepare_rewrite._card
assert list(prepare_card.input_params["properties"]) == [
"report_path",
"action",
"selection",
"instruction",
]
assert "Protocol v2" in prepare_card.description
assert "UTF-8" in prepare_card.description
assert "byte" in prepare_card.description
prepare_schema = prepare_card.input_params
assert prepare_schema["required"] == ["report_path", "action", "selection"]
assert prepare_schema["additionalProperties"] is False
assert prepare_schema["properties"]["action"]["enum"] == [
"polish",
"expand",
"shorten",
]
selection_schema = prepare_schema["properties"]["selection"]
assert selection_schema["required"] == [
"protocol_version",
"start_byte",
"end_byte",
"selected_text",
"source_sha256",
]
assert selection_schema["additionalProperties"] is False
assert selection_schema["properties"]["protocol_version"] == {
"type": "integer",
"const": 2,
}
assert selection_schema["properties"]["start_byte"] == {
"type": "integer",
"minimum": 0,
}
assert selection_schema["properties"]["end_byte"] == {
"type": "integer",
"minimum": 0,
}
assert selection_schema["properties"]["source_sha256"] == {
"type": "string",
"pattern": "^[0-9a-f]{64}$",
}
commit_card = rt.deepresearch_commit_rewrite._card
assert list(commit_card.input_params["properties"]) == [
"context_token",
"structured_result",
]
assert "units" in commit_card.description
commit_schema = commit_card.input_params
assert commit_schema["required"] == ["context_token", "structured_result"]
assert commit_schema["additionalProperties"] is False
structured_schema = commit_schema["properties"]["structured_result"]
assert structured_schema["required"] == ["units", "facts_added"]
assert structured_schema["additionalProperties"] is False
assert structured_schema["properties"]["facts_added"] == {
"type": "boolean",
"const": False,
}
unit_schema = structured_schema["properties"]["units"]["items"]
assert unit_schema["required"] == ["unit_id", "slots"]
assert unit_schema["additionalProperties"] is False
slot_schema = unit_schema["properties"]["slots"]["items"]
assert slot_schema["required"] == ["slot_id", "text"]
assert slot_schema["additionalProperties"] is False
html_tool = rt.deepresearch_generate_rewrite_html
assert list(inspect.signature(html_tool._func).parameters) == [
"report_path",
"revision_id",
]
html_card = html_tool._card
assert html_card.name == "deepresearch_generate_rewrite_html"
assert (
"latest successful deepresearch_commit_rewrite result"
in html_card.description
)
assert html_card.input_params == {
"type": "object",
"properties": {
"report_path": {"type": "string"},
"revision_id": {
"type": "string",
"pattern": "^rev_[A-Za-z0-9_-]{1,128}$",
},
},
"required": ["report_path", "revision_id"],
"additionalProperties": False,
}
@pytest.mark.asyncio
async def test_prepare_invoke_keeps_full_lifecycle_for_valid_and_invalid_inputs():
valid_payload = {
"report_path": "/workspace/report.md",
"action": "polish",
"selection": _selection(),
}
invalid_payload = {
**valid_payload,
"selection": {**_selection(), "extra": "sensitive extra"},
}
with patch.object(
rt, "_get_route", return_value={"session_id": "S1"}
), patch.object(
rt, "_get_effective_request_output_dir", return_value="/workspace"
), patch.object(
rt, "prepare_rewrite", return_value={"context_token": "T1", "units": []}
) as core:
valid_raw, valid_events = await _invoke_with_event_probe(
rt.deepresearch_prepare_rewrite, valid_payload
)
invalid_raw, invalid_events = await _invoke_with_event_probe(
rt.deepresearch_prepare_rewrite, invalid_payload
)
assert json.loads(valid_raw)["status"] == "prepared"
assert json.loads(invalid_raw)["error_code"] == "BAD_REQUEST"
assert "sensitive" not in invalid_raw
assert core.call_count == 1
assert set(valid_events) == set(_INVOKE_LIFECYCLE_EVENTS)
assert invalid_events == valid_events
@pytest.mark.asyncio
@pytest.mark.parametrize(
("tool_instance", "payload", "core_name", "error_code"),
[
(
rt.deepresearch_prepare_rewrite,
{
"report_path": "/SECRET/report.md",
"action": "polish",
"selection": _selection(),
"extra": "SECRET-extra",
},
"prepare_rewrite",
"BAD_REQUEST",
),
(
rt.deepresearch_prepare_rewrite,
{"report_path": "/SECRET/report.md", "action": "polish"},
"prepare_rewrite",
"BAD_REQUEST",
),
(
rt.deepresearch_commit_rewrite,
{
"context_token": "token",
"structured_result": {
"units": [{
"unit_id": "unit_1",
"slots": [{"slot_id": "slot_1", "text": "new"}],
}],
"facts_added": False,
},
"extra": "SECRET-extra",
},
"commit_rewrite",
"MODEL_OUTPUT_INVALID",
),
(
rt.deepresearch_commit_rewrite,
{"context_token": "SECRET-token"},
"commit_rewrite",
"MODEL_OUTPUT_INVALID",
),
],
)
async def test_top_level_parse_errors_return_safe_json_inside_lifecycle(
tool_instance, payload, core_name, error_code
):
with patch.object(rt, core_name, side_effect=AssertionError("core called")) as core:
result, events = await _invoke_with_event_probe(tool_instance, payload)
assert isinstance(result, str)
assert json.loads(result) == {
"status": "error",
"error_code": error_code,
"error": "invalid tool input",
}
assert "SECRET" not in result
assert "/SECRET/report.md" not in result
core.assert_not_called()
assert events == [
ToolCallEvents.TOOL_INVOKE_INPUT,
ToolCallEvents.TOOL_CALL_STARTED,
ToolCallEvents.TOOL_PARSE_STARTED,
ToolCallEvents.TOOL_CALL_FINISHED,
ToolCallEvents.TOOL_INVOKE_OUTPUT,
]
@pytest.mark.asyncio
@pytest.mark.parametrize(
("change", "value", "error_code"),
[
("action", "delete", "BAD_REQUEST"),
("selection_extra", "sensitive extra", "BAD_REQUEST"),
("protocol_version", 1, "SELECTION_PROTOCOL_UNSUPPORTED"),
],
)
async def test_prepare_invoke_rejects_contract_violations_before_core(
change, value, error_code
):
selection = _selection()
payload = {
"report_path": "/sensitive/report.md",
"action": "polish",
"selection": selection,
}
if change == "selection_extra":
selection["extra"] = value
elif change == "protocol_version":
selection["protocol_version"] = value
else:
payload[change] = value
with patch.object(
rt, "_get_route", return_value={"session_id": "S1"}
), patch.object(
rt, "_get_effective_request_output_dir", return_value="/workspace"
), patch.object(
rt, "prepare_rewrite", side_effect=AssertionError("core called")
) as core:
raw = await rt.deepresearch_prepare_rewrite.invoke(payload)
assert json.loads(raw)["error_code"] == error_code
assert "原句" not in raw
assert "/sensitive/report.md" not in raw
core.assert_not_called()
@pytest.mark.asyncio
@pytest.mark.parametrize("change", ["structured_extra", "facts_added"])
async def test_commit_invoke_rejects_contract_violations_before_core(change):
structured_result = {
"units": [{
"unit_id": "unit_1",
"slots": [{"slot_id": "slot_1", "text": "sensitive output"}],
}],
"facts_added": False,
}
if change == "structured_extra":
structured_result["extra"] = "sensitive extra"
else:
structured_result["facts_added"] = True
with patch.object(
rt, "_get_route", return_value={"session_id": "S1"}
), patch.object(
rt, "commit_rewrite", side_effect=AssertionError("core called")
) as core:
raw = await rt.deepresearch_commit_rewrite.invoke({
"context_token": "sensitive-token",
"structured_result": structured_result,
})
assert json.loads(raw)["error_code"] == "MODEL_OUTPUT_INVALID"
assert "sensitive" not in raw
core.assert_not_called()
@pytest.mark.asyncio
async def test_prepare_and_commit_tools_return_short_outcomes_and_deliver_file(tmp_path):
report, _ = _document(tmp_path)
selection = _selection()
route = {"request_id": "R1", "channel_id": "CH1", "session_id": "S1"}
with patch.object(rt, "_get_route", return_value=route), patch.object(
rt, "_get_effective_request_output_dir", return_value=str(tmp_path)
):
prepared_raw = await rt.deepresearch_prepare_rewrite._func(
report_path=str(report),
action="polish",
selection=selection,
instruction="",
)
prepared = json.loads(prepared_raw)
push = AsyncMock()
with patch(
"jiuwenswarm.server.gateway_push.transport.WebSocketGatewayPushTransport",
return_value=push,
):
committed_raw = await rt.deepresearch_commit_rewrite._func(
context_token=prepared["context_token"],
structured_result=_structured_result(prepared),
)
committed = json.loads(committed_raw)
assert prepared["status"] == "prepared"
assert committed["status"] == "completed"
assert committed["report_delivered"] is True
assert committed["delivery_status"] == "delivered"
assert committed["delivery_error_code"] is None
assert committed["citation_integrity_status"] == "verified"
assert committed["citation_semantic_status"] == "not_verified"
assert "citation_status" not in committed
assert Path(committed["report_path"]).is_file()
push.send_push.assert_awaited_once()
assert push.send_push.await_args.args[0]["payload"]["event_type"] == "chat.file"
@pytest.mark.asyncio
async def test_commit_inherits_and_delivers_hidden_citation_artifacts(tmp_path):
citation_artifacts = {
"raw_report_path": str(tmp_path / "report.raw_report.md"),
"citations_preview_path": str(tmp_path / "report.citations.preview.json"),
}
report, _ = _document(tmp_path, citation_artifacts=citation_artifacts)
route = {"request_id": "R1", "channel_id": "CH1", "session_id": "S1"}
with patch.object(rt, "_get_route", return_value=route), patch.object(
rt, "_get_effective_request_output_dir", return_value=str(tmp_path)
):
prepared = json.loads(
await rt.deepresearch_prepare_rewrite._func(
report_path=str(report),
action="polish",
selection=_selection(),
instruction="",
)
)
push = AsyncMock()
with patch(
"jiuwenswarm.server.gateway_push.transport.WebSocketGatewayPushTransport",
return_value=push,
):
committed = json.loads(
await rt.deepresearch_commit_rewrite._func(
context_token=prepared["context_token"],
structured_result=_structured_result(prepared),
)
)
child_provenance = json.loads(
Path(committed["provenance_path"]).read_text(encoding="utf-8")
)
assert child_provenance["citation_artifacts"] == citation_artifacts
payload = push.send_push.await_args.args[0]["payload"]
assert payload["files"] == [{
"path": committed["report_path"],
"name": Path(committed["report_path"]).name,
}]
assert payload["metadata"] == {
"artifactBundle": {
"schemaVersion": "1.0",
"relatedArtifacts": [
{
"type": "raw_report",
"path": citation_artifacts["raw_report_path"],
"contentType": "text/markdown",
"relatedToPathIndex": 0,
},
{
"type": "citations_preview",
"path": citation_artifacts["citations_preview_path"],
"contentType": "application/json",
"schemaVersion": "1.1",
"relatedToPathIndex": 0,
},
],
}
}
assert "citations_path" not in json.dumps(payload)
@pytest.mark.asyncio
@pytest.mark.parametrize(
"provenance_content",
[None, "not-json", "[]", '{"citation_artifacts": "invalid"}'],
)
async def test_deliver_report_omits_metadata_for_unusable_provenance(
tmp_path, provenance_content
):
provenance_path = tmp_path / "child.provenance.json"
if provenance_content is not None:
provenance_path.write_text(provenance_content, encoding="utf-8")
push = AsyncMock()
route = {"request_id": "R1", "channel_id": "CH1", "session_id": "S1"}
with patch(
"jiuwenswarm.server.gateway_push.transport.WebSocketGatewayPushTransport",
return_value=push,
):
delivered = await rt._deliver_report(
str(tmp_path / "child.md"), str(provenance_path), route
)
assert delivered is True
payload = push.send_push.await_args.args[0]["payload"]
assert payload["event_type"] == "chat.file"
assert "metadata" not in payload
@pytest.mark.asyncio
async def test_deliver_report_omits_metadata_for_oversized_provenance(tmp_path):
provenance_path = tmp_path / "child.provenance.json"
provenance_path.write_text(
json.dumps({"citation_artifacts": {"raw_report_path": "x" * 100}}),
encoding="utf-8",
)
push = AsyncMock()
route = {"request_id": "R1", "channel_id": "CH1", "session_id": "S1"}
with patch.object(rt, "_CITATION_PROVENANCE_MAX_BYTES", 32), patch(
"jiuwenswarm.server.gateway_push.transport.WebSocketGatewayPushTransport",
return_value=push,
):
delivered = await rt._deliver_report(
str(tmp_path / "child.md"), str(provenance_path), route
)
assert delivered is True
assert "metadata" not in push.send_push.await_args.args[0]["payload"]
@pytest.mark.asyncio
async def test_prepare_core_exception_returns_safe_internal_error(tmp_path, caplog):
report, _ = _document(tmp_path)
route = {"session_id": "S1"}
with patch.object(rt, "_get_route", return_value=route), patch.object(
rt, "_get_effective_request_output_dir", return_value=str(tmp_path)
), patch.object(
rt, "prepare_rewrite", side_effect=RuntimeError("secret /internal/path")
), caplog.at_level(logging.ERROR, logger=rt.__name__):
raw = await rt.deepresearch_prepare_rewrite._func(
report_path=str(report), action="polish", selection=_selection()
)
assert json.loads(raw) == {
"status": "error",
"error_code": "INTERNAL_ERROR",
"error": "rewrite preparation failed",
}
assert "secret" not in raw
assert "/internal/path" not in raw
assert "secret" not in caplog.text
assert "/internal/path" not in caplog.text
@pytest.mark.asyncio
async def test_commit_core_exception_returns_safe_write_error_before_delivery(caplog):
route = {"request_id": "R1", "channel_id": "CH1", "session_id": "S1"}
delivery = AsyncMock()
with patch.object(rt, "_get_route", return_value=route), patch.object(
rt, "commit_rewrite", side_effect=OSError("secret /internal/path")
), patch.object(rt, "_deliver_report", delivery), caplog.at_level(
logging.ERROR, logger=rt.__name__
):
raw = await rt.deepresearch_commit_rewrite._func(
context_token="token",
structured_result={
"units": [{
"unit_id": "unit_1",
"slots": [{"slot_id": "slot_1", "text": "new"}],
}],
"facts_added": False,
},
)
assert json.loads(raw) == {
"status": "error",
"error_code": "WRITE_FAILED",
"error": "rewrite commit failed",
}
assert "secret" not in raw
assert "/internal/path" not in raw
assert "secret" not in caplog.text
assert "/internal/path" not in caplog.text
delivery.assert_not_awaited()
@pytest.mark.asyncio
async def test_commit_publish_observer_runs_before_delivery_and_callback_failure_isolated():
delivery_entered = asyncio.Event()
allow_delivery = asyncio.Event()
result = {
"report_path": "/workspace/report-v2.md",
"provenance_path": "/workspace/report-v2.provenance.json",
"revision_id": "rev_child",
}
async def blocking_delivery(*_args):
delivery_entered.set()
await allow_delivery.wait()
return True
observed = []
with patch.object(rt, "_validate_commit_contract"), patch.object(
rt, "_get_route", return_value={"session_id": "S1", "channel_id": "C1"}
), patch.object(rt, "commit_rewrite", return_value=result), patch.object(
rt, "_deliver_report", side_effect=blocking_delivery
), rt._observe_rewrite_publish(lambda published: observed.append(published)):
task = asyncio.create_task(
rt.deepresearch_commit_rewrite._func("token", {"units": []})
)
await delivery_entered.wait()
assert observed == [result]
allow_delivery.set()
assert json.loads(await task)["report_delivered"] is True
with patch.object(rt, "_validate_commit_contract"), patch.object(
rt, "_get_route", return_value={"session_id": "S1", "channel_id": "C1"}
), patch.object(rt, "commit_rewrite", return_value=result), patch.object(
rt, "_deliver_report", new=AsyncMock(return_value=True)
), rt._observe_rewrite_publish(
lambda _published: (_ for _ in ()).throw(RuntimeError("observer-secret"))
):
raw = await rt.deepresearch_commit_rewrite._func("token", {"units": []})
assert json.loads(raw)["status"] == "completed"
@pytest.mark.asyncio
async def test_commit_publish_observer_is_context_local_between_concurrent_tasks():
def commit(*, context_token, **_kwargs):
return {
"report_path": f"/workspace/{context_token}.md",
"provenance_path": f"/workspace/{context_token}.json",
"revision_id": f"rev_{context_token}",
}
async def invoke(label):
observed = []
with rt._observe_rewrite_publish(
lambda published: observed.append(published["revision_id"])
):
await rt.deepresearch_commit_rewrite._func(label, {"units": []})
return observed
with patch.object(rt, "_validate_commit_contract"), patch.object(
rt, "_get_route", return_value={"session_id": "S1", "channel_id": "C1"}
), patch.object(rt, "commit_rewrite", side_effect=commit), patch.object(
rt, "_deliver_report", new=AsyncMock(return_value=True)
):
first, second = await asyncio.gather(invoke("a"), invoke("b"))
assert first == ["rev_a"]
assert second == ["rev_b"]
@pytest.mark.asyncio
async def test_commit_without_channel_keeps_completed_revision_and_marks_delivery_failed(tmp_path):
report, _ = _document(tmp_path)
route = {"request_id": "R1", "session_id": "S1"}
with patch.object(rt, "_get_route", return_value=route), patch.object(
rt, "_get_effective_request_output_dir", return_value=str(tmp_path)
):
prepared = json.loads(
await rt.deepresearch_prepare_rewrite._func(
report_path=str(report), action="polish", selection=_selection()
)
)
committed = json.loads(
await rt.deepresearch_commit_rewrite._func(
context_token=prepared["context_token"],
structured_result=_structured_result(prepared),
)
)
repeated = json.loads(
await rt.deepresearch_commit_rewrite._func(
context_token=prepared["context_token"],
structured_result=_structured_result(prepared),
)
)
assert committed["status"] == "completed"
assert committed["report_delivered"] is False
assert committed["delivery_status"] == "failed"
assert committed["delivery_error_code"] == "REPORT_DELIVERY_FAILED"
assert "error_code" not in committed
assert Path(committed["report_path"]).is_file()
assert Path(committed["provenance_path"]).is_file()
assert committed["document_id"] == "doc_test"
assert committed["revision_id"].startswith("rev_")
assert committed["citation_integrity_status"] == "verified"
assert committed["citation_semantic_status"] == "not_verified"
assert repeated["error_code"] == "CONTEXT_EXPIRED"
@pytest.mark.asyncio
async def test_commit_transport_failure_does_not_mask_completed_revision(tmp_path):
report, _ = _document(tmp_path)
route = {"request_id": "R1", "channel_id": "CH1", "session_id": "S1"}
with patch.object(rt, "_get_route", return_value=route), patch.object(
rt, "_get_effective_request_output_dir", return_value=str(tmp_path)
):
prepared = json.loads(
await rt.deepresearch_prepare_rewrite._func(
report_path=str(report), action="polish", selection=_selection()
)
)
push = AsyncMock()
push.send_push.side_effect = RuntimeError("secret transport detail")
with patch(
"jiuwenswarm.server.gateway_push.transport.WebSocketGatewayPushTransport",
return_value=push,
), patch.object(rt.logger, "exception") as exception_log, patch.object(
rt.logger, "error"
) as error_log:
committed_raw = await rt.deepresearch_commit_rewrite._func(
context_token=prepared["context_token"],
structured_result=_structured_result(prepared),
)
committed = json.loads(committed_raw)
assert committed["status"] == "completed"
assert committed["report_delivered"] is False
assert committed["delivery_status"] == "failed"
assert committed["delivery_error_code"] == "REPORT_DELIVERY_FAILED"
assert "error_code" not in committed
assert "secret transport detail" not in committed_raw
exception_log.assert_not_called()
assert "secret transport detail" not in str(error_log.call_args_list)
assert Path(committed["report_path"]).is_file()
@pytest.mark.asyncio
async def test_prepare_passes_protocol_v2_selection_to_core_unchanged(tmp_path):
report, _ = _document(tmp_path)
selection = _selection()
prepared = {"context_token": "T1", "units": []}
with patch.object(rt, "_get_route", return_value={"session_id": "S1"}), patch.object(
rt, "_get_effective_request_output_dir", return_value=str(tmp_path)
), patch.object(rt, "prepare_rewrite", return_value=prepared) as core_prepare:
raw = await rt.deepresearch_prepare_rewrite._func(
report_path=str(report),
action="polish",
selection=selection,
)
assert json.loads(raw) == {"status": "prepared", **prepared}
assert core_prepare.call_args.kwargs["selection"] is selection
@pytest.mark.asyncio
async def test_prepare_tool_returns_stable_error_without_leaking_selection(tmp_path, caplog):
report, _ = _document(tmp_path)
report.write_text("已变化。\n", encoding="utf-8")
selection = _selection()
with patch.object(rt, "_get_route", return_value={"session_id": "S1"}), patch.object(
rt, "_get_effective_request_output_dir", return_value=str(tmp_path)
), caplog.at_level(logging.INFO, logger=rt.__name__):
raw = await rt.deepresearch_prepare_rewrite._func(
report_path=str(report), action="polish", selection=selection
)
result = json.loads(raw)
assert result == {"status": "error", "error_code": "REVISION_CONFLICT", "error": "the report revision changed"}
assert "原句" not in raw
assert "原句" not in caplog.text
@pytest.mark.asyncio
async def test_generate_rewrite_html_invoke_keeps_lifecycle_and_rejects_invalid_schema():
valid_payload = {
"report_path": "/workspace/rewrite.md",
"revision_id": "rev_child",
}
invalid_payload = {**valid_payload, "extra": "SECRET-extra"}
export = {
"report_path": "/workspace/rewrite.md",
"final_result": {"response_content": "rewritten"},
}
html_path = Path("/workspace/rewrite.html")
with patch.object(
rt, "_get_route", return_value={"session_id": "S1", "channel_id": "CH1"}
), patch.object(
rt, "_get_effective_request_output_dir", return_value="/workspace"
), patch.object(
rt, "prepare_html_export", return_value=export
) as prepare, patch.object(
rt, "_generate_report_html", AsyncMock(return_value=html_path)
), patch.object(
rt, "_deliver_html", AsyncMock(return_value=True)
):
valid_raw, valid_events = await _invoke_with_event_probe(
rt.deepresearch_generate_rewrite_html, valid_payload
)
invalid_raw, invalid_events = await _invoke_with_event_probe(
rt.deepresearch_generate_rewrite_html, invalid_payload
)
assert json.loads(valid_raw) == {
"status": "completed",
"html_delivered": True,
"delivery_status": "delivered",
}
assert json.loads(invalid_raw) == {
"status": "error",
"error_code": "BAD_REQUEST",
"error": "invalid tool input",
}
assert "SECRET" not in invalid_raw
prepare.assert_called_once()
assert set(valid_events) == set(_INVOKE_LIFECYCLE_EVENTS)
assert invalid_events == [
ToolCallEvents.TOOL_INVOKE_INPUT,
ToolCallEvents.TOOL_CALL_STARTED,
ToolCallEvents.TOOL_PARSE_STARTED,
ToolCallEvents.TOOL_CALL_FINISHED,
ToolCallEvents.TOOL_INVOKE_OUTPUT,
]
@pytest.mark.asyncio
async def test_generate_rewrite_html_passes_inputs_generates_once_and_delivers_only_html():
route = {"request_id": "R1", "channel_id": "CH1", "session_id": "S1"}
final_result = {"response_content": "rewritten"}
export = {
"report_path": "/workspace/child.md",
"final_result": final_result,
}
html_path = Path("/workspace/child.html")
generator = AsyncMock(
return_value=(
html_path,
"fallback",
"invoke_llm",
"llm_call_failed",
)
)
delivery = AsyncMock(return_value=True)
with patch.object(rt, "_get_route", return_value=route), patch.object(
rt, "_get_effective_request_output_dir", return_value="/workspace"
), patch.object(
rt, "prepare_html_export", return_value=export
) as prepare, patch.object(
rt, "_generate_report_html", generator
), patch.object(
rt, "_deliver_html", delivery
):
raw = await rt.deepresearch_generate_rewrite_html._func(
report_path="/workspace/child.md",
revision_id="rev_child",
)
assert json.loads(raw) == {
"status": "completed",
"html_delivered": True,
"delivery_status": "delivered",
"html_style_status": "fallback",
"html_style_phase": "invoke_llm",
"html_style_reason_code": "llm_call_failed",
}
prepare.assert_called_once_with(
workspace_root="/workspace",
report_path="/workspace/child.md",
revision_id="rev_child",
)
generator.assert_awaited_once_with(
final_result,
Path("/workspace/child.md"),
"rewritten",
)
delivery.assert_awaited_once_with(
html_path,
route,
"fallback",
"invoke_llm",
"llm_call_failed",
)
assert "/workspace" not in raw
@pytest.mark.asyncio
@pytest.mark.parametrize(
("output_dir", "route"),
[
(None, {"session_id": "S1", "channel_id": "CH1"}),
("/workspace", {"channel_id": "CH1"}),
("/workspace", {"session_id": "S1"}),
],
)
async def test_generate_rewrite_html_requires_workspace_and_full_route_before_core(
output_dir, route
):
with patch.object(rt, "_get_route", return_value=route), patch.object(
rt, "_get_effective_request_output_dir", return_value=output_dir
), patch.object(
rt, "prepare_html_export", side_effect=AssertionError("core called")
) as prepare:
raw = await rt.deepresearch_generate_rewrite_html._func(
report_path="/SECRET/child.md",
revision_id="rev_child",
)
assert json.loads(raw) == {
"status": "error",
"error_code": "BAD_REQUEST",
"error": "rewrite HTML workspace or route is unavailable",
}
assert "SECRET" not in raw
prepare.assert_not_called()
@pytest.mark.asyncio
@pytest.mark.parametrize("error_code", ["BAD_REQUEST", "REVISION_CONFLICT"])
async def test_generate_rewrite_html_returns_safe_core_errors(error_code, caplog):
with patch.object(
rt, "_get_route", return_value={"session_id": "S1", "channel_id": "CH1"}
), patch.object(
rt, "_get_effective_request_output_dir", return_value="/workspace"
), patch.object(
rt,
"prepare_html_export",
side_effect=rt.RewriteError(error_code, "SECRET /internal/source.md"),
), caplog.at_level(logging.INFO, logger=rt.__name__):
raw = await rt.deepresearch_generate_rewrite_html._func(
report_path="/SECRET/child.md",
revision_id="rev_child",
)
expected_message = {
"BAD_REQUEST": "invalid HTML export request",
"REVISION_CONFLICT": "rewrite revision is unavailable",
}[error_code]
assert json.loads(raw) == {
"status": "error",
"error_code": error_code,
"error": expected_message,
}
assert "SECRET" not in raw
assert "/internal" not in raw
assert "SECRET" not in caplog.text
assert "/internal" not in caplog.text
@pytest.mark.asyncio
@pytest.mark.parametrize(
"generation_effect",
[None, RuntimeError("SECRET /internal/generated.html")],
)
async def test_generate_rewrite_html_generation_failure_does_not_deliver(
generation_effect, caplog
):
generator = AsyncMock()
if isinstance(generation_effect, Exception):
generator.side_effect = generation_effect
else:
generator.return_value = generation_effect
delivery = AsyncMock()
with patch.object(
rt, "_get_route", return_value={"session_id": "S1", "channel_id": "CH1"}
), patch.object(
rt, "_get_effective_request_output_dir", return_value="/workspace"
), patch.object(
rt,
"prepare_html_export",
return_value={
"report_path": "/workspace/child.md",
"final_result": {"response_content": "rewritten"},
},
), patch.object(
rt, "_generate_report_html", generator
), patch.object(
rt, "_deliver_html", delivery
), caplog.at_level(logging.ERROR, logger=rt.__name__):
raw = await rt.deepresearch_generate_rewrite_html._func(
report_path="/workspace/child.md",
revision_id="rev_child",
)
assert json.loads(raw) == {
"status": "error",
"error_code": "HTML_GENERATION_FAILED",
"error": "HTML generation failed; the Markdown rewrite remains available",
}
assert "SECRET" not in raw
assert "/internal" not in raw
assert "SECRET" not in caplog.text
assert "/internal" not in caplog.text
generator.assert_awaited_once()
delivery.assert_not_awaited()
@pytest.mark.asyncio
@pytest.mark.parametrize(
"delivery_effect",
[False, RuntimeError("SECRET /internal/delivery")],
)
async def test_generate_rewrite_html_delivery_failure_is_safe(delivery_effect, caplog):
delivery = AsyncMock()
if isinstance(delivery_effect, Exception):
delivery.side_effect = delivery_effect
else:
delivery.return_value = delivery_effect
with patch.object(
rt, "_get_route", return_value={"session_id": "S1", "channel_id": "CH1"}
), patch.object(
rt, "_get_effective_request_output_dir", return_value="/workspace"
), patch.object(
rt,
"prepare_html_export",
return_value={
"report_path": "/workspace/child.md",
"final_result": {"response_content": "rewritten"},
},
), patch.object(
rt, "_generate_report_html", AsyncMock(return_value=Path("/workspace/child.html"))
), patch.object(
rt, "_deliver_html", delivery
), caplog.at_level(logging.ERROR, logger=rt.__name__):
raw = await rt.deepresearch_generate_rewrite_html._func(
report_path="/workspace/child.md",
revision_id="rev_child",
)
assert json.loads(raw) == {
"status": "error",
"error_code": "HTML_DELIVERY_FAILED",
"error": "HTML delivery failed; the Markdown rewrite remains available",
}
assert "SECRET" not in raw
assert "/internal" not in raw
assert "SECRET" not in caplog.text
assert "/internal" not in caplog.text
delivery.assert_awaited_once()
@pytest.mark.asyncio
async def test_generate_rewrite_html_unexpected_preparation_failure_is_safe(caplog):
with patch.object(
rt, "_get_route", return_value={"session_id": "S1", "channel_id": "CH1"}
), patch.object(
rt, "_get_effective_request_output_dir", return_value="/workspace"
), patch.object(
rt,
"prepare_html_export",
side_effect=RuntimeError("SECRET /internal/preparation"),
), caplog.at_level(logging.ERROR, logger=rt.__name__):
raw = await rt.deepresearch_generate_rewrite_html._func(
report_path="/SECRET/child.md",
revision_id="rev_child",
)
assert json.loads(raw) == {
"status": "error",
"error_code": "INTERNAL_ERROR",
"error": "HTML export preparation failed",
}
assert "SECRET" not in raw
assert "/internal" not in raw
assert "SECRET" not in caplog.text
assert "/internal" not in caplog.text
@pytest.mark.asyncio
async def test_deliver_html_sends_style_status_metadata():
push = AsyncMock()
route = {"request_id": "R1", "channel_id": "CH1", "session_id": "S1"}
with patch(
"jiuwenswarm.server.gateway_push.transport.WebSocketGatewayPushTransport",
return_value=push,
):
delivered = await rt._deliver_html(
Path("/workspace/child.html"),
route,
"fallback",
"invoke_llm",
"llm_call_failed",
)
assert delivered is True
push.send_push.assert_awaited_once_with({
"request_id": "R1",
"channel_id": "CH1",
"session_id": "S1",
"payload": {
"event_type": "chat.file",
"files": [{"path": "/workspace/child.html", "name": "child.html"}],
"metadata": {
"htmlStyleStatus": "fallback",
"htmlStylePhase": "invoke_llm",
"htmlStyleReasonCode": "llm_call_failed",
},
},
"is_complete": False,
})