"""Observability E21: every message carries a stable `mid`. A recorded step points at the transcript message it produced by its `mid`, a ULID stamped when the message is appended or inserted. Positions move (a stub inserted mid-history after a restart, a rewritten file); the `mid` does not. Like `ts`, it must never reach a provider. """ from __future__ import annotations import asyncio import aisuite as ai from coworker.engine import TurnEngine from coworker.permissions import PermissionEngine from coworker.providers import AssistantTurn, ModelCapabilities, ProviderClient, ToolCall from coworker.tools import ToolRegistry class CapturingProvider(ProviderClient): def __init__(self, turns): self._turns = list(turns) self.calls: list[list[dict]] = [] def complete(self, *, model, messages, tools=None, **settings): self.calls.append([dict(m) for m in messages]) return self._turns.pop(0) def capabilities(self, model): return ModelCapabilities() def _text(text): return AssistantTurn(text=text, finish_reason="stop") def _tool(name, args, call_id="call_1"): return AssistantTurn( tool_calls=[ToolCall(id=call_id, name=name, arguments=args)], finish_reason="tool_calls", ) def _engine(tmp_path, turns, *, messages=None, instructions=None): provider = CapturingProvider(turns) registry = ToolRegistry() registry.register_all(ai.toolkits.files(root=str(tmp_path), allow_write=True)) engine = TurnEngine( provider=provider, registry=registry, permissions=PermissionEngine(workspace_root=tmp_path), model="gpt-5.5", messages=messages, instructions=instructions, ) return engine, provider def _run(engine, text): async def _go(): return [ev async for ev in engine.run(text)] return asyncio.run(_go()) def test_every_message_gets_a_unique_mid(tmp_path): (tmp_path / "a.txt").write_text("hello", encoding="utf-8") engine, _ = _engine( tmp_path, [_tool("read_file", {"path": "a.txt"}), _text("it says hello")], instructions="be brief", ) _run(engine, "read a.txt") assert [m["role"] for m in engine.messages] == ["system", "user", "assistant", "tool", "assistant"] mids = [m["mid"] for m in engine.messages] assert all(isinstance(mid, str) and len(mid) == 26 for mid in mids) assert len(set(mids)) == len(mids) assert mids[1:] == sorted(mids[1:]) # sortable by creation def test_mid_never_reaches_a_provider(tmp_path): (tmp_path / "a.txt").write_text("hello", encoding="utf-8") engine, provider = _engine(tmp_path, [_tool("read_file", {"path": "a.txt"}), _text("done")]) _run(engine, "read a.txt") assert provider.calls assert all("mid" not in m for call in provider.calls for m in call) assert all("mid" in m for m in engine.messages) # the strip is a copy def test_a_stub_inserted_mid_history_gets_its_own_mid_and_others_keep_theirs(tmp_path): # A restart left an assistant tool call with no result, followed by later messages. history = [ {"role": "user", "content": "do it", "mid": "01OLDUSER000000000000000000"[:26]}, { "role": "assistant", "content": "", "tool_calls": [{"id": "call_9", "type": "function", "function": {"name": "read_file", "arguments": "{}"}}], "mid": "01OLDASSIST0000000000000000"[:26], }, {"role": "user", "content": "still there?", "mid": "01OLDUSER200000000000000000"[:26]}, ] before = {m["mid"] for m in history} engine, _ = _engine(tmp_path, [_text("yes")], messages=history) _run(engine, "hello") stub = engine.messages[2] assert stub["role"] == "tool" and stub["tool_call_id"] == "call_9" assert stub["mid"] not in before assert {m["mid"] for m in engine.messages if m["mid"] in before} == before def test_messages_saved_before_mids_still_work(tmp_path): # A transcript written before E21: no mid anywhere. Nothing breaks, nothing is backfilled. history = [{"role": "user", "content": "hi"}, {"role": "assistant", "content": "hello"}] engine, provider = _engine(tmp_path, [_text("again")], messages=history) _run(engine, "once more") assert "mid" not in engine.messages[0] and "mid" not in engine.messages[1] assert "mid" in engine.messages[-1] assert all("mid" not in m for call in provider.calls for m in call)