test(uipath-agents): four coded-framework e2e tests

Adds zero-to-running tests for the four coded-agent frameworks the
skill teaches, each going scaffold -> uip codedagent init -> uip
codedagent run end-to-end:

- skill-agent-coded-simple-echo (smoke) — Pydantic Input/Output, no
  LLM, deterministic; runs the agent locally and asserts echoed
  output.
- skill-agent-coded-langgraph-classifier (e2e) — StateGraph + lazy
  UiPathChat() inside a node, schema-sync from Pydantic
  GraphInput/GraphOutput.
- skill-agent-coded-llamaindex-workflow (e2e) — Workflow subclass
  with StartEvent/StopEvent fields and lazy UiPathOpenAI inside a
  @step.
- skill-agent-coded-openai-agents-handoff (e2e) — multi-agent triage
  with handoffs to billing/technical specialists, exercising the
  factory-function pattern (def main() -> Agent).

Each task uses a goal-only prompt so the skill drives the "how".
Each check script asserts: pyproject hygiene (no [build-system],
authors present, framework dep declared), runtime config file shape
(langgraph.json / llama_index.json / openai_agents.json /
uipath.json functions), source-code shape (Pydantic models,
framework-specific exports), the lazy-LLM-init invariant via
_shared/ast_lazy_init_check, schema-sync between declared models
and entry-points.json, and bindings.json envelope well-formedness.

Author: radugheo

