azure-functions-durable 1.3.3__py3-none-any.whl → 1.4.0rc2__py3-none-any.whl

azure/durable_functions/openai_agents/orchestrator_generator.py

@@ -0,0 +1,67 @@
+#  Copyright (c) Microsoft Corporation. All rights reserved.
+#  Licensed under the MIT License.
+from functools import partial
+from typing import Optional
+from agents import ModelProvider, ModelResponse
+from agents.run import set_default_agent_runner
+from azure.durable_functions.models.DurableOrchestrationContext import DurableOrchestrationContext
+from azure.durable_functions.models.RetryOptions import RetryOptions
+from .model_invocation_activity import DurableModelActivityInput, ModelInvoker
+from .task_tracker import TaskTracker
+from .runner import DurableOpenAIRunner
+from .context import DurableAIAgentContext
+from .event_loop import ensure_event_loop
+from .usage_telemetry import UsageTelemetry
+
+
+async def durable_openai_agent_activity(input: str, model_provider: ModelProvider) -> str:
+    """Activity logic that handles OpenAI model invocations."""
+    activity_input = DurableModelActivityInput.from_json(input)
+
+    model_invoker = ModelInvoker(model_provider=model_provider)
+    result = await model_invoker.invoke_model_activity(activity_input)
+
+    # Use safe/public Pydantic API when possible. Prefer model_dump_json if result is a BaseModel
+    # Otherwise handle common types (str/bytes/dict/list) and fall back to json.dumps.
+    import json as _json
+
+    if hasattr(result, "model_dump_json"):
+        # Pydantic v2 BaseModel
+        json_str = result.model_dump_json()
+    else:
+        if isinstance(result, bytes):
+            json_str = result.decode()
+        elif isinstance(result, str):
+            json_str = result
+        else:
+            # Try the internal serializer as a last resort, but fall back to json.dumps
+            try:
+                json_bytes = ModelResponse.__pydantic_serializer__.to_json(result)
+                json_str = json_bytes.decode()
+            except Exception:
+                json_str = _json.dumps(result)
+
+    return json_str
+
+
+def durable_openai_agent_orchestrator_generator(
+        func,
+        durable_orchestration_context: DurableOrchestrationContext,
+        model_retry_options: Optional[RetryOptions],
+        activity_name: str,
+):
+    """Adapts the synchronous OpenAI Agents function to an Durable orchestrator generator."""
+    # Log versions the first time this generator is invoked
+    UsageTelemetry.log_usage_once()
+
+    ensure_event_loop()
+    task_tracker = TaskTracker(durable_orchestration_context)
+    durable_ai_agent_context = DurableAIAgentContext(
+        durable_orchestration_context, task_tracker, model_retry_options
+    )
+    durable_openai_runner = DurableOpenAIRunner(
+        context=durable_ai_agent_context, activity_name=activity_name)
+    set_default_agent_runner(durable_openai_runner)
+
+    func_with_context = partial(func, durable_ai_agent_context)
+    return task_tracker.execute_orchestrator_function(func_with_context)

azure/durable_functions/openai_agents/runner.py

