agentsml-impl 0.2.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- agentsml_impl/__init__.py +3 -0
- agentsml_impl/cli.py +472 -0
- agentsml_impl/compiler/__init__.py +1 -0
- agentsml_impl/compiler/capabilities.py +330 -0
- agentsml_impl/compiler/conditions.py +177 -0
- agentsml_impl/compiler/diagnostics.py +112 -0
- agentsml_impl/compiler/durations.py +31 -0
- agentsml_impl/compiler/expressions.py +123 -0
- agentsml_impl/compiler/identifiers.py +60 -0
- agentsml_impl/compiler/ir.py +391 -0
- agentsml_impl/compiler/limits.py +28 -0
- agentsml_impl/compiler/loader.py +83 -0
- agentsml_impl/compiler/naming.py +87 -0
- agentsml_impl/compiler/planner.py +79 -0
- agentsml_impl/compiler/render.py +90 -0
- agentsml_impl/compiler/schema_validation.py +121 -0
- agentsml_impl/compiler/semantic_validation.py +424 -0
- agentsml_impl/protocols/__init__.py +1 -0
- agentsml_impl/runtime/__init__.py +1 -0
- agentsml_impl/runtime/events.py +59 -0
- agentsml_impl/runtime/json_schema.py +138 -0
- agentsml_impl/runtime/tools.py +145 -0
- agentsml_impl/schemas/agentsml.schema.json +406 -0
- agentsml_impl/schemas/v0.1/agentsml.schema.json +628 -0
- agentsml_impl/schemas/v0.2/agentsml.schema.json +363 -0
- agentsml_impl/schemas/v0.3/agentsml.schema.json +406 -0
- agentsml_impl/targets/__init__.py +1 -0
- agentsml_impl/targets/a2a/__init__.py +0 -0
- agentsml_impl/targets/a2a/adapter.py +94 -0
- agentsml_impl/targets/a2a/capabilities.yaml +25 -0
- agentsml_impl/targets/ag2/__init__.py +0 -0
- agentsml_impl/targets/ag2/adapter.py +655 -0
- agentsml_impl/targets/ag2/capabilities.yaml +37 -0
- agentsml_impl/targets/ag_ui/__init__.py +0 -0
- agentsml_impl/targets/ag_ui/adapter.py +123 -0
- agentsml_impl/targets/ag_ui/capabilities.yaml +25 -0
- agentsml_impl/targets/agno/__init__.py +0 -0
- agentsml_impl/targets/agno/adapter.py +191 -0
- agentsml_impl/targets/agno/capabilities.yaml +26 -0
- agentsml_impl/targets/ap2/__init__.py +0 -0
- agentsml_impl/targets/ap2/adapter.py +84 -0
- agentsml_impl/targets/ap2/capabilities.yaml +25 -0
- agentsml_impl/targets/base.py +157 -0
- agentsml_impl/targets/bedrock_agentcore/__init__.py +0 -0
- agentsml_impl/targets/bedrock_agentcore/adapter.py +592 -0
- agentsml_impl/targets/bedrock_agentcore/capabilities.yaml +26 -0
- agentsml_impl/targets/claude_agent_sdk/__init__.py +0 -0
- agentsml_impl/targets/claude_agent_sdk/adapter.py +178 -0
- agentsml_impl/targets/claude_agent_sdk/capabilities.yaml +26 -0
- agentsml_impl/targets/crewai/__init__.py +0 -0
- agentsml_impl/targets/crewai/adapter.py +441 -0
- agentsml_impl/targets/crewai/capabilities.yaml +30 -0
- agentsml_impl/targets/databricks/__init__.py +0 -0
- agentsml_impl/targets/databricks/adapter.py +427 -0
- agentsml_impl/targets/databricks/capabilities.yaml +26 -0
- agentsml_impl/targets/flowise/__init__.py +0 -0
- agentsml_impl/targets/flowise/adapter.py +71 -0
- agentsml_impl/targets/flowise/capabilities.yaml +26 -0
- agentsml_impl/targets/google_adk/__init__.py +0 -0
- agentsml_impl/targets/google_adk/adapter.py +589 -0
- agentsml_impl/targets/google_adk/capabilities.yaml +36 -0
- agentsml_impl/targets/langchain/__init__.py +1 -0
- agentsml_impl/targets/langchain/adapter.py +351 -0
- agentsml_impl/targets/langchain/capabilities.yaml +30 -0
- agentsml_impl/targets/langflow/__init__.py +0 -0
- agentsml_impl/targets/langflow/adapter.py +147 -0
- agentsml_impl/targets/langflow/capabilities.yaml +26 -0
- agentsml_impl/targets/langgraph/__init__.py +0 -0
- agentsml_impl/targets/langgraph/adapter.py +911 -0
- agentsml_impl/targets/langgraph/capabilities.yaml +33 -0
- agentsml_impl/targets/llamaindex/__init__.py +1 -0
- agentsml_impl/targets/llamaindex/adapter.py +406 -0
- agentsml_impl/targets/llamaindex/capabilities.yaml +31 -0
- agentsml_impl/targets/lyzr/__init__.py +0 -0
- agentsml_impl/targets/lyzr/adapter.py +146 -0
- agentsml_impl/targets/lyzr/capabilities.yaml +26 -0
- agentsml_impl/targets/mastra/__init__.py +0 -0
- agentsml_impl/targets/mastra/adapter.py +635 -0
- agentsml_impl/targets/mastra/capabilities.yaml +32 -0
- agentsml_impl/targets/mcp_server/__init__.py +0 -0
- agentsml_impl/targets/mcp_server/adapter.py +141 -0
- agentsml_impl/targets/mcp_server/capabilities.yaml +25 -0
- agentsml_impl/targets/microsoft_agent_framework/__init__.py +0 -0
- agentsml_impl/targets/microsoft_agent_framework/adapter.py +563 -0
- agentsml_impl/targets/microsoft_agent_framework/capabilities.yaml +26 -0
- agentsml_impl/targets/n8n/__init__.py +0 -0
- agentsml_impl/targets/n8n/adapter.py +139 -0
- agentsml_impl/targets/n8n/capabilities.yaml +26 -0
- agentsml_impl/targets/openai_agents/__init__.py +0 -0
- agentsml_impl/targets/openai_agents/adapter.py +175 -0
- agentsml_impl/targets/openai_agents/capabilities.yaml +27 -0
- agentsml_impl/targets/pydantic_ai/__init__.py +0 -0
- agentsml_impl/targets/pydantic_ai/adapter.py +922 -0
- agentsml_impl/targets/pydantic_ai/capabilities.yaml +37 -0
- agentsml_impl/targets/registry.py +290 -0
- agentsml_impl/targets/relevance_ai/__init__.py +0 -0
- agentsml_impl/targets/relevance_ai/adapter.py +66 -0
- agentsml_impl/targets/relevance_ai/capabilities.yaml +26 -0
- agentsml_impl/targets/smolagents/__init__.py +0 -0
- agentsml_impl/targets/smolagents/adapter.py +210 -0
- agentsml_impl/targets/smolagents/capabilities.yaml +27 -0
- agentsml_impl/targets/snowflake_cortex/__init__.py +0 -0
- agentsml_impl/targets/snowflake_cortex/adapter.py +167 -0
- agentsml_impl/targets/snowflake_cortex/capabilities.yaml +26 -0
- agentsml_impl/targets/spring_ai/__init__.py +1 -0
- agentsml_impl/targets/spring_ai/adapter.py +626 -0
- agentsml_impl/targets/spring_ai/capabilities.yaml +31 -0
- agentsml_impl/targets/strands_agents/__init__.py +1 -0
- agentsml_impl/targets/strands_agents/adapter.py +309 -0
- agentsml_impl/targets/strands_agents/capabilities.yaml +29 -0
- agentsml_impl/targets/support_matrix.py +91 -0
- agentsml_impl/targets/ucp/__init__.py +0 -0
- agentsml_impl/targets/ucp/adapter.py +86 -0
- agentsml_impl/targets/ucp/capabilities.yaml +25 -0
- agentsml_impl/targets/vercel_ai/__init__.py +1 -0
- agentsml_impl/targets/vercel_ai/adapter.py +349 -0
- agentsml_impl/targets/vercel_ai/capabilities.yaml +30 -0
- agentsml_impl/targets/vertex_agent_engine/__init__.py +0 -0
- agentsml_impl/targets/vertex_agent_engine/adapter.py +407 -0
- agentsml_impl/targets/vertex_agent_engine/capabilities.yaml +26 -0
- agentsml_impl/targets/zapier_agents/__init__.py +0 -0
- agentsml_impl/targets/zapier_agents/adapter.py +106 -0
- agentsml_impl/targets/zapier_agents/capabilities.yaml +26 -0
- agentsml_impl-0.2.0.dist-info/METADATA +109 -0
- agentsml_impl-0.2.0.dist-info/RECORD +129 -0
- agentsml_impl-0.2.0.dist-info/WHEEL +5 -0
- agentsml_impl-0.2.0.dist-info/entry_points.txt +3 -0
- agentsml_impl-0.2.0.dist-info/licenses/LICENSE +28 -0
- agentsml_impl-0.2.0.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,911 @@
|
|
|
1
|
+
"""LangGraph target adapter — Level 1 code generation."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
from pathlib import Path
|
|
5
|
+
|
|
6
|
+
from agentsml_impl.compiler.identifiers import python_identifier_ir
|
|
7
|
+
from agentsml_impl.compiler.ir import AgentSystemIR, ModelIR
|
|
8
|
+
from agentsml_impl.compiler.conditions import ConditionError, compile_condition, compile_condition_with_references
|
|
9
|
+
from agentsml_impl.compiler.durations import parse_duration_seconds
|
|
10
|
+
from agentsml_impl.compiler.limits import MAX_MODEL_TOKENS, clamp_max_tokens
|
|
11
|
+
from agentsml_impl.compiler.diagnostics import DiagCode, DiagnosticSet
|
|
12
|
+
from agentsml_impl.compiler.planner import GenerationPlan
|
|
13
|
+
from agentsml_impl.compiler.render import toml_string, write_file
|
|
14
|
+
from agentsml_impl.compiler.naming import snake_identifier
|
|
15
|
+
from agentsml_impl.runtime.tools import generate_tools_module
|
|
16
|
+
from agentsml_impl.runtime.json_schema import generate_models_source
|
|
17
|
+
from agentsml_impl.targets.base import TargetAdapter, GenerationResult
|
|
18
|
+
|
|
19
|
+
JSON_OUTPUT_INSTRUCTION = (
|
|
20
|
+
"Respond with a single JSON object only, with no surrounding text. "
|
|
21
|
+
"Workflow conditions read fields from your reply."
|
|
22
|
+
)
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
class Adapter(TargetAdapter):
|
|
26
|
+
@property
|
|
27
|
+
def name(self) -> str:
|
|
28
|
+
return "langgraph"
|
|
29
|
+
|
|
30
|
+
def analyze(self, ir: AgentSystemIR, diagnostics: DiagnosticSet) -> None:
|
|
31
|
+
from agentsml_impl.compiler.capabilities import analyze_capabilities
|
|
32
|
+
analyze_capabilities(ir, self.name, diagnostics)
|
|
33
|
+
|
|
34
|
+
def generate(self, ir: AgentSystemIR, plan: GenerationPlan,
|
|
35
|
+
out_dir: Path, diagnostics: DiagnosticSet) -> GenerationResult:
|
|
36
|
+
ir = python_identifier_ir(ir)
|
|
37
|
+
out_dir.mkdir(parents=True, exist_ok=True)
|
|
38
|
+
pkg = plan.package_name
|
|
39
|
+
src = out_dir / "src" / pkg
|
|
40
|
+
src.mkdir(parents=True, exist_ok=True)
|
|
41
|
+
|
|
42
|
+
files: list[str] = []
|
|
43
|
+
files += _write_pyproject(ir, plan, out_dir)
|
|
44
|
+
files += _write_state(ir, plan, src, out_dir)
|
|
45
|
+
files += _write_tools(ir, src, out_dir, diagnostics)
|
|
46
|
+
files += _write_schemas(ir, src, out_dir, diagnostics)
|
|
47
|
+
graph_files, use_async = _write_graph(ir, plan, src, out_dir, diagnostics)
|
|
48
|
+
files += graph_files
|
|
49
|
+
files += _write_run(plan, src, out_dir, use_async)
|
|
50
|
+
files += _write_init(plan, src, out_dir)
|
|
51
|
+
files += _write_readme(ir, plan, out_dir)
|
|
52
|
+
return GenerationResult(target=self.name, out_dir=out_dir,
|
|
53
|
+
files_written=files, success=True)
|
|
54
|
+
|
|
55
|
+
|
|
56
|
+
_EFFORT_BUDGET_TOKENS = {"low": 1024, "medium": 4096, "high": 16000}
|
|
57
|
+
|
|
58
|
+
|
|
59
|
+
def _reasoning_kwargs(provider: str, reasoning, ds: DiagnosticSet | None = None,
|
|
60
|
+
path: str = "") -> str:
|
|
61
|
+
"""Provider-specific model kwargs for an agent's Draft 0.3 `reasoning` block.
|
|
62
|
+
|
|
63
|
+
Returned as a leading-comma kwargs string (or empty). Mapping:
|
|
64
|
+
openai/azure: reasoning_effort=<effort> (off -> omitted)
|
|
65
|
+
anthropic: thinking={"type": "enabled", "budget_tokens": N}
|
|
66
|
+
google: thinking_budget=N, include_thoughts=<expose_trace>
|
|
67
|
+
Effort levels without an explicit budget_tokens map to 1024/4096/16000 tokens.
|
|
68
|
+
"""
|
|
69
|
+
if reasoning is None:
|
|
70
|
+
return ""
|
|
71
|
+
effort = reasoning.effort
|
|
72
|
+
budget = reasoning.budget_tokens
|
|
73
|
+
if budget is None and effort in _EFFORT_BUDGET_TOKENS:
|
|
74
|
+
budget = _EFFORT_BUDGET_TOKENS[effort]
|
|
75
|
+
if provider in ("openai", "azure", "azure-openai", "anthropic") and ds is not None and (
|
|
76
|
+
reasoning.budget_tokens is not None or reasoning.expose_trace is not None):
|
|
77
|
+
dropped = [n for n, v in (("budget_tokens", reasoning.budget_tokens if provider != "anthropic" else None),
|
|
78
|
+
("expose_trace", reasoning.expose_trace)) if v is not None]
|
|
79
|
+
if dropped:
|
|
80
|
+
ds.add_warning(
|
|
81
|
+
DiagCode.LOSSY_MAPPING,
|
|
82
|
+
f"reasoning.{'/'.join(dropped)} has no {provider} model kwarg in the generated "
|
|
83
|
+
"LangGraph code and is dropped.",
|
|
84
|
+
target="langgraph", path=path or None,
|
|
85
|
+
)
|
|
86
|
+
if provider in ("openai", "azure", "azure-openai"):
|
|
87
|
+
return f", reasoning_effort={effort!r}" if effort in ("low", "medium", "high") else ""
|
|
88
|
+
if provider == "anthropic":
|
|
89
|
+
if effort == "off" or budget is None:
|
|
90
|
+
return ""
|
|
91
|
+
return f', thinking={{"type": "enabled", "budget_tokens": {max(budget, 1024)}}}'
|
|
92
|
+
if provider in ("google", "gemini", "google-cloud"):
|
|
93
|
+
out = ""
|
|
94
|
+
if effort == "off":
|
|
95
|
+
out += ", thinking_budget=0"
|
|
96
|
+
elif budget is not None:
|
|
97
|
+
out += f", thinking_budget={budget}"
|
|
98
|
+
if reasoning.expose_trace is not None:
|
|
99
|
+
out += f", include_thoughts={bool(reasoning.expose_trace)!r}"
|
|
100
|
+
return out
|
|
101
|
+
return ""
|
|
102
|
+
|
|
103
|
+
|
|
104
|
+
def _model_str(model: ModelIR, ds: DiagnosticSet | None = None, reasoning=None) -> str:
|
|
105
|
+
p = model.provider.lower()
|
|
106
|
+
n = model.name
|
|
107
|
+
t = model.parameters.get("temperature", 0.1)
|
|
108
|
+
parameters = dict(model.parameters)
|
|
109
|
+
if "max_tokens" in parameters:
|
|
110
|
+
clamped, was_clamped = clamp_max_tokens(parameters["max_tokens"])
|
|
111
|
+
parameters["max_tokens"] = clamped
|
|
112
|
+
if was_clamped and ds is not None:
|
|
113
|
+
ds.add_warning(
|
|
114
|
+
DiagCode.UNSUPPORTED_FEATURE,
|
|
115
|
+
f"Model '{model.key}' requested {model.parameters['max_tokens']} completion tokens, "
|
|
116
|
+
f"which is above the {MAX_MODEL_TOKENS} token ceiling. The generated model call "
|
|
117
|
+
f"requests {clamped} tokens instead.",
|
|
118
|
+
path=f"models.{model.key}.parameters.max_tokens",
|
|
119
|
+
recommendation=(
|
|
120
|
+
f"Set max_tokens to at most {MAX_MODEL_TOKENS} so the request fits the "
|
|
121
|
+
"served model's context window."
|
|
122
|
+
),
|
|
123
|
+
)
|
|
124
|
+
extra = "".join(
|
|
125
|
+
f", {key}={parameters[key]!r}"
|
|
126
|
+
for key in ("max_tokens", "extra_body")
|
|
127
|
+
if key in parameters
|
|
128
|
+
)
|
|
129
|
+
rk = _reasoning_kwargs(p, reasoning, ds, f"models.{model.key}.reasoning")
|
|
130
|
+
if p == "openai":
|
|
131
|
+
return f'ChatOpenAI(model="{n}", temperature={t}{extra}{rk})'
|
|
132
|
+
if p in ("google", "gemini", "google-cloud"):
|
|
133
|
+
return f'ChatGoogleGenerativeAI(model="{n}", temperature={t}{rk})'
|
|
134
|
+
if p == "anthropic":
|
|
135
|
+
# Anthropic rejects temperature != 1 when extended thinking is enabled.
|
|
136
|
+
temp = "" if "thinking=" in rk else f", temperature={t}"
|
|
137
|
+
return f'ChatAnthropic(model="{n}"{temp}{rk})'
|
|
138
|
+
if p in ("azure", "azure-openai"):
|
|
139
|
+
return f'AzureChatOpenAI(deployment_name="{n}"{extra}{rk})'
|
|
140
|
+
return f'ChatOpenAI(model="{n}", temperature={t}{extra}) # TODO: unknown provider {p!r}'
|
|
141
|
+
|
|
142
|
+
|
|
143
|
+
def _provider_imports(ir: AgentSystemIR) -> str:
|
|
144
|
+
imports: set[str] = set()
|
|
145
|
+
for agent in ir.agents.values():
|
|
146
|
+
m = ir.models.get(agent.model)
|
|
147
|
+
if not m:
|
|
148
|
+
continue
|
|
149
|
+
p = m.provider.lower()
|
|
150
|
+
if p == "openai":
|
|
151
|
+
imports.add("from langchain_openai import ChatOpenAI")
|
|
152
|
+
elif p in ("google", "gemini", "google-cloud"):
|
|
153
|
+
imports.add("from langchain_google_genai import ChatGoogleGenerativeAI")
|
|
154
|
+
elif p == "anthropic":
|
|
155
|
+
imports.add("from langchain_anthropic import ChatAnthropic")
|
|
156
|
+
elif p in ("azure", "azure-openai"):
|
|
157
|
+
imports.add("from langchain_openai import AzureChatOpenAI")
|
|
158
|
+
else:
|
|
159
|
+
imports.add("from langchain_openai import ChatOpenAI # fallback")
|
|
160
|
+
return "\n".join(sorted(imports))
|
|
161
|
+
|
|
162
|
+
|
|
163
|
+
def _write_pyproject(ir: AgentSystemIR, plan: GenerationPlan, out_dir: Path) -> list[str]:
|
|
164
|
+
c = f'''\
|
|
165
|
+
[build-system]
|
|
166
|
+
requires = ["setuptools>=68"]
|
|
167
|
+
build-backend = "setuptools.build_meta"
|
|
168
|
+
|
|
169
|
+
[project]
|
|
170
|
+
name = "{plan.package_name}"
|
|
171
|
+
version = "{ir.metadata.version or '0.1.0'}"
|
|
172
|
+
description = {toml_string(ir.metadata.description or plan.project_name)}
|
|
173
|
+
requires-python = ">=3.11"
|
|
174
|
+
dependencies = [
|
|
175
|
+
"langgraph>=1.2.20",
|
|
176
|
+
"langchain-core>=1.8.0",
|
|
177
|
+
"langchain-openai>=1.7.4",
|
|
178
|
+
"langchain-google-genai>=2.0",
|
|
179
|
+
"langchain-anthropic>=0.3",
|
|
180
|
+
"python-dotenv",
|
|
181
|
+
]
|
|
182
|
+
|
|
183
|
+
[tool.setuptools.packages.find]
|
|
184
|
+
where = ["src"]
|
|
185
|
+
'''
|
|
186
|
+
write_file(out_dir, "pyproject.toml", c)
|
|
187
|
+
return ["pyproject.toml"]
|
|
188
|
+
|
|
189
|
+
|
|
190
|
+
_APPROVAL_MODES = ("always", "once_per_session", "per_arguments")
|
|
191
|
+
|
|
192
|
+
|
|
193
|
+
def _tool_approval_policy(ir: AgentSystemIR, ds: DiagnosticSet | None = None) -> dict[str, str]:
|
|
194
|
+
"""Map generated tool function name -> approval mode for tools that need approval."""
|
|
195
|
+
policy: dict[str, str] = {}
|
|
196
|
+
for key, tool in ir.tools.items():
|
|
197
|
+
if not tool.needs_approval:
|
|
198
|
+
continue
|
|
199
|
+
mode = tool.approval_mode or "always"
|
|
200
|
+
if mode not in _APPROVAL_MODES:
|
|
201
|
+
if ds is not None:
|
|
202
|
+
ds.add_warning(
|
|
203
|
+
DiagCode.LOSSY_MAPPING,
|
|
204
|
+
f"Tool '{key}' approval_mode '{mode}' is not implemented by the langgraph target; "
|
|
205
|
+
"it is enforced as 'always'.",
|
|
206
|
+
target="langgraph", path=f"tools.{key}.approval_mode",
|
|
207
|
+
)
|
|
208
|
+
mode = "always"
|
|
209
|
+
policy[snake_identifier(key, prefix="tool")] = mode
|
|
210
|
+
return policy
|
|
211
|
+
|
|
212
|
+
|
|
213
|
+
_GUARDED_TOOL_NODE = '''
|
|
214
|
+
|
|
215
|
+
def guarded_tool_node(tools: list[Any], policy: dict[str, str]) -> Callable[[WorkflowState], dict[str, Any]]:
|
|
216
|
+
"""ToolNode that asks a human before running tools that need approval.
|
|
217
|
+
|
|
218
|
+
Before such a tool runs the graph calls ``interrupt({{"type": "tool_approval", "tool": name,
|
|
219
|
+
"args": args}})`` and proceeds only when the resumed decision approves. A rejected call yields
|
|
220
|
+
an error ToolMessage. ``policy`` maps tool name -> ``always`` | ``once_per_session`` |
|
|
221
|
+
``per_arguments``; approvals for the latter two are remembered in ``tool_approvals`` state
|
|
222
|
+
(per thread). Requires a checkpointer.
|
|
223
|
+
"""
|
|
224
|
+
import hashlib
|
|
225
|
+
from langchain_core.messages import ToolMessage
|
|
226
|
+
from langgraph.prebuilt import ToolNode
|
|
227
|
+
|
|
228
|
+
inner = ToolNode(tools)
|
|
229
|
+
|
|
230
|
+
def node(state: WorkflowState) -> dict[str, Any]:
|
|
231
|
+
last = state["messages"][-1]
|
|
232
|
+
approvals = dict(state.get("tool_approvals") or {{}})
|
|
233
|
+
new: dict[str, Any] = {{}}
|
|
234
|
+
allowed: list[dict[str, Any]] = []
|
|
235
|
+
rejected: dict[str, Any] = {{}}
|
|
236
|
+
for call in last.tool_calls:
|
|
237
|
+
mode = policy.get(call["name"])
|
|
238
|
+
if mode is None:
|
|
239
|
+
allowed.append(call)
|
|
240
|
+
continue
|
|
241
|
+
if mode == "once_per_session":
|
|
242
|
+
key = call["name"]
|
|
243
|
+
else:
|
|
244
|
+
canonical = json.dumps(call.get("args", {{}}), sort_keys=True, default=str, separators=(",", ":"))
|
|
245
|
+
key = call["name"] + ":" + hashlib.sha256(canonical.encode()).hexdigest()
|
|
246
|
+
if mode != "always" and key in approvals:
|
|
247
|
+
allowed.append(call)
|
|
248
|
+
continue
|
|
249
|
+
decision = interrupt({{"type": "tool_approval", "tool": call["name"], "args": call.get("args", {{}})}})
|
|
250
|
+
if is_approved(decision):
|
|
251
|
+
allowed.append(call)
|
|
252
|
+
if mode != "always":
|
|
253
|
+
approvals[key] = True
|
|
254
|
+
new[key] = True
|
|
255
|
+
else:
|
|
256
|
+
rejected[call["id"]] = ToolMessage(
|
|
257
|
+
content=f"Tool call '{{call['name']}}' was rejected by a human reviewer and did not run.",
|
|
258
|
+
tool_call_id=call["id"], name=call["name"], status="error")
|
|
259
|
+
results: dict[str, Any] = dict(rejected)
|
|
260
|
+
if allowed:
|
|
261
|
+
out = inner.invoke({{"messages": [last.model_copy(update={{"tool_calls": allowed}})]}})
|
|
262
|
+
for msg in out["messages"]:
|
|
263
|
+
results[msg.tool_call_id] = msg
|
|
264
|
+
ordered = [results[c["id"]] for c in last.tool_calls if c["id"] in results]
|
|
265
|
+
return {{"messages": ordered, "tool_approvals": new}}
|
|
266
|
+
|
|
267
|
+
return node
|
|
268
|
+
'''
|
|
269
|
+
|
|
270
|
+
|
|
271
|
+
def _write_state(ir: AgentSystemIR, plan: GenerationPlan, src: Path, out_dir: Path) -> list[str]:
|
|
272
|
+
wf = ir.workflows.get(plan.main_workflow_key)
|
|
273
|
+
extra_fields: list[str] = []
|
|
274
|
+
if wf and wf.state:
|
|
275
|
+
for fname, fschema in wf.state.get("schema", {}).get("properties", {}).items():
|
|
276
|
+
t = fschema.get("type", "Any")
|
|
277
|
+
py = {"string": "str", "integer": "int", "boolean": "bool",
|
|
278
|
+
"number": "float", "array": "list"}.get(t, "Any")
|
|
279
|
+
extra_fields.append(f" {snake_identifier(fname, prefix='state')}: Optional[{py}] = None")
|
|
280
|
+
extra = "\n".join(extra_fields) or " # No extra state fields"
|
|
281
|
+
gated = bool(_tool_approval_policy(ir))
|
|
282
|
+
approvals_field = " tool_approvals: Annotated[dict[str, Any], merge_dicts]\n" if gated else ""
|
|
283
|
+
guard_block = _GUARDED_TOOL_NODE.format() if gated else ""
|
|
284
|
+
c = f'''\
|
|
285
|
+
"""Workflow state — auto-generated for {plan.project_name}."""
|
|
286
|
+
from __future__ import annotations
|
|
287
|
+
import asyncio
|
|
288
|
+
import json
|
|
289
|
+
import operator
|
|
290
|
+
from typing import Annotated, Any, Callable, Optional
|
|
291
|
+
from langchain_core.messages import AIMessage, BaseMessage, HumanMessage
|
|
292
|
+
from langgraph.graph.message import add_messages
|
|
293
|
+
from langgraph.types import interrupt
|
|
294
|
+
from typing import TypedDict
|
|
295
|
+
|
|
296
|
+
|
|
297
|
+
def merge_dicts(left: dict[str, Any], right: dict[str, Any]) -> dict[str, Any]:
|
|
298
|
+
return {{**left, **right}}
|
|
299
|
+
|
|
300
|
+
|
|
301
|
+
class WorkflowState(TypedDict, total=False):
|
|
302
|
+
messages: Annotated[list[BaseMessage], add_messages]
|
|
303
|
+
input: dict[str, Any]
|
|
304
|
+
steps: Annotated[dict[str, Any], merge_dicts]
|
|
305
|
+
state: Annotated[dict[str, Any], merge_dicts]
|
|
306
|
+
{approvals_field}{extra}
|
|
307
|
+
|
|
308
|
+
|
|
309
|
+
_OPERATORS: dict[str, Callable[[Any, Any], bool]] = {{
|
|
310
|
+
"==": operator.eq,
|
|
311
|
+
"!=": operator.ne,
|
|
312
|
+
"<": operator.lt,
|
|
313
|
+
"<=": operator.le,
|
|
314
|
+
">": operator.gt,
|
|
315
|
+
">=": operator.ge,
|
|
316
|
+
}}
|
|
317
|
+
|
|
318
|
+
|
|
319
|
+
def compare(left: Any, op: str, right: Any) -> bool:
|
|
320
|
+
try:
|
|
321
|
+
return bool(_OPERATORS[op](left, right))
|
|
322
|
+
except TypeError:
|
|
323
|
+
return False
|
|
324
|
+
|
|
325
|
+
|
|
326
|
+
def lookup(ctx: dict[str, Any], path: str) -> Any:
|
|
327
|
+
value: Any = ctx
|
|
328
|
+
for part in path.split("."):
|
|
329
|
+
if isinstance(value, dict):
|
|
330
|
+
value = value.get(part)
|
|
331
|
+
elif isinstance(value, list) and part.isdigit() and int(part) < len(value):
|
|
332
|
+
value = value[int(part)]
|
|
333
|
+
else:
|
|
334
|
+
return None
|
|
335
|
+
return value
|
|
336
|
+
|
|
337
|
+
|
|
338
|
+
def parse_step_output(text: Any) -> dict[str, Any]:
|
|
339
|
+
try:
|
|
340
|
+
value = json.loads(text)
|
|
341
|
+
except (TypeError, ValueError):
|
|
342
|
+
return {{"text": text}}
|
|
343
|
+
return value if isinstance(value, dict) else {{"value": value}}
|
|
344
|
+
|
|
345
|
+
|
|
346
|
+
def record_step_output(update: dict[str, Any], step_id: str, approval: Any = None) -> dict[str, Any]:
|
|
347
|
+
messages = update.get("messages") or []
|
|
348
|
+
output = parse_step_output(messages[-1].content) if messages else {{}}
|
|
349
|
+
entry: dict[str, Any] = {{"output": output}}
|
|
350
|
+
if approval is not None:
|
|
351
|
+
entry["approval"] = approval
|
|
352
|
+
return {{**update, "steps": {{step_id: entry}}, "state": {{step_id: output}}}}
|
|
353
|
+
|
|
354
|
+
|
|
355
|
+
def with_step_output(step_id: str, node: Callable[[WorkflowState], dict[str, Any]]) -> Callable[[WorkflowState], dict[str, Any]]:
|
|
356
|
+
def wrapped(state: WorkflowState) -> dict[str, Any]:
|
|
357
|
+
return record_step_output(node(state), step_id)
|
|
358
|
+
return wrapped
|
|
359
|
+
|
|
360
|
+
|
|
361
|
+
def with_timeout(step_id: str, node: Any, seconds: float, on_timeout: str = "error",
|
|
362
|
+
fallback_output: tuple = (), fallback_node: Any = None) -> Callable[[WorkflowState], Any]:
|
|
363
|
+
"""Run a sync node as an async LangGraph node so ``add_node(timeout=...)`` applies.
|
|
364
|
+
|
|
365
|
+
``error`` lets LangGraph's NodeTimeoutError propagate (and be retried by the node
|
|
366
|
+
retry policy). ``return_to_model`` and ``fallback`` enforce the same deadline here,
|
|
367
|
+
catch the timeout, and return a state update instead of failing the run.
|
|
368
|
+
In ``fallback`` mode a declared ``fallback_output`` (a 1-tuple holding the value) is returned
|
|
369
|
+
as the step output; otherwise ``fallback_node`` (the step re-run with the fallback model) runs
|
|
370
|
+
under the same deadline and its timeout propagates.
|
|
371
|
+
"""
|
|
372
|
+
async def wrapped(state: WorkflowState) -> dict[str, Any]:
|
|
373
|
+
run = node.ainvoke(state) if hasattr(node, "ainvoke") else asyncio.to_thread(node, state)
|
|
374
|
+
if on_timeout == "error":
|
|
375
|
+
return await run
|
|
376
|
+
try:
|
|
377
|
+
return await asyncio.wait_for(run, timeout=seconds)
|
|
378
|
+
except asyncio.TimeoutError:
|
|
379
|
+
if on_timeout == "return_to_model":
|
|
380
|
+
message = f"step {{step_id}} timed out after {{seconds:g}}s"
|
|
381
|
+
return record_step_output({{"messages": [HumanMessage(content=message)]}}, step_id)
|
|
382
|
+
if fallback_output:
|
|
383
|
+
return record_step_output({{"messages": [AIMessage(content=json.dumps(fallback_output[0]))]}}, step_id)
|
|
384
|
+
if fallback_node is not None:
|
|
385
|
+
rerun = (fallback_node.ainvoke(state) if hasattr(fallback_node, "ainvoke")
|
|
386
|
+
else asyncio.to_thread(fallback_node, state))
|
|
387
|
+
return await asyncio.wait_for(rerun, timeout=seconds)
|
|
388
|
+
return record_step_output({{"messages": [AIMessage(content="{{}}")]}}, step_id)
|
|
389
|
+
return wrapped
|
|
390
|
+
|
|
391
|
+
|
|
392
|
+
_APPROVAL_REJECTIONS = {{"rejected", "reject", "no", "denied", "deny", "false", "declined"}}
|
|
393
|
+
|
|
394
|
+
|
|
395
|
+
def is_approved(decision: Any) -> bool:
|
|
396
|
+
"""Interpret a human decision as approved or not.
|
|
397
|
+
|
|
398
|
+
A decision is rejected when it is None, False, or a string naming a rejection.
|
|
399
|
+
"""
|
|
400
|
+
if decision is None or decision is False:
|
|
401
|
+
return False
|
|
402
|
+
if isinstance(decision, str):
|
|
403
|
+
return decision.strip().lower() not in _APPROVAL_REJECTIONS
|
|
404
|
+
return bool(decision)
|
|
405
|
+
|
|
406
|
+
|
|
407
|
+
def with_approval(step_id: str, payload: dict[str, Any], node: Callable[[WorkflowState], dict[str, Any]]) -> Callable[[WorkflowState], dict[str, Any]]:
|
|
408
|
+
"""Gate a step on a human decision.
|
|
409
|
+
|
|
410
|
+
The graph pauses until a decision is supplied with ``Command(resume=...)``.
|
|
411
|
+
A rejected decision skips the step.
|
|
412
|
+
"""
|
|
413
|
+
def wrapped(state: WorkflowState) -> dict[str, Any]:
|
|
414
|
+
decision = interrupt(payload)
|
|
415
|
+
if not is_approved(decision):
|
|
416
|
+
return {{"messages": [], "steps": {{step_id: {{"approval": decision}}}}}}
|
|
417
|
+
return record_step_output(node(state), step_id, decision)
|
|
418
|
+
return wrapped
|
|
419
|
+
{guard_block}'''
|
|
420
|
+
rel = f"src/{src.name}/state.py"
|
|
421
|
+
write_file(out_dir, rel, c)
|
|
422
|
+
return [rel]
|
|
423
|
+
|
|
424
|
+
|
|
425
|
+
def _write_tools(ir: AgentSystemIR, src: Path, out_dir: Path, ds: DiagnosticSet) -> list[str]:
|
|
426
|
+
if not ir.tools:
|
|
427
|
+
return []
|
|
428
|
+
c = generate_tools_module(ir.tools, ds, framework="langgraph")
|
|
429
|
+
rel = f"src/{src.name}/tools.py"
|
|
430
|
+
write_file(out_dir, rel, c)
|
|
431
|
+
return [rel]
|
|
432
|
+
|
|
433
|
+
|
|
434
|
+
def _write_schemas(ir: AgentSystemIR, src: Path, out_dir: Path, ds: DiagnosticSet) -> list[str]:
|
|
435
|
+
schemas = {f"{k}_output": v.output_schema for k, v in ir.agents.items() if v.output_schema}
|
|
436
|
+
if not schemas:
|
|
437
|
+
return []
|
|
438
|
+
c = generate_models_source(schemas, ds)
|
|
439
|
+
rel = f"src/{src.name}/schemas.py"
|
|
440
|
+
write_file(out_dir, rel, c)
|
|
441
|
+
return [rel]
|
|
442
|
+
|
|
443
|
+
|
|
444
|
+
def _approval_payload(step) -> str:
|
|
445
|
+
"""Build the interrupt payload for an approval step."""
|
|
446
|
+
approval = step.approval
|
|
447
|
+
reason = "human approval required"
|
|
448
|
+
if isinstance(approval, dict):
|
|
449
|
+
reason = str(approval.get("reason") or reason)
|
|
450
|
+
elif isinstance(approval, str):
|
|
451
|
+
reason = approval
|
|
452
|
+
payload: dict = {"step": step.id, "reason": reason}
|
|
453
|
+
if isinstance(approval, dict):
|
|
454
|
+
payload["approval"] = approval
|
|
455
|
+
return repr(payload)
|
|
456
|
+
|
|
457
|
+
|
|
458
|
+
def _node_options(step, wf_key: str, ds: DiagnosticSet) -> str:
|
|
459
|
+
"""Extra add_node kwargs for Draft 0.3 `retry` and `timeout` (leading comma or empty)."""
|
|
460
|
+
opts = ""
|
|
461
|
+
r = step.retry
|
|
462
|
+
max_attempts = r.valid_max_attempts() if r is not None else None
|
|
463
|
+
if r is not None and max_attempts is not None:
|
|
464
|
+
args: list[str] = [f"max_attempts={max_attempts}"]
|
|
465
|
+
if r.backoff in ("none", "linear"):
|
|
466
|
+
# RetryPolicy only models a geometric factor; linear has no native form.
|
|
467
|
+
args.append("backoff_factor=1.0")
|
|
468
|
+
if r.backoff == "linear":
|
|
469
|
+
ds.add_warning(
|
|
470
|
+
DiagCode.LOSSY_MAPPING,
|
|
471
|
+
f"Step '{step.id}' uses linear backoff; LangGraph RetryPolicy supports only "
|
|
472
|
+
"a constant or geometric factor, so a constant interval is generated.",
|
|
473
|
+
target="langgraph", path=f"workflows.{wf_key}.steps.{step.id}.retry.backoff",
|
|
474
|
+
)
|
|
475
|
+
elif r.backoff == "exponential":
|
|
476
|
+
args.append("backoff_factor=2.0")
|
|
477
|
+
for field_name, kwarg in (("initial_interval", "initial_interval"),
|
|
478
|
+
("max_interval", "max_interval")):
|
|
479
|
+
raw = getattr(r, field_name)
|
|
480
|
+
val = parse_duration_seconds(raw)
|
|
481
|
+
if val is not None:
|
|
482
|
+
args.append(f"{kwarg}={val}")
|
|
483
|
+
elif raw is not None:
|
|
484
|
+
ds.add_warning(
|
|
485
|
+
DiagCode.LOSSY_MAPPING,
|
|
486
|
+
f"Step '{step.id}' retry.{field_name} {raw!r} is not a parseable duration "
|
|
487
|
+
"and is ignored.",
|
|
488
|
+
target="langgraph", path=f"workflows.{wf_key}.steps.{step.id}.retry.{field_name}",
|
|
489
|
+
)
|
|
490
|
+
opts += f", retry_policy=RetryPolicy({', '.join(args)})"
|
|
491
|
+
if step.timeout is not None:
|
|
492
|
+
secs = parse_duration_seconds(step.timeout)
|
|
493
|
+
if secs is None:
|
|
494
|
+
ds.add_warning(
|
|
495
|
+
DiagCode.LOSSY_MAPPING,
|
|
496
|
+
f"Step '{step.id}' timeout {step.timeout!r} is not a parseable duration "
|
|
497
|
+
"and is not enforced.",
|
|
498
|
+
target="langgraph", path=f"workflows.{wf_key}.steps.{step.id}.timeout",
|
|
499
|
+
)
|
|
500
|
+
else:
|
|
501
|
+
mode = (r.on_timeout if r is not None and r.on_timeout else "error")
|
|
502
|
+
# Catching modes enforce the deadline inside the wrapper; the node-level
|
|
503
|
+
# timeout is a slightly later backstop so the wrapper wins the race.
|
|
504
|
+
node_secs = secs if mode == "error" else secs + 1.0
|
|
505
|
+
opts += f", timeout={node_secs:g}"
|
|
506
|
+
if mode == "fallback" and step.fallback is None:
|
|
507
|
+
ds.add_info(
|
|
508
|
+
DiagCode.LOSSY_MAPPING,
|
|
509
|
+
f"Step '{step.id}' retry.on_timeout=fallback: the step declares no fallback "
|
|
510
|
+
"value, so the generated node returns an empty JSON object on timeout.",
|
|
511
|
+
target="langgraph", path=f"workflows.{wf_key}.steps.{step.id}.retry.on_timeout",
|
|
512
|
+
)
|
|
513
|
+
return opts
|
|
514
|
+
|
|
515
|
+
|
|
516
|
+
def _timeout_wrap(step, node_expr: str) -> tuple[str, bool]:
|
|
517
|
+
"""Wrap a node expression for a step with a parseable timeout. Returns (expr, is_async)."""
|
|
518
|
+
secs = parse_duration_seconds(step.timeout) if step.timeout is not None else None
|
|
519
|
+
if secs is None:
|
|
520
|
+
return node_expr, False
|
|
521
|
+
mode = step.retry.on_timeout if step.retry is not None and step.retry.on_timeout else "error"
|
|
522
|
+
extra = ""
|
|
523
|
+
fb = step.fallback
|
|
524
|
+
if mode == "fallback" and fb is not None:
|
|
525
|
+
if fb.has_output:
|
|
526
|
+
extra = f", fallback_output=({fb.output!r},)"
|
|
527
|
+
elif fb.model:
|
|
528
|
+
extra = f', fallback_node=with_step_output("{step.id}", {_fallback_node_name(step)})'
|
|
529
|
+
return f'with_timeout("{step.id}", {node_expr}, {secs:g}, "{mode}"{extra})', True
|
|
530
|
+
|
|
531
|
+
|
|
532
|
+
def _fallback_node_name(step) -> str:
|
|
533
|
+
return snake_identifier(step.id, prefix="step") + "_fallback_node"
|
|
534
|
+
|
|
535
|
+
|
|
536
|
+
def _tw(step, expr: str) -> str:
|
|
537
|
+
return _timeout_wrap(step, expr)[0]
|
|
538
|
+
|
|
539
|
+
|
|
540
|
+
def _write_graph(ir: AgentSystemIR, plan: GenerationPlan, src: Path,
|
|
541
|
+
out_dir: Path, ds: DiagnosticSet) -> tuple[list[str], bool]:
|
|
542
|
+
wf = ir.workflows.get(plan.main_workflow_key)
|
|
543
|
+
if not wf:
|
|
544
|
+
return [], False
|
|
545
|
+
|
|
546
|
+
approval_policy = _tool_approval_policy(ir, ds)
|
|
547
|
+
pkg = src.name
|
|
548
|
+
steps = wf.steps
|
|
549
|
+
step_ids = [s.id for s in steps]
|
|
550
|
+
|
|
551
|
+
# LLM bindings
|
|
552
|
+
llm_lines: list[str] = []
|
|
553
|
+
for ak, agent in ir.agents.items():
|
|
554
|
+
agent_var = snake_identifier(ak, prefix="agent")
|
|
555
|
+
m = ir.models.get(agent.model)
|
|
556
|
+
if not m:
|
|
557
|
+
continue
|
|
558
|
+
mstr = _model_str(m, ds, agent.reasoning)
|
|
559
|
+
if agent.reasoning is not None:
|
|
560
|
+
llm_lines.append(
|
|
561
|
+
f"# reasoning for agent '{ak}' (AgentsML 0.3) passed as provider model kwargs below; "
|
|
562
|
+
"providers without a mapping ignore it."
|
|
563
|
+
)
|
|
564
|
+
if agent.tools:
|
|
565
|
+
tool_vars = ", ".join(snake_identifier(tool, prefix="tool") for tool in agent.tools)
|
|
566
|
+
llm_lines.append(f'{agent_var}_llm = {mstr}.bind_tools([{tool_vars}])')
|
|
567
|
+
else:
|
|
568
|
+
llm_lines.append(f'{agent_var}_llm = {mstr}')
|
|
569
|
+
|
|
570
|
+
# Fallback-model bindings (step.fallback.model, used by retry.on_timeout=fallback)
|
|
571
|
+
fallback_fns: list[str] = []
|
|
572
|
+
for step in steps:
|
|
573
|
+
fb = step.fallback
|
|
574
|
+
agent = ir.agents.get(step.agent) if step.agent else None
|
|
575
|
+
if (fb is None or fb.has_output or not fb.model or agent is None
|
|
576
|
+
or fb.model not in ir.models):
|
|
577
|
+
continue
|
|
578
|
+
base = snake_identifier(step.id, prefix="step")
|
|
579
|
+
mstr = _model_str(ir.models[fb.model], ds, agent.reasoning)
|
|
580
|
+
if agent.tools:
|
|
581
|
+
tool_vars = ", ".join(snake_identifier(t, prefix="tool") for t in agent.tools)
|
|
582
|
+
mstr = f"{mstr}.bind_tools([{tool_vars}])"
|
|
583
|
+
llm_lines.append(f"{base}_fallback_llm = {mstr}")
|
|
584
|
+
fallback_fns.append((base, agent))
|
|
585
|
+
|
|
586
|
+
# Node functions
|
|
587
|
+
condition_steps: set[str] = set()
|
|
588
|
+
for edge in wf.edges:
|
|
589
|
+
if edge.condition:
|
|
590
|
+
try:
|
|
591
|
+
_, refs = compile_condition_with_references(str(edge.condition))
|
|
592
|
+
except ConditionError:
|
|
593
|
+
continue
|
|
594
|
+
for ref in refs:
|
|
595
|
+
parts = ref.split(".")
|
|
596
|
+
if parts[0] == "steps" and len(parts) > 1:
|
|
597
|
+
condition_steps.add(parts[1])
|
|
598
|
+
json_agents = {s.agent for s in steps if s.id in condition_steps and s.agent}
|
|
599
|
+
node_fns: list[str] = []
|
|
600
|
+
for ak, agent in ir.agents.items():
|
|
601
|
+
agent_var = snake_identifier(ak, prefix="agent")
|
|
602
|
+
inst_preview = agent.instructions[:60].rstrip()
|
|
603
|
+
system_text = agent.instructions
|
|
604
|
+
if ak in json_agents:
|
|
605
|
+
system_text = f"{system_text}\n\n{JSON_OUTPUT_INSTRUCTION}"
|
|
606
|
+
node_fns.append(f'''\
|
|
607
|
+
def {agent_var}_node(state: WorkflowState) -> dict:
|
|
608
|
+
"""Node for agent '{ak}'. Instructions: {inst_preview}..."""
|
|
609
|
+
response = {agent_var}_llm.invoke([SystemMessage(content={system_text!r})] + state["messages"])
|
|
610
|
+
return {{"messages": [response]}}''')
|
|
611
|
+
|
|
612
|
+
for base, agent in fallback_fns:
|
|
613
|
+
system_text = agent.instructions
|
|
614
|
+
if next((k for k, v in ir.agents.items() if v is agent), None) in json_agents:
|
|
615
|
+
system_text = f"{system_text}\n\n{JSON_OUTPUT_INSTRUCTION}"
|
|
616
|
+
node_fns.append(f'''\
|
|
617
|
+
def {base}_fallback_node(state: WorkflowState) -> dict:
|
|
618
|
+
"""Fallback-model re-run of step '{base}' (retry.on_timeout=fallback)."""
|
|
619
|
+
response = {base}_fallback_llm.invoke([SystemMessage(content={system_text!r})] + state["messages"])
|
|
620
|
+
return {{"messages": [response]}}''')
|
|
621
|
+
|
|
622
|
+
# add_node calls
|
|
623
|
+
add_nodes: list[str] = []
|
|
624
|
+
approval_nodes: list[str] = []
|
|
625
|
+
any_async = False
|
|
626
|
+
for step in steps:
|
|
627
|
+
payload = _approval_payload(step) if step.approval else None
|
|
628
|
+
node_opts = _node_options(step, wf.key, ds)
|
|
629
|
+
any_async = any_async or ", timeout=" in node_opts
|
|
630
|
+
if step.agent and step.agent in ir.agents:
|
|
631
|
+
agent_node = f'{snake_identifier(step.agent, prefix="agent")}_node'
|
|
632
|
+
if payload:
|
|
633
|
+
_wrapped = _tw(step, f'with_approval("{step.id}", {payload}, {agent_node})')
|
|
634
|
+
add_nodes.append(f' graph.add_node("{step.id}", {_wrapped}{node_opts})')
|
|
635
|
+
else:
|
|
636
|
+
_wrapped = _tw(step, f'with_step_output("{step.id}", {agent_node})')
|
|
637
|
+
add_nodes.append(f' graph.add_node("{step.id}", {_wrapped}{node_opts})')
|
|
638
|
+
elif step.tool and step.tool in ir.tools:
|
|
639
|
+
tool_node = f'ToolNode([{snake_identifier(step.tool, prefix="tool")}])'
|
|
640
|
+
if payload:
|
|
641
|
+
_wrapped = _tw(step, f'with_approval("{step.id}", {payload}, {tool_node})')
|
|
642
|
+
add_nodes.append(f' graph.add_node("{step.id}", {_wrapped}{node_opts})')
|
|
643
|
+
else:
|
|
644
|
+
add_nodes.append(f' graph.add_node("{step.id}", {_tw(step, tool_node)}{node_opts})')
|
|
645
|
+
elif payload:
|
|
646
|
+
approval_fn = f'{snake_identifier(step.id, prefix="step")}_approval'
|
|
647
|
+
approval_nodes.append(f'''\
|
|
648
|
+
def {approval_fn}(state: WorkflowState) -> dict:
|
|
649
|
+
"""Approval step '{step.id}'. Pauses the run until a decision is supplied."""
|
|
650
|
+
decision = interrupt({payload})
|
|
651
|
+
return {{"messages": [], "steps": {{"{step.id}": {{"approval": decision}}}}}}''')
|
|
652
|
+
add_nodes.append(f' graph.add_node("{step.id}", {_tw(step, approval_fn)}{node_opts})')
|
|
653
|
+
else:
|
|
654
|
+
add_nodes.append(f' graph.add_node("{step.id}", lambda s: s) # TODO')
|
|
655
|
+
|
|
656
|
+
# Edges
|
|
657
|
+
unconditional: dict[str, list[str]] = {sid: [] for sid in step_ids}
|
|
658
|
+
conditional: dict[str, list[tuple[str, str]]] = {sid: [] for sid in step_ids}
|
|
659
|
+
if wf.edges:
|
|
660
|
+
for edge in wf.edges:
|
|
661
|
+
if edge.condition:
|
|
662
|
+
try:
|
|
663
|
+
predicate = compile_condition(str(edge.condition))
|
|
664
|
+
except ConditionError as exc:
|
|
665
|
+
ds.add_warning(DiagCode.NONPORTABLE_EXPRESSION,
|
|
666
|
+
f"Condition on edge {edge.from_step} -> {edge.to_step} was not compiled ({exc}); the edge is never taken.",
|
|
667
|
+
path=f"workflows.{plan.main_workflow_key}.edges",
|
|
668
|
+
recommendation="Use comparisons, &&, ||, ! and input/state/steps references.")
|
|
669
|
+
predicate = "False"
|
|
670
|
+
conditional.setdefault(edge.from_step, []).append((predicate, edge.to_step))
|
|
671
|
+
else:
|
|
672
|
+
unconditional.setdefault(edge.from_step, []).append(edge.to_step)
|
|
673
|
+
else:
|
|
674
|
+
for src, dst in zip(step_ids, step_ids[1:]):
|
|
675
|
+
unconditional.setdefault(src, []).append(dst)
|
|
676
|
+
|
|
677
|
+
routes: list[str] = []
|
|
678
|
+
add_edges: list[str] = []
|
|
679
|
+
if step_ids:
|
|
680
|
+
add_edges.append(f' graph.add_edge(START, "{step_ids[0]}")')
|
|
681
|
+
route_sources = {
|
|
682
|
+
s.id for s in steps
|
|
683
|
+
if conditional.get(s.id)
|
|
684
|
+
or any(t in ir.tools for t in (ir.agents[s.agent].tools if s.agent in ir.agents else []))
|
|
685
|
+
}
|
|
686
|
+
incoming: dict[str, list[str]] = {}
|
|
687
|
+
for src, dsts in unconditional.items():
|
|
688
|
+
for dst in dsts:
|
|
689
|
+
if src not in incoming.setdefault(dst, []):
|
|
690
|
+
incoming[dst].append(src)
|
|
691
|
+
joins: dict[str, list[str]] = {}
|
|
692
|
+
for target, sources in incoming.items():
|
|
693
|
+
if len(sources) < 2:
|
|
694
|
+
continue
|
|
695
|
+
if any(src in route_sources for src in sources):
|
|
696
|
+
ds.add_warning(DiagCode.REQUIRES_ADAPTER,
|
|
697
|
+
f"Step '{target}' joins branches including a conditional or tool-calling step; "
|
|
698
|
+
"it is generated without join semantics.",
|
|
699
|
+
path=f"workflows.{plan.main_workflow_key}.edges",
|
|
700
|
+
recommendation="Join only unconditional predecessors that do not call tools.")
|
|
701
|
+
continue
|
|
702
|
+
joins[target] = sources
|
|
703
|
+
for step in steps:
|
|
704
|
+
uncond = unconditional.get(step.id, [])
|
|
705
|
+
conds = conditional.get(step.id, [])
|
|
706
|
+
agent = ir.agents.get(step.agent) if step.agent else None
|
|
707
|
+
agent_tools = [t for t in (agent.tools if agent else []) if t in ir.tools]
|
|
708
|
+
if not agent_tools and not conds:
|
|
709
|
+
for dst in uncond:
|
|
710
|
+
if dst not in joins:
|
|
711
|
+
add_edges.append(f' graph.add_edge("{step.id}", "{dst}")')
|
|
712
|
+
if not uncond:
|
|
713
|
+
add_edges.append(f' graph.add_edge("{step.id}", END)')
|
|
714
|
+
continue
|
|
715
|
+
|
|
716
|
+
route_name = snake_identifier(step.id, prefix="step") + "_route"
|
|
717
|
+
body: list[str] = []
|
|
718
|
+
destinations: dict[str, str] = {}
|
|
719
|
+
if agent_tools:
|
|
720
|
+
tool_node = f"{step.id}__tools"
|
|
721
|
+
tool_vars = ", ".join(snake_identifier(t, prefix="tool") for t in agent_tools)
|
|
722
|
+
if approval_policy:
|
|
723
|
+
add_nodes.append(f' graph.add_node("{tool_node}", guarded_tool_node([{tool_vars}], TOOL_APPROVAL_POLICY))')
|
|
724
|
+
else:
|
|
725
|
+
add_nodes.append(f' graph.add_node("{tool_node}", ToolNode([{tool_vars}]))')
|
|
726
|
+
body.append(' if getattr(state["messages"][-1], "tool_calls", None):')
|
|
727
|
+
body.append(' return ["call_tools"]')
|
|
728
|
+
destinations["call_tools"] = f'"{tool_node}"'
|
|
729
|
+
if conds:
|
|
730
|
+
body.append(' ctx = {"input": state.get("input", {}), "state": state.get("state", {}), "steps": state.get("steps", {})}')
|
|
731
|
+
for dst in uncond:
|
|
732
|
+
destinations[f"to_{dst}"] = f'"{dst}"'
|
|
733
|
+
body.append(" destinations: list[str] = [" + ", ".join(f'"{k}"' for k in destinations if k.startswith("to_")) + "]")
|
|
734
|
+
for predicate, dst in conds:
|
|
735
|
+
key = f"to_{dst}"
|
|
736
|
+
body.append(f" if {predicate}:")
|
|
737
|
+
body.append(f' destinations.append("{key}")')
|
|
738
|
+
destinations[key] = f'"{dst}"'
|
|
739
|
+
body.append(' return destinations or ["finish"]')
|
|
740
|
+
destinations["finish"] = "END"
|
|
741
|
+
|
|
742
|
+
routes.append("\n".join([
|
|
743
|
+
f"def {route_name}(state: WorkflowState) -> list[str]:",
|
|
744
|
+
f' """Route after step {step.id!r}: run tool calls, then every matching successor."""',
|
|
745
|
+
*body,
|
|
746
|
+
]))
|
|
747
|
+
path_map = ", ".join(f'"{key}": {target}' for key, target in destinations.items())
|
|
748
|
+
add_edges.append(f' graph.add_conditional_edges("{step.id}", {route_name}, {{{path_map}}})')
|
|
749
|
+
if agent_tools:
|
|
750
|
+
add_edges.append(f' graph.add_edge("{tool_node}", "{step.id}")')
|
|
751
|
+
|
|
752
|
+
for target, sources in joins.items():
|
|
753
|
+
add_edges.append(f' graph.add_edge({sources!r}, "{target}")')
|
|
754
|
+
|
|
755
|
+
interrupts = [s.id for s in steps if s.approval]
|
|
756
|
+
|
|
757
|
+
has_tools = bool(ir.tools)
|
|
758
|
+
tool_vars = [snake_identifier(tool, prefix="tool") for tool in ir.tools]
|
|
759
|
+
tools_import = f"from .tools import {', '.join(tool_vars)}" if has_tools else ""
|
|
760
|
+
tool_node_line = (f"tool_node = ToolNode([{', '.join(tool_vars)}])"
|
|
761
|
+
if has_tools else "# No tools defined")
|
|
762
|
+
if approval_policy:
|
|
763
|
+
tool_node_line += f"\n\n# Tools that need human approval (name -> approval_mode)\nTOOL_APPROVAL_POLICY = {approval_policy!r}"
|
|
764
|
+
state_import = "from .state import WorkflowState, compare, lookup, with_approval, with_step_output"
|
|
765
|
+
if any_async:
|
|
766
|
+
state_import = state_import.replace("with_step_output", "with_step_output, with_timeout")
|
|
767
|
+
if approval_policy:
|
|
768
|
+
state_import = state_import.replace("compare,", "compare, guarded_tool_node,")
|
|
769
|
+
|
|
770
|
+
prov_imports = _provider_imports(ir)
|
|
771
|
+
retry_import = ("from langgraph.types import RetryPolicy\n"
|
|
772
|
+
if "RetryPolicy(" in "".join(add_nodes) else "")
|
|
773
|
+
node_fn_block = "\n\n".join(node_fns + approval_nodes)
|
|
774
|
+
llm_block = "\n".join(llm_lines)
|
|
775
|
+
nodes_block = "\n".join(add_nodes)
|
|
776
|
+
edges_block = "\n".join(add_edges)
|
|
777
|
+
route_block = "\n\n".join(routes)
|
|
778
|
+
|
|
779
|
+
c = f'''\
|
|
780
|
+
"""LangGraph StateGraph for {plan.project_name}.
|
|
781
|
+
|
|
782
|
+
Auto-generated by agentsml-impl. Re-run to regenerate.
|
|
783
|
+
"""
|
|
784
|
+
from __future__ import annotations
|
|
785
|
+
from langchain_core.messages import HumanMessage, SystemMessage
|
|
786
|
+
from langgraph.graph import StateGraph, START, END
|
|
787
|
+
from langgraph.prebuilt import ToolNode
|
|
788
|
+
from langgraph.types import interrupt
|
|
789
|
+
{retry_import}from langgraph.checkpoint.memory import MemorySaver
|
|
790
|
+
{prov_imports}
|
|
791
|
+
{tools_import}
|
|
792
|
+
{state_import}
|
|
793
|
+
|
|
794
|
+
# LLM bindings
|
|
795
|
+
{llm_block}
|
|
796
|
+
|
|
797
|
+
# Tool node
|
|
798
|
+
{tool_node_line}
|
|
799
|
+
|
|
800
|
+
|
|
801
|
+
# Agent node functions
|
|
802
|
+
{node_fn_block}
|
|
803
|
+
|
|
804
|
+
|
|
805
|
+
{route_block}
|
|
806
|
+
|
|
807
|
+
|
|
808
|
+
def build_graph(checkpointer=None):
|
|
809
|
+
graph = StateGraph(WorkflowState)
|
|
810
|
+
{nodes_block}
|
|
811
|
+
{edges_block}
|
|
812
|
+
return graph.compile(checkpointer=checkpointer)
|
|
813
|
+
|
|
814
|
+
|
|
815
|
+
graph = build_graph(checkpointer=MemorySaver())
|
|
816
|
+
'''
|
|
817
|
+
rel = f"src/{pkg}/graph.py"
|
|
818
|
+
write_file(out_dir, rel, c)
|
|
819
|
+
return [rel], any_async
|
|
820
|
+
|
|
821
|
+
|
|
822
|
+
def _write_run(plan: GenerationPlan, src: Path, out_dir: Path, use_async: bool = False) -> list[str]:
|
|
823
|
+
pkg = src.name
|
|
824
|
+
if use_async:
|
|
825
|
+
call = lambda arg: f"asyncio.run(graph.ainvoke({arg}, config=config))" # noqa: E731
|
|
826
|
+
asyncio_import = "import asyncio\n"
|
|
827
|
+
else:
|
|
828
|
+
call = lambda arg: f"graph.invoke({arg}, config=config)" # noqa: E731
|
|
829
|
+
asyncio_import = ""
|
|
830
|
+
c = f'''\
|
|
831
|
+
"""Runner entrypoint for {plan.project_name} (LangGraph). Auto-generated."""
|
|
832
|
+
from __future__ import annotations
|
|
833
|
+
{asyncio_import}import sys
|
|
834
|
+
from typing import Any
|
|
835
|
+
from langchain_core.messages import HumanMessage
|
|
836
|
+
from langgraph.types import Command
|
|
837
|
+
from .graph import graph
|
|
838
|
+
|
|
839
|
+
|
|
840
|
+
def run(question: str, thread_id: str = "default") -> dict:
|
|
841
|
+
"""Start the workflow.
|
|
842
|
+
|
|
843
|
+
Returns the final state. If the workflow paused for a human decision, the
|
|
844
|
+
result contains an '__interrupt__' entry; pass that decision to resume().
|
|
845
|
+
"""
|
|
846
|
+
config = {{"configurable": {{"thread_id": thread_id}}}}
|
|
847
|
+
return {call('{{"messages": [HumanMessage(content=question)]}}')}
|
|
848
|
+
|
|
849
|
+
|
|
850
|
+
def resume(decision: Any, thread_id: str = "default") -> dict:
|
|
851
|
+
"""Continue a paused workflow with a human decision."""
|
|
852
|
+
config = {{"configurable": {{"thread_id": thread_id}}}}
|
|
853
|
+
return {call("Command(resume=decision)")}
|
|
854
|
+
|
|
855
|
+
|
|
856
|
+
def main() -> None:
|
|
857
|
+
q = " ".join(sys.argv[1:]) or "Hello!"
|
|
858
|
+
result = run(q)
|
|
859
|
+
msgs = result.get("messages", [])
|
|
860
|
+
if msgs:
|
|
861
|
+
print(msgs[-1].content)
|
|
862
|
+
|
|
863
|
+
|
|
864
|
+
if __name__ == "__main__":
|
|
865
|
+
main()
|
|
866
|
+
'''
|
|
867
|
+
rel = f"src/{pkg}/run.py"
|
|
868
|
+
write_file(out_dir, rel, c)
|
|
869
|
+
return [rel]
|
|
870
|
+
|
|
871
|
+
|
|
872
|
+
def _write_init(plan: GenerationPlan, src: Path, out_dir: Path) -> list[str]:
|
|
873
|
+
c = f'"""Package: {src.name} — {plan.project_name} (LangGraph)."""\n'
|
|
874
|
+
rel = f"src/{src.name}/__init__.py"
|
|
875
|
+
write_file(out_dir, rel, c)
|
|
876
|
+
return [rel]
|
|
877
|
+
|
|
878
|
+
|
|
879
|
+
def _write_readme(ir: AgentSystemIR, plan: GenerationPlan, out_dir: Path) -> list[str]:
|
|
880
|
+
agents_md = "\n".join(f"- `{k}`: {v.description or v.role or ''}" for k, v in ir.agents.items())
|
|
881
|
+
tools_md = "\n".join(f"- `{k}`: {v.description[:70]}" for k, v in ir.tools.items())
|
|
882
|
+
profiles = ", ".join(ir.profiles.all_profiles()) or "agentsml-core"
|
|
883
|
+
c = f"""\
|
|
884
|
+
# {plan.project_name} — LangGraph
|
|
885
|
+
|
|
886
|
+
> Auto-generated by `agentsml-impl` from `{plan.project_name}.agentsml.yaml`.
|
|
887
|
+
|
|
888
|
+
## Agents
|
|
889
|
+
{agents_md or "None"}
|
|
890
|
+
|
|
891
|
+
## Tools
|
|
892
|
+
{tools_md or "None"}
|
|
893
|
+
|
|
894
|
+
## Profiles
|
|
895
|
+
{profiles}
|
|
896
|
+
|
|
897
|
+
## Quickstart
|
|
898
|
+
```bash
|
|
899
|
+
pip install -e .
|
|
900
|
+
python -m {plan.package_name}.run "Your question here"
|
|
901
|
+
```
|
|
902
|
+
|
|
903
|
+
## Smoke test
|
|
904
|
+
```bash
|
|
905
|
+
python -c "import {plan.package_name}.graph; print('import OK')"
|
|
906
|
+
```
|
|
907
|
+
|
|
908
|
+
> See `diagnostics.yaml` for portability warnings.
|
|
909
|
+
"""
|
|
910
|
+
write_file(out_dir, "README.md", c)
|
|
911
|
+
return ["README.md"]
|