agentex-sdk 0.4.19__py3-none-any.whl → 0.4.20__py3-none-any.whl

agentex/lib/core/services/adk/providers/openai.py

@@ -1,51 +1,51 @@
 # Standard library imports
-from contextlib import AsyncExitStack, asynccontextmanager
 from typing import Any, Literal
+from contextlib import AsyncExitStack, asynccontextmanager
 
+from mcp import StdioServerParameters
 from agents import Agent, Runner, RunResult, RunResultStreaming
+from pydantic import BaseModel
+from agents.mcp import MCPServerStdio
 from agents.agent import StopAtTools, ToolsToFinalOutputFunction
 from agents.guardrail import InputGuardrail, OutputGuardrail
 from agents.exceptions import InputGuardrailTripwireTriggered, OutputGuardrailTripwireTriggered
-from agents.mcp import MCPServerStdio
-from mcp import StdioServerParameters
 from openai.types.responses import (
     ResponseCompletedEvent,
+    ResponseTextDeltaEvent,
     ResponseFunctionWebSearch,
-    ResponseCodeInterpreterToolCall,
     ResponseOutputItemDoneEvent,
-    ResponseTextDeltaEvent,
-    ResponseReasoningSummaryTextDeltaEvent,
-    ResponseReasoningSummaryTextDoneEvent,
-    ResponseReasoningTextDeltaEvent,
     ResponseReasoningTextDoneEvent,
+    ResponseCodeInterpreterToolCall,
+    ResponseReasoningTextDeltaEvent,
+    ResponseReasoningSummaryTextDoneEvent,
+    ResponseReasoningSummaryTextDeltaEvent,
 )
-from pydantic import BaseModel
 
 # Local imports
 from agentex import AsyncAgentex
-from agentex.lib.core.services.adk.streaming import (
-    StreamingService,
-    StreamingTaskMessageContext,
-)
+from agentex.lib.utils import logging
+from agentex.lib.utils.mcp import redact_mcp_server_params
+from agentex.lib.utils.temporal import heartbeat_if_in_workflow
 from agentex.lib.core.tracing.tracer import AsyncTracer
-from agentex.types.task_message_update import (
-    StreamTaskMessageDelta,
-    StreamTaskMessageFull,
-)
 from agentex.types.task_message_delta import (
     TextDelta,
-    ReasoningSummaryDelta,
     ReasoningContentDelta,
+    ReasoningSummaryDelta,
+)
+from agentex.types.task_message_update import (
+    StreamTaskMessageFull,
+    StreamTaskMessageDelta,
 )
 from agentex.types.task_message_content import (
-    ReasoningContent,
     TextContent,
+    ReasoningContent,
     ToolRequestContent,
     ToolResponseContent,
 )
-from agentex.lib.utils import logging
-from agentex.lib.utils.mcp import redact_mcp_server_params
-from agentex.lib.utils.temporal import heartbeat_if_in_workflow
+from agentex.lib.core.services.adk.streaming import (
+    StreamingService,
+    StreamingTaskMessageContext,
+)
 
 logger = logging.make_logger(__name__)
 
@@ -141,15 +141,15 @@ class OpenAIService:
             content = tool_output_item["output"]
         else:
             # Attribute access for structured objects
-            call_id = getattr(tool_output_item, "call_id", None)
-            content = getattr(tool_output_item, "output", None)
+            call_id = getattr(tool_output_item, "call_id", "")
+            content = getattr(tool_output_item, "output", "")
 
         # Get the name from the tool call map using generic approach
         tool_call = tool_call_map[call_id]
         if hasattr(tool_call, "name"):
-            tool_name = getattr(tool_call, "name")
+            tool_name = tool_call.name
         elif hasattr(tool_call, "type"):
-            tool_name = getattr(tool_call, "type")
+            tool_name = tool_call.type
         else:
             tool_name = type(tool_call).__name__
 
@@ -176,7 +176,7 @@ class OpenAIService:
         input_guardrails: list[InputGuardrail] | None = None,
         output_guardrails: list[OutputGuardrail] | None = None,
         max_turns: int | None = None,
-        previous_response_id: str | None = None,
+        previous_response_id: str | None = None,  # noqa: ARG002
     ) -> RunResult:
         """
         Run an agent without streaming or TaskMessage creation.
@@ -208,6 +208,8 @@ class OpenAIService:
         """
         redacted_params = redact_mcp_server_params(mcp_server_params)
 
