agentex-sdk 0.6.4__py3-none-any.whl → 0.6.7__py3-none-any.whl

agentex/_models.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import os
 import inspect
+import weakref
 from typing import TYPE_CHECKING, Any, Type, Union, Generic, TypeVar, Callable, Optional, cast
 from datetime import date, datetime
 from typing_extensions import (
@@ -256,15 +257,16 @@ class BaseModel(pydantic.BaseModel):
             mode: Literal["json", "python"] | str = "python",
             include: IncEx | None = None,
             exclude: IncEx | None = None,
+            context: Any | None = None,
             by_alias: bool | None = None,
             exclude_unset: bool = False,
             exclude_defaults: bool = False,
             exclude_none: bool = False,
+            exclude_computed_fields: bool = False,
             round_trip: bool = False,
             warnings: bool | Literal["none", "warn", "error"] = True,
-            context: dict[str, Any] | None = None,
-            serialize_as_any: bool = False,
             fallback: Callable[[Any], Any] | None = None,
+            serialize_as_any: bool = False,
         ) -> dict[str, Any]:
             """Usage docs: https://docs.pydantic.dev/2.4/concepts/serialization/#modelmodel_dump
 
@@ -272,16 +274,24 @@ class BaseModel(pydantic.BaseModel):
 
             Args:
                 mode: The mode in which `to_python` should run.
-                    If mode is 'json', the dictionary will only contain JSON serializable types.
-                    If mode is 'python', the dictionary may contain any Python objects.
-                include: A list of fields to include in the output.
-                exclude: A list of fields to exclude from the output.
+                    If mode is 'json', the output will only contain JSON serializable types.
+                    If mode is 'python', the output may contain non-JSON-serializable Python objects.
+                include: A set of fields to include in the output.
+                exclude: A set of fields to exclude from the output.
+                context: Additional context to pass to the serializer.
                 by_alias: Whether to use the field's alias in the dictionary key if defined.
-                exclude_unset: Whether to exclude fields that are unset or None from the output.
-                exclude_defaults: Whether to exclude fields that are set to their default value from the output.
-                exclude_none: Whether to exclude fields that have a value of `None` from the output.
-                round_trip: Whether to enable serialization and deserialization round-trip support.
-                warnings: Whether to log warnings when invalid fields are encountered.
+                exclude_unset: Whether to exclude fields that have not been explicitly set.
+                exclude_defaults: Whether to exclude fields that are set to their default value.
+                exclude_none: Whether to exclude fields that have a value of `None`.
+                exclude_computed_fields: Whether to exclude computed fields.
+                    While this can be useful for round-tripping, it is usually recommended to use the dedicated
+                    `round_trip` parameter instead.
+                round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+                warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+                    "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
+                fallback: A function to call when an unknown value is encountered. If not provided,
+                    a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
+                serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
 
             Returns:
                 A dictionary representation of the model.
@@ -298,6 +308,8 @@ class BaseModel(pydantic.BaseModel):
                 raise ValueError("serialize_as_any is only supported in Pydantic v2")
             if fallback is not None:
                 raise ValueError("fallback is only supported in Pydantic v2")
+            if exclude_computed_fields != False:
+                raise ValueError("exclude_computed_fields is only supported in Pydantic v2")
             dumped = super().dict(  # pyright: ignore[reportDeprecated]
                 include=include,
                 exclude=exclude,
@@ -314,15 +326,17 @@ class BaseModel(pydantic.BaseModel):
             self,
             *,
             indent: int | None = None,
+            ensure_ascii: bool = False,
             include: IncEx | None = None,
             exclude: IncEx | None = None,
+            context: Any | None = None,
             by_alias: bool | None = None,
             exclude_unset: bool = False,
             exclude_defaults: bool = False,
             exclude_none: bool = False,
+            exclude_computed_fields: bool = False,
             round_trip: bool = False,
             warnings: bool | Literal["none", "warn", "error"] = True,
-            context: dict[str, Any] | None = None,
             fallback: Callable[[Any], Any] | None = None,
             serialize_as_any: bool = False,
         ) -> str:
@@ -354,6 +368,10 @@ class BaseModel(pydantic.BaseModel):
                 raise ValueError("serialize_as_any is only supported in Pydantic v2")
             if fallback is not None:
                 raise ValueError("fallback is only supported in Pydantic v2")
+            if ensure_ascii != False:
+                raise ValueError("ensure_ascii is only supported in Pydantic v2")
+            if exclude_computed_fields != False:
+                raise ValueError("exclude_computed_fields is only supported in Pydantic v2")
             return super().json(  # type: ignore[reportDeprecated]
                 indent=indent,
                 include=include,
@@ -573,6 +591,9 @@ class CachedDiscriminatorType(Protocol):
     __discriminator__: DiscriminatorDetails
 
 
+DISCRIMINATOR_CACHE: weakref.WeakKeyDictionary[type, DiscriminatorDetails] = weakref.WeakKeyDictionary()
+
+
 class DiscriminatorDetails:
     field_name: str
     """The name of the discriminator field in the variant class, e.g.
@@ -615,8 +636,9 @@ class DiscriminatorDetails:
 
 
 def _build_discriminated_union_meta(*, union: type, meta_annotations: tuple[Any, ...]) -> DiscriminatorDetails | None:
-    if isinstance(union, CachedDiscriminatorType):
-        return union.__discriminator__
+    cached = DISCRIMINATOR_CACHE.get(union)
+    if cached is not None:
+        return cached
 
     discriminator_field_name: str | None = None
 