@@ -0,0 +1,103 @@
+#  Copyright (c) Microsoft Corporation. All rights reserved.
+#  Licensed under the MIT License.
+import json
+from dataclasses import replace
+from typing import Any, Union
+
+from agents import (
+    Agent,
+    RunConfig,
+    RunResult,
+    RunResultStreaming,
+    TContext,
+    TResponseInputItem,
+)
+from agents.run import DEFAULT_AGENT_RUNNER, DEFAULT_MAX_TURNS, AgentRunner
+from pydantic_core import to_json
+
+from .context import DurableAIAgentContext
+from .model_invocation_activity import DurableActivityModel
+
+
+class DurableOpenAIRunner:
+    """Runner for OpenAI agents using Durable Functions orchestration."""
+
+    def __init__(self, context: DurableAIAgentContext, activity_name: str) -> None:
+        self._runner = DEFAULT_AGENT_RUNNER or AgentRunner()
+        self._context = context
+        self._activity_name = activity_name
+
+    def _prepare_run_config(
+        self,
+        starting_agent: Agent[TContext],
+        input: Union[str, list[TResponseInputItem]],
+        **kwargs: Any,
+    ) -> tuple[Union[str, list[TResponseInputItem]], RunConfig, dict[str, Any]]:
+        """Prepare and validate the run configuration and parameters for agent execution."""
+        # Avoid https://github.com/pydantic/pydantic/issues/9541
+        normalized_input = json.loads(to_json(input))
+
+        run_config = kwargs.get("run_config") or RunConfig()
+
+        model_name = run_config.model or starting_agent.model
+        if model_name and not isinstance(model_name, str):
+            raise ValueError(
+                "For agent execution in Durable Functions, model name in run_config or "
+                "starting_agent must be a string."
+            )
+
+        updated_run_config = replace(
+            run_config,
+            model=DurableActivityModel(
+                model_name=model_name,
+                task_tracker=self._context._task_tracker,
+                retry_options=self._context._model_retry_options,
+                activity_name=self._activity_name,
+            ),
+        )
+
+        run_params = {
+            "context": kwargs.get("context"),
+            "max_turns": kwargs.get("max_turns", DEFAULT_MAX_TURNS),
+            "hooks": kwargs.get("hooks"),
+            "previous_response_id": kwargs.get("previous_response_id"),
+            "session": kwargs.get("session"),
+        }
+
+        return normalized_input, updated_run_config, run_params
+
+    def run_sync(
+        self,
+        starting_agent: Agent[TContext],
+        input: Union[str, list[TResponseInputItem]],
+        **kwargs: Any,
+    ) -> RunResult:
+        """Run an agent synchronously with the given input and configuration."""
+        normalized_input, updated_run_config, run_params = self._prepare_run_config(
+            starting_agent, input, **kwargs
+        )
+
+        return self._runner.run_sync(
+            starting_agent=starting_agent,
+            input=normalized_input,
+            run_config=updated_run_config,
+            **run_params,
+        )
+
+    def run(
+        self,
+        starting_agent: Agent[TContext],
+        input: Union[str, list[TResponseInputItem]],
+        **kwargs: Any,
+    ) -> RunResult:
+        """Run an agent asynchronously. Not supported in Durable Functions."""
+        raise RuntimeError("Durable Functions do not support asynchronous runs.")
+
+    def run_streamed(
+        self,
+        starting_agent: Agent[TContext],
+        input: Union[str, list[TResponseInputItem]],
+        **kwargs: Any,
+    ) -> RunResultStreaming:
+        """Run an agent with streaming. Not supported in Durable Functions."""
+        raise RuntimeError("Durable Functions do not support streaming.")

azure/durable_functions/openai_agents/task_tracker.py

