agent-framework-declarative 1.0.0rc2__tar.gz → 1.0.2__tar.gz

{agent_framework_declarative-1.0.0rc2 → agent_framework_declarative-1.0.2}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: agent-framework-declarative
-Version: 1.0.0rc2
+Version: 1.0.2
 Summary: Declarative specification support for Microsoft Agent Framework.
 Author-email: Microsoft <af-support@microsoft.com>
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Classifier: License :: OSI Approved :: MIT License
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Typing :: Typed
 License-File: LICENSE
-Requires-Dist: agent-framework-core>=1.9.0,<2
+Requires-Dist: agent-framework-core>=1.13.0,<2
 Requires-Dist: httpx>=0.27,<1
 Requires-Dist: powerfx>=0.0.32,<0.0.35; python_version < '3.14'
 Requires-Dist: pyyaml>=6.0,<7.0
@@ -29,7 +29,7 @@ Project-URL: source, https://github.com/microsoft/agent-framework/tree/main/pyth
 Please install this package via pip:
 
 ```bash
-pip install agent-framework-declarative --pre
+pip install agent-framework-declarative
 ```
 
 ## Release stage
@@ -37,8 +37,7 @@ pip install agent-framework-declarative --pre
 This package ships at two different stability levels:
 
 - **Declarative workflows** (`WorkflowFactory`, executors, handlers, and the
-  `_workflows` surface) are at **release-candidate** stability and may receive only
-  minor refinements before GA.
+  `_workflows` surface) are **stable**.
 - **Declarative agents** (`AgentFactory` and the YAML agent loading/parsing path:
   `DeclarativeLoaderError`, `ProviderLookupError`, `ProviderTypeMapping`) are
   **experimental** and may change or be removed in future versions without notice.

{agent_framework_declarative-1.0.0rc2 → agent_framework_declarative-1.0.2}/README.md

@@ -3,7 +3,7 @@
 Please install this package via pip:
 
 ```bash
-pip install agent-framework-declarative --pre
+pip install agent-framework-declarative
 ```
 
 ## Release stage
@@ -11,8 +11,7 @@ pip install agent-framework-declarative --pre
 This package ships at two different stability levels:
 
 - **Declarative workflows** (`WorkflowFactory`, executors, handlers, and the
-  `_workflows` surface) are at **release-candidate** stability and may receive only
-  minor refinements before GA.
+  `_workflows` surface) are **stable**.
 - **Declarative agents** (`AgentFactory` and the YAML agent loading/parsing path:
   `DeclarativeLoaderError`, `ProviderLookupError`, `ProviderTypeMapping`) are
   **experimental** and may change or be removed in future versions without notice.

{agent_framework_declarative-1.0.0rc2 → agent_framework_declarative-1.0.2}/agent_framework_declarative/__init__.py

@@ -5,7 +5,7 @@
 Release stage:
 
 * The declarative-workflows surface (``WorkflowFactory``, executors, handlers,
-  etc.) is at release-candidate stability.
+  etc.) is stable.
 * The declarative-agents surface (``AgentFactory`` and the YAML agent
   loading/parsing path: ``DeclarativeLoaderError``, ``ProviderLookupError``,
   ``ProviderTypeMapping``) is *experimental* and may change or be removed in

agent_framework_declarative-1.0.2/agent_framework_declarative/_feature_usage.py

@@ -0,0 +1,10 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from enum import IntEnum
+
+
+class FeatureIndex(IntEnum):
+    """Declarative-owned feature-usage indexes."""
+
+    DECLARATIVE_AGENT = 75
+    DECLARATIVE_WORKFLOW = 76

{agent_framework_declarative-1.0.0rc2 → agent_framework_declarative-1.0.2}/agent_framework_declarative/_loader.py