tests/tasks/uipath-agents/langgraph_classifier/check_langgraph_classifier.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""LangGraph agent project-shape check.
+
+Asserts the lazy-LLM-init invariant (Critical Rule C4 — the highest-cost
+coded mistake the report flags) and the schema-sync invariant
+(`agent.json`/`entry-points.json` reflect the Pydantic Input/Output
+classes the agent declared).
+
+Checks performed:
+
+  1. `support-classifier/pyproject.toml` declares `uipath-langchain`
+     as a dependency, has `[project]` with `authors`, and contains NO
+     `[build-system]` section.
+  2. The project has either `langgraph.json` (Pattern A — recommended)
+     OR `uipath.json` with a `functions.graph` entry (Pattern B). Both
+     are valid per the LangGraph integration guide.
+  3. `main.py` (or `graph.py`) defines `GraphInput`/`GraphOutput`
+     Pydantic models, exports a top-level `graph` variable, and has
+     NO module-level UiPath* construction (`UiPathChat`,
+     `UiPathAzureChatOpenAI`, etc.).
+  4. `entry-points.json` has one entrypoint whose schemas mention
+     `text` (input) and `category` (output) — proves `uip codedagent
+     init` ran AFTER the Pydantic models were written.
+  5. `bindings.json` is the v2.0 envelope (resource count is not
+     asserted — the classifier itself uses no SDK resources).
+
+Exits 0 on PASS, with a `FAIL: ...` message on the first violation.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+ROOT = Path(os.getcwd())
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from _shared.bindings_assertions import load_bindings  # noqa: E402
+from _shared.ast_lazy_init_check import find_module_level_llm_clients  # noqa: E402
+
+
+def _read_text(path: Path) -> str:
+    if not path.is_file():
+        sys.exit(f"FAIL: Missing {path}")
+    return path.read_text(encoding="utf-8")
+
+
+def _load_json(path: Path) -> dict:
+    raw = _read_text(path)
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError as e:
+        sys.exit(f"FAIL: {path} is not valid JSON: {e}")
+
+
+def check_pyproject() -> None:
+    text = _read_text(ROOT / "pyproject.toml")
+    if "[build-system]" in text:
+        sys.exit(
+            "FAIL: pyproject.toml contains a [build-system] section — "
+            "Critical Rule C1 forbids it."
+        )
+    if "[project]" not in text or "authors" not in text:
+        sys.exit("FAIL: pyproject.toml is missing [project] or `authors`")
+    if "uipath-langchain" not in text:
+        sys.exit(
+            "FAIL: pyproject.toml does not declare `uipath-langchain` — "
+            "the LangGraph integration guide makes this dependency mandatory."
+        )
+    print("OK: pyproject.toml is hygienic and declares uipath-langchain")
+
+
+def find_graph_module() -> Path:
+    for candidate in ("main.py", "graph.py"):
+        path = ROOT / candidate
+        if path.is_file():
+            return path
+    sys.exit(
+        "FAIL: neither main.py nor graph.py found under "
+        f"{ROOT} — LangGraph integration guide requires one."
+    )
+
+
+def check_graph_module(path: Path) -> None:
+    text = _read_text(path)
+    for needle in ("GraphInput", "GraphOutput", "graph"):
+        if needle not in text:
+            sys.exit(f"FAIL: {path.name} is missing `{needle}`")
+    if "StateGraph" not in text and "CompiledStateGraph" not in text:
+        sys.exit(f"FAIL: {path.name} does not reference StateGraph / CompiledStateGraph")
+    print(f"OK: {path.name} defines GraphInput, GraphOutput, and a graph variable")
+    violations = find_module_level_llm_clients(path)
+    if violations:
+        sys.exit("FAIL: " + " | ".join(violations))
+    print(
+        f"OK: {path.name} has no module-level UiPath* construction "
+        "(lazy-LLM-init invariant holds)"
+    )
+
+
+def check_runtime_config() -> None:
+    langgraph_json = ROOT / "langgraph.json"
+    uipath_json = ROOT / "uipath.json"
+    if langgraph_json.is_file():
+        doc = _load_json(langgraph_json)
+        graphs = doc.get("graphs") or {}
+        if not graphs:
+            sys.exit("FAIL: langgraph.json has no `graphs` mapping")
+        target = next(iter(graphs.values()))
+        if not isinstance(target, str) or ":graph" not in target:
+            sys.exit(
+                f'FAIL: langgraph.json graphs entry should map to a `<file>:graph` '
+                f'reference, got {target!r}'
+            )
+        print(f"OK: langgraph.json registers a graph -> {target!r}")
+        return
+    if uipath_json.is_file():
+        doc = _load_json(uipath_json)
+        functions = doc.get("functions") or {}
+        graph_entry = functions.get("graph")
+        if not graph_entry or ":graph" not in graph_entry:
+            sys.exit(
+                "FAIL: neither langgraph.json nor uipath.json `functions.graph` "
+                "is present — the runtime cannot find the compiled graph."
+            )
+        print(f'OK: uipath.json registers functions.graph -> {graph_entry!r}')
+        return
+    sys.exit(
+        "FAIL: project has neither langgraph.json nor uipath.json — at "
+        "least one is required for `uip codedagent init` to succeed."
+    )
+
+
+def check_entry_points() -> None:
+    doc = _load_json(ROOT / "entry-points.json")
+    entrypoints = doc.get("entryPoints") or []
+    if not entrypoints:
+        sys.exit("FAIL: entry-points.json has no entryPoints — `uip codedagent init` did not run successfully")
+    raw = json.dumps(entrypoints)
+    for field in ("text", "category"):
+        if field not in raw:
+            sys.exit(
+                f'FAIL: entry-points.json schemas do not mention `{field}`. '
+                f'Either `uip codedagent init` ran before the Pydantic models '
+                f'were written, or the models did not declare the expected '
+                f'fields. Got: {raw}'
+            )
+    print(
+        "OK: entry-points.json schemas reflect the GraphInput/GraphOutput "
+        "fields (text, category)"
+    )
+
+
+def check_bindings() -> None:
+    load_bindings(ROOT / "bindings.json")
+    print("OK: bindings.json envelope is well-formed")
+
+
+def main() -> None:
+    if not ROOT.is_dir():
+        sys.exit(f"FAIL: project directory {ROOT} does not exist")
+    check_pyproject()
+    graph_module = find_graph_module()
+    check_graph_module(graph_module)
+    check_runtime_config()
+    check_entry_points()
+    check_bindings()
+
+
+if __name__ == "__main__":
+    main()

tests/tasks/uipath-agents/langgraph_classifier/langgraph_classifier.yaml