@@ -0,0 +1,171 @@
+#  Copyright (c) Microsoft Corporation. All rights reserved.
+#  Licensed under the MIT License.
+import json
+import inspect
+from typing import Any
+
+from azure.durable_functions.models.DurableOrchestrationContext import (
+    DurableOrchestrationContext,
+)
+from azure.durable_functions.models.history.HistoryEventType import HistoryEventType
+from azure.durable_functions.models.RetryOptions import RetryOptions
+
+from .exceptions import YieldException
+
+
+class TaskTracker:
+    """Tracks activity calls and handles task result processing for durable AI agents."""
+
+    def __init__(self, context: DurableOrchestrationContext):
+        self._context = context
+        self._activities_called = 0
+        self._tasks_to_yield = []
+
+    def _get_activity_result_or_raise(self, task):
+        """Return the activity result if available; otherwise raise ``YieldException`` to defer.
+
+        The first time an activity is scheduled its result won't yet exist in the
+        orchestration history, so we raise ``YieldException`` with the task so the
+        orchestrator can yield it. On replay, once the corresponding TASK_COMPLETED
+        history event is present, we capture the result and queue the task for a
+        later yield (to preserve ordering) while returning the deserialized value.
+        """
+        self.record_activity_call()
+
+        histories = self._context.histories
+        completed_tasks = [
+            entry for entry in histories
+            if entry.event_type == HistoryEventType.TASK_COMPLETED
+        ]
+        if len(completed_tasks) < self._activities_called:
+            # Result not yet available in history -> raise to signal a yield now
+            raise YieldException(task)
+        # Result exists (replay). Queue task to be yielded after returning value.
+        #
+        # We cannot just yield it now because this method can be called from
+        # deeply nested code paths that we don't control (such as the
+        # OpenAI Agents SDK internals), and yielding here would lead to
+        # unintended behavior. Instead, we queue the task to be yielded
+        # later and return the result recorded in the history, so the
+        # code invoking this method can continue executing normally.
+        self._tasks_to_yield.append(task)
+
+        result_json = completed_tasks[self._activities_called - 1].Result
+        result = json.loads(result_json)
+        return result
+
+    def get_activity_call_result(self, activity_name, input: Any):
+        """Call an activity and return its result or raise ``YieldException`` if pending."""
+        task = self._context.call_activity(activity_name, input)
+        return self._get_activity_result_or_raise(task)
+
+    def get_activity_call_result_with_retry(
+        self, activity_name, retry_options: RetryOptions, input: Any
+    ):
+        """Call an activity with retry and return its result or raise YieldException if pending."""
+        task = self._context.call_activity_with_retry(activity_name, retry_options, input)
+        return self._get_activity_result_or_raise(task)
+
+    def record_activity_call(self):
+        """Record that an activity was called."""
+        self._activities_called += 1
+
+    def _yield_and_clear_tasks(self):
+        """Yield all accumulated tasks and clear the tasks list."""
+        for task in self._tasks_to_yield:
+            yield task
+        self._tasks_to_yield.clear()
+
+    def execute_orchestrator_function(self, func):
+        """Execute the orchestrator function with comprehensive task and exception handling.
+
+        The orchestrator function can exhibit any combination of the following behaviors:
+        - Execute regular code and return a value or raise an exception
+        - Invoke get_activity_call_result or get_activity_call_result_with_retry, which leads to
+          either interrupting the orchestrator function immediately (because of YieldException),
+          or queueing the task for later yielding while continuing execution
+        - Invoke DurableAIAgentContext.call_activity or call_activity_with_retry (which must lead
+          to corresponding record_activity_call invocations)
+        - Yield tasks (typically produced by DurableAIAgentContext methods like call_activity,
+          wait_for_external_event, etc.), which may or may not interrupt orchestrator function
+          execution
+        - Mix all of the above in any combination
+
+        This method converts both YieldException and regular yields into a sequence of yields
+        preserving the order, while also capturing return values through the generator protocol.
+        For example, if the orchestrator function yields task A, then queues task B for yielding,
+        then raises YieldException wrapping task C, this method makes sure that the resulting
+        sequence of yields is: (A, B, C).
+
+        Args
+        ----
+            func: The orchestrator function to execute (generator or regular function)
+
+        Yields
+        ------
+            Tasks yielded by the orchestrator function and tasks wrapped in YieldException
+
+        Returns
+        -------
+            The return value from the orchestrator function
+        """
+        if inspect.isgeneratorfunction(func):
+            gen = iter(func())
+            try:
+                # prime the subiterator
+                value = next(gen)
+                yield from self._yield_and_clear_tasks()
+                while True:
+                    try:
+                        # send whatever was sent into us down to the subgenerator
+                        yield from self._yield_and_clear_tasks()
+                        sent = yield value
+                    except GeneratorExit:
+                        # ensure the subgenerator is closed
+                        if hasattr(gen, "close"):
+                            gen.close()
+                        raise
+                    except BaseException as exc:
+                        # forward thrown exceptions if possible
+                        if hasattr(gen, "throw"):
+                            value = gen.throw(type(exc), exc, exc.__traceback__)
+                        else:
+                            raise
+                    else:
+                        # normal path: forward .send (or .__next__)
+                        if hasattr(gen, "send"):
+                            value = gen.send(sent)
+                        else:
+                            value = next(gen)
+            except StopIteration as e:
+                yield from self._yield_and_clear_tasks()
+                return TaskTracker._durable_serializer(e.value)
+            except YieldException as e:
+                yield from self._yield_and_clear_tasks()
+                yield e.task
+        else:
+            try:
+                result = func()
+                return TaskTracker._durable_serializer(result)
+            except YieldException as e:
+                yield from self._yield_and_clear_tasks()
+                yield e.task
+            finally:
+                yield from self._yield_and_clear_tasks()
+
+    @staticmethod
+    def _durable_serializer(obj: Any) -> str:
+        # Strings are already "serialized"
+        if type(obj) is str:
+            return obj
+
+        # Serialize "Durable" and OpenAI models, and typed dictionaries
+        if callable(getattr(obj, "to_json", None)):
+            return obj.to_json()
+
+        # Serialize Pydantic models
+        if callable(getattr(obj, "model_dump_json", None)):
+            return obj.model_dump_json()
+
+        # Fallback to default JSON serialization
+        return json.dumps(obj)