@@ -15,13 +15,15 @@ from agent_framework import (
 from agent_framework import (
     FunctionTool as AFFunctionTool,
 )
-from agent_framework._feature_stage import (  # type: ignore[reportPrivateUsage]
+from agent_framework._feature_stage import (
     ExperimentalFeature,
     experimental,
 )
+from agent_framework._telemetry import mark_feature_used
 from agent_framework.exceptions import AgentException
 from dotenv import load_dotenv
 
+from ._feature_usage import FeatureIndex
 from ._models import (
     AnonymousConnection,
     ApiKeyConnection,
@@ -42,9 +44,9 @@ from ._models import (
 )
 
 if sys.version_info >= (3, 11):
-    from typing import TypedDict  # type: ignore # pragma: no cover
+    from typing import TypedDict  # pragma: no cover
 else:
-    from typing_extensions import TypedDict  # type: ignore # pragma: no cover
+    from typing_extensions import TypedDict  # pragma: no cover
 
 
 @experimental(feature_id=ExperimentalFeature.DECLARATIVE_AGENTS)
@@ -471,13 +473,15 @@ class AgentFactory:
         if output_schema := prompt_agent.outputSchema:
             chat_options["response_format"] = output_schema.to_json_schema()
         # Step 3: Create the agent instance
-        return Agent(
+        agent = Agent(
             client=client,
             name=prompt_agent.name,
             description=prompt_agent.description,
             instructions=prompt_agent.instructions,
             default_options=chat_options,  # type: ignore[arg-type]
         )
+        mark_feature_used(FeatureIndex.DECLARATIVE_AGENT)
+        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.
@@ -582,13 +586,15 @@ class AgentFactory:
             chat_options["tools"] = tools
         if output_schema := prompt_agent.outputSchema:
             chat_options["response_format"] = output_schema.to_json_schema()
-        return Agent(
+        agent = Agent(
             client=client,
             name=prompt_agent.name,
             description=prompt_agent.description,
             instructions=prompt_agent.instructions,
             default_options=chat_options,  # type: ignore[arg-type]
         )
+        mark_feature_used(FeatureIndex.DECLARATIVE_AGENT)
+        return agent
 
     async def _create_agent_with_provider(self, prompt_agent: PromptAgent, mapping: ProviderTypeMapping) -> Agent:
         """Create an Agent through a provider object that exposes ``create_agent``.
@@ -708,7 +714,7 @@ class AgentFactory:
         module = __import__(module_name, fromlist=[class_name])
         agent_class = getattr(module, class_name)
         setup_dict[mapping["model_field"]] = prompt_agent.model.id
-        return agent_class(**setup_dict)  # type: ignore[no-any-return]
+        return agent_class(**setup_dict)
 
     def _parse_chat_options(self, model: Model | None) -> dict[str, Any]:
         """Parse ModelOptions into chat options dictionary."""
@@ -753,7 +759,7 @@ class AgentFactory:
                     for binding in tool_resource.bindings:
                         if binding.name and (func := self.bindings.get(binding.name)):
                             break
-                return AFFunctionTool(  # type: ignore
+                return AFFunctionTool(
                     name=tool_resource.name,  # type: ignore
                     description=tool_resource.description,  # type: ignore
                     input_model=tool_resource.parameters.to_json_schema() if tool_resource.parameters else None,

{agent_framework_declarative-1.0.0rc2 → agent_framework_declarative-1.0.2}/agent_framework_declarative/_models.py

@@ -5,7 +5,7 @@ import logging
 import os
 from collections.abc import MutableMapping
 from contextvars import ContextVar
-from typing import TYPE_CHECKING, Any, Literal, TypeVar, Union, overload
+from typing import TYPE_CHECKING, Any, Literal, TypeVar, Union, cast, overload
 
 from agent_framework._serialization import SerializationMixin
 
@@ -121,7 +121,7 @@ class Property(SerializationMixin):
         # Only dispatch if we're being called on the base Property class
         if cls is not Property:
             # We're being called on a subclass, use the normal from_dict
-            return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)  # type: ignore[attr-defined, no-any-return]
+            return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)
 
         # The YAML spec uses 'type' for the data type, but Property stores it as 'kind'
         if "type" in value:
@@ -135,7 +135,7 @@ class Property(SerializationMixin):
         if kind == "object":
             return ObjectProperty.from_dict(value, dependencies=dependencies)
         # Default to Property for kind="property" or empty
-        return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)  # type: ignore[attr-defined, no-any-return]
+        return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)
 
 
 class ArrayProperty(Property):
@@ -203,6 +203,52 @@ class ObjectProperty(Property):
         self.properties = converted_properties
 
 
+def _normalize_nested_schemas(node: dict[str, Any]) -> None:
+    """Recursively convert a node's nested schemas to JSON Schema form.
+
+    Nested schemas (array ``items``, object ``properties``) keep the declarative
+    shape after serialization: ``kind`` instead of ``type``, empty ``enum``
+    placeholders, and object properties as a list of ``{"name": ..., ...}``
+    entries. OpenAI rejects schemas whose nested nodes lack a ``type`` key, so
+    apply the same conversion the top-level properties loop performs.
+    """
+    items = node.get("items")
+    if isinstance(items, dict):
+        _normalize_schema_node(cast("dict[str, Any]", items))
+    props = node.get("properties")
+    if not isinstance(props, list):
+        return
+    # Serialized PropertySchema shape: [{"name": ..., "kind": ..., ...}, ...].
+    # Validate every element BEFORE mutating any, so an unexpected shape
+    # leaves the node fully untouched rather than half-converted.
+    if not all(isinstance(prop, dict) and "name" in prop for prop in cast("list[Any]", props)):
+        return
+    new_props: dict[str, Any] = {}
+    required_fields: list[str] = []
+    for prop in cast("list[dict[str, Any]]", props):
+        prop_name = prop.pop("name")
+        if prop.pop("required", False):
+            required_fields.append(prop_name)
+        _normalize_schema_node(prop)
+        new_props[prop_name] = prop
+    node["properties"] = new_props
+    if required_fields:
+        node["required"] = required_fields
+
+
+def _normalize_schema_node(node: dict[str, Any]) -> None:
+    """Rename ``kind`` -> ``type``, drop empty ``enum``, and recurse into children."""
+    if "kind" in node:
+        node["type"] = node.pop("kind")
+    if not node.get("enum"):
+        node.pop("enum", None)
+    if node.get("type") == "object":
+        # OpenAI strict structured outputs require additionalProperties: false on
+        # every object node; chat clients only inject it at the schema root.
+        node.setdefault("additionalProperties", False)
+    _normalize_nested_schemas(node)
+
+
 class PropertySchema(SerializationMixin):
     """Object representing a property schema."""
 
@@ -235,7 +281,7 @@ class PropertySchema(SerializationMixin):
         # Filter out 'kind', 'type', 'name', and 'description' fields that may appear in YAML
         # but aren't PropertySchema params
         kwargs = {k: v for k, v in value.items() if k not in ("type", "kind", "name", "description")}
-        return SerializationMixin.from_dict.__func__(cls, kwargs, dependencies=dependencies)  # type: ignore[attr-defined, no-any-return]
+        return SerializationMixin.from_dict.__func__(cls, kwargs, dependencies=dependencies)
 
     def to_json_schema(self) -> dict[str, Any]:
         """Get a schema out of this PropertySchema to create pydantic models."""
@@ -244,13 +290,10 @@ class PropertySchema(SerializationMixin):
         required_fields: list[str] = []
         for prop in json_schema.get("properties", []):
             prop_name = prop.pop("name")
-            prop["type"] = prop.pop("kind", None)
             # Convert property-level 'required' boolean to a top-level 'required' array
             if prop.pop("required", False):
                 required_fields.append(prop_name)
-            # Remove empty enum arrays
-            if not prop.get("enum"):
-                prop.pop("enum", None)
+            _normalize_schema_node(prop)
             new_props[prop_name] = prop
         json_schema["type"] = "object"
         json_schema["properties"] = new_props
@@ -287,26 +330,18 @@ class Connection(SerializationMixin):
         # Only dispatch if we're being called on the base Connection class
         if cls is not Connection:
             # We're being called on a subclass, use the normal from_dict
-            return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)  # type: ignore[attr-defined, no-any-return]
+            return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)
 
         kind = value.get("kind", "").lower()
         if kind == "reference":
-            return SerializationMixin.from_dict.__func__(  # type: ignore[attr-defined, no-any-return]
-                ReferenceConnection, value, dependencies=dependencies
-            )
+            return SerializationMixin.from_dict.__func__(ReferenceConnection, value, dependencies=dependencies)
         if kind == "remote":
-            return SerializationMixin.from_dict.__func__(  # type: ignore[attr-defined, no-any-return]
-                RemoteConnection, value, dependencies=dependencies
-            )
+            return SerializationMixin.from_dict.__func__(RemoteConnection, value, dependencies=dependencies)
         if kind in ("key", "apikey"):
-            return SerializationMixin.from_dict.__func__(  # type: ignore[attr-defined, no-any-return]
-                ApiKeyConnection, value, dependencies=dependencies
-            )
+            return SerializationMixin.from_dict.__func__(ApiKeyConnection, value, dependencies=dependencies)
         if kind == "anonymous":
-            return SerializationMixin.from_dict.__func__(  # type: ignore[attr-defined, no-any-return]
-                AnonymousConnection, value, dependencies=dependencies
-            )
-        return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)  # type: ignore[attr-defined, no-any-return]
+            return SerializationMixin.from_dict.__func__(AnonymousConnection, value, dependencies=dependencies)
+        return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)
 
 
 class ReferenceConnection(Connection):
@@ -525,13 +560,13 @@ class AgentDefinition(SerializationMixin):
         # Only dispatch if we're being called on the base AgentDefinition class
         if cls is not AgentDefinition:
             # We're being called on a subclass, use the normal from_dict
-            return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)  # type: ignore[attr-defined, no-any-return]
+            return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)
 
         kind = value.get("kind", "")
         if kind == "Prompt" or kind == "Agent":
             return PromptAgent.from_dict(value, dependencies=dependencies)
         # Default to AgentDefinition
-        return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)  # type: ignore[attr-defined, no-any-return]
+        return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)
 
 
 ToolT = TypeVar("ToolT", bound="Tool")
@@ -571,39 +606,25 @@ class Tool(SerializationMixin):
         # Only dispatch if we're being called on the base Tool class
         if cls is not Tool:
             # We're being called on a subclass, use the normal from_dict
-            return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)  # type: ignore[attr-defined, no-any-return]
+            return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)
 
         kind = value.get("kind", "")
         if kind == "function":
-            return SerializationMixin.from_dict.__func__(  # type: ignore[attr-defined, no-any-return]
-                FunctionTool, value, dependencies=dependencies
-            )
+            return SerializationMixin.from_dict.__func__(FunctionTool, value, dependencies=dependencies)
         if kind == "custom":
-            return SerializationMixin.from_dict.__func__(  # type: ignore[attr-defined, no-any-return]
-                CustomTool, value, dependencies=dependencies
-            )
+            return SerializationMixin.from_dict.__func__(CustomTool, value, dependencies=dependencies)
         if kind == "web_search":
-            return SerializationMixin.from_dict.__func__(  # type: ignore[attr-defined, no-any-return]
-                WebSearchTool, value, dependencies=dependencies
-            )
+            return SerializationMixin.from_dict.__func__(WebSearchTool, value, dependencies=dependencies)
         if kind == "file_search":
-            return SerializationMixin.from_dict.__func__(  # type: ignore[attr-defined, no-any-return]
-                FileSearchTool, value, dependencies=dependencies
-            )
+            return SerializationMixin.from_dict.__func__(FileSearchTool, value, dependencies=dependencies)
         if kind == "mcp":
-            return SerializationMixin.from_dict.__func__(  # type: ignore[attr-defined, no-any-return]
-                McpTool, value, dependencies=dependencies
-            )
+            return SerializationMixin.from_dict.__func__(McpTool, value, dependencies=dependencies)
         if kind == "openapi":
-            return SerializationMixin.from_dict.__func__(  # type: ignore[attr-defined, no-any-return]
-                OpenApiTool, value, dependencies=dependencies
-            )
+            return SerializationMixin.from_dict.__func__(OpenApiTool, value, dependencies=dependencies)
         if kind == "code_interpreter":
-            return SerializationMixin.from_dict.__func__(  # type: ignore[attr-defined, no-any-return]
-                CodeInterpreterTool, value, dependencies=dependencies
-            )
+            return SerializationMixin.from_dict.__func__(CodeInterpreterTool, value, dependencies=dependencies)
         # Default to base Tool class
-        return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)  # type: ignore[attr-defined, no-any-return]
+        return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)
 
 
 class FunctionTool(Tool):
@@ -901,18 +922,14 @@ class Resource(SerializationMixin):
         # Only dispatch if we're being called on the base Resource class
         if cls is not Resource:
             # We're being called on a subclass, use the normal from_dict
-            return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)  # type: ignore[attr-defined, no-any-return]
+            return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)
 
         kind = value.get("kind", "")
         if kind == "model":
-            return SerializationMixin.from_dict.__func__(  # type: ignore[attr-defined, no-any-return]
-                ModelResource, value, dependencies=dependencies
-            )
+            return SerializationMixin.from_dict.__func__(ModelResource, value, dependencies=dependencies)
         if kind == "tool":
-            return SerializationMixin.from_dict.__func__(  # type: ignore[attr-defined, no-any-return]
-                ToolResource, value, dependencies=dependencies
-            )
-        return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)  # type: ignore[attr-defined, no-any-return]
+            return SerializationMixin.from_dict.__func__(ToolResource, value, dependencies=dependencies)
+        return SerializationMixin.from_dict.__func__(cls, value, dependencies=dependencies)
 
 
 class ModelResource(Resource):

{agent_framework_declarative-1.0.0rc2 → agent_framework_declarative-1.0.2}/agent_framework_declarative/_workflows/_declarative_base.py

@@ -50,12 +50,12 @@ try:
 except (ImportError, RuntimeError):
     # ImportError: powerfx package not installed
     # RuntimeError: .NET runtime not available or misconfigured
-    Engine = None  # type: ignore[assignment, misc]
+    Engine = None
 
 if sys.version_info >= (3, 11):
-    from typing import TypedDict  # type: ignore # pragma: no cover
+    from typing import TypedDict  # pragma: no cover
 else:
-    from typing_extensions import TypedDict  # type: ignore # pragma: no cover
+    from typing_extensions import TypedDict  # pragma: no cover
 
 
 logger = logging.getLogger(__name__)
@@ -147,11 +147,11 @@ def discover_env_references(node: Any) -> set[str]:
                 names.update(_ENV_REFERENCE_RE.findall(value))
             return
         if isinstance(value, Mapping):
-            for inner in cast(Mapping[Any, Any], value).values():  # type: ignore[redundant-cast]
+            for inner in cast(Mapping[Any, Any], value).values():
                 visit(inner)
             return
         if isinstance(value, list):
-            for item in cast(list[Any], value):  # type: ignore[redundant-cast]
+            for item in cast(list[Any], value):
                 visit(item)
 
     visit(node)
@@ -243,7 +243,7 @@ def _make_powerfx_safe(value: Any) -> Any:
         return {str(k): _make_powerfx_safe(v) for k, v in value_dict.items()}
 
     if isinstance(value, list):
-        value_list = cast(list[Any], value)  # type: ignore[redundant-cast]
+        value_list = cast(list[Any], value)
         return [_make_powerfx_safe(item) for item in value_list]
 
     # Try to convert objects with __dict__ or dataclass-style attributes
@@ -581,10 +581,10 @@ class DeclarativeWorkflowState:
 
                 original_culture = cast(Any, CultureInfo.CurrentCulture)  # pyright: ignore[reportUnknownMemberType]
                 try:
-                    CultureInfo.CurrentCulture = CultureInfo(_POWERFX_EVAL_LOCALE)  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+                    CultureInfo.CurrentCulture = CultureInfo(_POWERFX_EVAL_LOCALE)
                     return engine.eval(formula, symbols=symbols, locale=_POWERFX_EVAL_LOCALE)
                 finally:
-                    CultureInfo.CurrentCulture = original_culture  # pyright: ignore[reportUnknownMemberType]
+                    CultureInfo.CurrentCulture = original_culture
             except ValueError as e:
                 error_msg = str(e)
                 # Handle undefined variable errors gracefully by returning None
@@ -780,7 +780,7 @@ class DeclarativeWorkflowState:
         """
         messages: Any = self.eval(f"={inner_expr}")
         if isinstance(messages, list) and messages:
-            message_list = cast(list[Any], messages)  # type: ignore[redundant-cast]
+            message_list = cast(list[Any], messages)
             last_msg: Any = message_list[-1]
             if isinstance(last_msg, dict):
                 last_msg_dict = cast(dict[str, Any], last_msg)
@@ -791,7 +791,7 @@ class DeclarativeWorkflowState:
                 # Message.text concatenates text from all TextContent items
                 contents_obj = last_msg_dict.get("contents", [])
                 if isinstance(contents_obj, list):
-                    contents = cast(list[Any], contents_obj)  # type: ignore[redundant-cast]
+                    contents = cast(list[Any], contents_obj)
                     text_parts: list[str] = []
                     for content in contents:
                         if isinstance(content, dict):
@@ -1215,7 +1215,7 @@ class DeclarativeActionExecutor(Executor):
             state.set("System.LastMessageText", trigger)
         elif not isinstance(
             trigger,
-            (ActionTrigger, ActionComplete, ConditionResult, LoopIterationResult, LoopControl),  # pyright: ignore[reportUnknownArgumentType]
+            (ActionTrigger, ActionComplete, ConditionResult, LoopIterationResult, LoopControl),
         ):
             # Any other type - convert to string like .NET's DefaultTransform
             input_str = str(cast(Any, trigger))

{agent_framework_declarative-1.0.0rc2 → agent_framework_declarative-1.0.2}/agent_framework_declarative/_workflows/_declarative_builder.py

@@ -433,7 +433,7 @@ class DeclarativeWorkflowBuilder:
 
         # Store the chain for later reference
         if first_executor is not None:
-            first_executor._chain_executors = executors_in_chain  # type: ignore[attr-defined]
+            first_executor._chain_executors = executors_in_chain
 
         return first_executor
 

{agent_framework_declarative-1.0.0rc2 → agent_framework_declarative-1.0.2}/agent_framework_declarative/_workflows/_executors_agents.py

@@ -2,7 +2,7 @@
 
 """Agent invocation executors for declarative workflows.
 
-These executors handle invoking Azure AI Foundry agents and other AI agents,
+These executors handle invoking Microsoft Foundry agents and other AI agents,
 supporting both streaming responses and human-in-loop patterns.
 
 Aligned with .NET's InvokeAzureAgentExecutor behavior including:
@@ -16,6 +16,7 @@ import contextlib
 import json
 import logging
 import uuid
+from collections.abc import Iterator
 from dataclasses import dataclass, field
 from typing import Any, cast
 
@@ -36,6 +37,218 @@ from ._declarative_base import (
 
 logger = logging.getLogger(__name__)
 
+_CODE_FENCE = "```"
+_JSON_CODE_FENCE_QUALIFIER = "json"
+_MAX_JSON_DECODE_BUDGET_MULTIPLIER = 4
+_NO_JSON = object()
+
+
+def _iter_fenced_blocks(text: str, *, require_json_qualifier: bool) -> Iterator[str]:
+    """Yield non-overlapping fenced blocks in source order."""
+    search_start = 0
+    while True:
+        opening_index = text.find(_CODE_FENCE, search_start)
+        if opening_index < 0:
+            return
+
+        content_start = opening_index + len(_CODE_FENCE)
+        if require_json_qualifier:
+            if not text.startswith(_JSON_CODE_FENCE_QUALIFIER, content_start):
+                search_start = content_start
+                continue
+
+            qualifier_end = content_start + len(_JSON_CODE_FENCE_QUALIFIER)
+            if (
+                qualifier_end < len(text)
+                and not text[qualifier_end].isspace()
+                and text[qualifier_end] not in "{["
+                and not text.startswith(_CODE_FENCE, qualifier_end)
+            ):
+                search_start = content_start
+                continue
+            content_start = qualifier_end
+
+        while content_start < len(text) and text[content_start].isspace():
+            content_start += 1
+
+        closing_index = text.find(_CODE_FENCE, content_start)
+        if closing_index < 0:
+            return
+
+        yield text[content_start:closing_index].strip()
+        search_start = closing_index + len(_CODE_FENCE)
+
+
+def _index_escaped_quotes(text: str) -> bytearray:
+    """Index quote characters preceded by an odd-length backslash run."""
+    escaped_quotes = bytearray(len(text))
+    backslash_count = 0
+
+    for index, char in enumerate(text):
+        if char == "\\":
+            backslash_count += 1
+            continue
+
+        if char == '"' and backslash_count % 2 == 1:
+            escaped_quotes[index] = 1
+        backslash_count = 0
+
+    return escaped_quotes
+
+
+def _index_json_candidates_forward(text: str, escaped_quotes: bytearray) -> set[tuple[int, int]]:
+    """Index JSON candidate ranges from left to right."""
+    candidates: set[tuple[int, int]] = set()
+    object_openings: list[int] = []
+    array_openings: list[int] = []
+    in_string = False
+
+    for index, char in enumerate(text):
+        if not object_openings and not array_openings:
+            if char in "{[":
+                (object_openings if char == "{" else array_openings).append(index)
+            continue
+
+        if char == '"' and not escaped_quotes[index]:
+            in_string = not in_string
+            continue
+
+        if in_string:
+            continue
+
+        if char in "{[":
+            (object_openings if char == "{" else array_openings).append(index)
+        elif char == "}" and object_openings:
+            candidates.add((object_openings.pop(), index))
+        elif char == "]" and array_openings:
+            candidates.add((array_openings.pop(), index))
+
+    return candidates
+
+
+def _index_json_candidates_reverse(text: str, escaped_quotes: bytearray) -> set[tuple[int, int]]:
+    """Index JSON candidate ranges from right to left."""
+    candidates: set[tuple[int, int]] = set()
+    object_closings: list[int] = []
+    array_closings: list[int] = []
+    in_string = False
+
+    for index in range(len(text) - 1, -1, -1):
+        char = text[index]
+        if not object_closings and not array_closings:
+            if char in "}]":
+                (object_closings if char == "}" else array_closings).append(index)
+            continue
+
+        if char == '"' and not escaped_quotes[index]:
+            in_string = not in_string
+            continue
+
+        if in_string:
+            continue
+
+        if char in "}]":
+            (object_closings if char == "}" else array_closings).append(index)
+        elif char == "{" and object_closings:
+            candidates.add((index, object_closings.pop()))
+        elif char == "[" and array_closings:
+            candidates.add((index, array_closings.pop()))
+
+    return candidates
+
+
+def _find_last_decodable_json(text: str) -> Any:
+    """Find the last decodable JSON object or array within text."""
+    escaped_quotes = _index_escaped_quotes(text)
+    candidates = _index_json_candidates_forward(text, escaped_quotes)
+    candidates.update(_index_json_candidates_reverse(text, escaped_quotes))
+
+    candidate_groups: list[tuple[int, int, list[tuple[int, int]]]] = []
+    for candidate in sorted(candidates):
+        json_start, json_end = candidate
+        if not candidate_groups or json_start > candidate_groups[-1][1]:
+            candidate_groups.append((json_start, json_end, [candidate]))
+            continue
+
+        group_start, group_end, group_candidates = candidate_groups[-1]
+        group_candidates.append(candidate)
+        candidate_groups[-1] = (group_start, max(group_end, json_end), group_candidates)
+
+    for group_start, group_end, group_candidates in reversed(candidate_groups):
+        group_span = group_end - group_start + 1
+        primary_decode_budget = group_span * (_MAX_JSON_DECODE_BUDGET_MULTIPLIER // 2)
+        recovery_decode_budget = group_span * (
+            _MAX_JSON_DECODE_BUDGET_MULTIPLIER - (_MAX_JSON_DECODE_BUDGET_MULTIPLIER // 2)
+        )
+        attempted_candidates: set[tuple[int, int]] = set()
+        last_json: Any = _NO_JSON
+        consumed_end = -1
+        candidate_index = 0
+
+        while candidate_index < len(group_candidates) and primary_decode_budget > 0:
+            json_start, json_end = group_candidates[candidate_index]
+            candidate_index += 1
+            if json_start <= consumed_end:
+                continue
+
+            candidate_length = json_end - json_start + 1
+            if candidate_length > primary_decode_budget:
+                continue
+
+            primary_decode_budget -= candidate_length
+            attempted_candidates.add((json_start, json_end))
+            try:
+                last_json = json.loads(text[json_start : json_end + 1])
+            except json.JSONDecodeError:
+                continue
+
+            consumed_end = json_end
+            while candidate_index < len(group_candidates) and group_candidates[candidate_index][0] <= consumed_end:
+                candidate_index += 1
+
+        recovery_candidates = sorted(
+            group_candidates,
+            key=lambda candidate: (candidate[1] - candidate[0], -candidate[0]),
+        )
+        recovered_json: Any = _NO_JSON
+        recovered_range: tuple[int, int] | None = None
+        for json_start, json_end in recovery_candidates:
+            if recovery_decode_budget == 0:
+                break
+            if (json_start, json_end) in attempted_candidates or json_start <= consumed_end:
+                continue
+
+            candidate_length = json_end - json_start + 1
+            if candidate_length > recovery_decode_budget:
+                continue
+
+            recovery_decode_budget -= candidate_length
+            try:
+                candidate_json = json.loads(text[json_start : json_end + 1])
+            except json.JSONDecodeError:
+                continue
+
+            candidate_contains_recovered = (
+                recovered_range is not None and json_start <= recovered_range[0] and json_end >= recovered_range[1]
+            )
+            recovered_contains_candidate = (
+                recovered_range is not None and recovered_range[0] <= json_start and recovered_range[1] >= json_end
+            )
+            if (
+                recovered_range is None
+                or candidate_contains_recovered
+                or (not recovered_contains_candidate and json_start > recovered_range[0])
+            ):
+                recovered_json = candidate_json
+                recovered_range = (json_start, json_end)
+
+        if recovered_json is not _NO_JSON:
+            return recovered_json
+        if last_json is not _NO_JSON:
+            return last_json
+
+    raise json.JSONDecodeError("No valid JSON found in response", text, 0)
+
 
 def _extract_json_from_response(text: str) -> Any:
     r"""Extract and parse JSON from an agent response.
@@ -58,13 +271,11 @@ def _extract_json_from_response(text: str) -> Any:
         text: The raw text response from an agent
 
     Returns:
-        Parsed JSON as a Python dict/list, or None if parsing fails
+        Parsed JSON, or None if the response is empty.
 
     Raises:
         json.JSONDecodeError: If no valid JSON can be extracted
     """
-    import re
-
     if not text:
         return None
 
@@ -79,96 +290,18 @@ def _extract_json_from_response(text: str) -> Any:
     except json.JSONDecodeError:
         pass
 
-    # Try extracting from markdown code blocks: ```json ... ``` or ``` ... ```
-    # Use the last code block if there are multiple
-    code_block_patterns = [
-        r"```json\s*\n?(.*?)\n?```",  # ```json ... ```
-        r"```\s*\n?(.*?)\n?```",  # ``` ... ```
-    ]
-    for pattern in code_block_patterns:
-        matches = list(re.finditer(pattern, text, re.DOTALL))
-        if matches:
-            # Try the last match first (most likely to be the final result)
-            for match in reversed(matches):
-                try:
-                    return json.loads(match.group(1).strip())
-                except json.JSONDecodeError:
-                    continue
-
-    # Find ALL JSON objects {...} or arrays [...] in the text and return the last valid one
-    # This handles cases where agents stream multiple JSON objects (partial, then final)
-    all_json_objects: list[Any] = []
-
-    pos = 0
-    while pos < len(text):
-        # Find next { or [
-        json_start = -1
-        bracket_char = None
-        for i in range(pos, len(text)):
-            if text[i] == "{":
-                json_start = i
-                bracket_char = "{"
-                break
-            if text[i] == "[":
-                json_start = i
-                bracket_char = "["
-                break
-
-        if json_start < 0:
-            break  # No more JSON objects
-
-        # Find matching closing bracket
-        open_bracket = bracket_char
-        close_bracket = "}" if open_bracket == "{" else "]"
-        depth = 0
-        in_string = False
-        escape_next = False
-        found_end = False
-
-        for i in range(json_start, len(text)):
-            char = text[i]
-
-            if escape_next:
-                escape_next = False
-                continue
-
-            if char == "\\":
-                escape_next = True
-                continue
-
-            if char == '"' and not escape_next:
-                in_string = not in_string
-                continue
-
-            if in_string:
+    # Exactly-qualified JSON fences take precedence over plain fences.
+    for require_json_qualifier in (True, False):
+        last_fenced_json: Any = _NO_JSON
+        for block in _iter_fenced_blocks(text, require_json_qualifier=require_json_qualifier):
+            try:
+                last_fenced_json = json.loads(block)
+            except json.JSONDecodeError:
                 continue
+        if last_fenced_json is not _NO_JSON:
+            return last_fenced_json
 
-            if char == open_bracket:
-                depth += 1
-            elif char == close_bracket:
-                depth -= 1
-                if depth == 0:
-                    # Found the end
-                    potential_json = text[json_start : i + 1]
-                    try:
-                        parsed = json.loads(potential_json)
-                        all_json_objects.append(parsed)
-                    except json.JSONDecodeError:
-                        pass
-                    pos = i + 1
-                    found_end = True
-                    break
-
-        if not found_end:
-            # Malformed JSON, move past the start character
-            pos = json_start + 1
-
-    # Return the last valid JSON object (most likely to be the final/complete result)
-    if all_json_objects:
-        return all_json_objects[-1]
-
-    # Unable to extract JSON
-    raise json.JSONDecodeError("No valid JSON found in response", text, 0)
+    return _find_last_decodable_json(text)
 
 
 def _validate_conversation_history(messages: list[Message], agent_name: str) -> None:
@@ -371,7 +504,7 @@ def _normalize_variable_path(variable: str) -> str:
 
 
 class InvokeAzureAgentExecutor(DeclarativeActionExecutor):
-    """Executor that invokes an Azure AI Foundry agent.
+    """Executor that invokes a Microsoft Foundry agent.
 
     This executor supports both Python-style and .NET-style YAML schemas:
 

{agent_framework_declarative-1.0.0rc2 → agent_framework_declarative-1.0.2}/agent_framework_declarative/_workflows/_executors_basic.py

@@ -361,7 +361,9 @@ class EditTableV2Executor(DeclarativeActionExecutor):
 
         table_path = self._action_def.get("table") or _get_variable_path(self._action_def, "variable")
         operation = self._action_def.get("operation", "add").lower()
-        item = self._action_def.get("item") or self._action_def.get("value")
+        item = self._action_def.get("item")
+        if item is None:
+            item = self._action_def.get("value")
         key_field = self._action_def.get("key")
         index = self._action_def.get("index")
 
@@ -543,12 +545,12 @@ class ParseValueExecutor(DeclarativeActionExecutor):
             if value is None:
                 return []
             if isinstance(value, list):
-                return cast(list[Any], value)  # type: ignore[redundant-cast]
+                return cast(list[Any], value)
             if isinstance(value, str):
                 try:
                     parsed = json.loads(value)
                     if isinstance(parsed, list):
-                        return cast(list[Any], parsed)  # type: ignore[redundant-cast]
+                        return cast(list[Any], parsed)
                     return [parsed]
                 except json.JSONDecodeError:
                     return [value]

{agent_framework_declarative-1.0.0rc2 → agent_framework_declarative-1.0.2}/agent_framework_declarative/_workflows/_executors_mcp.py

@@ -135,7 +135,7 @@ def _format_outputs_for_send(parsed_results: list[Any]) -> str:
     if not parsed_results:
         return ""
     if all(isinstance(item, str) for item in parsed_results):
-        return "\n".join(parsed_results)  # type: ignore[arg-type]
+        return "\n".join(parsed_results)
     if len(parsed_results) == 1:
         return json.dumps(parsed_results[0], ensure_ascii=False)
     return json.dumps(parsed_results, ensure_ascii=False)

{agent_framework_declarative-1.0.0rc2 → agent_framework_declarative-1.0.2}/agent_framework_declarative/_workflows/_factory.py

@@ -24,7 +24,9 @@ from agent_framework import (
     SupportsAgentRun,
     Workflow,
 )
+from agent_framework._telemetry import mark_feature_used
 
+from .._feature_usage import FeatureIndex
 from .._loader import AgentFactory
 from ._declarative_base import DeclarativeEnvConfig, discover_env_references
 from ._declarative_builder import DeclarativeWorkflowBuilder
@@ -471,6 +473,7 @@ class WorkflowFactory:
             len(graph_builder._executors),  # type: ignore[reportPrivateUsage]
         )
 
+        mark_feature_used(FeatureIndex.DECLARATIVE_WORKFLOW)
         return workflow
 
     def _normalize_workflow_def(self, workflow_def: dict[str, Any]) -> dict[str, Any]:

{agent_framework_declarative-1.0.0rc2 → agent_framework_declarative-1.0.2}/agent_framework_declarative/_workflows/_http_handler.py

@@ -181,7 +181,7 @@ class DefaultHttpRequestHandler:
             params=params,
             headers=headers or None,
             content=content,
-            timeout=timeout,  # type: ignore[arg-type]
+            timeout=timeout,
         )
 
         # Preserve multi-value headers (e.g. multiple Set-Cookie) as list[str].

{agent_framework_declarative-1.0.0rc2 → agent_framework_declarative-1.0.2}/agent_framework_declarative/_workflows/_powerfx_functions.py

@@ -52,7 +52,7 @@ def message_text(messages: Any) -> str:
     if isinstance(messages, list):
         # List of messages - concatenate all text
         texts: list[str] = []
-        message_list = cast(list[Any], messages)  # type: ignore[redundant-cast]
+        message_list = cast(list[Any], messages)
         for msg in message_list:
             if isinstance(msg, str):
                 texts.append(msg)

{agent_framework_declarative-1.0.0rc2 → agent_framework_declarative-1.0.2}/agent_framework_declarative/_workflows/_state.py

@@ -284,7 +284,7 @@ class WorkflowState:
         if existing is None:
             self.set(path, [value])
         elif isinstance(existing, list):
-            existing_list = cast(list[Any], existing)  # type: ignore[redundant-cast]
+            existing_list = cast(list[Any], existing)
             existing_list.append(value)
             self.set(path, existing_list)
         else:

{agent_framework_declarative-1.0.0rc2 → agent_framework_declarative-1.0.2}/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.0.0rc2"
+version = "1.0.2"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"
@@ -12,7 +12,7 @@ urls.release_notes = "https://github.com/microsoft/agent-framework/releases?q=ta
 urls.issues = "https://github.com/microsoft/agent-framework/issues"
 classifiers = [
   "License :: OSI Approved :: MIT License",
-  "Development Status :: 4 - Beta",
+  "Development Status :: 5 - Production/Stable",
   "Intended Audience :: Developers",
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3.10",
@@ -22,7 +22,7 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-    "agent-framework-core>=1.9.0,<2",
+    "agent-framework-core>=1.13.0,<2",
     "httpx>=0.27,<1",
     "powerfx>=0.0.32,<0.0.35; python_version < '3.14'",
     "pyyaml>=6.0,<7.0",