+        if self.tracer is None:
+            raise RuntimeError("Tracer not initialized - ensure tracer is provided to OpenAIService")
         trace = self.tracer.trace(trace_id)
         async with trace.span(
             parent_id=parent_span_id,
@@ -230,8 +232,11 @@ class OpenAIService:
             heartbeat_if_in_workflow("run agent")
 
             async with mcp_server_context(mcp_server_params, mcp_timeout_seconds) as servers:
-                tools = [tool.to_oai_function_tool() for tool in tools] if tools else []
-                handoffs = [Agent(**handoff.model_dump()) for handoff in handoffs] if handoffs else []
+                tools = [
+                    tool.to_oai_function_tool() if hasattr(tool, 'to_oai_function_tool') else tool  # type: ignore[attr-defined]
+                    for tool in tools
+                ] if tools else []
+                handoffs = [Agent(**handoff.model_dump()) for handoff in handoffs] if handoffs else []  # type: ignore[misc]
 
                 agent_kwargs = {
                     "name": agent_name,
@@ -245,7 +250,10 @@ class OpenAIService:
                     "tool_use_behavior": tool_use_behavior,
                 }
                 if model_settings is not None:
-                    agent_kwargs["model_settings"] = model_settings.to_oai_model_settings()
+                    agent_kwargs["model_settings"] = (
+                        model_settings.to_oai_model_settings() if hasattr(model_settings, 'to_oai_model_settings')  # type: ignore[attr-defined]
+                        else model_settings
+                    )
                 if input_guardrails is not None:
                     agent_kwargs["input_guardrails"] = input_guardrails
                 if output_guardrails is not None:
@@ -303,7 +311,7 @@ class OpenAIService:
         input_guardrails: list[InputGuardrail] | None = None,
         output_guardrails: list[OutputGuardrail] | None = None,
         max_turns: int | None = None,
-        previous_response_id: str | None = None,
+        previous_response_id: str | None = None,  # noqa: ARG002
     ) -> RunResult:
         """
         Run an agent with automatic TaskMessage creation.
@@ -337,6 +345,8 @@ class OpenAIService:
 
         redacted_params = redact_mcp_server_params(mcp_server_params)
 
+        if self.tracer is None:
+            raise RuntimeError("Tracer not initialized - ensure tracer is provided to OpenAIService")
         trace = self.tracer.trace(trace_id)
         async with trace.span(
             parent_id=parent_span_id,
@@ -360,8 +370,11 @@ class OpenAIService:
             heartbeat_if_in_workflow("run agent auto send")
 
             async with mcp_server_context(mcp_server_params, mcp_timeout_seconds) as servers:
-                tools = [tool.to_oai_function_tool() for tool in tools] if tools else []
-                handoffs = [Agent(**handoff.model_dump()) for handoff in handoffs] if handoffs else []
+                tools = [
+                    tool.to_oai_function_tool() if hasattr(tool, 'to_oai_function_tool') else tool  # type: ignore[attr-defined]
+                    for tool in tools
+                ] if tools else []
+                handoffs = [Agent(**handoff.model_dump()) for handoff in handoffs] if handoffs else []  # type: ignore[misc]
                 agent_kwargs = {
                     "name": agent_name,
                     "instructions": agent_instructions,
@@ -374,7 +387,10 @@ class OpenAIService:
                     "tool_use_behavior": tool_use_behavior,
                 }
                 if model_settings is not None:
-                    agent_kwargs["model_settings"] = model_settings.to_oai_model_settings()
+                    agent_kwargs["model_settings"] = (
+                        model_settings.to_oai_model_settings() if hasattr(model_settings, 'to_oai_model_settings')  # type: ignore[attr-defined]
+                        else model_settings
+                    )
                 if input_guardrails is not None:
                     agent_kwargs["input_guardrails"] = input_guardrails
                 if output_guardrails is not None:
@@ -414,7 +430,7 @@ class OpenAIService:
                     if item.type == "message_output_item":
                         text_content = TextContent(
                             author="agent",
-                            content=item.raw_item.content[0].text,
+                            content=item.raw_item.content[0].text,  # type: ignore[union-attr]
                         )
                         # Create message for the final result using streaming context
                         async with self.streaming_service.streaming_task_message_context(
@@ -504,7 +520,7 @@ class OpenAIService:
         input_guardrails: list[InputGuardrail] | None = None,
         output_guardrails: list[OutputGuardrail] | None = None,
         max_turns: int | None = None,
-        previous_response_id: str | None = None,
+        previous_response_id: str | None = None,  # noqa: ARG002
     ) -> RunResultStreaming:
         """
         Run an agent with streaming enabled but no TaskMessage creation.