azure/durable_functions/openai_agents/tools.py

@@ -0,0 +1,148 @@
+#  Copyright (c) Microsoft Corporation. All rights reserved.
+#  Licensed under the MIT License.
+"""Tool conversion utilities for Azure Durable Functions OpenAI agent operations."""
+
+from typing import Any, Union
+
+from agents import (
+    CodeInterpreterTool,
+    FileSearchTool,
+    FunctionTool,
+    HostedMCPTool,
+    ImageGenerationTool,
+    Tool,
+    UserError,
+    WebSearchTool,
+)
+from openai.types.responses.tool_param import Mcp
+from pydantic import BaseModel
+
+
+# Built-in tool types that can be serialized directly without conversion
+BUILT_IN_TOOL_TYPES = (
+    FileSearchTool,
+    WebSearchTool,
+    ImageGenerationTool,
+    CodeInterpreterTool,
+)
+
+
+class DurableFunctionTool(BaseModel):
+    """Serializable representation of a FunctionTool.
+
+    Contains only the data needed by the model execution to
+    determine what tool to call, not the actual tool invocation.
+    """
+
+    name: str
+    description: str
+    params_json_schema: dict[str, Any]
+    strict_json_schema: bool = True
+
+
+class DurableMCPToolConfig(BaseModel):
+    """Serializable representation of a HostedMCPTool.
+
+    Contains only the data needed by the model execution to
+    determine what tool to call, not the actual tool invocation.
+    """
+
+    tool_config: Mcp
+
+
+DurableTool = Union[
+    DurableFunctionTool,
+    FileSearchTool,
+    WebSearchTool,
+    ImageGenerationTool,
+    CodeInterpreterTool,
+    DurableMCPToolConfig,
+]
+
+
+def create_tool_from_durable_tool(
+    durable_tool: DurableTool,
+) -> Tool:
+    """Convert a DurableTool to an OpenAI agent Tool for execution.
+
+    This function transforms Durable Functions tool definitions into actual
+    OpenAI agent Tool instances that can be used during model execution.
+
+    Parameters
+    ----------
+    durable_tool : DurableTool
+        The Durable tool definition to convert
+
+    Returns
+    -------
+    Tool
+        An OpenAI agent Tool instance ready for execution
+
+    Raises
+    ------
+    UserError
+        If the tool type is not supported
+    """
+    # Built-in tools that don't need conversion
+    if isinstance(durable_tool, BUILT_IN_TOOL_TYPES):
+        return durable_tool
+
+    # Convert Durable MCP tool configuration to HostedMCPTool
+    if isinstance(durable_tool, DurableMCPToolConfig):
+        return HostedMCPTool(
+            tool_config=durable_tool.tool_config,
+        )
+
+    # Convert Durable function tool to FunctionTool
+    if isinstance(durable_tool, DurableFunctionTool):
+        return FunctionTool(
+            name=durable_tool.name,
+            description=durable_tool.description,
+            params_json_schema=durable_tool.params_json_schema,
+            on_invoke_tool=lambda ctx, input: "",
+            strict_json_schema=durable_tool.strict_json_schema,
+        )
+
+    raise UserError(f"Unsupported tool type: {durable_tool}")
+
+
+def convert_tool_to_durable_tool(tool: Tool) -> DurableTool:
+    """Convert an OpenAI agent Tool to a DurableTool for serialization.
+
+    This function transforms OpenAI agent Tool instances into Durable Functions
+    tool definitions that can be serialized and passed to activities.
+
+    Parameters
+    ----------
+    tool : Tool
+        The OpenAI agent Tool to convert
+
+    Returns
+    -------
+    DurableTool
+        A serializable tool definition
+
+    Raises
+    ------
+    ValueError
+        If the tool type is not supported for conversion
+    """
+    # Built-in tools that can be serialized directly
+    if isinstance(tool, BUILT_IN_TOOL_TYPES):
+        return tool
+
+    # Convert HostedMCPTool to Durable MCP configuration
+    elif isinstance(tool, HostedMCPTool):
+        return DurableMCPToolConfig(tool_config=tool.tool_config)
+
+    # Convert FunctionTool to Durable function tool
+    elif isinstance(tool, FunctionTool):
+        return DurableFunctionTool(
+            name=tool.name,
+            description=tool.description,
+            params_json_schema=tool.params_json_schema,
+            strict_json_schema=tool.strict_json_schema,
+        )
+
+    else:
+        raise ValueError(f"Unsupported tool type for Durable Functions: {type(tool).__name__}")

