agent-framework-orchestrations 1.2.0__tar.gz → 1.3.0__tar.gz

{agent_framework_orchestrations-1.2.0 → agent_framework_orchestrations-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-framework-orchestrations
-Version: 1.2.0
+Version: 1.3.0
 Summary: Orchestration patterns for Microsoft Agent Framework. Includes SequentialBuilder, ConcurrentBuilder, HandoffBuilder, GroupChatBuilder, and MagenticBuilder.
 Author-email: Microsoft <af-support@microsoft.com>
 Requires-Python: >=3.10
@@ -75,6 +75,19 @@ workflow = (
 )
 ```
 
+By default, each user response returns to the agent that requested it. To have the start agent re-evaluate every user
+turn, disable return-to-previous routing:
+
+```python
+workflow = (
+    HandoffBuilder()
+    .participants([triage, billing, support])
+    .with_start_agent(triage)
+    .enable_return_to_previous(False)
+    .build()
+)
+```
+
 ### GroupChatBuilder
 
 Orchestrator-directed multi-agent conversations:

{agent_framework_orchestrations-1.2.0 → agent_framework_orchestrations-1.3.0}/README.md

@@ -51,6 +51,19 @@ workflow = (
 )
 ```
 
+By default, each user response returns to the agent that requested it. To have the start agent re-evaluate every user
+turn, disable return-to-previous routing:
+
+```python
+workflow = (
+    HandoffBuilder()
+    .participants([triage, billing, support])
+    .with_start_agent(triage)
+    .enable_return_to_previous(False)
+    .build()
+)
+```
+
 ### GroupChatBuilder
 
 Orchestrator-directed multi-agent conversations:

{agent_framework_orchestrations-1.2.0 → agent_framework_orchestrations-1.3.0}/agent_framework_orchestrations/_group_chat.py

@@ -52,7 +52,7 @@ from ._base_group_chat_orchestrator import (
 )
 from ._feature_usage import FeatureIndex
 from ._orchestration_request_info import AgentApprovalExecutor
-from ._orchestrator_helpers import clean_conversation_for_handoff
+from ._orchestrator_helpers import clean_conversation_for_handoff, extract_markdown_fence_bodies
 from ._participant_output_config import (
     UNSET,
     _coalesce_output_from,  # pyright: ignore[reportPrivateUsage]
@@ -450,7 +450,9 @@ class AgentBasedGroupChatOrchestrator(BaseGroupChatOrchestrator):
 
         Preferred path is structured output (`agent_response.value`) when available.
         If only text is available, first attempt strict JSON parsing and then apply a
-        temporary concatenated-JSON fallback as a stop-gap.
+        temporary concatenated-JSON fallback as a stop-gap. Providers that ignore
+        `response_format` often wrap the JSON in a Markdown code fence, so the body of
+        the last fenced block is tried as well.
         """
         try:
             structured_value = agent_response.value
@@ -470,6 +472,11 @@ class AgentBasedGroupChatOrchestrator(BaseGroupChatOrchestrator):
         if response_text and response_text not in text_candidates:
             text_candidates.append(response_text)
 
+        for candidate in list(text_candidates):
+            fence_bodies = extract_markdown_fence_bodies(candidate)
+            if fence_bodies and fence_bodies[-1] not in text_candidates:
+                text_candidates.append(fence_bodies[-1])
+
         last_error: Exception | None = None
         for candidate in text_candidates:
             try:

{agent_framework_orchestrations-1.2.0 → agent_framework_orchestrations-1.3.0}/agent_framework_orchestrations/_handoff.py

@@ -38,7 +38,7 @@ from copy import deepcopy
 from dataclasses import dataclass
 from typing import Any, Literal, cast
 
-from agent_framework import Agent, AgentResponse, Message, SupportsAgentRun
+from agent_framework import Agent, AgentResponse, ContextProvider, Message, SessionContext, SupportsAgentRun
 from agent_framework._middleware import FunctionInvocationContext, FunctionMiddleware, MiddlewareTermination
 from agent_framework._sessions import AgentSession
 from agent_framework._telemetry import mark_feature_used
@@ -136,6 +136,7 @@ class _AutoHandoffMiddleware(FunctionMiddleware):
     def __init__(self, handoffs: Sequence[HandoffConfiguration]) -> None:
         """Initialise middleware with the mapping from tool name to specialist id."""
         self._handoff_functions = {get_handoff_tool_name(handoff.target_id): handoff.target_id for handoff in handoffs}
+        self._invoked_handoffs: list[tuple[str, str]] = []
 
     async def process(
         self,
@@ -147,13 +148,43 @@ class _AutoHandoffMiddleware(FunctionMiddleware):
             await call_next()
             return
 
+        call_id = context.metadata.get("call_id")
+        if not isinstance(call_id, str) or not call_id:
+            raise RuntimeError("Generated handoff invocation is missing its function call ID.")
+        target_id = self._handoff_functions[context.function.name]
+        self._invoked_handoffs.append((call_id, target_id))
+
         # Short-circuit execution and provide deterministic response payload for the tool call.
         # Parse the result using the default parser to ensure in a form that can be passed directly to LLM APIs.
-        context.result = FunctionTool.parse_result({
-            HANDOFF_FUNCTION_RESULT_KEY: self._handoff_functions[context.function.name]
-        })
+        context.result = FunctionTool.parse_result({HANDOFF_FUNCTION_RESULT_KEY: target_id})
         raise MiddlewareTermination(result=context.result)
 
+    def consume_invoked_handoffs(self) -> list[tuple[str, str]]:
+        """Consume handoffs that were intercepted since the previous completed response."""
+        invoked_handoffs = self._invoked_handoffs
+        self._invoked_handoffs = []
+        return invoked_handoffs
+
+
+class _AutoHandoffContextProvider(ContextProvider):
+    """Add auto-handoff middleware after application context providers."""
+
+    def __init__(self, middleware: _AutoHandoffMiddleware) -> None:
+        """Initialize the provider with the generated handoff middleware."""
+        super().__init__("agent_framework.handoff")
+        self._middleware = middleware
+
+    async def before_run(
+        self,
+        *,
+        agent: SupportsAgentRun,
+        session: AgentSession,
+        context: SessionContext,
+        state: dict[str, Any],
+    ) -> None:
+        """Add handoff interception after previously configured provider middleware."""
+        context.extend_middleware(self.source_id, self._middleware)
+
 
 @dataclass
 class HandoffAgentUserRequest:
@@ -210,6 +241,7 @@ class HandoffAgentExecutor(AgentExecutor):
         *,
         agent_session: AgentSession | None = None,
         is_start_agent: bool = False,
+        user_response_target_id: str | None = None,
         termination_condition: TerminationCondition | None = None,
         autonomous_mode: bool = False,
         autonomous_mode_prompt: str | None = None,
@@ -223,6 +255,8 @@ class HandoffAgentExecutor(AgentExecutor):
             agent_session: Optional AgentSession that manages the agent's execution context
             is_start_agent: Whether this agent is the starting agent in the handoff workflow.
                             There can only be one starting agent in a handoff workflow.
+            user_response_target_id: Optional executor ID that should handle user responses.
+                                     Defaults to this executor.
             termination_condition: Optional callable that determines when to terminate the workflow
             autonomous_mode: Whether the agent should operate involve external systems after
                              a response that does not trigger a handoff or before the turn
@@ -233,12 +267,14 @@ class HandoffAgentExecutor(AgentExecutor):
                                     This will guide the agent in the absence of user input.
             autonomous_mode_turn_limit: Maximum number of autonomous turns before requesting user input.
         """
-        cloned_agent = self._prepare_agent_with_handoffs(agent, handoffs)
+        self._auto_handoff_middleware = _AutoHandoffMiddleware(handoffs)
+        cloned_agent = self._prepare_agent_with_handoffs(agent, handoffs, self._auto_handoff_middleware)
         super().__init__(cloned_agent, session=agent_session)
 
         self._handoff_targets = {handoff.target_id for handoff in handoffs}
         self._termination_condition = termination_condition
         self._is_start_agent = is_start_agent
+        self._user_response_target_id = user_response_target_id
 
         # Autonomous mode members
         self._autonomous_mode = autonomous_mode
@@ -250,12 +286,14 @@ class HandoffAgentExecutor(AgentExecutor):
         self,
         agent: Agent,
         handoffs: Sequence[HandoffConfiguration],
+        auto_handoff_middleware: _AutoHandoffMiddleware,
     ) -> Agent:
         """Prepare an agent by adding handoff tools for the specified target agents.
 
         Args:
             agent: The ``Agent`` instance to prepare
             handoffs: Sequence of handoff configurations defining target agents
+            auto_handoff_middleware: Middleware that intercepts generated handoff tools
 
         Returns:
             A cloned ``Agent`` instance with handoff tools added
@@ -264,11 +302,14 @@ class HandoffAgentExecutor(AgentExecutor):
         cloned_agent = self._clone_chat_agent(agent)
         # Add handoff tools to the cloned agent
         self._apply_auto_tools(cloned_agent, handoffs)
-        # Add middleware to handle handoff tool invocations
-        middleware = _AutoHandoffMiddleware(handoffs)
-        existing_middleware = list(cloned_agent.middleware or [])
-        existing_middleware.append(middleware)
-        cloned_agent.middleware = existing_middleware
+        if cloned_agent.context_providers:
+            # Provider middleware is added after agent middleware. Contribute the interceptor
+            # last so existing provider policies can inspect or block generated handoff calls.
+            cloned_agent.context_providers.append(_AutoHandoffContextProvider(auto_handoff_middleware))
+        else:
+            existing_middleware = list(cloned_agent.middleware or [])
+            existing_middleware.append(auto_handoff_middleware)
+            cloned_agent.middleware = existing_middleware
 
         return cloned_agent
 
@@ -473,8 +514,15 @@ class HandoffAgentExecutor(AgentExecutor):
         # Broadcast the user response to all other agents
         await self._broadcast_messages(response, ctx)
 
-        # Append the user response messages to the cache
+        # Keep this executor synchronized even when another agent handles the response.
         self._cache.extend(response)
+        if self._user_response_target_id is not None and self._user_response_target_id != self.id:
+            await ctx.send_message(
+                AgentExecutorRequest(messages=[], should_respond=True),
+                target_id=self._user_response_target_id,
+            )
+            return
+
         await self._run_agent_and_emit(ctx)
 
     async def _broadcast_messages(
@@ -493,9 +541,10 @@ class HandoffAgentExecutor(AgentExecutor):
     def _is_handoff_requested(self, response: AgentResponse) -> tuple[str, Message] | None:
         """Determine if the agent response includes a handoff request.
 
-        If a handoff tool is invoked, the middleware will short-circuit execution
-        and provide a synthetic result that includes the target agent ID. The message
-        that contains the function result will be the last message in the response.
+        If a generated handoff tool is invoked, the middleware will short-circuit execution
+        and provide a synthetic result that includes the target agent ID. The matching
+        function call must occur in the same response, and the message containing its
+        function result must be the last message in the response.
 
         Args:
             response: The AgentResponse to inspect for handoff requests
@@ -510,12 +559,18 @@ class HandoffAgentExecutor(AgentExecutor):
             messages. By returning the full message, we can ensure the agent's chat history remains valid with
             a function result for the handoff tool call.
         """
-        if not response.messages:
+        invoked_handoffs = self._auto_handoff_middleware.consume_invoked_handoffs()
+        if not invoked_handoffs or not response.messages:
             return None
 
         last_message = response.messages[-1]
         for content in last_message.contents:
-            if content.type == "function_result":
+            if content.type == "function_result" and content.call_id:
+                matching_handoffs = [target_id for call_id, target_id in invoked_handoffs if call_id == content.call_id]
+                if len(matching_handoffs) != 1:
+                    continue
+                handoff_target = matching_handoffs[0]
+
                 payload = content.result
                 parsed_payload: dict[str, Any] | None = None
                 if isinstance(payload, Mapping):
@@ -529,11 +584,9 @@ class HandoffAgentExecutor(AgentExecutor):
                         parsed_payload = {key: value for key, value in maybe_payload.items() if isinstance(key, str)}  # pyright: ignore[reportUnknownVariableType]
 
                 if parsed_payload:
-                    handoff_target = parsed_payload.get(HANDOFF_FUNCTION_RESULT_KEY)
-                    if isinstance(handoff_target, str):
+                    payload_target = parsed_payload.get(HANDOFF_FUNCTION_RESULT_KEY)
+                    if payload_target == handoff_target:
                         return handoff_target, last_message
-            else:
-                continue
 
         return None
 
@@ -581,6 +634,8 @@ class HandoffBuilder:
     Agents can hand off to other agents using `.add_handoff()`. This provides a decentralized
     approach to multi-agent collaboration. Handoffs can be configured using `.add_handoff`. If
     none are specified, all agents can hand off to all others by default (making a mesh topology).
+    By default, user responses return to the agent that requested them. Use
+    `.enable_return_to_previous(False)` to route user responses through the start agent instead.
 
     Participants must be ``Agent`` instances. ``SupportsAgentRun`` protocol implementors that
     are not ``Agent`` subclasses are not supported because handoff workflows require cloning,
@@ -648,6 +703,7 @@ class HandoffBuilder:
 
         # Handoff related members
         self._handoff_config: dict[str, set[HandoffConfiguration]] = {}
+        self._return_to_previous: bool = True
 
         # Checkpoint related members
         self._checkpoint_storage: CheckpointStorage | None = checkpoint_storage
@@ -822,6 +878,33 @@ class HandoffBuilder:
 
         return self
 
+    def enable_return_to_previous(self, enabled: bool = True) -> "HandoffBuilder":
+        """Configure whether user responses return to the agent that requested them.
+
+        Return-to-previous routing is enabled by default. Disable it to route each user response
+        through the configured start agent so that agent can re-evaluate the conversation before
+        handing off again.
+
+        Args:
+            enabled: Whether user responses should return to the agent that requested them.
+
+        Returns:
+            Self for method chaining.
+
+        Example:
+
+        .. code-block:: python
+
+            workflow = (
+                HandoffBuilder(participants=[triage, billing, support])
+                .with_start_agent(triage)
+                .enable_return_to_previous(False)
+                .build()
+            )
+        """
+        self._return_to_previous = enabled
+        return self
+
     def with_autonomous_mode(
         self,
         *,
@@ -1113,6 +1196,7 @@ class HandoffBuilder:
                 agent=agent,
                 handoffs=handoffs.get(resolved_id, []),
                 is_start_agent=(id == self._start_id),
+                user_response_target_id=None if self._return_to_previous else self._start_id,
                 termination_condition=self._termination_condition,
                 autonomous_mode=autonomous_mode,
                 autonomous_mode_prompt=self._autonomous_mode_prompts.get(id, None),

{agent_framework_orchestrations-1.2.0 → agent_framework_orchestrations-1.3.0}/agent_framework_orchestrations/_magentic.py

@@ -4,12 +4,12 @@ import asyncio
 import contextlib
 import json
 import logging
-import re
 import sys
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
 from enum import Enum
+from functools import partial
 from typing import Any, ClassVar, Literal, TypeVar, cast
 
 from agent_framework import (
@@ -38,6 +38,7 @@ from ._base_group_chat_orchestrator import (
     ParticipantRegistry,
 )
 from ._feature_usage import FeatureIndex
+from ._orchestrator_helpers import extract_markdown_fence_bodies
 from ._participant_output_config import (
     UNSET,
     _coalesce_output_from,  # pyright: ignore[reportPrivateUsage]
@@ -413,9 +414,12 @@ def _extract_json(text: str) -> dict[str, Any]:
 
     The `text` method is concatenating multiple text contents from diff msgs into a single string.
     """
-    fence = re.search(r"```(?:json)?\s*(\{[\s\S]*?\})\s*```", text, flags=re.IGNORECASE)
-    if fence:
-        candidate = fence.group(1)
+    fenced_object = next(
+        (body for body in extract_markdown_fence_bodies(text) if body.startswith("{") and body.endswith("}")),
+        None,
+    )
+    if fenced_object is not None:
+        candidate = fenced_object
     else:
         # Find first balanced JSON object
         start = text.find("{")
@@ -1435,9 +1439,14 @@ class MagenticBuilder:
             name: Optional workflow identifier. Defaults to ``"Magentic"``.
             participants: Sequence of agent or executor instances for the workflow.
             manager: Pre-configured manager instance (subclass of MagenticManagerBase).
-            manager_factory: Callable that returns a new MagenticManagerBase instance.
-            manager_agent: Agent instance for creating a StandardMagenticManager.
-            manager_agent_factory: Callable that returns a new agent instance for creating a StandardMagenticManager.
+                The same instance, including its mutable state, is reused by every workflow
+                built with this builder. Do not share a stateful manager across concurrent or
+                interleaved workflows; use manager_factory to create a fresh manager per build.
+            manager_factory: Callable invoked on each build to return a new MagenticManagerBase instance.
+            manager_agent: Agent instance used to create a new StandardMagenticManager on each build.
+                Each workflow has its own manager, but the supplied agent is shared.
+            manager_agent_factory: Callable invoked on each build to return a new agent instance
+                for a new StandardMagenticManager.
             task_ledger: Optional custom task ledger (used with manager_agent/manager_agent_factory).
             task_ledger_facts_prompt: Custom prompt for extracting facts.
             task_ledger_plan_prompt: Custom prompt for generating initial plan.
@@ -1691,7 +1700,8 @@ class MagenticBuilder:
             self._manager = manager
             _log_warning_if_constructor_args_provided()
         elif manager_agent is not None:
-            self._manager = StandardMagenticManager(
+            self._manager_factory = partial(
+                StandardMagenticManager,
                 agent=manager_agent,
                 task_ledger=task_ledger,
                 task_ledger_facts_prompt=task_ledger_facts_prompt,
@@ -1781,7 +1791,12 @@ class MagenticBuilder:
         return executors
 
     def build(self) -> Workflow:
-        """Build a Magentic workflow with the orchestrator and all agent executors."""
+        """Build a Magentic workflow with the orchestrator and all agent executors.
+
+        A new standard manager is created for each build when configured with manager_agent
+        or manager_agent_factory. An explicitly supplied manager instance is reused unchanged;
+        manager_factory is called on each build to obtain a manager.
+        """
         mark_feature_used(FeatureIndex.ORCHESTRATION_MAGENTIC)
         logger.info(f"Building Magentic workflow with {len(self._participants)} participants")
 

{agent_framework_orchestrations-1.2.0 → agent_framework_orchestrations-1.3.0}/agent_framework_orchestrations/_orchestration_request_info.py

@@ -221,13 +221,12 @@ class AgentApprovalExecutor(WorkflowExecutor):
         request_info_cls = _TerminalAgentRequestInfoExecutor if terminal else AgentRequestInfoExecutor
         request_info_executor = request_info_cls(id="agent_request_info_executor")
 
-        # Both inner executors yield the inner workflow's terminal output (the agent
-        # during its turn; the _TerminalAgentRequestInfoExecutor after approval), so
-        # both must be designated for WorkflowExecutor.get_outputs() to surface them.
+        # Only the request info executor surfaces approved responses. The agent's
+        # unapproved response remains available through the request_info event.
         return (
             WorkflowBuilder(
                 start_executor=agent_executor,
-                output_from=[agent_executor, request_info_executor],
+                output_from=[request_info_executor],
             )
             # Create a loop between agent executor and request info executor
             .add_edge(agent_executor, request_info_executor)

agent_framework_orchestrations-1.3.0/agent_framework_orchestrations/_orchestrator_helpers.py

@@ -0,0 +1,163 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+"""Shared orchestrator utilities for group chat patterns.
+
+This module provides simple, reusable functions for common orchestration tasks.
+No inheritance required - just import and call.
+"""
+
+import logging
+
+from agent_framework._types import Message
+
+logger = logging.getLogger(__name__)
+
+
+# Semantic content types that carry real user input and must survive handoff routing.
+# Everything else (function calls, function results, approval payloads, tool outputs)
+# is runtime-only tool-control state that providers reject when replayed.
+_USER_SEMANTIC_CONTENT_TYPES: frozenset[str] = frozenset({"text", "data", "uri", "hosted_file", "hosted_vector_store"})
+
+
+def clean_conversation_for_handoff(conversation: list[Message]) -> list[Message]:
+    """Clean the conversation history for handoff routing.
+
+    Handoff executors must not replay prior tool-control artifacts (function calls,
+    tool outputs, approval payloads) into future model turns, or providers may reject
+    the next request due to unmatched tool-call state. At the same time, genuine user
+    input such as images or files must be preserved so the receiving agent keeps the
+    full context of the request.
+
+    This helper builds a cleaned copy of the conversation:
+    - Keeps text content on every message.
+    - Additionally keeps semantic multimodal content (data, uri, hosted_file,
+      hosted_vector_store) on user messages.
+    - Keeps assistant and other non-user messages text-only, because providers treat
+      multimodal parts as input-only and reject them when replayed on assistant turns.
+    - Drops tool-control payloads (function_call, function_result, approval payloads, etc.).
+    - Drops messages with no remaining content.
+    - Preserves original roles and author names for retained messages.
+
+    Args:
+        conversation: Full conversation history, including tool-control content
+    Returns:
+        Cleaned conversation history suitable for handoff routing, with semantic
+        multimodal content preserved on user messages.
+    """
+    cleaned: list[Message] = []
+    for msg in conversation:
+        # Tool-control content (function_call/function_result/approval payloads) is
+        # runtime-only and must not be replayed in future model turns.
+        allowed_types = _USER_SEMANTIC_CONTENT_TYPES if str(msg.role).lower() == "user" else frozenset({"text"})
+        retained = [
+            content
+            for content in msg.contents
+            if content.type in allowed_types and (content.type != "text" or content.text)
+        ]
+        if not retained:
+            continue
+
+        msg_copy = Message(
+            role=msg.role,
+            contents=retained,
+            author_name=msg.author_name,
+            additional_properties=dict(msg.additional_properties) if msg.additional_properties else None,
+        )
+        cleaned.append(msg_copy)
+
+    return cleaned
+
+
+def create_completion_message(
+    *,
+    text: str | None = None,
+    author_name: str,
+    reason: str = "completed",
+) -> Message:
+    """Create a standardized completion message.
+
+    Simple helper to avoid duplicating completion message creation.
+
+    Args:
+        text: Message text, or None to generate default
+        author_name: Author/orchestrator name
+        reason: Reason for completion (for default text generation)
+
+    Returns:
+        Message with assistant role
+    """
+    message_text = text or f"Conversation {reason}."
+    return Message(
+        role="assistant",
+        contents=[message_text],
+        author_name=author_name,
+    )
+
+
+_FENCE_MARKER = "```"
+
+
+def _backtick_run_end(text: str, start: int) -> int:
+    """Return the index just past the run of backticks that begins at ``start``."""
+    end = start
+    while end < len(text) and text[end] == "`":
+        end += 1
+    return end
+
+
+def _fence_info_string_end(text: str, start: int) -> int:
+    """Return the index just past the info string of an opening fence such as ``json`` or ``application/json``.
+
+    An info string has to start with a letter, so a same-line body such as ``{"a": 1}`` that
+    follows the fence directly is left in place.
+    """
+    index = start
+    while index < len(text) and text[index] in " \t":
+        index += 1
+    if index >= len(text) or not text[index].isalpha():
+        return start
+    while index < len(text) and (text[index].isalnum() or text[index] in "_-+./"):
+        index += 1
+    return index
+
+
+def extract_markdown_fence_bodies(text: str) -> list[str]:
+    """Return the stripped bodies of the Markdown code fences in ``text``, in source order.
+
+    Model output that ignores ``response_format`` often wraps JSON in a fence. An opening fence
+    is a run of three or more backticks followed by an optional info string. The closing fence
+    is the next run that is at least as long and ends its line, so backticks inside a JSON
+    string value (which always end in a quote on the same line) never close the block, and an
+    outer fence can use more backticks than the ones inside it. A fence that is never closed
+    yields nothing.
+
+    The scan advances through ``text`` without backtracking, so it stays linear in the input
+    length for malformed output such as an unterminated fence followed by whitespace.
+    """
+    bodies: list[str] = []
+    length = len(text)
+    open_start = text.find(_FENCE_MARKER)
+    while open_start != -1:
+        open_end = _backtick_run_end(text, open_start)
+        closing_marker = text[open_start:open_end]
+        body_start = _fence_info_string_end(text, open_end)
+
+        search_from = body_start
+        close_start = close_end = -1
+        while (run_start := text.find(closing_marker, search_from)) != -1:
+            run_end = _backtick_run_end(text, run_start)
+            line_end = run_end
+            while line_end < length and text[line_end] in " \t\r":
+                line_end += 1
+            if line_end == length or text[line_end] == "\n":
+                close_start, close_end = run_start, run_end
+                break
+            search_from = line_end
+        if close_start == -1:
+            break
+
+        body = text[body_start:close_start].strip()
+        if body:
+            bodies.append(body)
+        open_start = text.find(_FENCE_MARKER, close_end)
+    return bodies

{agent_framework_orchestrations-1.2.0 → agent_framework_orchestrations-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ description = "Orchestration patterns for Microsoft Agent Framework. Includes Se
 authors = [{ name = "Microsoft", email = "af-support@microsoft.com"}]
 readme = "README.md"
 requires-python = ">=3.10"
-version = "1.2.0"
+version = "1.3.0"
 license-files = ["LICENSE"]
 urls.homepage = "https://aka.ms/agent-framework"
 urls.source = "https://github.com/microsoft/agent-framework/tree/main/python"

agent_framework_orchestrations-1.2.0/agent_framework_orchestrations/_orchestrator_helpers.py

@@ -1,78 +0,0 @@
-# Copyright (c) Microsoft. All rights reserved.
-
-"""Shared orchestrator utilities for group chat patterns.
-
-This module provides simple, reusable functions for common orchestration tasks.
-No inheritance required - just import and call.
-"""
-
-import logging
-
-from agent_framework._types import Message
-
-logger = logging.getLogger(__name__)
-
-
-def clean_conversation_for_handoff(conversation: list[Message]) -> list[Message]:
-    """Keep only plain text chat history for handoff routing.
-
-    Handoff executors must not replay prior tool-control artifacts (function calls,
-    tool outputs, approval payloads) into future model turns, or providers may reject
-    the next request due to unmatched tool-call state.
-
-    This helper builds a text-only copy of the conversation:
-    - Drops all non-text content from every message.
-    - Drops messages with no remaining text content.
-    - Preserves original roles and author names for retained text messages.
-
-    Args:
-        conversation: Full conversation history, including tool-control content
-    Returns:
-        Cleaned conversation history with only text content, suitable for handoff routing
-    """
-    cleaned: list[Message] = []
-    for msg in conversation:
-        # Keep only plain text history for handoff routing. Tool-control content
-        # (function_call/function_result/approval payloads) is runtime-only and
-        # must not be replayed in future model turns.
-        text_parts = [content.text for content in msg.contents if content.type == "text" and content.text]
-        # TODO(@taochen): This is a simplified check that considers any non-text content as a tool call.
-        # We need to enhance this logic to specifically identify tool related contents.
-        if not text_parts:
-            continue
-
-        msg_copy = Message(
-            role=msg.role,
-            contents=[" ".join(text_parts)],
-            author_name=msg.author_name,
-            additional_properties=dict(msg.additional_properties) if msg.additional_properties else None,
-        )
-        cleaned.append(msg_copy)
-
-    return cleaned
-
-
-def create_completion_message(
-    *,
-    text: str | None = None,
-    author_name: str,
-    reason: str = "completed",
-) -> Message:
-    """Create a standardized completion message.
-
-    Simple helper to avoid duplicating completion message creation.
-
-    Args:
-        text: Message text, or None to generate default
-        author_name: Author/orchestrator name
-        reason: Reason for completion (for default text generation)
-
-    Returns:
-        Message with assistant role
-    """
-    message_text = text or f"Conversation {reason}."
-    return Message(
-        role="assistant",
-        contents=[message_text],
-        author_name=author_name,
-    )