@@ -669,7 +691,7 @@ def _build_discriminated_union_meta(*, union: type, meta_annotations: tuple[Any,
         discriminator_field=discriminator_field_name,
         discriminator_alias=discriminator_alias,
     )
-    cast(CachedDiscriminatorType, union).__discriminator__ = details
+    DISCRIMINATOR_CACHE.setdefault(union, details)
     return details
 
 

agentex/_utils/_sync.py

@@ -1,10 +1,8 @@
 from __future__ import annotations
 
-import sys
 import asyncio
 import functools
-import contextvars
-from typing import Any, TypeVar, Callable, Awaitable
+from typing import TypeVar, Callable, Awaitable
 from typing_extensions import ParamSpec
 
 import anyio
@@ -15,34 +13,11 @@ T_Retval = TypeVar("T_Retval")
 T_ParamSpec = ParamSpec("T_ParamSpec")
 
 
-if sys.version_info >= (3, 9):
-    _asyncio_to_thread = asyncio.to_thread
-else:
-    # backport of https://docs.python.org/3/library/asyncio-task.html#asyncio.to_thread
-    # for Python 3.8 support
-    async def _asyncio_to_thread(
-        func: Callable[T_ParamSpec, T_Retval], /, *args: T_ParamSpec.args, **kwargs: T_ParamSpec.kwargs
-    ) -> Any:
-        """Asynchronously run function *func* in a separate thread.
-
-        Any *args and **kwargs supplied for this function are directly passed
-        to *func*. Also, the current :class:`contextvars.Context` is propagated,
-        allowing context variables from the main thread to be accessed in the
-        separate thread.
-
-        Returns a coroutine that can be awaited to get the eventual result of *func*.
-        """
-        loop = asyncio.events.get_running_loop()
-        ctx = contextvars.copy_context()
-        func_call = functools.partial(ctx.run, func, *args, **kwargs)
-        return await loop.run_in_executor(None, func_call)
-
-
 async def to_thread(
     func: Callable[T_ParamSpec, T_Retval], /, *args: T_ParamSpec.args, **kwargs: T_ParamSpec.kwargs
 ) -> T_Retval:
     if sniffio.current_async_library() == "asyncio":
-        return await _asyncio_to_thread(func, *args, **kwargs)
+        return await asyncio.to_thread(func, *args, **kwargs)
 
     return await anyio.to_thread.run_sync(
         functools.partial(func, *args, **kwargs),
@@ -53,10 +28,7 @@ async def to_thread(
 def asyncify(function: Callable[T_ParamSpec, T_Retval]) -> Callable[T_ParamSpec, Awaitable[T_Retval]]:
     """
     Take a blocking function and create an async one that receives the same
-    positional and keyword arguments. For python version 3.9 and above, it uses
-    asyncio.to_thread to run the function in a separate thread. For python version
-    3.8, it uses locally defined copy of the asyncio.to_thread function which was
-    introduced in python 3.9.
+    positional and keyword arguments.
 
     Usage:
 

agentex/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "agentex"
-__version__ = "0.6.4"  # x-release-please-version
+__version__ = "0.6.7"  # x-release-please-version

agentex/lib/cli/templates/default/manifest.yaml.j2

@@ -86,7 +86,7 @@ agent:
 
   # Optional: Set Environment variables for running your agent locally as well 
   # as for deployment later on
-  # env:
+  env: {}
   #   OPENAI_API_KEY: "<YOUR_OPENAI_API_KEY_HERE>"
   #   OPENAI_BASE_URL: "<YOUR_OPENAI_BASE_URL_HERE>"
   #   OPENAI_ORG_ID: "<YOUR_OPENAI_ORG_ID_HERE>"
@@ -100,13 +100,12 @@ deployment:
     repository: "" # Update with your container registry
     tag: "latest"  # Default tag, should be versioned in production
 
+  imagePullSecrets: [] # Update with your image pull secret names
+    # - name: my-registry-secret
+
   # Global deployment settings that apply to all clusters
-  # These can be overridden in cluster-specific files (deploy/*.yaml)
+  # These can be overridden in cluster-specific environments (environments.yaml)
   global:
-    agent:
-      name: "{{ agent_name }}"
-      description: "{{ description }}"
-    
     # Default replica count
     replicaCount: 1
     

agentex/lib/cli/templates/default/project/acp.py.j2

@@ -1,29 +1,56 @@
 from agentex.lib.sdk.fastacp.fastacp import FastACP
 from agentex.lib.types.fastacp import AsyncACPConfig
 from agentex.lib.types.acp import SendEventParams, CancelTaskParams, CreateTaskParams
+from agentex.lib.utils.logging import make_logger
+from agentex.types.text_content import TextContent
+from agentex.lib import adk
+
+
+logger = make_logger(__name__)
 
 
 # Create an ACP server
+# This sets up the core server that will handle task creation, events, and cancellation
+# The `type="base"` configuration is the default configuration for the ACP server
 acp = FastACP.create(
     acp_type="async",
-    config=AsyncACPConfig(type="base")
+    config=AsyncACPConfig(
+        type="base",
+    ),
 )
 
 
+# This handler is called first whenever a new task is created.
+# It's a good place to initialize any state or resources needed for the task.
 @acp.on_task_event_send
 async def handle_task_event_send(params: SendEventParams):
-    # For this tutorial, we print the parameters sent to the handler 
-    # so you can see where and how messages within a task are handled
-    print(f"Hello world! I just received this message: {params}")
+    # For this tutorial, we log the parameters sent to the handler 
+    # so you can see where and how messages within a long running task are handled
+    logger.info(f"Received task event send rpc: {params}")
+        
+    # 1. Echo back the client's message to show it in the UI. This is not done by default so the agent developer has full control over what is shown to the user.
+    await adk.messages.create(task_id=params.task.id, content=params.event.content)
+
+    # 2. Send a simple response message.
+    # In future tutorials, this is where we'll add more sophisticated response logic.
+    await adk.messages.create(
+        task_id=params.task.id,
+        content=TextContent(
+            author="agent",
+            content=f"Hello! I've received your message. I can't respond right now, but in future tutorials we'll see how you can get me to intelligently respond to your message.",
+        ),
+    )
 
 @acp.on_task_cancel
 async def handle_task_canceled(params: CancelTaskParams):
     # For this tutorial, we print the parameters sent to the handler 
     # so you can see where and how task cancellation is handled
-    print(f"Hello world! Task canceled: {params.task.id}") 
+    logger.info(f"Received task cancel rpc: {params}")
 
 @acp.on_task_create
 async def handle_task_create(params: CreateTaskParams):
-    # For this tutorial, we print the parameters sent to the handler 
+    # For this tutorial, we log the parameters sent to the handler 
     # so you can see where and how task creation is handled
-    print(f"Hello world! Task created: {params.task.id}")
+
+    # Here is where you can initialize any state or resources needed for the task.
+    logger.info(f"Received task create rpc: {params}")

agentex/lib/cli/templates/sync/manifest.yaml.j2

@@ -74,14 +74,14 @@ agent:
   # Optional: Credentials mapping
   # Maps Kubernetes secrets to environment variables
   # Common credentials include:
-  # credentials:
+  credentials: [] # Update with your credentials
   #   - env_var_name: OPENAI_API_KEY
   #     secret_name: openai-api-key
   #     secret_key: api-key
 
   # Optional: Set Environment variables for running your agent locally as well 
   # as for deployment later on
-  # env:
+  env: {} # Update with your environment variables
   #   OPENAI_API_KEY: "<YOUR_OPENAI_API_KEY_HERE>"
   #   OPENAI_BASE_URL: "<YOUR_OPENAI_BASE_URL_HERE>"
   #   OPENAI_ORG_ID: "<YOUR_OPENAI_ORG_ID_HERE>"
@@ -95,14 +95,13 @@ deployment:
   image:
     repository: "" # Update with your container registry
     tag: "latest"  # Default tag, should be versioned in production
+  
+  imagePullSecrets: [] # Update with your image pull secret names
+    # - name: my-registry-secret
 
   # Global deployment settings that apply to all clusters
-  # These can be overridden in cluster-specific files (deploy/*.yaml)
+  # These can be overridden in cluster-specific environments (environments.yaml)
   global:
-    agent:
-      name: "{{ agent_name }}"
-      description: "{{ description }}"
-    
     # Default replica count
     replicaCount: 1
     

agentex/lib/cli/templates/temporal/manifest.yaml.j2

@@ -106,7 +106,7 @@ agent:
   
   # Optional: Set Environment variables for running your agent locally as well 
   # as for deployment later on
-  # env:
+  env: {}
   #   OPENAI_API_KEY: "<YOUR_OPENAI_API_KEY_HERE>"
   #   OPENAI_BASE_URL: "<YOUR_OPENAI_BASE_URL_HERE>"
   #   OPENAI_ORG_ID: "<YOUR_OPENAI_ORG_ID_HERE>"
@@ -121,16 +121,12 @@ deployment:
     repository: "" # Update with your container registry
     tag: "latest"  # Default tag, should be versioned in production
 
-  imagePullSecrets:
-    - name: my-registry-secret  # Update with your image pull secret name
+  imagePullSecrets: [] # Update with your image pull secret name
+    # - name: my-registry-secret
 
   # Global deployment settings that apply to all clusters
-  # These can be overridden using --override-file with custom configuration files
+  # These can be overridden in cluster-specific environments (environments.yaml)
   global:
-    agent:
-      name: "{{ agent_name }}"
-      description: "{{ description }}"
-    
     # Default replica count
     replicaCount: 1
     

agentex/lib/core/temporal/plugins/openai_agents/models/temporal_streaming_model.py

@@ -497,12 +497,32 @@ class TemporalStreamingModel(Model):
                     include_list.append("message.output_text.logprobs")
                 # Build response format for verbosity and structured output
                 response_format = NOT_GIVEN
+
                 if output_schema is not None:
-                    # Handle structured output schema
-                    # This would need conversion logic similar to Converter.get_response_format
-                    pass  # TODO: Implement output_schema conversion
-                elif model_settings.verbosity is not None:
-                    response_format = {"verbosity": model_settings.verbosity}
+                    # Handle structured output schema for Responses API
+                    # The Responses API expects the schema in the 'text' parameter with a 'format' key
+                    logger.debug(f"[TemporalStreamingModel] Converting output_schema to Responses API format")
+                    try:
+                        # Get the JSON schema from the output schema
+                        schema_dict = output_schema.json_schema()
+                        response_format = {
+                            "format": {
+                                "type": "json_schema",
+                                "name": "final_output",
+                                "schema": schema_dict,
+                                "strict": output_schema.is_strict_json_schema() if hasattr(output_schema, 'is_strict_json_schema') else True,
+                            }
+                        }
+                        logger.debug(f"[TemporalStreamingModel] Built response_format with json_schema: {response_format}")
+                    except Exception as e:
+                        logger.warning(f"Failed to convert output_schema: {e}")
+                        response_format = NOT_GIVEN
+
+                if model_settings.verbosity is not None:
+                    if response_format is not NOT_GIVEN and isinstance(response_format, dict):
+                        response_format["verbosity"] = model_settings.verbosity
+                    else:
+                        response_format = {"verbosity": model_settings.verbosity}
 
                 # Build extra_args dict for additional parameters
                 extra_args = dict(model_settings.extra_args or {})
@@ -529,7 +549,7 @@ class TemporalStreamingModel(Model):
                     parallel_tool_calls=self._non_null_or_not_given(model_settings.parallel_tool_calls),
                     # Context and truncation
                     truncation=self._non_null_or_not_given(model_settings.truncation),
-                    # Response configuration
+                    # Response configuration (includes structured output schema)
                     text=response_format,
                     include=include_list if include_list else NOT_GIVEN,
                     # Metadata and storage
@@ -546,219 +566,225 @@ class TemporalStreamingModel(Model):
                 # Process the stream of events from Responses API
                 output_items = []
                 current_text = ""
+                streaming_context = None
                 reasoning_context = None
                 reasoning_summaries = []
                 reasoning_contents = []
-                current_reasoning_summary = ""
                 event_count = 0
 
                 # We expect task_id to always be provided for streaming
                 if not task_id:
                     raise ValueError("[TemporalStreamingModel] task_id is required for streaming model")
 
-                # Use proper async with context manager for streaming to Redis
-                async with adk.streaming.streaming_task_message_context(
-                    task_id=task_id,
-                    initial_content=TextContent(
-                        author="agent",
-                        content="",
-                        format="markdown",
-                    ),
-                ) as streaming_context:
-                    # Process events from the Responses API stream
-                    function_calls_in_progress = {}  # Track function calls being streamed
-
-                    async for event in stream:
-                        event_count += 1
-
-                        # Log event type
-                        logger.debug(f"[TemporalStreamingModel] Event {event_count}: {type(event).__name__}")
-
-                        # Handle different event types using isinstance for type safety
-                        if isinstance(event, ResponseOutputItemAddedEvent):
-                            # New output item (reasoning, function call, or message)
-                            item = getattr(event, 'item', None)
-                            output_index = getattr(event, 'output_index', 0)
-
-                            if item and getattr(item, 'type', None) == 'reasoning':
-                                logger.debug(f"[TemporalStreamingModel] Starting reasoning item")
-                                if not reasoning_context:
-                                    # Start a reasoning context for streaming reasoning to UI
-                                    reasoning_context = await adk.streaming.streaming_task_message_context(
-                                        task_id=task_id,
-                                        initial_content=ReasoningContent(
-                                            author="agent",
-                                            summary=[],
-                                            content=[],
-                                            type="reasoning",
-                                            style="active",
-                                        ),
-                                    ).__aenter__()
-                            elif item and getattr(item, 'type', None) == 'function_call':
-                                # Track the function call being streamed
-                                function_calls_in_progress[output_index] = {
-                                    'id': getattr(item, 'id', ''),
-                                    'call_id': getattr(item, 'call_id', ''),
-                                    'name': getattr(item, 'name', ''),
-                                    'arguments': getattr(item, 'arguments', ''),
-                                }
-                                logger.debug(f"[TemporalStreamingModel] Starting function call: {item.name}")
-
-                        elif isinstance(event, ResponseFunctionCallArgumentsDeltaEvent):
-                            # Stream function call arguments
-                            output_index = getattr(event, 'output_index', 0)
-                            delta = getattr(event, 'delta', '')
-
-                            if output_index in function_calls_in_progress:
-                                function_calls_in_progress[output_index]['arguments'] += delta
-                                logger.debug(f"[TemporalStreamingModel] Function call args delta: {delta[:50]}...")
-
-                        elif isinstance(event, ResponseFunctionCallArgumentsDoneEvent):
-                            # Function call arguments complete
-                            output_index = getattr(event, 'output_index', 0)
-                            arguments = getattr(event, 'arguments', '')
-
-                            if output_index in function_calls_in_progress:
-                                function_calls_in_progress[output_index]['arguments'] = arguments
-                                logger.debug(f"[TemporalStreamingModel] Function call args done")
-
-                        elif isinstance(event, (ResponseReasoningTextDeltaEvent, ResponseReasoningSummaryTextDeltaEvent, ResponseTextDeltaEvent)):
-                            # Handle text streaming
-                            delta = getattr(event, 'delta', '')
-
-                            if isinstance(event, ResponseReasoningSummaryTextDeltaEvent) and reasoning_context:
-                                # Stream reasoning summary deltas - these are the actual reasoning tokens!
-                                try:
-                                    # Use ReasoningSummaryDelta for reasoning summaries
-                                    summary_index = getattr(event, 'summary_index', 0)
-                                    delta_obj = ReasoningSummaryDelta(
-                                        summary_index=summary_index,
-                                        summary_delta=delta,
-                                        type="reasoning_summary",
-                                    )
-                                    update = StreamTaskMessageDelta(
-                                        parent_task_message=reasoning_context.task_message,
-                                        delta=delta_obj,
-                                        type="delta",
-                                    )
-                                    await reasoning_context.stream_update(update)
-                                    # Accumulate the reasoning summary
-                                    if len(reasoning_summaries) <= summary_index:
-                                        reasoning_summaries.extend([""] * (summary_index + 1 - len(reasoning_summaries)))
-                                    reasoning_summaries[summary_index] += delta
-                                    logger.debug(f"[TemporalStreamingModel] Streamed reasoning summary: {delta[:30]}..." if len(delta) > 30 else f"[TemporalStreamingModel] Streamed reasoning summary: {delta}")
-                                except Exception as e:
-                                    logger.warning(f"Failed to send reasoning delta: {e}")
-                            elif isinstance(event, ResponseReasoningTextDeltaEvent) and reasoning_context:
-                                # Regular reasoning delta (if these ever appear)
+                # Process events from the Responses API stream
+                function_calls_in_progress = {}  # Track function calls being streamed
+
+                async for event in stream:
+                    event_count += 1
+
+                    # Log event type
+                    logger.debug(f"[TemporalStreamingModel] Event {event_count}: {type(event).__name__}")
+
+                    # Handle different event types using isinstance for type safety
+                    if isinstance(event, ResponseOutputItemAddedEvent):
+                        # New output item (reasoning, function call, or message)
+                        item = getattr(event, 'item', None)
+                        output_index = getattr(event, 'output_index', 0)
+
+                        if item and getattr(item, 'type', None) == 'reasoning':
+                            logger.debug(f"[TemporalStreamingModel] Starting reasoning item")
+                            if not reasoning_context:
+                                # Start a reasoning context for streaming reasoning to UI
+                                reasoning_context = await adk.streaming.streaming_task_message_context(
+                                    task_id=task_id,
+                                    initial_content=ReasoningContent(
+                                        author="agent",
+                                        summary=[],
+                                        content=[],
+                                        type="reasoning",
+                                        style="active",
+                                    ),
+                                ).__aenter__()
+                        elif item and getattr(item, 'type', None) == 'function_call':
+                            # Track the function call being streamed
+                            function_calls_in_progress[output_index] = {
+                                'id': getattr(item, 'id', ''),
+                                'call_id': getattr(item, 'call_id', ''),
+                                'name': getattr(item, 'name', ''),
+                                'arguments': getattr(item, 'arguments', ''),
+                            }
+                            logger.debug(f"[TemporalStreamingModel] Starting function call: {item.name}")
+
+                        elif item and getattr(item, 'type', None) == 'message':
+                            # Track the message being streamed
+                            streaming_context = await adk.streaming.streaming_task_message_context(
+                                task_id=task_id,
+                                initial_content=TextContent(
+                                    author="agent",
+                                    content="",
+                                    format="markdown",
+                                ),
+                            ).__aenter__()
+
+                    elif isinstance(event, ResponseFunctionCallArgumentsDeltaEvent):
+                        # Stream function call arguments
+                        output_index = getattr(event, 'output_index', 0)
+                        delta = getattr(event, 'delta', '')
+
+                        if output_index in function_calls_in_progress:
+                            function_calls_in_progress[output_index]['arguments'] += delta
+                            logger.debug(f"[TemporalStreamingModel] Function call args delta: {delta[:50]}...")
+
+                    elif isinstance(event, ResponseFunctionCallArgumentsDoneEvent):
+                        # Function call arguments complete
+                        output_index = getattr(event, 'output_index', 0)
+                        arguments = getattr(event, 'arguments', '')
+
+                        if output_index in function_calls_in_progress:
+                            function_calls_in_progress[output_index]['arguments'] = arguments
+                            logger.debug(f"[TemporalStreamingModel] Function call args done")
+
+                    elif isinstance(event, (ResponseReasoningTextDeltaEvent, ResponseReasoningSummaryTextDeltaEvent, ResponseTextDeltaEvent)):
+                        # Handle text streaming
+                        delta = getattr(event, 'delta', '')
+
+                        if isinstance(event, ResponseReasoningSummaryTextDeltaEvent) and reasoning_context:
+                            # Stream reasoning summary deltas - these are the actual reasoning tokens!
+                            try:
+                                # Use ReasoningSummaryDelta for reasoning summaries
+                                summary_index = getattr(event, 'summary_index', 0)
+                                delta_obj = ReasoningSummaryDelta(
+                                    summary_index=summary_index,
+                                    summary_delta=delta,
+                                    type="reasoning_summary",
+                                )
+                                update = StreamTaskMessageDelta(
+                                    parent_task_message=reasoning_context.task_message,
+                                    delta=delta_obj,
+                                    type="delta",
+                                )
+                                await reasoning_context.stream_update(update)
+                                # Accumulate the reasoning summary
+                                if len(reasoning_summaries) <= summary_index:
+                                    logger.debug(f"[TemporalStreamingModel] Extending reasoning summaries: {summary_index}")
+                                    reasoning_summaries.extend([""] * (summary_index + 1 - len(reasoning_summaries)))
+                                reasoning_summaries[summary_index] += delta
+                                logger.debug(f"[TemporalStreamingModel] Streamed reasoning summary: {delta[:30]}..." if len(delta) > 30 else f"[TemporalStreamingModel] Streamed reasoning summary: {delta}")
+                            except Exception as e:
+                                logger.warning(f"Failed to send reasoning delta: {e}")
+                        elif isinstance(event, ResponseReasoningTextDeltaEvent) and reasoning_context:
+                            # Regular reasoning delta (if these ever appear)
+                            try:
+                                delta_obj = ReasoningContentDelta(
+                                    content_index=0,
+                                    content_delta=delta,
+                                    type="reasoning_content",
+                                )
+                                update = StreamTaskMessageDelta(
+                                    parent_task_message=reasoning_context.task_message,
+                                    delta=delta_obj,
+                                    type="delta",
+                                )
+                                await reasoning_context.stream_update(update)
+                                reasoning_contents.append(delta)
+                            except Exception as e:
+                                logger.warning(f"Failed to send reasoning delta: {e}")
+                        elif isinstance(event, ResponseTextDeltaEvent):
+                            # Stream regular text output
+                            current_text += delta
+                            try:
+                                delta_obj = TextDelta(
+                                    type="text",
+                                    text_delta=delta,
+                                )
+                                update = StreamTaskMessageDelta(
+                                    parent_task_message=streaming_context.task_message if streaming_context else None,
+                                    delta=delta_obj,
+                                    type="delta",
+                                )
+                                await streaming_context.stream_update(update) if streaming_context else None
+                            except Exception as e:
+                                logger.warning(f"Failed to send text delta: {e}")
+
+                    elif isinstance(event, ResponseOutputItemDoneEvent):
+                        # Output item completed
+                        item = getattr(event, 'item', None)
+                        output_index = getattr(event, 'output_index', 0)
+
+                        if item and getattr(item, 'type', None) == 'reasoning':
+                            if reasoning_context and reasoning_summaries:
+                                logger.debug(f"[TemporalStreamingModel] Reasoning itme completed, sending final update")
                                 try:
-                                    delta_obj = ReasoningContentDelta(
-                                        content_index=0,
-                                        content_delta=delta,
-                                        type="reasoning_content",
+                                    # Send a full message update with the complete reasoning content
+                                    complete_reasoning_content = ReasoningContent(
+                                        author="agent",
+                                        summary=reasoning_summaries,  # Use accumulated summaries
+                                        content=reasoning_contents if reasoning_contents else [],
+                                        type="reasoning",
+                                        style="static",
                                     )
-                                    update = StreamTaskMessageDelta(
-                                        parent_task_message=reasoning_context.task_message,
-                                        delta=delta_obj,
-                                        type="delta",
-                                    )
-                                    await reasoning_context.stream_update(update)
-                                    reasoning_contents.append(delta)
-                                except Exception as e:
-                                    logger.warning(f"Failed to send reasoning delta: {e}")
-                            elif isinstance(event, ResponseTextDeltaEvent):
-                                # Stream regular text output
-                                current_text += delta
-                                try:
-                                    delta_obj = TextDelta(
-                                        type="text",
-                                        text_delta=delta,
-                                    )
-                                    update = StreamTaskMessageDelta(
-                                        parent_task_message=streaming_context.task_message,
-                                        delta=delta_obj,
-                                        type="delta",
+
+                                    await reasoning_context.stream_update(
+                                        update=StreamTaskMessageFull(
+                                            parent_task_message=reasoning_context.task_message,
+                                            content=complete_reasoning_content,
+                                            type="full",
+                                        ),
                                     )
-                                    await streaming_context.stream_update(update)
+
+                                    # Close the reasoning context after sending the final update
+                                    # This matches the reference implementation pattern
+                                    await reasoning_context.close()
+                                    reasoning_context = None
+                                    logger.debug(f"[TemporalStreamingModel] Closed reasoning context after final update")
                                 except Exception as e:
-                                    logger.warning(f"Failed to send text delta: {e}")
-
-                        elif isinstance(event, ResponseOutputItemDoneEvent):
-                            # Output item completed
-                            item = getattr(event, 'item', None)
-                            output_index = getattr(event, 'output_index', 0)
-
-                            if item and getattr(item, 'type', None) == 'reasoning':
-                                if reasoning_context and reasoning_summaries:
-                                    logger.debug(f"[TemporalStreamingModel] Reasoning itme completed, sending final update")
-                                    try:
-                                        # Send a full message update with the complete reasoning content
-                                        complete_reasoning_content = ReasoningContent(
-                                            author="agent",
-                                            summary=reasoning_summaries,  # Use accumulated summaries
-                                            content=reasoning_contents if reasoning_contents else [],
-                                            type="reasoning",
-                                            style="static",
-                                        )
-
-                                        await reasoning_context.stream_update(
-                                            update=StreamTaskMessageFull(
-                                                parent_task_message=reasoning_context.task_message,
-                                                content=complete_reasoning_content,
-                                                type="full",
-                                            ),
-                                        )
-
-                                        # Close the reasoning context after sending the final update
-                                        # This matches the reference implementation pattern
-                                        await reasoning_context.close()
-                                        reasoning_context = None
-                                        logger.debug(f"[TemporalStreamingModel] Closed reasoning context after final update")
-                                    except Exception as e:
-                                        logger.warning(f"Failed to send reasoning part done update: {e}")
-
-                            elif item and getattr(item, 'type', None) == 'function_call':
-                                # Function call completed - add to output
-                                if output_index in function_calls_in_progress:
-                                    call_data = function_calls_in_progress[output_index]
-                                    logger.debug(f"[TemporalStreamingModel] Function call completed: {call_data['name']}")
-
-                                    # Create proper function call object
-                                    tool_call = ResponseFunctionToolCall(
-                                        id=call_data['id'],
-                                        call_id=call_data['call_id'],
-                                        type="function_call",
-                                        name=call_data['name'],
-                                        arguments=call_data['arguments'],
-                                    )
-                                    output_items.append(tool_call)
-
-                        elif isinstance(event, ResponseReasoningSummaryPartAddedEvent):
-                            # New reasoning part/summary started - reset accumulator
-                            part = getattr(event, 'part', None)
-                            if part:
-                                part_type = getattr(part, 'type', 'unknown')
-                                logger.debug(f"[TemporalStreamingModel] New reasoning part: type={part_type}")
-                                # Reset the current reasoning summary for this new part
-                                current_reasoning_summary = ""
-
-                        elif isinstance(event, ResponseReasoningSummaryPartDoneEvent):
-                            # Reasoning part completed - ResponseOutputItemDoneEvent will handle the final update
-                            logger.debug(f"[TemporalStreamingModel] Reasoning part completed")
-
-                        elif isinstance(event, ResponseCompletedEvent):
-                            # Response completed
-                            logger.debug(f"[TemporalStreamingModel] Response completed")
-                            response = getattr(event, 'response', None)
-                            if response and hasattr(response, 'output'):
-                                # Use the final output from the response
-                                output_items = response.output
-                                logger.debug(f"[TemporalStreamingModel] Found {len(output_items)} output items in final response")
-
-                    # End of event processing loop - close any open contexts
-                    if reasoning_context:
-                        await reasoning_context.close()
-                        reasoning_context = None
+                                    logger.warning(f"Failed to send reasoning part done update: {e}")
+
+                        elif item and getattr(item, 'type', None) == 'function_call':
+                            # Function call completed - add to output
+                            if output_index in function_calls_in_progress:
+                                call_data = function_calls_in_progress[output_index]
+                                logger.debug(f"[TemporalStreamingModel] Function call completed: {call_data['name']}")
+
+                                # Create proper function call object
+                                tool_call = ResponseFunctionToolCall(
+                                    id=call_data['id'],
+                                    call_id=call_data['call_id'],
+                                    type="function_call",
+                                    name=call_data['name'],
+                                    arguments=call_data['arguments'],
+                                )
+                                output_items.append(tool_call)
+
+                    elif isinstance(event, ResponseReasoningSummaryPartAddedEvent):
+                        # New reasoning part/summary started - reset accumulator
+                        part = getattr(event, 'part', None)
+                        if part:
+                            part_type = getattr(part, 'type', 'unknown')
+                            logger.debug(f"[TemporalStreamingModel] New reasoning part: type={part_type}")
+                            # Reset the current reasoning summary for this new part
+
+                    elif isinstance(event, ResponseReasoningSummaryPartDoneEvent):
+                        # Reasoning part completed - ResponseOutputItemDoneEvent will handle the final update
+                        logger.debug(f"[TemporalStreamingModel] Reasoning part completed")
+
+                    elif isinstance(event, ResponseCompletedEvent):
+                        # Response completed
+                        logger.debug(f"[TemporalStreamingModel] Response completed")
+                        response = getattr(event, 'response', None)
+                        if response and hasattr(response, 'output'):
+                            # Use the final output from the response
+                            output_items = response.output
+                            logger.debug(f"[TemporalStreamingModel] Found {len(output_items)} output items in final response")
+
+                # End of event processing loop - close any open contexts
+                if reasoning_context:
+                    await reasoning_context.close()
+                    reasoning_context = None
+
+                if streaming_context:
+                    await streaming_context.close()
+                    streaming_context = None
 
                 # Build the response from output items collected during streaming
                 # Create output from the items we collected
@@ -800,6 +826,8 @@ class TemporalStreamingModel(Model):
                 # Serialize response output items for span tracing
                 new_items = []
                 final_output = None
+                tool_calls = []
+                tool_outputs = []
 
                 for item in response_output:
                     try:
@@ -819,12 +847,38 @@ class TemporalStreamingModel(Model):
                         logger.warning(f"Failed to serialize item in temporal_streaming_model: {e}")
                         continue
 
+                # Extract tool calls and outputs from input
+                try:
+                    if isinstance(input, list):
+                        for item in input:
+                            try:
+                                item_dict = _serialize_item(item) if not isinstance(item, dict) else item
+                                if item_dict:
+                                    # Capture function calls
+                                    if item_dict.get('type') == 'function_call':
+                                        tool_calls.append(item_dict)
+                                    # Capture function outputs
+                                    elif item_dict.get('type') == 'function_call_output':
+                                        tool_outputs.append(item_dict)
+                            except Exception:
+                                pass
+                except Exception as e:
+                    logger.warning(f"Failed to extract tool calls and outputs: {e}")
+
                 # Set span output with structured data
                 if span:
-                    span.output = {
+                    output_data = {
                         "new_items": new_items,
                         "final_output": final_output,
                     }
+                    # Include tool calls if any were in the input
+                    if tool_calls:
+                        output_data["tool_calls"] = tool_calls
+                    # Include tool outputs if any were processed
+                    if tool_outputs:
+                        output_data["tool_outputs"] = tool_outputs
+                    
+                    span.output = output_data
 
                 # Return the response
                 return ModelResponse(

agentex/lib/sdk/fastacp/base/base_acp_server.py

@@ -78,6 +78,9 @@ class BaseACPServer(FastAPI):
         self.add_middleware(RequestIDMiddleware)
         self._handlers: dict[RPCMethod, Callable] = {}
 
+        # Agent info to return in healthz
+        self.agent_id: str | None = None
+
     @classmethod
     def create(cls):
         """Create and initialize BaseACPServer instance"""
@@ -96,6 +99,7 @@ class BaseACPServer(FastAPI):
             env_vars = EnvironmentVariables.refresh()
             if env_vars.AGENTEX_BASE_URL:
                 await register_agent(env_vars)
+                self.agent_id = env_vars.AGENT_ID
             else:
                 logger.warning("AGENTEX_BASE_URL not set, skipping agent registration")
 
@@ -105,7 +109,10 @@ class BaseACPServer(FastAPI):
 
     async def _healthz(self):
         """Health check endpoint"""
-        return {"status": "healthy"}
+        result = {"status": "healthy"}
+        if self.agent_id:
+            result["agent_id"] = self.agent_id
+        return result
 
     def _wrap_handler(self, fn: Callable[..., Awaitable[Any]]):
         """Wraps handler functions to provide JSON-RPC 2.0 response format"""

{agentex_sdk-0.6.4.dist-info → agentex_sdk-0.6.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: agentex-sdk
-Version: 0.6.4
+Version: 0.6.7
 Summary: The official Python library for the agentex API
 Project-URL: Homepage, https://github.com/scaleapi/scale-agentex-python
 Project-URL: Repository, https://github.com/scaleapi/scale-agentex-python
@@ -55,6 +55,7 @@ Requires-Dist: tzdata>=2025.2
 Requires-Dist: tzlocal>=5.3.1
 Requires-Dist: uvicorn>=0.31.1
 Requires-Dist: watchfiles<1.0,>=0.24.0
+Requires-Dist: yaspin>=3.1.0
 Provides-Extra: aiohttp
 Requires-Dist: aiohttp; extra == 'aiohttp'
 Requires-Dist: httpx-aiohttp>=0.1.9; extra == 'aiohttp'
@@ -68,7 +69,7 @@ Description-Content-Type: text/markdown
 <!-- prettier-ignore -->
 [![PyPI version](https://img.shields.io/pypi/v/agentex-sdk.svg?label=pypi%20(stable))](https://pypi.org/project/agentex-sdk/)
 
-The Agentex Python library provides convenient access to the Agentex REST API from any Python 3.8+
+The Agentex Python library provides convenient access to the Agentex REST API from any Python 3.9+
 application. The library includes type definitions for all request params and response fields,
 and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).
 
@@ -453,7 +454,7 @@ print(agentex.__version__)
 
 ## Requirements
 
-Python 3.8 or higher.
+Python 3.9 or higher.
 
 ## Contributing
 

{agentex_sdk-0.6.4.dist-info → agentex_sdk-0.6.7.dist-info}/RECORD

@@ -5,13 +5,13 @@ agentex/_compat.py,sha256=DQBVORjFb33zch24jzkhM14msvnzY7mmSmgDLaVFUM8,6562
 agentex/_constants.py,sha256=oGldMuFz7eZtwD8_6rJUippKhZB5fGSA7ffbCDGourA,466
 agentex/_exceptions.py,sha256=B09aFjWFRSShb9BFJd-MNDblsGDyGk3w-vItYmjg_AI,3222
 agentex/_files.py,sha256=KnEzGi_O756MvKyJ4fOCW_u3JhOeWPQ4RsmDvqihDQU,3545
-agentex/_models.py,sha256=lKnskYPONAWDvWo8tmbbVk7HmG7UOsI0Nve0vSMmkRc,30452
+agentex/_models.py,sha256=3D65psj_C02Mw0K2zpBWrn1khmrvtEXgTTQ6P4r3tUY,31837
 agentex/_qs.py,sha256=craIKyvPktJ94cvf9zn8j8ekG9dWJzhWv0ob34lIOv4,4828
 agentex/_resource.py,sha256=S1t7wmR5WUvoDIhZjo_x-E7uoTJBynJ3d8tPJMQYdjw,1106
 agentex/_response.py,sha256=Tb9zazsnemO2rTxWtBjAD5WBqlhli5ZaXGbiKgdu5DE,28794
 agentex/_streaming.py,sha256=p-m2didLkbw_VBZsP4QqeIPc2haAdGZmB0BOU3gUM2A,10153
 agentex/_types.py,sha256=F6X63N7bOstytAtVqJ9Yl7T_JbR9Od2MJfZ_iK5DqOY,7237
-agentex/_version.py,sha256=aqKdT0Jt6xBNgHPcCkDvPAaRPHGW9fWqLx7ayeP03X0,159
+agentex/_version.py,sha256=hFgfMDcXgm5wkZ_37lejLUTDpbuA7laOIRtc6YkGeRk,159
 agentex/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agentex/_utils/__init__.py,sha256=7fch0GT9zpNnErbciSpUNa-SjTxxjY6kxHxKMOM4AGs,2305
 agentex/_utils/_compat.py,sha256=D8gtAvjJQrDWt9upS0XaG9Rr5l1QhiAx_I_1utT_tt0,1195
@@ -21,7 +21,7 @@ agentex/_utils/_proxy.py,sha256=aglnj2yBTDyGX9Akk2crZHrl10oqRmceUy2Zp008XEs,1975
 agentex/_utils/_reflection.py,sha256=ZmGkIgT_PuwedyNBrrKGbxoWtkpytJNU1uU4QHnmEMU,1364
 agentex/_utils/_resources_proxy.py,sha256=W1Rrg7LVZHLIUq40nOfgQv6orKG16CKqDRKHiaSUVYg,594
 agentex/_utils/_streams.py,sha256=SMC90diFFecpEg_zgDRVbdR3hSEIgVVij4taD-noMLM,289
-agentex/_utils/_sync.py,sha256=TpGLrrhRNWTJtODNE6Fup3_k7zrWm1j2RlirzBwre-0,2862
+agentex/_utils/_sync.py,sha256=HBnZkkBnzxtwOZe0212C4EyoRvxhTVtTrLFDz2_xVCg,1589
 agentex/_utils/_transform.py,sha256=NjCzmnfqYrsAikUHQig6N9QfuTVbKipuP3ur9mcNF-E,15951
 agentex/_utils/_typing.py,sha256=fb420NYkXitEaod2CiEH-hCtzG1z9WKUQiFtuukHtr4,4967
 agentex/_utils/_utils.py,sha256=ugfUaneOK7I8h9b3656flwf5u_kthY0gvNuqvgOLoSU,12252
@@ -73,18 +73,18 @@ agentex/lib/cli/templates/default/Dockerfile.j2,sha256=Q-8T9mid_DfgZlQd6JFZKphdD
 agentex/lib/cli/templates/default/README.md.j2,sha256=78MxbwnFZqHx48A41hbngSl-cnJcc8sqZzvoocsbKoE,6359
 agentex/lib/cli/templates/default/dev.ipynb.j2,sha256=wWOZJuccKtrtN5-f44Ma8puQUNf-Q6geTPzI-QlioOA,3393
 agentex/lib/cli/templates/default/environments.yaml.j2,sha256=xEtxkMISgIAsqFTn_2dxqx0wbmj5mczv4dRei_8ZHcM,1821
-agentex/lib/cli/templates/default/manifest.yaml.j2,sha256=QkGnce9Xn5HLtFxu5Kezfukr5F0_i0izbze9D0EVAKQ,3853
+agentex/lib/cli/templates/default/manifest.yaml.j2,sha256=8XpW1Qobk08HRKQ22-ZHnqUO9zC7FLx6CAj8cZ_4zFw,3879
 agentex/lib/cli/templates/default/pyproject.toml.j2,sha256=eyN6dYqJTFzb5WztJMxboy9Wc0XPXVnKYaF5JBxJE7o,507
 agentex/lib/cli/templates/default/requirements.txt.j2,sha256=iTmO-z8qFkUa1jTctFCs0WYuq7Sqi6VNQAwATakh2fQ,94
 agentex/lib/cli/templates/default/test_agent.py.j2,sha256=PAlGQC5p3CRQxZsa0QVb0EIHWanFKBOd4Xb5TNuVjzs,5186
-agentex/lib/cli/templates/default/project/acp.py.j2,sha256=kyeXXBIDDNCqEmvEcbK-eR-rtMjyZ1Q2xXMRXMmRbkU,1130
+agentex/lib/cli/templates/default/project/acp.py.j2,sha256=w6dQ2f5inBeSp3ba-8KHGaig8h9oXYk7FxwCmXvqUGM,2398
 agentex/lib/cli/templates/sync/.dockerignore.j2,sha256=hweGFxw5eDZYsb5EnRHpv27o9M1HF2PEWOxqsfBBcAE,320
 agentex/lib/cli/templates/sync/Dockerfile-uv.j2,sha256=9-xbz3mh5yGuSxtQ6FRltzY45OyUzvi1ZmlfwOioK-M,1085
 agentex/lib/cli/templates/sync/Dockerfile.j2,sha256=-P2CwE84h4mwO1Gnl779c4MdoOcVX8_ndpesq9M4fQQ,1093
 agentex/lib/cli/templates/sync/README.md.j2,sha256=_S7Ngl4qOUQHPFldLXDBvuIWPFU2-WcuxGmr5EXLX6k,8816
 agentex/lib/cli/templates/sync/dev.ipynb.j2,sha256=Z42iRveuI_k5LcJqWX-3H1glPtNTkxg_MKVe1lwuJos,6055
 agentex/lib/cli/templates/sync/environments.yaml.j2,sha256=BGprRPca_Y2sPA7kOiSK8COYp4_USoikB4cQ3wbAg94,1769
-agentex/lib/cli/templates/sync/manifest.yaml.j2,sha256=V497KXzvA76sHrgIJ5zRJptpIH8sGbSXZaIsEyp5NZ4,3747
+agentex/lib/cli/templates/sync/manifest.yaml.j2,sha256=pvH3AmdSsp4NvOtQkGTHE9ZM5wou0j99RF5ITWK5wH8,3848
 agentex/lib/cli/templates/sync/pyproject.toml.j2,sha256=eyN6dYqJTFzb5WztJMxboy9Wc0XPXVnKYaF5JBxJE7o,507
 agentex/lib/cli/templates/sync/requirements.txt.j2,sha256=iTmO-z8qFkUa1jTctFCs0WYuq7Sqi6VNQAwATakh2fQ,94
 agentex/lib/cli/templates/sync/test_agent.py.j2,sha256=zMJMCqWcEvKUUxfXSC0GRtLveqvGTknZjZWy2-HbtNU,2049
@@ -95,7 +95,7 @@ agentex/lib/cli/templates/temporal/Dockerfile.j2,sha256=N1Z73jb8pnxsjP9zbs-tSyNH
 agentex/lib/cli/templates/temporal/README.md.j2,sha256=wJKvycGC-2scQbs8uRgW9HcDa9SU2jjLeuUZ2abVAPk,10853
 agentex/lib/cli/templates/temporal/dev.ipynb.j2,sha256=wWOZJuccKtrtN5-f44Ma8puQUNf-Q6geTPzI-QlioOA,3393
 agentex/lib/cli/templates/temporal/environments.yaml.j2,sha256=zu7-nGRt_LF3qmWFxR_izTUOYQXuDZeypEVa03kVW10,2096
-agentex/lib/cli/templates/temporal/manifest.yaml.j2,sha256=hqDWx70ykAQlV1E_me01nF7-Y22Dwb0N1wGkj2bDC6c,4686
+agentex/lib/cli/templates/temporal/manifest.yaml.j2,sha256=k1TVT6QmE25KEXyNxx7m58vCowsFq74naiRgKrbwaho,4604
 agentex/lib/cli/templates/temporal/pyproject.toml.j2,sha256=MoR1g6KnGOQrXWOXhFKMw561kgpxy0tdom0KLtQe8A8,548
 agentex/lib/cli/templates/temporal/requirements.txt.j2,sha256=iTmO-z8qFkUa1jTctFCs0WYuq7Sqi6VNQAwATakh2fQ,94
 agentex/lib/cli/templates/temporal/test_agent.py.j2,sha256=PAlGQC5p3CRQxZsa0QVb0EIHWanFKBOd4Xb5TNuVjzs,5186
@@ -171,7 +171,7 @@ agentex/lib/core/temporal/plugins/openai_agents/hooks/hooks.py,sha256=qbB6RLPlve
 agentex/lib/core/temporal/plugins/openai_agents/interceptors/__init__.py,sha256=hrj6lRPi9nb_HAohRK4oPnaji69QQ6brj-Wu2q0mU0s,521
 agentex/lib/core/temporal/plugins/openai_agents/interceptors/context_interceptor.py,sha256=sBLJonJJ5Ke1BJIlzbqtGeO5p8NIbvftbEYQbjgeZCE,7256
 agentex/lib/core/temporal/plugins/openai_agents/models/__init__.py,sha256=FeTt91JkSfYLlCTdrVFpjcQ0asbQyCd6Rl5efqZkslo,791
-agentex/lib/core/temporal/plugins/openai_agents/models/temporal_streaming_model.py,sha256=_lHjIlHsqAbFqsj8PXgqyUbdsr6gy7Yvot-YnLxj4fc,42962
+agentex/lib/core/temporal/plugins/openai_agents/models/temporal_streaming_model.py,sha256=elOGyx5UyRVCkvGi6sNFucRareG7zs4gT4kv_U4Cy1o,45372
 agentex/lib/core/temporal/plugins/openai_agents/models/temporal_tracing_model.py,sha256=BiuIhSvyNfocwMYQtxOoqgMpyJsMHLkyXzYPYnw4ChA,17458
 agentex/lib/core/temporal/plugins/openai_agents/tests/__init__.py,sha256=suEVJuonfBoVZ3IqdO0UMn0hkFFzDqRoso0VEOit-KQ,80
 agentex/lib/core/temporal/plugins/openai_agents/tests/conftest.py,sha256=oMI_3dVn6DoiLgCjRVUeQE_Z2Gz3tGTwPxTQ1krjKSE,7692
@@ -202,7 +202,7 @@ agentex/lib/sdk/config/project_config.py,sha256=uMrg9BqEQFcnqdlqqSLYsaQkP1mMedhE
 agentex/lib/sdk/config/validation.py,sha256=ox8g2vwjYsmfNcz4G-sbPw0ccWjylJRG5bufTEPQMCk,9024
 agentex/lib/sdk/fastacp/__init__.py,sha256=UvAdexdnfb4z0F4a2sfXROFyh9EjH89kf3AxHPybzCM,75
 agentex/lib/sdk/fastacp/fastacp.py,sha256=3aT74pFwF76VoTbQnGZsF6As42aLa2o_JrO6EP_XHQM,4591
-agentex/lib/sdk/fastacp/base/base_acp_server.py,sha256=1ltdXNidNE1SeVYBmwf4WxGRRn6eb2u9hn6SOOgp2g0,16932
+agentex/lib/sdk/fastacp/base/base_acp_server.py,sha256=W2rMZUC-5GLvLJsLFKZHtmyG9Uhrsgffqo9qcomThsQ,17163
 agentex/lib/sdk/fastacp/base/constants.py,sha256=FxhXqdaqazQIxFTfAMzl4wx50TMCzBvoNtRI7hUdL2o,837
 agentex/lib/sdk/fastacp/impl/async_base_acp.py,sha256=xT95pQ-jQpDtBpB8-Z_ZWNuwG9eXgJEluGzQ7vfo8UE,2675
 agentex/lib/sdk/fastacp/impl/sync_acp.py,sha256=0yNaWr9k28U3jKucKRoV8a53LsPyfyqwlJupe6e5pv0,3933
@@ -330,8 +330,8 @@ agentex/types/messages/batch_update_params.py,sha256=Ug5CThbD49a8j4qucg04OdmVrp_
 agentex/types/messages/batch_update_response.py,sha256=TbSBe6SuPzjXXWSj-nRjT1JHGBooTshHQQDa1AixQA8,278
 agentex/types/shared/__init__.py,sha256=IKs-Qn5Yja0kFh1G1kDqYZo43qrOu1hSoxlPdN-85dI,149
 agentex/types/shared/delete_response.py,sha256=8qH3zvQXaOHYQSHyXi7UQxdR4miTzR7V9K4zXVsiUyk,215
-agentex_sdk-0.6.4.dist-info/METADATA,sha256=jsfcoPc8yA4e9Ve522MCmyeYbI6JjE3K-igsLjtRDso,15375
-agentex_sdk-0.6.4.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-agentex_sdk-0.6.4.dist-info/entry_points.txt,sha256=V7vJuMZdF0UlvgX6KiBN7XUvq_cxF5kplcYvc1QlFaQ,62
-agentex_sdk-0.6.4.dist-info/licenses/LICENSE,sha256=Q1AOx2FtRcMlyMgQJ9eVN2WKPq2mQ33lnB4tvWxabLA,11337
-agentex_sdk-0.6.4.dist-info/RECORD,,
+agentex_sdk-0.6.7.dist-info/METADATA,sha256=-kCWZMsYVsBTLgWWy_4SDsA0NXu9tTShBQ3cxlvYFfk,15404
+agentex_sdk-0.6.7.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+agentex_sdk-0.6.7.dist-info/entry_points.txt,sha256=V7vJuMZdF0UlvgX6KiBN7XUvq_cxF5kplcYvc1QlFaQ,62
+agentex_sdk-0.6.7.dist-info/licenses/LICENSE,sha256=Q1AOx2FtRcMlyMgQJ9eVN2WKPq2mQ33lnB4tvWxabLA,11337
+agentex_sdk-0.6.7.dist-info/RECORD,,