azure/durable_functions/openai_agents/usage_telemetry.py

@@ -0,0 +1,69 @@
+#  Copyright (c) Microsoft Corporation. All rights reserved.
+#  Licensed under the MIT License.
+
+
+class UsageTelemetry:
+    """Handles telemetry logging for OpenAI Agents SDK integration usage."""
+
+    # Class-level flag to ensure logging happens only once across all instances
+    _usage_logged = False
+
+    @classmethod
+    def log_usage_once(cls):
+        """Log OpenAI Agents SDK integration usage exactly once.
+
+        Fails gracefully if metadata cannot be retrieved.
+        """
+        if cls._usage_logged:
+            return
+
+        # NOTE: Any log line beginning with the special prefix defined below will be
+        # captured by the Azure Functions host as a Language Worker console log and
+        # forwarded to internal telemetry pipelines.
+        # Do not change this constant value without coordinating with the Functions
+        # host team.
+        LANGUAGE_WORKER_CONSOLE_LOG_PREFIX = "LanguageWorkerConsoleLog"
+
+        package_versions = cls._collect_openai_agent_package_versions()
+        msg = (
+            f"{LANGUAGE_WORKER_CONSOLE_LOG_PREFIX}"  # Prefix captured by Azure Functions host
+            "Detected OpenAI Agents SDK integration with Durable Functions. "
+            f"Package versions: {package_versions}"
+        )
+        print(msg)
+
+        cls._usage_logged = True
+
+    @classmethod
+    def _collect_openai_agent_package_versions(cls) -> str:
+        """Collect versions of relevant packages for telemetry logging.
+
+        Returns
+        -------
+        str
+            Comma-separated list of name=version entries or "(unavailable)" if
+            versions could not be determined.
+        """
+        try:
+            try:
+                from importlib import metadata  # Python 3.8+
+            except ImportError:  # pragma: no cover - legacy fallback
+                import importlib_metadata as metadata  # type: ignore
+
+            package_names = [
+                "azure-functions-durable",
+                "openai",
+                "openai-agents",
+            ]
+
+            versions = []
+            for package_name in package_names:
+                try:
+                    ver = metadata.version(package_name)
+                    versions.append(f"{package_name}={ver}")
+                except Exception:  # noqa: BLE001 - swallow and continue
+                    versions.append(f"{package_name}=(not installed)")
+
+            return ", ".join(versions) if versions else "(unavailable)"
+        except Exception:  # noqa: BLE001 - never let version gathering break user code
+            return "(unavailable)"

