Skip to content

Self-improving AI Employees for everyone

test(employees): archive Gmail issue diagnostic reproductions

trohitg7b4233a2cd07
diff --git a/.tmp_issue_validation/README.md b/.tmp_issue_validation/README.md
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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
+
+
+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.py
new file mode 100644
index 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")