agentex-sdk 0.6.3__py3-none-any.whl → 0.6.5__py3-none-any.whl

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.3"  # x-release-please-version
+__version__ = "0.6.5"  # x-release-please-version

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

@@ -357,9 +357,19 @@ class TemporalStreamingModel(Model):
             reasoning_param = {
                 "effort": model_settings.reasoning.effort,
             }
-            # Add generate_summary if specified and not None
-            if hasattr(model_settings.reasoning, 'generate_summary') and model_settings.reasoning.generate_summary is not None:
-                reasoning_param["summary"] = model_settings.reasoning.generate_summary
+            # Add summary if specified (check both 'summary' and 'generate_summary' for compatibility)
+            summary_value = None
+            if hasattr(model_settings.reasoning, 'summary') and model_settings.reasoning.summary is not None:
+                summary_value = model_settings.reasoning.summary
+            elif (
+                hasattr(model_settings.reasoning, 'generate_summary')
+                and model_settings.reasoning.generate_summary is not None
+            ):
+                summary_value = model_settings.reasoning.generate_summary
+
+            if summary_value is not None:
+                reasoning_param["summary"] = summary_value
+
             logger.debug(f"[TemporalStreamingModel] Using reasoning param: {reasoning_param}")
             return reasoning_param
 
@@ -487,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 {})
@@ -519,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
@@ -536,181 +566,154 @@ 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', '')
+                # Process events from the Responses API stream
+                function_calls_in_progress = {}  # Track function calls being streamed
 
-                            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]}...")
+                async for event in stream:
+                    event_count += 1
 
-                        elif isinstance(event, ResponseFunctionCallArgumentsDoneEvent):
-                            # Function call arguments complete
-                            output_index = getattr(event, 'output_index', 0)
-                            arguments = getattr(event, 'arguments', '')
+                    # Log event type
+                    logger.debug(f"[TemporalStreamingModel] Event {event_count}: {type(event).__name__}")
 
-                            if output_index in function_calls_in_progress:
-                                function_calls_in_progress[output_index]['arguments'] = arguments
-                                logger.debug(f"[TemporalStreamingModel] Function call args done")
+                    # 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)
 
-                        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)
-                                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,
-                                        delta=delta_obj,
-                                        type="delta",
-                                    )
-                                    await streaming_context.stream_update(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':
-                                logger.debug(f"[TemporalStreamingModel] Reasoning item completed")
-                                # Don't close the context here - let it stay open for more reasoning events
-                                # It will be closed when we send the final update or at the end
-                            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 - send final update and close if this is the last part
+                        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 part completed, sending final update")
+                                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(
@@ -737,19 +740,51 @@ class TemporalStreamingModel(Model):
                                 except Exception as e:
                                     logger.warning(f"Failed to send reasoning part done update: {e}")
 
-                        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
+                        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
@@ -842,10 +877,16 @@ class TemporalStreamingModel(Model):
 class TemporalStreamingModelProvider(ModelProvider):
     """Custom model provider that returns a streaming-capable model."""
 
-    def __init__(self):
-        """Initialize the provider."""
+    def __init__(self, openai_client: Optional[AsyncOpenAI] = None):
+        """Initialize the provider.
+
+        Args:
+            openai_client: Optional custom AsyncOpenAI client to use for all models.
+                          If not provided, each model will create its own default client.
+        """
         super().__init__()
-        logger.info("[TemporalStreamingModelProvider] Initialized")
+        self.openai_client = openai_client
+        logger.info(f"[TemporalStreamingModelProvider] Initialized, custom_client={openai_client is not None}")
 
     @override
     def get_model(self, model_name: Union[str, None]) -> Model:
@@ -860,5 +901,5 @@ class TemporalStreamingModelProvider(ModelProvider):
         # Use the provided model_name or default to gpt-4o
         actual_model = model_name if model_name else "gpt-4o"
         logger.info(f"[TemporalStreamingModelProvider] Creating TemporalStreamingModel for model_name: {actual_model}")
-        model = TemporalStreamingModel(model_name=actual_model)
+        model = TemporalStreamingModel(model_name=actual_model, openai_client=self.openai_client)
         return model

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.3.dist-info → agentex_sdk-0.6.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: agentex-sdk
-Version: 0.6.3
+Version: 0.6.5
 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

{agentex_sdk-0.6.3.dist-info → agentex_sdk-0.6.5.dist-info}/RECORD

@@ -11,7 +11,7 @@ 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=c2fQYF_Uula9lejrW5sHf4Mfcdn6IMrnCDZlp3EDgno,159
+agentex/_version.py,sha256=r7u5V4-ao2MtjmYwTsNUkpyaHQ7CJR7ZAG4nuT0xZxc,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
@@ -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=ZODPIUuvSZO5eYhByMv2n87SOKYjAh9JunkJm8ECRPQ,42310
+agentex/lib/core/temporal/plugins/openai_agents/models/temporal_streaming_model.py,sha256=ca1EeVXu7jehXyWbV_QvJBo60iMKoCNqgjeFtQ-1frs,43906
 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.3.dist-info/METADATA,sha256=FPfO3b3DUDmtZvVDGhsammLJgD_PlhwLG-zQqo7DzKI,15375
-agentex_sdk-0.6.3.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-agentex_sdk-0.6.3.dist-info/entry_points.txt,sha256=V7vJuMZdF0UlvgX6KiBN7XUvq_cxF5kplcYvc1QlFaQ,62
-agentex_sdk-0.6.3.dist-info/licenses/LICENSE,sha256=Q1AOx2FtRcMlyMgQJ9eVN2WKPq2mQ33lnB4tvWxabLA,11337
-agentex_sdk-0.6.3.dist-info/RECORD,,
+agentex_sdk-0.6.5.dist-info/METADATA,sha256=RyqOx-PvKF-CECR8mWmH3fbywmVXzoWNOmNwMW3OsDY,15375
+agentex_sdk-0.6.5.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+agentex_sdk-0.6.5.dist-info/entry_points.txt,sha256=V7vJuMZdF0UlvgX6KiBN7XUvq_cxF5kplcYvc1QlFaQ,62
+agentex_sdk-0.6.5.dist-info/licenses/LICENSE,sha256=Q1AOx2FtRcMlyMgQJ9eVN2WKPq2mQ33lnB4tvWxabLA,11337
+agentex_sdk-0.6.5.dist-info/RECORD,,