Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
test(employees): archive Gmail issue diagnostic reproductions
trohitg7b4233a2cd07
diff --git a/.tmp_issue_validation/README.md b/.tmp_issue_validation/README.mdnew file mode 100644index 00000000..12862713--- /dev/null+++ b/.tmp_issue_validation/README.md@@ -0,0 +1,17 @@+# Original Gmail issue diagnostics++These scripts preserve the investigation that confirmed issues #143–145 before+the fixes. They assert the original behavior and are historical diagnostics,+not the current regression suite.++To reproduce the original observations, use a separate checkout of pre-fix+revision `988f7c5422ba055095e4d497eea6d390e5224107`, copy these diagnostic files+into `.tmp_issue_validation/`, and follow the commands in each script.+The payload diagnostic also inspects the reported revision `d36f7db`.++The permanent regression coverage for the corrected behavior lives under+`server/tests/services/employees/` and `server/tests/temporal/`.++`test_event_flag.py` records the separate framework-disabled investigation;+that behavior remains outside the scope of the three implemented fixes.+The diagnostics use synthetic email content and intercept external services.diff --git a/.tmp_issue_validation/test_employee_stall.py b/.tmp_issue_validation/test_employee_stall.pynew file mode 100644index 00000000..376cf286--- /dev/null+++ b/.tmp_issue_validation/test_employee_stall.py@@ -0,0 +1,103 @@+r"""Read-only diagnostic for #145; outbound node execution is intercepted.++Run from server/: .venv\Scripts\python.exe -m pytest -c pyproject.toml -p tests.conftest+ ../.tmp_issue_validation/test_employee_stall.py -q -p no:cacheprovider+The real Database session/task-query methods use an isolated SQLite database.+No LLM, Temporal server, credentials, approval or Gmail service is contacted.+"""+from __future__ import annotations++import importlib.util+import sys+from pathlib import Path+from types import SimpleNamespace+from unittest.mock import AsyncMock+from uuid import uuid4++import pytest+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine+from sqlalchemy.pool import StaticPool+from sqlmodel import SQLModel++from models.database import AgentTeam, TeamTask+from models.employees import EmployeeJob+from services.employees.jobs import bind_job_team, deliver_job, job_progress+from tests.services.employees.test_jobs import context, install, saved+++async def isolated_database():+ name = "tests._employee_stall_db_" + uuid4().hex+ source = Path(__file__).resolve().parents[1] / "server/core/database.py"+ spec = importlib.util.spec_from_file_location(name, source)+ module = importlib.util.module_from_spec(spec)+ sys.modules[name] = module+ spec.loader.exec_module(module)+ database = module.Database(SimpleNamespace())+ database.engine = create_async_engine("sqlite+aiosqlite:///:memory:", poolclass=StaticPool)+ database.async_session = async_sessionmaker(database.engine, class_=AsyncSession, expire_on_commit=False)+ async with database.engine.begin() as connection:+ await connection.run_sync(lambda sync: SQLModel.metadata.create_all(+ sync, tables=[EmployeeJob.__table__, AgentTeam.__table__, TeamTask.__table__]+ ))+ try:+ yield database+ finally:+ await database.shutdown()+ sys.modules.pop(name, None)+++def intercepted_delivery(isolated_database, monkeypatch):+ execute = AsyncMock(return_value={"success": True, "result": {"approved": True}})+ monkeypatch.setattr("core.container.container", SimpleNamespace(+ database=lambda: isolated_database,+ workflow_service=lambda: SimpleNamespace(execute_node=execute),+ ))+ return execute+++async def test_zero_tasks_and_lead_final_draft_persist_working_without_approval(+ isolated_database, intercepted_delivery,+):+ database = isolated_database+ await install(database, sink="gmailSend")+ async with database.reserved_session() as session:+ job = await session.get(EmployeeJob, "job")+ job.team_id = None+ job.state = "running"+ session.add(AgentTeam(id="team", workflow_id="7", team_lead_node_id="lead"))+ await session.commit()+ await bind_job_team(database, workflow_id="7", lead_node_id="lead", execution_id="origin", team_id="team")+ assert await database.get_team_tasks("team") == []+ assert (await saved(database)).state == "working"++ result = await deliver_job(database, context("Here is my drafted email reply."), lead_node_id="lead")++ assert result == {"delivered": False, "state": "working", "job_id": "job"}+ job = await saved(database)+ assert job.state == "working"+ assert job.result is None+ assert job.delivery["inflight"] is None+ assert job.delivery["completed"] == []+ assert (await job_progress(database, "7"))["state"] == "working"+ intercepted_delivery.assert_not_awaited()+++async def test_accepted_task_control_enters_approval_then_gmail_and_finishes(+ isolated_database, intercepted_delivery,+):+ database = isolated_database+ await install(database, sink="gmailSend")+ async with database.reserved_session() as session:+ session.add(AgentTeam(id="team", workflow_id="7", team_lead_node_id="lead"))+ session.add(TeamTask(id="accepted-task", team_id="team", title="Draft reply",+ created_by="lead", assigned_to="specialist", workflow_id="7", status="accepted"))+ await session.commit()+ assert [task["status"] for task in await database.get_team_tasks("team")] == ["accepted"]++ result = await deliver_job(database, context("The reviewed email reply."), lead_node_id="lead")++ assert result == {"delivered": True, "state": "delivered", "job_id": "job"}+ assert (await saved(database)).state == "delivered"+ assert [call.kwargs["node_type"] for call in intercepted_delivery.await_args_list] == ["approvalGate", "gmailSend"]diff --git a/.tmp_issue_validation/test_event_flag.py b/.tmp_issue_validation/test_event_flag.pynew file mode 100644index 00000000..857d9a36--- /dev/null+++ b/.tmp_issue_validation/test_event_flag.py@@ -0,0 +1,41 @@+"""Issue #143 diagnostic: flag-off drops teammate completion delivery.++Run from server with its Python and ``-p tests.conftest``. Only external+delivery functions are mocked; the task-event producer and dispatch are real.+"""++from types import SimpleNamespace+from unittest.mock import AsyncMock++import pytest++from nodes.agent._events import broadcast_agent_task_completed+from services.events import dispatch++[email protected]("enabled", [False, True])+async def test_task_completion_dispatch_depends_on_framework_flag(monkeypatch, enabled):+ monkeypatch.setattr(+ dispatch, "Settings", lambda: SimpleNamespace(event_framework_enabled=enabled)+ )+ signal = AsyncMock()+ broadcast = AsyncMock()+ monkeypatch.setattr(dispatch, "_signal_running_consumers", signal)+ monkeypatch.setattr(dispatch, "_broadcast_in_process", broadcast)++ await broadcast_agent_task_completed(+ task_id="diagnostic-task",+ agent_name="Worker",+ agent_node_id="worker",+ parent_node_id="lead",+ workflow_id="diagnostic-workflow",+ result="Reviewed email draft",+ )++ assert signal.await_count == int(enabled)+ assert broadcast.await_count == int(enabled)+ if enabled:+ event = signal.await_args.args[0]+ assert event.data["task_id"] == "diagnostic-task"+ assert event.data["result"] == "Reviewed email draft"diff --git a/.tmp_issue_validation/test_gmail_payload.py b/.tmp_issue_validation/test_gmail_payload.pynew file mode 100644index 00000000..6e8ac8d4--- /dev/null+++ b/.tmp_issue_validation/test_gmail_payload.py@@ -0,0 +1,226 @@+"""Read-only diagnostic for GitHub #143; these assert observed behavior.++The controller, listener, graph construction, Gmail formatter, starter+substitution, and parameter resolver are real. Only Temporal runtime/I/O+entry points are replaced. No Gmail server, real child workflow, LLM, or+approval queue is exercised.++Run from server/ (the shared test bootstrap stubs unrelated application DI):+.venv/Scripts/python.exe -m pytest ../.tmp_issue_validation/test_gmail_payload.py -q -s -p tests.conftest -p no:cacheprovider+"""++from __future__ import annotations++import asyncio+import base64+import copy+import functools+import importlib+import json+from pathlib import Path+import subprocess+import sys+import types+from unittest.mock import MagicMock++import pytest++ROOT = Path(__file__).resolve().parents[1]+sys.path.insert(0, str(ROOT / "server"))+sys.path.insert(0, str(ROOT))++from nodes.google._events import gmail_message_received+from nodes.google._gmail import format_message+from services.employees.builder import _substitute+from services.parameter_resolver import ParameterResolver+from temporalio import workflow++[email protected]_cache+def historical_source(revision: str, stem: str) -> str:+ return subprocess.check_output(+ ["git", "show", f"{revision}:server/services/temporal/{stem}.py"],+ cwd=ROOT,+ text=True,+ encoding="utf-8",+ )+++def load_temporal_modules(revision: str, monkeypatch):+ """Use exact historical workflow source without changing the checkout."""+ package = importlib.import_module("services.temporal")+ stems = (+ "trigger_listener_workflow",+ "polling_trigger_workflow",+ "workflow_control_workflow",+ )+ current = {+ stem: importlib.import_module(f"services.temporal.{stem}")+ for stem in stems+ }+ if revision == "working":+ return current+ loaded = {}+ for stem in stems:+ name = f"services.temporal.{stem}"+ module = types.ModuleType(name)+ module.__package__ = "services.temporal"+ module.__file__ = f"git:{revision}:server/services/temporal/{stem}.py"+ monkeypatch.setitem(sys.modules, name, module)+ monkeypatch.setattr(package, stem, module)+ exec(compile(historical_source(revision, stem), module.__file__, "exec"), module.__dict__)+ loaded[stem] = module+ return loaded+++def gmail_poll_result():+ """Use the real Gmail formatter, then the polling activity's stable ID."""+ body = "Please reply to this email."+ raw = format_message(+ {+ "id": "gmail-test",+ "threadId": "gmail-thread",+ "snippet": body,+ "labelIds": ["INBOX", "UNREAD"],+ "payload": {+ "headers": [+ {"name": "From", "value": "[email protected]"},+ {"name": "Subject", "value": "Reply requested"},+ ],+ "body": {"data": base64.urlsafe_b64encode(body.encode()).decode()},+ },+ },+ include_body=True,+ )+ raw.setdefault("id", raw["message_id"])+ assert "data" not in raw+ return raw+++ "revision,control_version,queue_patch,enveloped,expect_loss",+ [+ ("d36f7db", 0, True, False, True),+ ("d36f7db", 0, True, True, False),+ ("d36f7db", 0, False, False, False),+ ("working", 0, True, False, True),+ ("working", 0, True, True, False),+ ("working", 0, False, False, False),+ ("working", 1, True, False, True),+ ("working", 1, True, True, False),+ ],+)+async def test_controller_poll_to_child_to_mission(+ monkeypatch, revision, control_version, queue_patch, enveloped, expect_loss+):+ modules = load_temporal_modules(revision, monkeypatch)+ controller = modules["workflow_control_workflow"].WorkflowControlWorkflow()+ email = gmail_poll_result()+ event = gmail_message_received(email).model_dump(mode="json") if enveloped else email+ captured = []+ polls = []+ completed = asyncio.Event()++ async def fake_wait(predicate):+ while not predicate():+ await asyncio.sleep(0)++ async def fake_sleep(_duration):+ await asyncio.sleep(0)++ async def fake_activity(name, payload, **_options):+ if name == "poll.googleGmailReceive.v1":+ polls.append(copy.deepcopy(payload))+ if payload["baseline_only"]:+ return {"events": [], "seen_ids": ["old-gmail"]}+ if len(polls) == 2:+ return {"events": [copy.deepcopy(event)], "seen_ids": ["old-gmail", "gmail-test"]}+ await completed.wait()+ return {"events": [], "seen_ids": ["old-gmail", "gmail-test"]}+ if name == "evaluate_trigger_filter_activity":+ return True+ if name == "broadcast_trigger_status_activity":+ return None+ raise AssertionError(f"Unexpected activity: {name}")++ async def fake_child(name, *, args, **_options):+ assert name == "MachinaWorkflow"+ captured.append(args[0])+ controller._closed = True+ completed.set()++ monkeypatch.setattr(workflow, "logger", MagicMock())+ monkeypatch.setattr(workflow, "patched", lambda name: queue_patch if name == "controller-durable-queue-v2" else True)+ monkeypatch.setattr(workflow, "wait_condition", fake_wait)+ monkeypatch.setattr(workflow, "sleep", fake_sleep)+ monkeypatch.setattr(workflow, "execute_activity", fake_activity)+ monkeypatch.setattr(workflow, "start_child_workflow", fake_child)+ monkeypatch.setattr(workflow, "in_workflow", lambda: False)+ monkeypatch.setattr(workflow, "info", lambda: types.SimpleNamespace(+ workflow_id="gmail-controller", run_id="probe-run",+ get_current_history_length=lambda: 0,+ is_continue_as_new_suggested=lambda: False,+ ))++ nodes = [+ {"id": "gmail", "type": "googleGmailReceive", "data": {"label": "Gmail"}},+ {"id": "job", "type": "employeeJob", "data": {"label": "Employee job"}},+ ]+ edges = [{"source": "gmail", "target": "job", "sourceHandle": "output-main", "targetHandle": "input-main"}]+ spec = {+ "listener_id": "gmail-listener", "workflow_type": "PollingTriggerWorkflow",+ "trigger_node_id": "gmail", "event_type": "com.opencompany.gmail.message.received",+ "listener_args": {+ "trigger_node_id": "gmail", "trigger_label": "gmail", "node_type": "googleGmailReceive",+ "workflow_id": "gmail-probe", "workflow_slug": "gmail-probe",+ "data_scope_id": "gmail-probe-scope", "graphVersion": 2, "generation": 1,+ "version": 1, "filter_params": {"poll_interval": 60}, "seen_ids": [],+ "nodes": nodes, "edges": edges,+ },+ }+ control_data = {+ "state": "running", "generation": 1,+ "execution_control_version": control_version,+ "controller_workflow_id": "gmail-controller",+ "triggers": {"gmail-listener": spec},+ }+ try:+ await asyncio.wait_for(controller.run(control_data), timeout=5)+ finally:+ completed.set()+ for task in controller._poll_tasks.values():+ task.cancel()+ await asyncio.gather(*controller._poll_tasks.values(), return_exceptions=True)++ assert len(captured) == 1+ assert len(polls) >= 2+ assert polls[0]["baseline_only"] is True+ assert polls[1]["baseline_only"] is False+ child = captured[0]+ trigger = next(node for node in child["nodes"] if node["id"] == "gmail")+ assert trigger["_pre_executed"] is True+ output = trigger["_trigger_output"]+ assert output["_event_envelope"] == event++ config = json.loads((ROOT / "server/config/employee_apps.json").read_text(encoding="utf-8"))+ prompt = _substitute(config["apps"]["gmail"]["trigger"]["prompt"], {}, "gmail", {})++ async def shared_output(*_args):+ raise AssertionError("The mission must use this run's trigger output")++ resolver = ParameterResolver(None, shared_output)+ resolved = await resolver.resolve(+ {"mission": prompt}, "job", child["nodes"], child["edges"], "gmail-probe-scope",+ run_outputs={"gmail": output},+ )+ expected_complete = "New email from [email protected]\nSubject: Reply requested\n\nPlease reply to this email."+ if expect_loss:+ assert set(output) == {"_event_envelope"}+ assert resolved["mission"] == "New email from \nSubject: \n\n"+ else:+ assert output["from"] == email["from"]+ assert output["subject"] == email["subject"]+ assert output["body"] == email["body"]+ assert resolved["mission"] == expected_complete+ print(f"{revision} control={control_version} queue_patch={queue_patch} enveloped={enveloped}: {resolved['mission']!r}")diff --git a/.tmp_issue_validation/test_long_email.py b/.tmp_issue_validation/test_long_email.pynew file mode 100644index 00000000..4ea28df5--- /dev/null+++ b/.tmp_issue_validation/test_long_email.py@@ -0,0 +1,141 @@+r"""Read-only diagnostics for issue #144; no product code or external services.++Run from server/:+ .\.venv\Scripts\python.exe -m pytest -q -s -o asyncio_mode=auto -p tests.conftest \+ ../.tmp_issue_validation/test_long_email.py -p no:cacheprovider++tests.conftest isolates app/container imports. Gmail decoding, parameter+resolution, employee parameter validation, v2 admission, job creation and+SQLite persistence below use the actual implementations.+"""+from __future__ import annotations++import base64++import pytest+from pydantic import ValidationError+from sqlalchemy.dialects import postgresql+from sqlalchemy.schema import CreateTable++from models.employees import Employee, EmployeeJob+from nodes.google._gmail import format_message+from nodes.workflow.employee_job import EmployeeJobParams+from services.employees.builder import build_employee_graph+from services.employees.team_runtime import admit_employee_runtime_job+from services.parameter_resolver import ParameterResolver+from tests.services.employees.test_graph_builder import hire, inputs+from tests.services.employees.test_jobs import database # noqa: F401+++def gmail_team():+ request = hire(+ name="Leo", role="Inbox assistant", apps=["Gmail"],+ job="Read new email, answer what you can and flag the rest",+ steps=[{"title": "Read new email", "role": "trigger", "app": "Gmail"}],+ trigger={"kind": "app_event", "app": "Gmail"},+ )+ return build_employee_graph(inputs(request, "gmail", connected={"gmail"}, team=True))+++def email_event(body: str):+ return format_message({+ "id": "long-message", "threadId": "email-thread",+ "labelIds": ["INBOX", "UNREAD"],+ "payload": {+ "mimeType": "text/html",+ "headers": [+ {"name": "From", "value": "[email protected]"},+ {"name": "Subject", "value": "Promotion"},+ ],+ "body": {"data": base64.urlsafe_b64encode(body.encode()).decode()},+ },+ }, include_body=True)+++async def resolved_mission(built, event):+ async def absent_output(*_args):+ return {}++ # Recipe v1 assigned this same trigger-derived prompt to intake.mission.+ lead = built.node_roles["agent"]+ parameters = await ParameterResolver(None, absent_output).resolve(+ {"mission": built.parameters[lead]["prompt"]}, lead,+ built.nodes, built.edges, "diagnostic-scope",+ run_outputs={built.node_roles["trigger"]: event},+ )+ return parameters["mission"]+++async def test_reported_86310_character_body_reproduces_v1_cap():+ built = gmail_team()+ body = "<p>" + "x" * 86303 + "</p>"+ event = email_event(body)+ mission = await resolved_mission(built, event)++ assert len(body) == len(event["body"]) == 86310+ assert mission.endswith(body)+ assert len(mission) == 86364+ with pytest.raises(ValidationError) as caught:+ EmployeeJobParams(operation="intake", mission=mission)+ error = caught.value.errors()[0]+ assert error["loc"] == ("mission",)+ assert error["type"] == "string_too_long"+ assert error["msg"] == "String should have at most 20000 characters"+ print(f"#144 v1: body={len(body)}, mission={len(mission)}, error={error['msg']}")++[email protected]("mission_length", [19999, 20000, 20001])+async def test_v1_limit_applies_to_entire_resolved_mission(mission_length):+ built = gmail_team()+ prefix_length = len(await resolved_mission(built, email_event("")))+ body = "x" * (mission_length - prefix_length)+ mission = await resolved_mission(built, email_event(body))+ assert len(mission) == mission_length+ if mission_length <= 20000:+ assert EmployeeJobParams(operation="intake", mission=mission).mission == mission+ else:+ with pytest.raises(ValidationError, match="at most 20000"):+ EmployeeJobParams(operation="intake", mission=mission)+ print(f"#144 v1 boundary: mission={mission_length}, admitted={mission_length <= 20000}")+++async def test_current_v2_admission_persists_same_long_mission_in_sqlite(database):+ built = gmail_team()+ assert built.team_plan["version"] == 2+ assert not any(node["type"] == "employeeJob" for node in built.nodes)+ lead, trigger = built.node_roles["agent"], built.node_roles["trigger"]+ assert any(edge["source"] == trigger and edge["target"] == lead for edge in built.edges)+ event = email_event("<p>" + "x" * 86303 + "</p>")+ mission = await resolved_mission(built, event)+ assert await database.save_workflow(+ "7", "Long email diagnostic", "long-email-diagnostic",+ {"graphVersion": 2, "owner_id": "owner", "nodes": built.nodes, "edges": built.edges},+ )+ async with database.reserved_session() as session:+ session.add(Employee(+ id="long-email-employee", workflow_id="7", owner_id="owner",+ hire_state="ready", team_plan=built.team_plan, node_roles=built.node_roles,+ ))+ await session.commit()++ context = {+ "workflow_id": "7", "node_id": lead, "execution_id": "long-email-origin",+ "nodes": built.nodes, "edges": built.edges, "generation": 1,+ "session_id": "7", "data_scope_id": "diagnostic-scope", "user_id": "owner",+ "parameter_snapshot": built.parameters, "inputs": {trigger: event},+ }+ # This calls the actual create_job and commits an EmployeeJob row.+ await admit_employee_runtime_job(database, context, built.team_plan, mission)+ async with database.get_session() as session:+ stored = await session.get(EmployeeJob, context["employee_job_id"])+ assert stored is not None+ assert stored.mission == mission+ assert stored.source["outputs"][trigger]["body"] == event["body"]+ assert stored.state == "running"+ print(f"#144 current v2 SQLite: admitted and persisted mission={len(stored.mission)}")+++def test_postgresql_schema_evidence_only():+ ddl = str(CreateTable(EmployeeJob.__table__).compile(dialect=postgresql.dialect()))+ assert "mission VARCHAR(20000) NOT NULL" in ddl+ print("#144 PostgreSQL: schema still has mission VARCHAR(20000); no live PostgreSQL reproduction")