agent-framework-declarative 1.2.1__tar.gz → 1.4.0__tar.gz

{agent_framework_declarative-1.2.1 → agent_framework_declarative-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: agent-framework-declarative
-Version: 1.2.1
+Version: 1.4.0
 Summary: Declarative specification support for Microsoft Agent Framework.
 Author-email: Microsoft <af-support@microsoft.com>
 Requires-Python: >=3.10
@@ -15,14 +15,16 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Typing :: Typed
 License-File: LICENSE
-Requires-Dist: agent-framework-core>=1.20.0,<2
-Requires-Dist: httpx>=0.27,<1
+Requires-Dist: agent-framework-core>=1.23.0,<2
+Requires-Dist: httpx>=0.27,<0.29
+Requires-Dist: httpx2>=2.0.0,<3
 Requires-Dist: powerfx>=0.0.32,<0.0.35; python_version < '3.14'
 Requires-Dist: pyyaml>=6.0,<7.0
 Project-URL: homepage, https://aka.ms/agent-framework
 Project-URL: issues, https://github.com/microsoft/agent-framework/issues
 Project-URL: release_notes, https://github.com/microsoft/agent-framework/releases?q=tag%3Apython-1&expanded=true
 Project-URL: source, https://github.com/microsoft/agent-framework/tree/main/python
+Import-Name: agent_framework_declarative
 
 # Get Started with Microsoft Agent Framework Declarative
 
@@ -32,6 +34,11 @@ Please install this package via pip:
 pip install agent-framework-declarative
 ```
 
+The package currently advertises Python 3.10–3.13 support. Python 3.14 and
+3.15 can install the package, but Power Fx expressions are unavailable because
+the `powerfx` dependency requires a `pythonnet` build that does not support
+those Python versions.
+
 ## Release stage
 
 This package ships at two different stability levels:
@@ -66,6 +73,31 @@ Explicit `Cookie` request headers remain supported. Response `Set-Cookie` header
 remain available in `HttpRequestResult.headers`; disabling persistence does not redact
 the response.
 
+## HTTP response body limits
+
+`DefaultHttpRequestHandler` limits response bodies to **10 MiB** by default.
+Configure a positive integer `max_response_body_bytes` on the handler when a host
+requires a different bound. The bound applies to received bytes and each decoded
+stage, including intermediate redirect and authentication responses. Responses
+above the bound raise `httpx.StreamError` before text conversion or workflow
+assignment, and their streams are closed without closing caller-owned clients.
+
+The handler restricts HTTPX's generated `Accept-Encoding` default to `gzip, deflate`
+and supports identity, gzip, and deflate
+responses, including up to four encoding stages. Unsupported encodings,
+incomplete encoded bodies, and trailing encoded data raise `httpx.DecodingError`.
+Empty encoded responses are validated unless the response is bodyless (HEAD,
+1xx, 204, 205, 304, or a successful CONNECT response). Deflate input is retained
+within the same bound until its wrapped or raw format can be validated.
+Explicit request `Accept-Encoding` headers and client values that differ from
+HTTPX's generated default are preserved but do not enable additional decoders.
+Caller-supplied response hooks and transports must not
+buffer response bodies before the handler applies its limit.
+
+HTTPX support is limited to the 0.27 and 0.28 series because the bounded
+intermediate-response cache and generated default-header integration depend
+on HTTPX internals. Compatibility tests cover HTTPX 0.27.0 and 0.28.1.
+
 ## MCP handler session lifetime
 
 `DefaultMCPToolHandler()` reuses MCP sessions through a bounded LRU cache.

{agent_framework_declarative-1.2.1 → agent_framework_declarative-1.4.0}/README.md

@@ -6,6 +6,11 @@ Please install this package via pip:
 pip install agent-framework-declarative
 ```
 
+The package currently advertises Python 3.10–3.13 support. Python 3.14 and
+3.15 can install the package, but Power Fx expressions are unavailable because
+the `powerfx` dependency requires a `pythonnet` build that does not support
+those Python versions.
+
 ## Release stage
 
 This package ships at two different stability levels:
@@ -40,6 +45,31 @@ Explicit `Cookie` request headers remain supported. Response `Set-Cookie` header
 remain available in `HttpRequestResult.headers`; disabling persistence does not redact
 the response.
 
+## HTTP response body limits
+
+`DefaultHttpRequestHandler` limits response bodies to **10 MiB** by default.
+Configure a positive integer `max_response_body_bytes` on the handler when a host
+requires a different bound. The bound applies to received bytes and each decoded
+stage, including intermediate redirect and authentication responses. Responses
+above the bound raise `httpx.StreamError` before text conversion or workflow
+assignment, and their streams are closed without closing caller-owned clients.
+
+The handler restricts HTTPX's generated `Accept-Encoding` default to `gzip, deflate`
+and supports identity, gzip, and deflate
+responses, including up to four encoding stages. Unsupported encodings,
+incomplete encoded bodies, and trailing encoded data raise `httpx.DecodingError`.
+Empty encoded responses are validated unless the response is bodyless (HEAD,
+1xx, 204, 205, 304, or a successful CONNECT response). Deflate input is retained
+within the same bound until its wrapped or raw format can be validated.
+Explicit request `Accept-Encoding` headers and client values that differ from
+HTTPX's generated default are preserved but do not enable additional decoders.
+Caller-supplied response hooks and transports must not
+buffer response bodies before the handler applies its limit.
+
+HTTPX support is limited to the 0.27 and 0.28 series because the bounded
+intermediate-response cache and generated default-header integration depend
+on HTTPX internals. Compatibility tests cover HTTPX 0.27.0 and 0.28.1.
+
 ## MCP handler session lifetime
 
 `DefaultMCPToolHandler()` reuses MCP sessions through a bounded LRU cache.

{agent_framework_declarative-1.2.1 → agent_framework_declarative-1.4.0}/agent_framework_declarative/_loader.py

@@ -290,7 +290,7 @@ class AgentFactory:
         load_dotenv(dotenv_path=env_file_path, encoding=env_file_encoding)
 
     def create_agent_from_yaml_path(self, yaml_path: str | Path) -> Agent:
-        """Create a Agent from a YAML file path.
+        """Create an Agent from a YAML file path.
 
         This method does the following things:
 
@@ -298,7 +298,7 @@ class AgentFactory:
         2. Validates that the loaded object is a PromptAgent.
         3. Creates the appropriate ChatClient based on the model provider and apiType.
         4. Parses the tools, options, and response format from the PromptAgent.
-        5. Creates and returns a Agent instance with the configured properties.
+        5. Creates and returns an Agent instance with the configured properties.
 
         Args:
             yaml_path: Path to the YAML file representation of a PromptAgent.
@@ -344,7 +344,7 @@ class AgentFactory:
         return self.create_agent_from_yaml(yaml_str)
 
     def create_agent_from_yaml(self, yaml_str: str) -> Agent:
-        """Create a Agent from a YAML string.
+        """Create an Agent from a YAML string.
 
         This method does the following things:
 
@@ -352,7 +352,7 @@ class AgentFactory:
         2. Validates that the loaded object is a PromptAgent.
         3. Creates the appropriate ChatClient based on the model provider and apiType.
         4. Parses the tools, options, and response format from the PromptAgent.
-        5. Creates and returns a Agent instance with the configured properties.
+        5. Creates and returns an Agent instance with the configured properties.
 
         Args:
             yaml_str: YAML string representation of a PromptAgent.
@@ -417,7 +417,7 @@ class AgentFactory:
         return self.create_agent_from_dict(yaml.safe_load(yaml_str))
 
     def create_agent_from_dict(self, agent_def: dict[str, Any]) -> Agent:
-        """Create a Agent from a dictionary definition.
+        """Create an Agent from a dictionary definition.
 
         This method does the following things:
 
@@ -425,7 +425,7 @@ class AgentFactory:
         2. Validates that the loaded object is a PromptAgent.
         3. Creates the appropriate ChatClient based on the model provider and apiType.
         4. Parses the tools, options, and response format from the PromptAgent.
-        5. Creates and returns a Agent instance with the configured properties.
+        5. Creates and returns an Agent instance with the configured properties.
 
         Args:
             agent_def: Dictionary representation of a PromptAgent.
@@ -485,7 +485,7 @@ class AgentFactory:
         return agent
 
     async def create_agent_from_yaml_path_async(self, yaml_path: str | Path) -> Agent:
-        """Async version: Create a Agent from a YAML file path.
+        """Async version: Create an Agent from a YAML file path.
 
         This is the async counterpart to ``create_agent_from_dict`` and is useful when
         the rest of your setup is already async.
@@ -516,7 +516,7 @@ class AgentFactory:
         return await self.create_agent_from_yaml_async(yaml_str)
 
     async def create_agent_from_yaml_async(self, yaml_str: str) -> Agent:
-        """Async version: Create a Agent from a YAML string.
+        """Async version: Create an Agent from a YAML string.
 
         Use this method when the surrounding call site is already async and you
         want to build an agent directly from YAML text.
@@ -547,7 +547,7 @@ class AgentFactory:
         return await self.create_agent_from_dict_async(yaml.safe_load(yaml_str))
 
     async def create_agent_from_dict_async(self, agent_def: dict[str, Any]) -> Agent:
-        """Async version: Create a Agent from a dictionary definition.
+        """Async version: Create an Agent from a dictionary definition.
 
         This is the async counterpart to ``create_agent_from_dict`` and is useful when
         the rest of your setup is already async.
@@ -740,10 +740,11 @@ class AgentFactory:
             chat_options["stop"] = options.stopSequences
         if options.allowMultipleToolCalls is not None:
             chat_options["allow_multiple_tool_calls"] = options.allowMultipleToolCalls
-        if (chat_tool_mode := options.additionalProperties.pop("chatToolMode", None)) is not None:
+        additional_properties = options.additionalProperties.copy()
+        if (chat_tool_mode := additional_properties.pop("chatToolMode", None)) is not None:
             chat_options["tool_choice"] = chat_tool_mode
-        if options.additionalProperties:
-            chat_options["additional_chat_options"] = options.additionalProperties
+        if additional_properties:
+            chat_options["additional_chat_options"] = additional_properties
         return chat_options
 
     def _parse_tools(self, tools: list[Tool] | None) -> list[AFFunctionTool | dict[str, Any]] | None:

{agent_framework_declarative-1.2.1 → agent_framework_declarative-1.4.0}/agent_framework_declarative/_workflows/_declarative_base.py

@@ -46,6 +46,10 @@ from agent_framework import (
 from agent_framework._workflows._state import State
 
 from ._errors import DeclarativeWorkflowError
+from ._powerfx_functions import (
+    _iter_powerfx_expression_indices,  # pyright: ignore[reportPrivateUsage]
+    whole_call_args,
+)
 from ._powerfx_limits import _PowerFxStateBudget, _validate_powerfx_state  # pyright: ignore[reportPrivateUsage]
 from ._state_path import _is_safe_path_segment  # pyright: ignore[reportPrivateUsage]
 
@@ -68,73 +72,6 @@ logger = logging.getLogger(__name__)
 _ENV_REFERENCE_RE = re.compile(r"\bEnv\.([A-Za-z_][A-Za-z0-9_]*)")
 
 
-def _skip_powerfx_opaque_token(formula: str, start: int) -> int:
-    """Return the end of an ordinary quoted token or comment, or start if neither."""
-    quote = formula[start]
-    if quote in ('"', "'"):
-        pos = start + 1
-        while pos < len(formula):
-            if formula[pos] == quote:
-                if pos + 1 < len(formula) and formula[pos + 1] == quote:
-                    pos += 2
-                    continue
-                return pos + 1
-            pos += 1
-        return pos
-    if formula.startswith("//", start):
-        pos = start + 2
-        while pos < len(formula) and formula[pos] not in "\r\n":
-            pos += 1
-        return pos
-    if formula.startswith("/*", start):
-        end = formula.find("*/", start + 2)
-        return len(formula) if end == -1 else end + 2
-    return start
-
-
-def _iter_powerfx_expression_indices(formula: str) -> Iterator[int]:
-    """Yield code positions, excluding literals/comments but including interpolation expressions."""
-    # None denotes interpolated text; integers track record braces in expression sections.
-    scopes: list[int | None] = [0]
-    cursor = 0
-    while cursor < len(formula):
-        depth = scopes[-1]
-        char = formula[cursor]
-        if depth is None:
-            if formula.startswith(('""', "{{", "}}"), cursor):
-                cursor += 2
-                continue
-            if char == "{":
-                scopes.append(0)
-            elif char == '"':
-                scopes.pop()
-            cursor += 1
-            continue
-
-        if formula.startswith('$"', cursor):
-            scopes.append(None)
-            cursor += 2
-            continue
-
-        token_end = _skip_powerfx_opaque_token(formula, cursor)
-        if token_end != cursor:
-            cursor = token_end
-            continue
-
-        if char == "{":
-            scopes[-1] = depth + 1
-        elif char == "}":
-            if depth > 0:
-                scopes[-1] = depth - 1
-            elif len(scopes) > 1:
-                scopes.pop()
-                cursor += 1
-                continue
-
-        yield cursor
-        cursor += 1
-
-
 @dataclass(frozen=True)
 class DeclarativeEnvConfig:
     """Configuration that populates the PowerFx ``Env`` symbol for a workflow.
@@ -721,50 +658,50 @@ class DeclarativeWorkflowState:
 
         Returns None if the formula is not a custom function call.
         """
-        import re
+        formula = formula.strip()
 
         # Concat/Concatenate - string concatenation
         # In standard PowerFx, Concatenate is for strings, Concat is for tables.
         # Copilot Studio uses Concat for strings, so we support both.
-        match = re.match(r"(?:Concat|Concatenate)\((.+)\)$", formula.strip())
-        if match:
-            args_str = match.group(1)
+        args_str = whole_call_args(formula, "Concat", "Concatenate")
+        # Empty arguments fall through so PowerFx reports the arity error.
+        if args_str:
             # Parse comma-separated arguments (handling nested parentheses)
             args = self._parse_function_args(args_str)
             evaluated_args: list[str] = []
             for arg in args:
                 arg = arg.strip()
-                if arg.startswith('"') and arg.endswith('"'):
+                if re.fullmatch(r'"(?:[^"]|"")*"', arg):
                     # String literal
-                    evaluated_args.append(arg[1:-1])
+                    evaluated_args.append(arg[1:-1].replace('""', '"'))
                 elif arg.startswith("'") and arg.endswith("'"):
                     # Single-quoted string literal
                     evaluated_args.append(arg[1:-1])
                 else:
-                    # Variable reference - evaluate it
+                    # Variable reference or expression - evaluate it
                     result = self.eval(f"={arg}")
                     evaluated_args.append(str(result) if result is not None else "")
             return "".join(evaluated_args)
 
         # UserMessage(expr) - creates a user message dict
-        match = re.match(r"UserMessage\((.+)\)$", formula.strip())
-        if match:
-            inner_expr = match.group(1).strip()
+        inner_args = whole_call_args(formula, "UserMessage")
+        if inner_args:
+            inner_expr = inner_args.strip()
             # Evaluate the inner expression
             text = self.eval(f"={inner_expr}")
             return {"role": "user", "text": str(text) if text else ""}
 
         # AgentMessage(expr) - creates an assistant message dict
-        match = re.match(r"AgentMessage\((.+)\)$", formula.strip())
-        if match:
-            inner_expr = match.group(1).strip()
+        inner_args = whole_call_args(formula, "AgentMessage")
+        if inner_args:
+            inner_expr = inner_args.strip()
             text = self.eval(f"={inner_expr}")
             return {"role": "assistant", "text": str(text) if text else ""}
 
         # MessageText(expr) - extracts text from the last message
-        match = re.match(r"MessageText\((.+)\)$", formula.strip())
-        if match:
-            inner_expr = match.group(1).strip()
+        inner_args = whole_call_args(formula, "MessageText")
+        if inner_args:
+            inner_expr = inner_args.strip()
             # Reuse the helper method for consistent text extraction
             return self._eval_and_replace_message_text(inner_expr)
 
@@ -983,8 +920,9 @@ class DeclarativeWorkflowState:
         Captures brace-delimited tokens whose root segment is an identifier
         (``[A-Za-z][A-Za-z0-9_]*``) followed by zero or more ``.`` separated
         dict-key segments. Resolution is delegated to :meth:`get`; unresolved
-        tokens are replaced with the empty string. Tokens that do not look
-        like state paths (e.g. ``{foo-bar}``, ``{Ctrl+C}``) are left literal.
+        tokens are replaced with the empty string. Substituted values remain
+        literal and are not interpolated again. Tokens that do not look like
+        state paths (e.g. ``{foo-bar}``, ``{Ctrl+C}``) are left literal.
 
         Args:
             text: Text that may contain {Variable.Path} references
@@ -1004,12 +942,7 @@ class DeclarativeWorkflowState:
         # per-segment safety on attribute traversal.
         pattern = r"\{([A-Za-z][A-Za-z0-9_]*(?:\.[^{}\s.]+)*)\}"
 
-        result = text
-        for match in re.finditer(pattern, text):
-            replacement = replace_var(match)
-            result = result.replace(match.group(0), replacement, 1)
-
-        return result
+        return re.sub(pattern, replace_var, text)
 
 
 # Message types for inter-executor communication

{agent_framework_declarative-1.2.1 → agent_framework_declarative-1.4.0}/agent_framework_declarative/_workflows/_declarative_builder.py

@@ -173,7 +173,8 @@ class DeclarativeWorkflowBuilder:
         self._checkpoint_storage = checkpoint_storage
         self._pending_gotos: list[tuple[Any, str]] = []  # (goto_executor, target_id)
         self._validate = validate
-        self._seen_explicit_ids: set[str] = set()  # Track explicit IDs for duplicate detection
+        self._seen_explicit_ids: set[str] = set()
+        self._generated_ids: set[str] = set()
         self._http_request_handler = http_request_handler
         self._mcp_tool_handler = mcp_tool_handler
         self._env_config: DeclarativeEnvConfig = env_config if env_config is not None else DeclarativeEnvConfig()
@@ -201,6 +202,9 @@ class DeclarativeWorkflowBuilder:
         if self._validate:
             self._validate_workflow(actions)
 
+        # Reserve nested and forward-declared executor IDs before naming internal nodes.
+        self._collect_explicit_ids(actions)
+
         # Create a stable entry node as the start executor, then wire it to the first action.
         # This avoids needing a placeholder since the entry executor isn't known until after
         # _create_executors_for_actions runs (which itself needs the builder to add edges).
@@ -238,6 +242,39 @@ class DeclarativeWorkflowBuilder:
 
         return builder.build()
 
+    def _collect_explicit_ids(self, actions: list[dict[str, Any]] | None) -> None:
+        """Reserve authored executor IDs, excluding virtual structures and skipped actions."""
+        if not actions:
+            return
+        for action_def in actions:
+            kind = action_def.get("kind", "")
+            creates_executor = (
+                kind in ALL_ACTION_EXECUTORS
+                or kind in ("BreakLoop", "ContinueLoop")
+                or (kind == "GotoAction" and bool(action_def.get("target") or action_def.get("actionId")))
+            )
+            if creates_executor and (explicit_id := action_def.get("id")):
+                self._seen_explicit_ids.add(explicit_id)
+            if kind == "If":
+                self._collect_explicit_ids(action_def.get("then", action_def.get("actions", [])))
+                self._collect_explicit_ids(action_def.get("else", []))
+            elif kind == "ConditionGroup":
+                for branch in action_def.get("conditions", []):
+                    self._collect_explicit_ids(branch.get("actions", []))
+                self._collect_explicit_ids(action_def.get("elseActions", []))
+            elif kind == "Foreach":
+                self._collect_explicit_ids(action_def.get("actions", []))
+
+    def _allocate_generated_id(self, preferred_id: str) -> str:
+        """Retain the existing ID unless an authored or generated ID already uses it."""
+        candidate = preferred_id
+        suffix = 2
+        while candidate in self._seen_explicit_ids or candidate in self._generated_ids or candidate in self._executors:
+            candidate = f"{preferred_id}_{suffix}"
+            suffix += 1
+        self._generated_ids.add(candidate)
+        return candidate
+
     def _validate_workflow(self, actions: list[dict[str, Any]]) -> None:
         """Validate the workflow definition before building.
 
@@ -489,7 +526,8 @@ class DeclarativeWorkflowBuilder:
             action_id = explicit_id
         else:
             parent_id = (parent_context or {}).get("parent_id")
-            action_id = f"{parent_id}_{kind}_{self._action_index}" if parent_id else f"{kind}_{self._action_index}"
+            preferred_id = f"{parent_id}_{kind}_{self._action_index}" if parent_id else f"{kind}_{self._action_index}"
+            action_id = self._allocate_generated_id(preferred_id)
         self._action_index += 1
 
         # Pass agents/tools to specialized executors
@@ -574,7 +612,7 @@ class DeclarativeWorkflowBuilder:
         evaluator = IfConditionEvaluatorExecutor(
             action_def,
             condition_expr,
-            id=f"{action_id}_eval",
+            id=self._allocate_generated_id(f"{action_id}_eval"),
         )
         self._executors[evaluator.id] = evaluator
 
@@ -588,7 +626,9 @@ class DeclarativeWorkflowBuilder:
         else_passthrough = None
         if not else_entry:
             # No else branch - create a passthrough for continuation when condition is false
-            else_passthrough = JoinExecutor({"kind": "ElsePassthrough"}, id=f"{action_id}_else_pass")
+            else_passthrough = JoinExecutor(
+                {"kind": "ElsePassthrough"}, id=self._allocate_generated_id(f"{action_id}_else_pass")
+            )
             self._executors[else_passthrough.id] = else_passthrough
 
         # Wire evaluator to branches with conditions that check ConditionResult.branch_index
@@ -673,7 +713,7 @@ class DeclarativeWorkflowBuilder:
         evaluator: DeclarativeActionExecutor = ConditionGroupEvaluatorExecutor(
             action_def,
             conditions,
-            id=f"{action_id}_eval",
+            id=self._allocate_generated_id(f"{action_id}_eval"),
         )
 
         self._executors[evaluator.id] = evaluator
@@ -708,7 +748,9 @@ class DeclarativeWorkflowBuilder:
         else:
             # No else actions - create a passthrough for the "no match" case
             # This allows the workflow to continue to the next action when no condition matches
-            default_passthrough = JoinExecutor({"kind": "DefaultPassthrough"}, id=f"{action_id}_default")
+            default_passthrough = JoinExecutor(
+                {"kind": "DefaultPassthrough"}, id=self._allocate_generated_id(f"{action_id}_default")
+            )
             self._executors[default_passthrough.id] = default_passthrough
             branch_exits.append(default_passthrough)
 
@@ -781,15 +823,17 @@ class DeclarativeWorkflowBuilder:
         self._action_index += 1
 
         # Create foreach init executor
-        init_executor = ForeachInitExecutor(action_def, id=f"{action_id}_init")
+        init_executor = ForeachInitExecutor(action_def, id=self._allocate_generated_id(f"{action_id}_init"))
         self._executors[init_executor.id] = init_executor
 
         # Create foreach next executor (for advancing to next item)
-        next_executor = ForeachNextExecutor(action_def, init_executor.id, id=f"{action_id}_next")
+        next_executor = ForeachNextExecutor(
+            action_def, init_executor.id, id=self._allocate_generated_id(f"{action_id}_next")
+        )
         self._executors[next_executor.id] = next_executor
 
         # Create join node for loop exit
-        join_executor = JoinExecutor({"kind": "Join"}, id=f"{action_id}_exit")
+        join_executor = JoinExecutor({"kind": "Join"}, id=self._allocate_generated_id(f"{action_id}_exit"))
         self._executors[join_executor.id] = join_executor
 
         # Create loop body
@@ -865,7 +909,7 @@ class DeclarativeWorkflowBuilder:
             return None
 
         # Create a pass-through executor for the goto
-        action_id = action_def.get("id") or f"goto_{target_id}_{self._action_index}"
+        action_id = action_def.get("id") or self._allocate_generated_id(f"goto_{target_id}_{self._action_index}")
         self._action_index += 1
 
         # Use JoinExecutor as a simple pass-through node
@@ -892,7 +936,7 @@ class DeclarativeWorkflowBuilder:
 
         if parent_context and "loop_next_executor" in parent_context:
             loop_next = parent_context["loop_next_executor"]
-            action_id = action_def.get("id") or f"Break_{self._action_index}"
+            action_id = action_def.get("id") or self._allocate_generated_id(f"Break_{self._action_index}")
             self._action_index += 1
 
             executor = BreakLoopExecutor(action_def, loop_next.id, id=action_id)
@@ -920,7 +964,7 @@ class DeclarativeWorkflowBuilder:
 
         if parent_context and "loop_next_executor" in parent_context:
             loop_next = parent_context["loop_next_executor"]
-            action_id = action_def.get("id") or f"Continue_{self._action_index}"
+            action_id = action_def.get("id") or self._allocate_generated_id(f"Continue_{self._action_index}")
             self._action_index += 1
 
             executor = ContinueLoopExecutor(action_def, loop_next.id, id=action_id)

{agent_framework_declarative-1.2.1 → agent_framework_declarative-1.4.0}/agent_framework_declarative/_workflows/_executors_basic.py

@@ -6,6 +6,7 @@ These executors handle simple actions like SetValue, SendActivity, etc.
 Each action becomes a node in the workflow graph.
 """
 
+import math
 import uuid
 from collections.abc import Mapping
 from typing import Any, cast
@@ -52,7 +53,8 @@ class SetValueExecutor(DeclarativeActionExecutor):
         """Handle the SetValue action."""
         state = await self._ensure_state_initialized(ctx, trigger)
 
-        path = self._action_def.get("path")
+        # The builder accepts 'variable' in place of 'path' for SetValue
+        path = self._action_def.get("path") or _get_variable_path(self._action_def)
         value = self._action_def.get("value")
 
         if path:
@@ -517,6 +519,9 @@ class ParseValueExecutor(DeclarativeActionExecutor):
                 try:
                     if "." in value:
                         return float(value)
+                    if "e" in value.lower():
+                        parsed_value = float(value)
+                        return parsed_value if math.isfinite(parsed_value) else 0
                     return int(value)
                 except ValueError:
                     return 0

{agent_framework_declarative-1.2.1 → agent_framework_declarative-1.4.0}/agent_framework_declarative/_workflows/_executors_control_flow.py

@@ -219,7 +219,11 @@ class ForeachNextExecutor(DeclarativeActionExecutor):
         trigger: Any,
         ctx: WorkflowContext[LoopIterationResult],
     ) -> None:
-        """Advance to next item and send result."""
+        """Handle loop-control signals or advance to the next item and send the result."""
+        if isinstance(trigger, LoopControl):
+            await self.handle_loop_control(trigger, ctx)
+            return
+
         state = await self._ensure_state_initialized(ctx, trigger)
 
         loop_id = self._init_executor_id

{agent_framework_declarative-1.2.1 → agent_framework_declarative-1.4.0}/agent_framework_declarative/_workflows/_executors_mcp.py

@@ -32,7 +32,7 @@ from collections.abc import Mapping
 from dataclasses import dataclass, field
 from typing import Any
 
-import httpx
+import httpx2 as httpx
 from agent_framework import (
     Content,
     Message,
@@ -503,10 +503,10 @@ class InvokeMcpToolActionExecutor(DeclarativeActionExecutor):
             )
         except Exception as exc:
             try:
-                from mcp.shared.exceptions import McpError
+                from mcp.shared.exceptions import MCPError
             except ImportError:  # pragma: no cover - mcp is a hard dep
                 raise
-            if isinstance(exc, McpError):
+            if isinstance(exc, MCPError):
                 message = str(exc) or type(exc).__name__
                 return MCPToolResult(
                     outputs=[Content.from_text(f"Error: {message}")],

{agent_framework_declarative-1.2.1 → agent_framework_declarative-1.4.0}/agent_framework_declarative/_workflows/_factory.py

@@ -596,7 +596,7 @@ class WorkflowFactory:
         Args:
             name: The name to register the agent under. Must match the agent name
                 referenced in InvokeAzureAgent actions.
-            agent: The agent instance (typically a Agent or similar).
+            agent: The agent instance (typically an Agent or similar).
 
         Returns:
             Self for method chaining.

{agent_framework_declarative-1.2.1 → agent_framework_declarative-1.4.0}/agent_framework_declarative/_workflows/_http_handler.py

@@ -21,13 +21,16 @@ enforces an allowlist or DNS-rebinding-resistant policy. This split mirrors the
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Awaitable, Callable, Mapping
+import sys
+import zlib
+from collections.abc import AsyncGenerator, Awaitable, Callable, Mapping
 from dataclasses import dataclass, field, replace
 from http.cookiejar import CookieJar, DefaultCookiePolicy
 from typing import Any, Protocol, runtime_checkable
 from urllib.parse import parse_qsl, quote, urlencode, urlsplit
 
 import httpx
+from httpx._client import ACCEPT_ENCODING
 
 __all__ = [
     "DefaultHttpRequestHandler",
@@ -142,6 +145,16 @@ class DefaultHttpRequestHandler:
     Explicit outbound ``Cookie`` headers and response ``Set-Cookie`` headers are preserved;
     the owned-client policy only prevents automatic cookie persistence.
 
+    Response bodies are limited to ``max_response_body_bytes`` (10 MiB by default),
+    both on the wire and after each gzip/deflate decoding stage. Other content encodings
+    are rejected. The limit also applies to redirect and authentication responses.
+    Caller-supplied response hooks must not eagerly read response bodies.
+
+    Keyword Args:
+        client: Optional caller-owned HTTP client.
+        client_provider: Optional per-request client provider.
+        max_response_body_bytes: Positive wire and decoded response-body limit in bytes.
+
     .. warning::
 
        This handler performs **no** URL filtering or SSRF protection. Wrap or
@@ -153,7 +166,13 @@ class DefaultHttpRequestHandler:
         *,
         client: httpx.AsyncClient | None = None,
         client_provider: ClientProvider | None = None,
+        max_response_body_bytes: int = 10 * 1024 * 1024,
     ) -> None:
+        if isinstance(max_response_body_bytes, bool) or not isinstance(max_response_body_bytes, int):
+            raise ValueError("max_response_body_bytes must be a positive integer.")
+        if max_response_body_bytes <= 0:
+            raise ValueError("max_response_body_bytes must be a positive integer.")
+        self._max_response_body_bytes = max_response_body_bytes
         self._owned_client: httpx.AsyncClient | None = None
         self._caller_client = client
         self._client_provider = client_provider
@@ -193,6 +212,8 @@ class DefaultHttpRequestHandler:
             timeout = httpx.USE_CLIENT_DEFAULT
 
         headers = dict(info.headers)
+        if not _has_header(headers, "accept-encoding") and client.headers.get("accept-encoding") == ACCEPT_ENCODING:
+            headers["Accept-Encoding"] = "gzip, deflate"
         content: bytes | str | None = None
         if info.body is not None:
             content = info.body
@@ -224,7 +245,19 @@ class DefaultHttpRequestHandler:
         )
         request.url = url
 
-        response = await client.send(request)
+        auth = client.auth
+        if auth is None:
+            auth = httpx.BasicAuth(url.username, url.password) if url.username or url.password else httpx.Auth()
+        response = await client.send(
+            request,
+            stream=True,
+            follow_redirects=False,
+            auth=_ResponseLimitAuth(
+                auth,
+                limit=self._max_response_body_bytes,
+                follow_redirects=client.follow_redirects,
+            ),
+        )
 
         # Preserve multi-value headers (e.g. multiple Set-Cookie) as list[str].
         # Normalize names to lowercase so lookups are consistent and case
@@ -296,3 +329,130 @@ def _has_header(headers: Mapping[str, str], name: str) -> bool:
     """Case-insensitive header presence check."""
     needle = name.lower()
     return any(key.lower() == needle for key in headers)
+
+
+class _ResponseLimitAuth(httpx.Auth):
+    """Read every response within bounds before HTTPX can buffer intermediate bodies."""
+
+    def __init__(self, auth: httpx.Auth, *, limit: int, follow_redirects: bool) -> None:
+        self._auth = auth
+        self._limit = limit
+        self._follow_redirects = follow_redirects
+
+    async def async_auth_flow(self, request: httpx.Request) -> AsyncGenerator[httpx.Request, httpx.Response]:
+        flow = self._auth.async_auth_flow(request)
+        try:
+            request = await flow.__anext__()
+            while True:
+                response = yield request
+                await _read_bounded_response(response, self._limit)
+                if self._follow_redirects and response.next_request is not None:
+                    request = response.next_request
+                    continue
+                try:
+                    request = await flow.asend(response)
+                except StopAsyncIteration:
+                    return
+        finally:
+            await flow.aclose()
+
+
+async def _read_bounded_response(response: httpx.Response, limit: int) -> None:
+    """Cache only bounded decoded content, preserving HTTPX text and auth behavior."""
+    try:
+        if response.is_stream_consumed:
+            if len(response.content) > limit:
+                raise httpx.StreamError("HTTP response body exceeds the configured limit.")
+            return
+
+        encodings = [
+            encoding.strip().lower()
+            for encoding in response.headers.get("content-encoding", "").split(",")
+            if encoding.strip().lower() != "identity" and encoding.strip()
+        ]
+        if (
+            response.request.method == "HEAD"
+            or 100 <= response.status_code < 200
+            or response.status_code in {204, 205, 304}
+            or (response.request.method == "CONNECT" and 200 <= response.status_code < 300)
+        ):
+            encodings = []
+        if len(encodings) > 4:
+            raise httpx.DecodingError("HTTP response has too many content encoding stages.", request=response.request)
+        decoders = [_BoundedContentDecoder(encoding, limit) for encoding in reversed(encodings)]
+        body = bytearray()
+        received = 0
+        async for chunk in response.aiter_raw():
+            received += len(chunk)
+            if received > limit:
+                raise httpx.StreamError("HTTP response body exceeds the configured limit.")
+            for decoder in decoders:
+                chunk = decoder.decode(chunk)
+            if len(body) + len(chunk) > limit:
+                raise httpx.StreamError("HTTP response body exceeds the configured limit.")
+            body.extend(chunk)
+        for index, decoder in enumerate(decoders):
+            chunk = decoder.finish()
+            for downstream in decoders[index + 1 :]:
+                chunk = downstream.decode(chunk)
+            if len(body) + len(chunk) > limit:
+                raise httpx.StreamError("HTTP response body exceeds the configured limit.")
+            body.extend(chunk)
+        # HTTPX rereads intermediate responses during auth/redirect handling. Populate
+        # its content cache so those reads cannot trigger automatic decoding again.
+        response._content = bytes(body)  # pyright: ignore[reportPrivateUsage]
+    finally:
+        await response.aclose()
+
+
+class _BoundedContentDecoder:
+    def __init__(self, encoding: str, limit: int) -> None:
+        if encoding not in {"gzip", "deflate"}:
+            raise httpx.DecodingError(f"Unsupported HTTP response content encoding: {encoding}.")
+        self._limit = limit
+        self._decoded = 0
+        self._input = bytearray()
+        self._decoder = zlib.decompressobj(zlib.MAX_WBITS | 16) if encoding == "gzip" else None
+
+    def decode(self, data: bytes) -> bytes:
+        if self._decoder is None:
+            # Raw deflate can share a wrapped stream's prefix. Retain bounded input
+            # until finalization so a failed candidate never reaches downstream stages.
+            if len(self._input) + len(data) > self._limit:
+                raise httpx.StreamError("HTTP response body exceeds the configured limit.")
+            self._input.extend(data)
+            return b""
+        try:
+            decoded = self._decoder.decompress(data, min(self._limit - self._decoded + 1, sys.maxsize))
+        except zlib.error as exc:
+            raise httpx.DecodingError(str(exc)) from exc
+        self._decoded += len(decoded)
+        if self._decoded > self._limit:
+            raise httpx.StreamError("HTTP response body exceeds the configured limit.")
+        if self._decoder.unused_data:
+            raise httpx.DecodingError("Unexpected data after HTTP response content encoding.")
+        return decoded
+
+    def finish(self) -> bytes:
+        if self._decoder is not None:
+            if not self._decoder.eof:
+                raise httpx.DecodingError("Incomplete HTTP response content encoding.")
+            return b""
+
+        data = bytes(self._input)
+        self._input.clear()
+        failures: list[httpx.DecodingError | httpx.StreamError] = []
+        for mode in (zlib.MAX_WBITS, -zlib.MAX_WBITS):
+            self._decoder = zlib.decompressobj(mode)
+            self._decoded = 0
+            try:
+                decoded = self.decode(data)
+                if not self._decoder.eof:
+                    raise httpx.DecodingError("Incomplete HTTP response content encoding.")
+                return decoded
+            except (httpx.DecodingError, httpx.StreamError) as exc:
+                failures.append(exc)
+        for error in failures:
+            if isinstance(error, httpx.StreamError):
+                raise error
+        raise failures[-1]

{agent_framework_declarative-1.2.1 → agent_framework_declarative-1.4.0}/agent_framework_declarative/_workflows/_mcp_handler.py

@@ -27,6 +27,7 @@ must trust the MCP server they invoke.
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import hashlib
 import json
 import logging
@@ -36,7 +37,7 @@ from contextvars import ContextVar, Token
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, ClassVar, Protocol, cast, runtime_checkable
 
-import httpx
+import httpx2 as httpx
 
 if TYPE_CHECKING:
     from agent_framework import Content
@@ -345,10 +346,10 @@ class DefaultMCPToolHandler:
             # Be defensive about MCP errors that may bubble up without being
             # wrapped in ToolExecutionException by custom parsers.
             try:
-                from mcp.shared.exceptions import McpError
+                from mcp.shared.exceptions import MCPError
             except ImportError:  # pragma: no cover - mcp is a hard dep but stay defensive
                 raise
-            if isinstance(exc, McpError):
+            if isinstance(exc, MCPError):
                 message = str(exc) or type(exc).__name__
                 return MCPToolResult(
                     outputs=[Content.from_text(f"Error: {message}")],
@@ -369,7 +370,7 @@ class DefaultMCPToolHandler:
     async def _invoke_list_tools(entry: _CacheEntry) -> MCPToolResult:
         """Handle the reserved :attr:`LIST_TOOLS_TOOL_NAME` invocation.
 
-        Pages through ``session.list_tools()`` (mirroring the pagination loop
+        Pages through the normalized MCP connection (mirroring the pagination loop
         in :meth:`agent_framework.MCPTool.load_tools`) and serialises the
         full catalog as a single ``TextContent`` containing JSON of shape
         ``{"tools": [{name, description, inputSchema, outputSchema}, ...]}``.
@@ -383,8 +384,16 @@ class DefaultMCPToolHandler:
         """
         from agent_framework import Content
 
-        session = getattr(entry.tool, "session", None)
-        if session is None:
+        require_connection: Any = getattr(entry.tool, "_require_connection", None)
+        connection: Any | None = None
+        session: Any | None = None
+        if callable(require_connection):
+            with contextlib.suppress(RuntimeError):
+                connection = require_connection()
+        else:
+            session = getattr(entry.tool, "session", None)
+
+        if connection is None and session is None:
             message = "MCP session is not connected; cannot list tools."
             return MCPToolResult(
                 outputs=[Content.from_text(f"Error: {message}")],
@@ -398,9 +407,14 @@ class DefaultMCPToolHandler:
         collected: list[Any] = []
         params: mcp_types.PaginatedRequestParams | None = None
         while True:
-            tool_list = await session.list_tools(params=params)
+            if connection is not None:
+                tool_list = await connection.list_tools_page(params)
+            elif session is not None:
+                tool_list = await session.list_tools(params=params)
+            else:  # pragma: no cover - guarded before entering the loop
+                raise RuntimeError("MCP connection became unavailable while listing tools.")
             collected.extend(tool_list.tools)
-            next_cursor = getattr(tool_list, "nextCursor", None)
+            next_cursor = getattr(tool_list, "next_cursor", getattr(tool_list, "nextCursor", None))
             if not next_cursor:
                 break
             params = mcp_types.PaginatedRequestParams(cursor=next_cursor)
@@ -410,8 +424,8 @@ class DefaultMCPToolHandler:
                 {
                     "name": tool.name,
                     "description": tool.description,
-                    "inputSchema": tool.inputSchema,
-                    "outputSchema": tool.outputSchema,
+                    "inputSchema": getattr(tool, "input_schema", getattr(tool, "inputSchema", None)),
+                    "outputSchema": getattr(tool, "output_schema", getattr(tool, "outputSchema", None)),
                 }
                 for tool in collected
             ],

{agent_framework_declarative-1.2.1 → agent_framework_declarative-1.4.0}/agent_framework_declarative/_workflows/_powerfx_functions.py

@@ -12,9 +12,156 @@ or registered with the PowerFx engine when it is available.
 
 from __future__ import annotations
 
+from collections.abc import Iterator
 from typing import Any, cast
 
 
+def _skip_powerfx_opaque_token(formula: str, start: int) -> int:
+    """Return the end of an ordinary quoted token or comment, or start if neither."""
+    quote = formula[start]
+    if quote in ('"', "'"):
+        pos = start + 1
+        while pos < len(formula):
+            if formula[pos] == quote:
+                if pos + 1 < len(formula) and formula[pos + 1] == quote:
+                    pos += 2
+                    continue
+                return pos + 1
+            pos += 1
+        return pos
+    if formula.startswith("//", start):
+        pos = start + 2
+        while pos < len(formula) and formula[pos] not in "\r\n":
+            pos += 1
+        return pos
+    if formula.startswith("/*", start):
+        end = formula.find("*/", start + 2)
+        # An unterminated /* is not a complete comment: leave it as code so a
+        # trailing one is not mistaken for trivia following a complete call.
+        return start if end == -1 else end + 2
+    return start
+
+
+def _iter_powerfx_expression_indices(formula: str) -> Iterator[int]:
+    """Yield code positions, excluding literals/comments but including interpolation expressions."""
+    # None denotes interpolated text; integers track record braces in expression sections.
+    scopes: list[int | None] = [0]
+    cursor = 0
+    while cursor < len(formula):
+        depth = scopes[-1]
+        char = formula[cursor]
+        if depth is None:
+            if formula.startswith(('""', "{{", "}}"), cursor):
+                cursor += 2
+                continue
+            if char == "{":
+                scopes.append(0)
+            elif char == '"':
+                scopes.pop()
+            cursor += 1
+            continue
+
+        if formula.startswith('$"', cursor):
+            scopes.append(None)
+            cursor += 2
+            continue
+
+        token_end = _skip_powerfx_opaque_token(formula, cursor)
+        if token_end != cursor:
+            cursor = token_end
+            continue
+
+        if char == "{":
+            scopes[-1] = depth + 1
+        elif char == "}":
+            if depth > 0:
+                scopes[-1] = depth - 1
+            elif len(scopes) > 1:
+                scopes.pop()
+                cursor += 1
+                continue
+
+        yield cursor
+        cursor += 1
+
+
+def _after_trailing_trivia(formula: str, start: int) -> int:
+    """Return the index after trailing whitespace and complete comments.
+
+    Unlike the expression walker, this never skips a string literal: a quoted
+    token after the call's own closing paren is trailing code, not trivia, so it
+    stops the scan and leaves the formula to PowerFx.
+    """
+    index = start
+    while index < len(formula):
+        if formula[index].isspace():
+            index += 1
+            continue
+        if formula.startswith(("//", "/*"), index):
+            token_end = _skip_powerfx_opaque_token(formula, index)
+            if token_end == index:
+                # Unterminated /* is not a complete comment, so real code follows.
+                break
+            index = token_end
+            continue
+        break
+    return index
+
+
+def whole_call_args(formula: str, *names: str) -> str | None:
+    """Return the argument text when ``formula`` is exactly one ``Name(...)`` call.
+
+    A custom-function handler must not fire for a formula that merely *starts*
+    with its name: the closing parenthesis has to be the call's own and nothing
+    but trivia may follow it. Otherwise a trailing operator is swallowed into the
+    argument list and the formula is evaluated as something the author never
+    wrote, instead of being left to PowerFx.
+
+    Parentheses inside string literals and comments are data, not delimiters, so
+    the scan walks the formula with the shared PowerFx expression walker: it
+    skips those tokens whole and counts only parentheses that are real code,
+    including those inside an interpolated string's ``{...}`` expression sections.
+
+    Args:
+        formula: The stripped formula to inspect.
+        *names: Candidate function names, matched case-sensitively.
+
+    Returns:
+        The text between the call's parentheses - an empty string for an
+        argument-less call - or None when ``formula`` is not a single complete
+        call to one of ``names``. Callers that require an argument check the
+        result for emptiness so the call still falls through to PowerFx, which
+        reports the arity error.
+    """
+    for name in names:
+        prefix = f"{name}("
+        if not formula.startswith(prefix):
+            continue
+        positions = _iter_powerfx_expression_indices(formula)
+        depth = 0
+        close_index = -1
+        for index in positions:
+            char = formula[index]
+            if char == "(":
+                depth += 1
+            elif char == ")":
+                depth -= 1
+                if depth == 0:
+                    close_index = index
+                    break
+        if close_index == -1:
+            # Unbalanced: the call never closes, so it is not a whole call.
+            return None
+        # Only whitespace and complete comments may follow the call's own closing
+        # paren. The suffix scan deliberately does not reuse the literal-skipping
+        # walker: a trailing string literal (or any other code) there means the
+        # formula is a larger expression the caller must not claim.
+        if _after_trailing_trivia(formula, close_index + 1) != len(formula):
+            return None
+        return formula[len(prefix) : close_index]
+    return None
+
+
 def message_text(messages: Any) -> str:
     """Extract text content from a message or list of messages.
 

{agent_framework_declarative-1.2.1 → agent_framework_declarative-1.4.0}/agent_framework_declarative/_workflows/_state.py

@@ -441,7 +441,7 @@ class WorkflowState:
         Returns:
             The evaluated result
         """
-        from ._powerfx_functions import CUSTOM_FUNCTIONS
+        from ._powerfx_functions import CUSTOM_FUNCTIONS, whole_call_args
 
         formula = formula.strip()
 
@@ -452,15 +452,15 @@ class WorkflowState:
             return not bool(result)
 
         # Handle Not() function
-        if formula.startswith("Not(") and formula.endswith(")"):
-            inner = formula[4:-1].strip()
-            result = self._eval_simple(inner)
+        not_args = whole_call_args(formula, "Not")
+        if not_args is not None:
+            result = self._eval_simple(not_args.strip())
             return not bool(result)
 
         # Handle function calls
         for func_name, func in CUSTOM_FUNCTIONS.items():
-            if formula.startswith(f"{func_name}(") and formula.endswith(")"):
-                args_str = formula[len(func_name) + 1 : -1]
+            args_str = whole_call_args(formula, func_name)
+            if args_str is not None:
                 # Simple argument parsing (doesn't handle nested calls well)
                 args = self._parse_function_args(args_str)
                 evaluated_args = [self._eval_simple(arg) if isinstance(arg, str) else arg for arg in args]

{agent_framework_declarative-1.2.1 → agent_framework_declarative-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ description = "Declarative specification support for Microsoft Agent Framework."
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.2.1"
+version = "1.4.0"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -22,8 +22,9 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.20.0,<2",
-    "httpx>=0.27,<1",
+    "agent-framework-core>=1.23.0,<2",
+    "httpx>=0.27,<0.29",
+    "httpx2>=2.0.0,<3",
     "powerfx>=0.0.32,<0.0.35; python_version < '3.14'",
     "pyyaml>=6.0,<7.0",
 ]
@@ -103,5 +104,5 @@ help = "Run the default unit test suite for this package."
 cmd = 'pytest -m "not integration" --cov=agent_framework_declarative --cov-report=term-missing:skip-covered tests'
 
 [build-system]
-requires = ["flit-core >= 3.11,<4.0"]
+requires = ["flit-core>=3.11,<5.0"]
 build-backend = "flit_core.buildapi"