{azure_functions_durable-1.3.3.dist-info → azure_functions_durable-1.4.0rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: azure-functions-durable
-Version: 1.3.3
+Version: 1.4.0rc2
 Summary: Durable Functions For Python
 Home-page: https://github.com/Azure/azure-functions-durable-python
 Author: Azure Functions team at Microsoft Corp.
@@ -58,4 +58,9 @@ Follow these instructions to get started with Durable Functions in Python:
 
 * Python Durable Functions requires [Azure Functions Core Tools](https://docs.microsoft.com/en-us/azure/azure-functions/functions-run-local) version 3.0.2630 or higher.
 
+## Durable OpenAI Agents (Preview)
+
+Build resilient, stateful AI agents backed by Durable Functions orchestration—see the full documentation at [docs/openai_agents/README.md](docs/openai_agents/README.md).
+
+
 

{azure_functions_durable-1.3.3.dist-info → azure_functions_durable-1.4.0rc2.dist-info}/RECORD

@@ -1,9 +1,9 @@
-azure/durable_functions/__init__.py,sha256=Syz9yrT8sHREVyxqvwjg8_c_h8yMTyuBHcDMsuQs1YM,2910
+azure/durable_functions/__init__.py,sha256=aTQRMnMb3zT3w28yEbYsEl-_f3x2Rf-kKp91E9nE8nk,3150
 azure/durable_functions/constants.py,sha256=JtknDhaVihMeo-ygY9QNofiO2KEqnQvopdfZ6Qatnik,414
 azure/durable_functions/entity.py,sha256=mUUzb1BZiDrUJjvxOTlnVURnKPyDGPJ3mXXMN0DKT7M,4649
 azure/durable_functions/orchestrator.py,sha256=SZni90Aweq0OZykHyMblfJpUndJ2woJmySarcsDiIK4,2554
 azure/durable_functions/decorators/__init__.py,sha256=wEubgP2rUUISwidZWgKx6mmzEeGKsSnpGmetjIUi1nw,150
-azure/durable_functions/decorators/durable_app.py,sha256=8K4gevZVYcDvifxXVuvTt8YzF8jx63c1PwdBBk1Vt0g,10114
+azure/durable_functions/decorators/durable_app.py,sha256=5ajbhMPKvZKZhYLCxsEn8J4sZO6Pql9j0nOTCxDaMuY,12599
 azure/durable_functions/decorators/metadata.py,sha256=p91rdCe6OSRYJaKAXnrfR0QCV3PoHK7aGy1m6WAnPIE,2828
 azure/durable_functions/models/DurableEntityContext.py,sha256=cyZmjjZu18oV9S4A2NpnXfjd1JQxPxp9EMmAR424UK0,5830
 azure/durable_functions/models/DurableHttpRequest.py,sha256=a5kgRdg4eA0sgyDcpmQWc0dbwP-o3BwWW2Ive0BYO_Q,2021
@@ -53,6 +53,17 @@ azure/durable_functions/models/utils/__init__.py,sha256=dQ6-HRUPsCtDIqGjRJ3TA6NX
 azure/durable_functions/models/utils/entity_utils.py,sha256=TqNTtRC8VuKFtqWLq9oEAloioV-FyinjgRYVKkCldHo,2881
 azure/durable_functions/models/utils/http_utils.py,sha256=AoCWjCapd_984J_4296iJ8cNJWEG8GIdhRttBPt0HnA,2551
 azure/durable_functions/models/utils/json_utils.py,sha256=zUn62pm3dQw054ZlK7F4uRP-UELjQC8EmZBU1WncHMg,3811
+azure/durable_functions/openai_agents/__init__.py,sha256=pAUkXR5ctS0leHiR0IwBC1aHurzOn70wasL-LDRcRnQ,374
+azure/durable_functions/openai_agents/context.py,sha256=tShhQmlMxvOGHvYu55e10xPp2mVHmeIUf37yUzzjE50,7551
+azure/durable_functions/openai_agents/event_loop.py,sha256=JxezIdw1TL-R77ITlarZZvk3F1IMXHqGUAuCgxKX5Wk,571
+azure/durable_functions/openai_agents/exceptions.py,sha256=AmbFAxpkrQ-LiU_LaU7-aWpb6dR-ETMs_XWkoCfZIoQ,394
+azure/durable_functions/openai_agents/handoffs.py,sha256=R8fuQ-FlZ3DQw1jI0WwU8gWwTlWdRLWW2EVrwsfDEuU,2195
+azure/durable_functions/openai_agents/model_invocation_activity.py,sha256=P94iMKVq9qfZyC_fUQWXb-tuOhvANaGhGvqVwUGfFVk,9783
+azure/durable_functions/openai_agents/orchestrator_generator.py,sha256=dvm5e2pk-wtpTog0XZ4iMy1eskLOgwHcMwswiZ3zCA8,2898
+azure/durable_functions/openai_agents/runner.py,sha256=qfsX52zaTDJpuU3_hxgkrEUtoHQ3GTMm5VYSgUXXsjA,3726
+azure/durable_functions/openai_agents/task_tracker.py,sha256=dBGIGlkIdbwxH2OJ3XJZBFazzC32JZ9hWpN4isxvYLQ,7749
+azure/durable_functions/openai_agents/tools.py,sha256=YahQOV1Duv0217tEwG6SX8gLLTvkQNLFi9E_6KUOjvI,4229
+azure/durable_functions/openai_agents/usage_telemetry.py,sha256=U4nqLJIv_vzxT2Y5FIUi9NkvCyHex1OY4eWY8flydNs,2646
 azure/durable_functions/testing/OrchestratorGeneratorWrapper.py,sha256=cjh-HAq5rVNCoR0pIbfGrqy6cKSf4S1KMQxrBMWU1-s,1728
 azure/durable_functions/testing/__init__.py,sha256=NLbltPtoPXK-0iMTwcKTKPjQlAWrEq55oDYmrhYz6vg,189
 tests/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -65,6 +76,10 @@ tests/models/test_DurableOrchestrationStatus.py,sha256=fnUZxrHGy771OoaD5TInELhaG
 tests/models/test_OrchestrationState.py,sha256=L-k8ScrqoDIZEqIUORbxXA7yCuMbVAUPr-7VmyuQkUc,1272
 tests/models/test_RpcManagementOptions.py,sha256=hvDzlJED8egJloju5nFvKYusgwLgy-o_avJAY6uzfdg,3190
 tests/models/test_TokenSource.py,sha256=wlRn-RPM72U6Ose4sa3Yvu2ng1VbAopDIbea90CYDjk,589
+tests/openai_agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/openai_agents/test_context.py,sha256=r5nGikUU2j23TmyknruR1ntP4UvxyvYrWil9Ap11qs4,21861
+tests/openai_agents/test_task_tracker.py,sha256=6vjalKmCb-CjpJysx7D0s_3CZaOPycE76TQpcX0ludU,13263
+tests/openai_agents/test_usage_telemetry.py,sha256=gB8efDTZhO9UvCwRTqmCELcgmtwbhSoA6_1Hy7kPCDQ,4825
 tests/orchestrator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/orchestrator/orchestrator_test_utils.py,sha256=ldgQGGuOVALcI98enRU08nF_VJd5ypJl-hVG-q0kH1o,5359
 tests/orchestrator/test_call_http.py,sha256=CvemeCayrQLjmjl3lpB1fk_CpV-DRPgfxLgD4iNgStQ,9103
@@ -83,6 +98,8 @@ tests/orchestrator/test_sub_orchestrator.py,sha256=QUb5Q3nLcCdhFwGaEQlYdoNQLUvI8
 tests/orchestrator/test_sub_orchestrator_with_retry.py,sha256=bfufQnteEZ9i3q7wzCvd8EwFmaOh89KPOpTPSJvlP1I,6040
 tests/orchestrator/test_task_any.py,sha256=9PQalbQW-Qx7_iO4Yjl1MR2hhsBjst6k00_4veIt97g,2695
 tests/orchestrator/models/OrchestrationInstance.py,sha256=CQ3qyNumjksuFNMujbESsvjadntP3b9VtTpEuI4hzaE,491
+tests/orchestrator/openai_agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/orchestrator/openai_agents/test_openai_agents.py,sha256=qa8DLkJ1IZV9C5kP2mnFfchriv4ppl1nIu9J_3rNlhA,24221
 tests/orchestrator/schemas/OrchetrationStateSchema.py,sha256=EyTsDUZ3K-9mVljLIlg8f_h2zsK228E0PMvvtyEWw24,2718
 tests/tasks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/tasks/tasks_test_utils.py,sha256=Ymc5GESJpzybBq3n2mT4IABDRNTVCerAZrlMilv0Pdk,737
@@ -96,8 +113,8 @@ tests/test_utils/json_utils.py,sha256=B0q3COMya7TGxbH-7sD_0ypWDSuaF4fpD4QV_oJPgG
 tests/test_utils/testClasses.py,sha256=U_u5qKxC9U81SzjLo7ejjPjEn_cE5qjaqoq8edGD6l8,1521
 tests/utils/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
 tests/utils/test_entity_utils.py,sha256=kdk5_DV_-bFu_5q2mw9o1yjyzh8Lcxv1jo1Q7is_ukA,748
-azure_functions_durable-1.3.3.dist-info/LICENSE,sha256=-VS-Izmxdykuae1Xc4vHtVUx02rNQi6SSQlONvvuYeQ,1090
-azure_functions_durable-1.3.3.dist-info/METADATA,sha256=3chTZDt7a-uj_TSYe2X48a03t5K7A7Ieyp1coS3H86c,3524
-azure_functions_durable-1.3.3.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-azure_functions_durable-1.3.3.dist-info/top_level.txt,sha256=h-L8XDVPJ9YzBbHlPvM7FVo1cqNGToNK9ix99ySGOUY,12
-azure_functions_durable-1.3.3.dist-info/RECORD,,
+azure_functions_durable-1.4.0rc2.dist-info/LICENSE,sha256=-VS-Izmxdykuae1Xc4vHtVUx02rNQi6SSQlONvvuYeQ,1090
+azure_functions_durable-1.4.0rc2.dist-info/METADATA,sha256=HOJS4Ub2kDvHZtLcJ1XLNp6P7-yqLO1tDBqGgKpJrHM,3742
+azure_functions_durable-1.4.0rc2.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+azure_functions_durable-1.4.0rc2.dist-info/top_level.txt,sha256=h-L8XDVPJ9YzBbHlPvM7FVo1cqNGToNK9ix99ySGOUY,12
+azure_functions_durable-1.4.0rc2.dist-info/RECORD,,