@@ -534,6 +550,8 @@ class OpenAIService:
         Returns:
             RunResultStreaming: The result of the agent run with streaming.
         """
+        if self.tracer is None:
+            raise RuntimeError("Tracer not initialized - ensure tracer is provided to OpenAIService")
         trace = self.tracer.trace(trace_id)
         redacted_params = redact_mcp_server_params(mcp_server_params)
 
@@ -558,8 +576,11 @@ class OpenAIService:
             heartbeat_if_in_workflow("run agent streamed")
 
             async with mcp_server_context(mcp_server_params, mcp_timeout_seconds) as servers:
-                tools = [tool.to_oai_function_tool() for tool in tools] if tools else []
-                handoffs = [Agent(**handoff.model_dump()) for handoff in handoffs] if handoffs else []
+                tools = [
+                    tool.to_oai_function_tool() if hasattr(tool, 'to_oai_function_tool') else tool  # type: ignore[attr-defined]
+                    for tool in tools
+                ] if tools else []
+                handoffs = [Agent(**handoff.model_dump()) for handoff in handoffs] if handoffs else []  # type: ignore[misc]
                 agent_kwargs = {
                     "name": agent_name,
                     "instructions": agent_instructions,
@@ -572,7 +593,10 @@ class OpenAIService:
                     "tool_use_behavior": tool_use_behavior,
                 }
                 if model_settings is not None:
-                    agent_kwargs["model_settings"] = model_settings.to_oai_model_settings()
+                    agent_kwargs["model_settings"] = (
+                        model_settings.to_oai_model_settings() if hasattr(model_settings, 'to_oai_model_settings')  # type: ignore[attr-defined]
+                        else model_settings
+                    )
                 if input_guardrails is not None:
                     agent_kwargs["input_guardrails"] = input_guardrails
                 if output_guardrails is not None:
@@ -630,7 +654,7 @@ class OpenAIService:
         input_guardrails: list[InputGuardrail] | None = None,
         output_guardrails: list[OutputGuardrail] | None = None,
         max_turns: int | None = None,
-        previous_response_id: str | None = None,
+        previous_response_id: str | None = None,  # noqa: ARG002
     ) -> RunResultStreaming:
         """
         Run an agent with streaming enabled and automatic TaskMessage creation.
@@ -669,6 +693,8 @@ class OpenAIService:
 
         tool_call_map: dict[str, Any] = {}
 
+        if self.tracer is None:
+            raise RuntimeError("Tracer not initialized - ensure tracer is provided to OpenAIService")
         trace = self.tracer.trace(trace_id)
         redacted_params = redact_mcp_server_params(mcp_server_params)
 
@@ -694,8 +720,11 @@ class OpenAIService:
             heartbeat_if_in_workflow("run agent streamed auto send")
 
             async with mcp_server_context(mcp_server_params, mcp_timeout_seconds) as servers:
-                tools = [tool.to_oai_function_tool() for tool in tools] if tools else []
-                handoffs = [Agent(**handoff.model_dump()) for handoff in handoffs] if handoffs else []
+                tools = [
+                    tool.to_oai_function_tool() if hasattr(tool, 'to_oai_function_tool') else tool  # type: ignore[attr-defined]
+                    for tool in tools
+                ] if tools else []
+                handoffs = [Agent(**handoff.model_dump()) for handoff in handoffs] if handoffs else []  # type: ignore[misc]
                 agent_kwargs = {
                     "name": agent_name,
                     "instructions": agent_instructions,
@@ -708,7 +737,10 @@ class OpenAIService:
                     "tool_use_behavior": tool_use_behavior,
                 }
                 if model_settings is not None:
-                    agent_kwargs["model_settings"] = model_settings.to_oai_model_settings()
+                    agent_kwargs["model_settings"] = (
+                        model_settings.to_oai_model_settings() if hasattr(model_settings, 'to_oai_model_settings')  # type: ignore[attr-defined]
+                        else model_settings
+                    )
                 if input_guardrails is not None:
                     agent_kwargs["input_guardrails"] = input_guardrails
                 if output_guardrails is not None:

agentex/lib/core/services/adk/providers/sgp.py

@@ -1,13 +1,13 @@
-import base64
 import os
+import base64
 import tempfile
 
 from scale_gp import SGPClient
 
-from agentex.lib.core.tracing.tracer import AsyncTracer
 from agentex.lib.types.files import FileContentResponse
 from agentex.lib.utils.logging import make_logger
 from agentex.lib.utils.temporal import heartbeat_if_in_workflow
+from agentex.lib.core.tracing.tracer import AsyncTracer
 
 logger = make_logger(__name__)
 
@@ -91,7 +91,7 @@ class SGPService:
                 )
 
             # Record metadata for tracing
-            span.output = {
+            span.output = {  # type: ignore[union-attr]
                 "file_id": file_id,
                 "mime_type": result.mime_type,
                 "content_size": len(result.base64_content),

agentex/lib/core/services/adk/state.py

@@ -1,9 +1,9 @@
 from typing import Any, Dict
 
 from agentex import AsyncAgentex
-from agentex.lib.core.tracing.tracer import AsyncTracer
 from agentex.types.state import State
 from agentex.lib.utils.logging import make_logger
+from agentex.lib.core.tracing.tracer import AsyncTracer
 
 logger = make_logger(__name__)
 
@@ -47,6 +47,10 @@ class StateService:
         parent_span_id: str | None = None,
     ) -> State | None:
         trace = self._tracer.trace(trace_id) if self._tracer else None
+        if trace is None:
+            # Handle case without tracing - implement the core logic here
+            return await self._agentex_client.states.retrieve(state_id)
+
         async with trace.span(
             parent_id=parent_span_id,
             name="get_state",

agentex/lib/core/services/adk/streaming.py

@@ -2,33 +2,33 @@ import json
 from typing import Literal
 
 from agentex import AsyncAgentex
-from agentex.lib.core.adapters.streams.port import StreamRepository
-from agentex.types.task_message_update import (
-    TaskMessageDelta, 
-    TaskMessageUpdate,
-    StreamTaskMessageStart,
-    StreamTaskMessageDelta,
-    StreamTaskMessageFull,
-    StreamTaskMessageDone,
+from agentex.lib.utils.logging import make_logger
+from agentex.types.data_content import DataContent
+from agentex.types.task_message import (
+    TaskMessage,
+    TaskMessageContent,
 )
+from agentex.types.text_content import TextContent
+from agentex.types.reasoning_content import ReasoningContent
 from agentex.types.task_message_delta import (
-    TextDelta,
     DataDelta,
+    TextDelta,
     ToolRequestDelta,
     ToolResponseDelta,
-    ReasoningSummaryDelta,
     ReasoningContentDelta,
+    ReasoningSummaryDelta,
 )
-from agentex.lib.utils.logging import make_logger
-from agentex.types.data_content import DataContent
-from agentex.types.task_message import (
-    TaskMessage,
-    TaskMessageContent,
+from agentex.types.task_message_update import (
+    TaskMessageDelta,
+    TaskMessageUpdate,
+    StreamTaskMessageDone,
+    StreamTaskMessageFull,
+    StreamTaskMessageDelta,
+    StreamTaskMessageStart,
 )
-from agentex.types.text_content import TextContent
 from agentex.types.tool_request_content import ToolRequestContent
 from agentex.types.tool_response_content import ToolResponseContent
-from agentex.types.reasoning_content import ReasoningContent
+from agentex.lib.core.adapters.streams.port import StreamRepository
 
 logger = make_logger(__name__)
 
@@ -265,7 +265,7 @@ class StreamingTaskMessageContext:
         elif isinstance(update, StreamTaskMessageFull):
             await self._agentex_client.messages.update(
                 task_id=self.task_id,
-                message_id=update.parent_task_message.id,
+                message_id=update.parent_task_message.id,  # type: ignore[union-attr]
                 content=update.content.model_dump(),
                 streaming_status="DONE",
             )
@@ -306,7 +306,7 @@ class StreamingService:
         Returns:
             True if event was streamed successfully, False otherwise
         """
-        stream_topic = _get_stream_topic(update.parent_task_message.task_id)
+        stream_topic = _get_stream_topic(update.parent_task_message.task_id)  # type: ignore[union-attr]
 
         try:
             await self._stream_repository.send_event(

agentex/lib/core/services/adk/tasks.py

@@ -1,8 +1,9 @@
 from agentex import AsyncAgentex
-from agentex.lib.core.tracing.tracer import AsyncTracer
 from agentex.types.task import Task
+from agentex.types.shared import DeleteResponse
 from agentex.lib.utils.logging import make_logger
 from agentex.lib.utils.temporal import heartbeat_if_in_workflow
+from agentex.lib.core.tracing.tracer import AsyncTracer
 
 logger = make_logger(__name__)
 
@@ -48,8 +49,13 @@ class TasksService:
         task_name: str | None = None,
         trace_id: str | None = None,
         parent_span_id: str | None = None,
-    ) -> Task:
+    ) -> Task | DeleteResponse:
         trace = self._tracer.trace(trace_id) if self._tracer else None
+        if trace is None:
+            # Handle case without tracing
+            response = await self._agentex_client.tasks.delete(task_id)
+            return Task(**response.model_dump())
+
         async with trace.span(
             parent_id=parent_span_id,
             name="delete_task",

agentex/lib/core/services/adk/tracing.py

@@ -1,9 +1,10 @@
 from typing import Any
-from agentex.lib.core.tracing.tracer import AsyncTracer
+
 from agentex.types.span import Span
 from agentex.lib.utils.logging import make_logger
-from agentex.lib.utils.model_utils import BaseModel
 from agentex.lib.utils.temporal import heartbeat_if_in_workflow
+from agentex.lib.utils.model_utils import BaseModel
+from agentex.lib.core.tracing.tracer import AsyncTracer
 
 logger = make_logger(__name__)
 

agentex/lib/core/services/adk/utils/templating.py

@@ -1,10 +1,10 @@
-from datetime import datetime
 from typing import Any
+from datetime import datetime
 
 from jinja2 import BaseLoader, Environment
 
-from agentex.lib.core.tracing.tracer import AsyncTracer
 from agentex.lib.utils.temporal import heartbeat_if_in_workflow
+from agentex.lib.core.tracing.tracer import AsyncTracer
 
 # Create a Jinja environment
 JINJA_ENV = Environment(
@@ -38,6 +38,8 @@ class TemplatingService:
         Returns:
             The rendered template as a string
         """
+        if self.tracer is None:
+            raise RuntimeError("Tracer not initialized - ensure tracer is provided to TemplatingService")
         trace = self.tracer.trace(trace_id)
         async with trace.span(
             parent_id=parent_span_id,

agentex/lib/core/temporal/activities/__init__.py

@@ -1,45 +1,45 @@
 import httpx
-from agentex.lib.adk.utils._modules.client import create_async_agentex_client
 from scale_gp import SGPClient, SGPClientError
 
-from agentex import AsyncAgentex
-from agentex.lib.core.adapters.llm.adapter_litellm import LiteLLMGateway
-from agentex.lib.core.adapters.streams.adapter_redis import RedisStreamRepository
-from agentex.lib.core.services.adk.acp.acp import ACPService
-from agentex.lib.core.services.adk.agent_task_tracker import AgentTaskTrackerService
-from agentex.lib.core.services.adk.events import EventsService
-from agentex.lib.core.services.adk.messages import MessagesService
-from agentex.lib.core.services.adk.providers.litellm import LiteLLMService
-from agentex.lib.core.services.adk.providers.openai import OpenAIService
-from agentex.lib.core.services.adk.providers.sgp import SGPService
+from agentex import AsyncAgentex  # noqa: F401
+from agentex.lib.core.tracing import AsyncTracer
 from agentex.lib.core.services.adk.state import StateService
-from agentex.lib.core.services.adk.streaming import StreamingService
 from agentex.lib.core.services.adk.tasks import TasksService
+from agentex.lib.core.services.adk.events import EventsService
+from agentex.lib.adk.utils._modules.client import create_async_agentex_client
+from agentex.lib.core.services.adk.acp.acp import ACPService
 from agentex.lib.core.services.adk.tracing import TracingService
+from agentex.lib.core.services.adk.messages import MessagesService
+from agentex.lib.core.services.adk.streaming import StreamingService
+from agentex.lib.core.services.adk.providers.sgp import SGPService
+from agentex.lib.core.adapters.llm.adapter_litellm import LiteLLMGateway
+from agentex.lib.core.services.adk.providers.openai import OpenAIService
 from agentex.lib.core.services.adk.utils.templating import TemplatingService
-from agentex.lib.core.temporal.activities.adk.acp.acp_activities import ACPActivities
-from agentex.lib.core.temporal.activities.adk.agent_task_tracker_activities import (
-    AgentTaskTrackerActivities,
-)
+from agentex.lib.core.adapters.streams.adapter_redis import RedisStreamRepository
+from agentex.lib.core.services.adk.providers.litellm import LiteLLMService
+from agentex.lib.core.services.adk.agent_task_tracker import AgentTaskTrackerService
+from agentex.lib.core.temporal.activities.adk.state_activities import StateActivities
+from agentex.lib.core.temporal.activities.adk.tasks_activities import TasksActivities
 from agentex.lib.core.temporal.activities.adk.events_activities import EventsActivities
+from agentex.lib.core.temporal.activities.adk.acp.acp_activities import ACPActivities
+from agentex.lib.core.temporal.activities.adk.tracing_activities import TracingActivities
 from agentex.lib.core.temporal.activities.adk.messages_activities import MessagesActivities
-from agentex.lib.core.temporal.activities.adk.providers.litellm_activities import (
-    LiteLLMActivities,
+from agentex.lib.core.temporal.activities.adk.streaming_activities import (
+    StreamingActivities,
 )
+from agentex.lib.core.temporal.activities.adk.providers.sgp_activities import SGPActivities
 from agentex.lib.core.temporal.activities.adk.providers.openai_activities import (
     OpenAIActivities,
 )
-from agentex.lib.core.temporal.activities.adk.providers.sgp_activities import SGPActivities
-from agentex.lib.core.temporal.activities.adk.state_activities import StateActivities
-from agentex.lib.core.temporal.activities.adk.streaming_activities import (
-    StreamingActivities,
-)
-from agentex.lib.core.temporal.activities.adk.tasks_activities import TasksActivities
-from agentex.lib.core.temporal.activities.adk.tracing_activities import TracingActivities
 from agentex.lib.core.temporal.activities.adk.utils.templating_activities import (
     TemplatingActivities,
 )
-from agentex.lib.core.tracing import AsyncTracer
+from agentex.lib.core.temporal.activities.adk.providers.litellm_activities import (
+    LiteLLMActivities,
+)
+from agentex.lib.core.temporal.activities.adk.agent_task_tracker_activities import (
+    AgentTaskTrackerActivities,
+)
 
 
 def get_all_activities(sgp_client=None):
@@ -204,7 +204,7 @@ def get_all_activities(sgp_client=None):
     # SGP activities
     if sgp_client is not None:
         sgp_all_activities = [
-            sgp_activities.download_file_content,
+            sgp_activities.download_file_content,  # type: ignore[union-attr]
         ]
         activities.extend(sgp_all_activities)
 

agentex/lib/core/temporal/activities/activity_helpers.py

@@ -1,5 +1,5 @@
-from datetime import timedelta
 from typing import Any, TypeVar
+from datetime import timedelta
 
 from pydantic import TypeAdapter
 from temporalio import workflow

agentex/lib/core/temporal/activities/adk/acp/acp_activities.py

@@ -3,13 +3,13 @@ from typing import Any, List
 
 from temporalio import activity
 
-from agentex.lib.core.services.adk.acp.acp import ACPService
-from agentex.types.event import Event
-from agentex.types.task_message import TaskMessage
-from agentex.types.task_message_content import TaskMessageContent
 from agentex.types.task import Task
+from agentex.types.event import Event
 from agentex.lib.types.tracing import BaseModelWithTraceParams
 from agentex.lib.utils.logging import make_logger
+from agentex.types.task_message import TaskMessage
+from agentex.types.task_message_content import TaskMessageContent
+from agentex.lib.core.services.adk.acp.acp import ACPService
 
 logger = make_logger(__name__)
 

agentex/lib/core/temporal/activities/adk/agent_task_tracker_activities.py

@@ -2,10 +2,10 @@ from enum import Enum
 
 from temporalio import activity
 
-from agentex.lib.core.services.adk.agent_task_tracker import AgentTaskTrackerService
 from agentex.lib.types.tracing import BaseModelWithTraceParams
 from agentex.lib.utils.logging import make_logger
 from agentex.types.agent_task_tracker import AgentTaskTracker
+from agentex.lib.core.services.adk.agent_task_tracker import AgentTaskTrackerService
 
 logger = make_logger(__name__)
 

agentex/lib/core/temporal/activities/adk/agents_activities.py

@@ -1,12 +1,12 @@
 from enum import Enum
 from typing import Optional
 
-from agentex.lib.core.services.adk.agents import AgentsService
-from agentex.types.agent import Agent
 from temporalio import activity
 
+from agentex.types.agent import Agent
 from agentex.lib.types.tracing import BaseModelWithTraceParams
 from agentex.lib.utils.logging import make_logger
+from agentex.lib.core.services.adk.agents import AgentsService
 
 logger = make_logger(__name__)
 

agentex/lib/core/temporal/activities/adk/events_activities.py

@@ -2,10 +2,10 @@ from enum import Enum
 
 from temporalio import activity
 
-from agentex.lib.core.services.adk.events import EventsService
 from agentex.types.event import Event
 from agentex.lib.types.tracing import BaseModelWithTraceParams
 from agentex.lib.utils.logging import make_logger
+from agentex.lib.core.services.adk.events import EventsService
 
 logger = make_logger(__name__)
 

agentex/lib/core/temporal/activities/adk/messages_activities.py

@@ -2,11 +2,11 @@ from enum import Enum
 
 from temporalio import activity
 
-from agentex.lib.core.services.adk.messages import MessagesService
-from agentex.types.task_message import TaskMessage
-from agentex.types.task_message_content import TaskMessageContent
 from agentex.lib.types.tracing import BaseModelWithTraceParams
 from agentex.lib.utils.logging import make_logger
+from agentex.types.task_message import TaskMessage
+from agentex.types.task_message_content import TaskMessageContent
+from agentex.lib.core.services.adk.messages import MessagesService
 
 logger = make_logger(__name__)
 

agentex/lib/core/temporal/activities/adk/providers/litellm_activities.py

@@ -2,11 +2,11 @@ from enum import Enum
 
 from temporalio import activity
 
-from agentex.lib.core.services.adk.providers.litellm import LiteLLMService
-from agentex.lib.types.llm_messages import Completion, LLMConfig
-from agentex.types.task_message import TaskMessage
-from agentex.lib.types.tracing import BaseModelWithTraceParams
 from agentex.lib.utils import logging
+from agentex.lib.types.tracing import BaseModelWithTraceParams
+from agentex.types.task_message import TaskMessage
+from agentex.lib.types.llm_messages import LLMConfig, Completion
+from agentex.lib.core.services.adk.providers.litellm import LiteLLMService
 
 logger = logging.make_logger(__name__)
 

agentex/lib/core/temporal/activities/adk/providers/sgp_activities.py

@@ -2,10 +2,10 @@ from enum import Enum
 
 from temporalio import activity
 
-from agentex.lib.core.services.adk.providers.sgp import SGPService
 from agentex.lib.types.files import FileContentResponse
 from agentex.lib.types.tracing import BaseModelWithTraceParams
 from agentex.lib.utils.logging import make_logger
+from agentex.lib.core.services.adk.providers.sgp import SGPService
 
 logger = make_logger(__name__)
 

agentex/lib/core/temporal/activities/adk/state_activities.py

@@ -3,10 +3,10 @@ from typing import Any
 
 from temporalio import activity
 
-from agentex.lib.core.services.adk.state import StateService
 from agentex.types.state import State
 from agentex.lib.types.tracing import BaseModelWithTraceParams
 from agentex.lib.utils.logging import make_logger
+from agentex.lib.core.services.adk.state import StateService
 
 logger = make_logger(__name__)