@@ -0,0 +1,97 @@
+task_id: skill-agent-coded-langgraph-classifier
+description: >
+  LangGraph coded agent zero-to-running. Verifies the skill guides the
+  agent to scaffold a LangGraph project (`uv add uipath-langchain` →
+  `uip codedagent new` → `langgraph.json` + `main.py` exporting a
+  compiled `graph`), keep LLM construction inside a node body
+  (Critical Rule C4 — module-level `UiPathChat()` would break
+  `uip codedagent init` with `ImportError`), let `uip codedagent
+  init` regenerate the schema from the actual code, and run the
+  classifier end-to-end via `uip codedagent run agent`. Closes
+  report Top-10 #1 (highest-priority coded gap, lazy-LLM-init
+  invariant).
+tags: [uipath-agents, e2e, coded, lifecycle:generate, lifecycle:execute, feature:framework-langgraph, feature:schema-sync]
+max_iterations: 1
+
+agent:
+  type: claude-code
+  permission_mode: acceptEdits
+  allowed_tools: ["Skill", "Bash", "Read", "Write", "Edit", "Glob", "Grep"]
+  turn_timeout: 1200
+
+sandbox:
+  driver: tempdir
+  python: {}
+
+initial_prompt: |
+  Build a LangGraph UiPath coded agent named `support-classifier` that
+  classifies a customer support ticket into one of three categories:
+  `billing`, `technical`, `general`. The agent uses `UiPathChat`
+  (routed through the UiPath LLM Gateway) for the classification.
+
+  Input: `{"text": "<support ticket text>"}` — a Pydantic
+  `GraphInput` with one `text: str` field.
+  Output: `{"category": "<billing|technical|general>", "text": "..."}`
+  — a Pydantic `GraphOutput` with `category: str` and `text: str`.
+
+  Take the agent end-to-end through scaffold → init → run. Use
+  `gpt-4o-mini-2024-07-18` (or another low-cost model the gateway
+  exposes) and pin `temperature=0` so the classification is
+  reproducible. Run the agent against
+  `'{"text": "I was charged twice for my last invoice."}'` — the
+  expected category is `billing`.
+
+  After `uip codedagent run agent '{"text": "..."}'` succeeds, write
+  `RAN_OK` to `run_marker.txt` in the project root so the test
+  harness can verify the run completed cleanly.
+
+  Do NOT publish, upload, or deploy. Do NOT pause between planning
+  and implementation. Complete the entire task end-to-end in a
+  single pass.
+
+success_criteria:
+  - type: command_executed
+    description: "Agent installed the LangGraph framework dependency"
+    tool_name: "Bash"
+    command_pattern: 'uv\s+add\s+uipath-langchain'
+    min_count: 1
+    weight: 1.0
+    pass_threshold: 1.0
+
+  - type: command_executed
+    description: "Agent scaffolded with uip codedagent new"
+    tool_name: "Bash"
+    command_pattern: 'uip\s+codedagent\s+new'
+    min_count: 1
+    weight: 1.5
+    pass_threshold: 1.0
+
+  - type: command_executed
+    description: "Agent ran uip codedagent init to generate entry-points.json"
+    tool_name: "Bash"
+    command_pattern: 'uip\s+codedagent\s+init'
+    min_count: 1
+    weight: 2.0
+    pass_threshold: 1.0
+
+  - type: command_executed
+    description: "Agent executed the agent locally with uip codedagent run"
+    tool_name: "Bash"
+    command_pattern: 'uip\s+codedagent\s+run\s+agent'
+    min_count: 1
+    weight: 2.0
+    pass_threshold: 1.0
+
+  - type: file_exists
+    description: "Agent wrote run_marker.txt after a successful run"
+    path: "run_marker.txt"
+    weight: 2.0
+    pass_threshold: 1.0
+
+  - type: run_command
+    description: "LangGraph project shape, lazy-LLM-init invariant, schema sync"
+    command: "python3 $TASK_DIR/check_langgraph_classifier.py"
+    timeout: 30
+    expected_exit_code: 0
+    weight: 5.0
+    pass_threshold: 1.0