agentex-sdk 0.1.0a6__py3-none-any.whl

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

@@ -0,0 +1,210 @@
+# Standard library imports
+from collections.abc import Callable
+from contextlib import AsyncExitStack, asynccontextmanager
+from enum import Enum
+from typing import Any, Literal
+
+from agents import RunResult, RunResultStreaming
+from agents.mcp import MCPServerStdio, MCPServerStdioParams
+from agents.model_settings import ModelSettings as OAIModelSettings
+from agents.tool import FunctionTool as OAIFunctionTool
+from mcp import StdioServerParameters
+from openai.types.responses.response_includable import ResponseIncludable
+from openai.types.shared.reasoning import Reasoning
+from temporalio import activity
+
+from agentex.lib.core.services.adk.providers.openai import OpenAIService
+
+# Local imports
+from agentex.lib.types.agent_results import (
+    SerializableRunResult,
+    SerializableRunResultStreaming,
+)
+
+# Third-party imports
+from agentex.lib.types.tracing import BaseModelWithTraceParams
+from agentex.lib.utils import logging
+
+logger = logging.make_logger(__name__)
+
+
+class OpenAIActivityName(str, Enum):
+    """Names of OpenAI agent activities."""
+
+    RUN_AGENT = "run_agent"
+    RUN_AGENT_AUTO_SEND = "run_agent_auto_send"
+    # Note: RUN_AGENT_STREAMED is not supported in Temporal due to generator limitations
+    RUN_AGENT_STREAMED_AUTO_SEND = "run_agent_streamed_auto_send"
+
+
+class FunctionTool(BaseModelWithTraceParams):
+    name: str
+    description: str
+    params_json_schema: dict[str, Any]
+    on_invoke_tool: Callable[[dict[str, Any]], Any]
+    strict_json_schema: bool = True
+    is_enabled: bool = True
+
+    def to_oai_function_tool(self) -> OAIFunctionTool:
+        return OAIFunctionTool(**self.model_dump(exclude=["trace_id", "parent_span_id"]))
+
+
+class ModelSettings(BaseModelWithTraceParams):
+    temperature: float | None = None
+    top_p: float | None = None
+    frequency_penalty: float | None = None
+    presence_penalty: float | None = None
+    tool_choice: Literal["auto", "required", "none"] | str | None = None
+    parallel_tool_calls: bool | None = None
+    truncation: Literal["auto", "disabled"] | None = None
+    max_tokens: int | None = None
+    reasoning: Reasoning | None = None
+    metadata: dict[str, str] | None = None
+    store: bool | None = None
+    include_usage: bool | None = None
+    response_include: list[ResponseIncludable] | None = None
+    extra_body: dict[str, str] | None = None
+    extra_headers: dict[str, str] | None = None
+    extra_args: dict[str, Any] | None = None
+
+    def to_oai_model_settings(self) -> OAIModelSettings:
+        return OAIModelSettings(**self.model_dump(exclude=["trace_id", "parent_span_id"]))
+
+
+class RunAgentParams(BaseModelWithTraceParams):
+    """Parameters for running an agent without streaming."""
+
+    input_list: list[dict]
+    mcp_server_params: list[StdioServerParameters]
+    agent_name: str
+    agent_instructions: str
+    handoff_description: str | None = None
+    handoffs: list["RunAgentParams"] | None = None
+    model: str | None = None
+    model_settings: ModelSettings | None = None
+    tools: list[FunctionTool] | None = None
+    output_type: Any = None
+    tool_use_behavior: Literal["run_llm_again", "stop_on_first_tool"] = "run_llm_again"
+    mcp_timeout_seconds: int | None = None
+
+
+class RunAgentAutoSendParams(RunAgentParams):
+    """Parameters for running an agent with automatic TaskMessage creation."""
+
+    task_id: str
+
+
+class RunAgentStreamedAutoSendParams(RunAgentParams):
+    """Parameters for running an agent with streaming and automatic TaskMessage creation."""
+
+    task_id: str
+
+
+@asynccontextmanager
+async def mcp_server_context(mcp_server_params: list[StdioServerParameters]):
+    """Context manager for MCP servers."""
+    servers: list[MCPServerStdio] = []
+    for params in mcp_server_params:
+        server = MCPServerStdio(
+            name=f"Server: {params.command}",
+            params=MCPServerStdioParams(**params.model_dump()),
+            cache_tools_list=True,
+            client_session_timeout_seconds=60,
+        )
+        servers.append(server)
+
+    async with AsyncExitStack() as stack:
+        for server in servers:
+            await stack.enter_async_context(server)
+        yield servers
+
+
+class OpenAIActivities:
+    """Activities for OpenAI agent operations."""
+
+    def __init__(self, openai_service: OpenAIService):
+        self._openai_service = openai_service
+
+    @activity.defn(name=OpenAIActivityName.RUN_AGENT)
+    async def run_agent(self, params: RunAgentParams) -> SerializableRunResult:
+        """Run an agent without streaming or TaskMessage creation."""
+        result = await self._openai_service.run_agent(
+            input_list=params.input_list,
+            mcp_server_params=params.mcp_server_params,
+            agent_name=params.agent_name,
+            agent_instructions=params.agent_instructions,
+            trace_id=params.trace_id,
+            parent_span_id=params.parent_span_id,
+            handoff_description=params.handoff_description,
+            handoffs=params.handoffs,
+            model=params.model,
+            model_settings=params.model_settings,
+            tools=params.tools,
+            output_type=params.output_type,
+            tool_use_behavior=params.tool_use_behavior,
+        )
+        return self._to_serializable_run_result(result)
+
+    @activity.defn(name=OpenAIActivityName.RUN_AGENT_AUTO_SEND)
+    async def run_agent_auto_send(
+        self, params: RunAgentAutoSendParams
+    ) -> SerializableRunResult:
+        """Run an agent with automatic TaskMessage creation."""
+        result = await self._openai_service.run_agent_auto_send(
+            task_id=params.task_id,
+            input_list=params.input_list,
+            mcp_server_params=params.mcp_server_params,
+            agent_name=params.agent_name,
+            agent_instructions=params.agent_instructions,
+            trace_id=params.trace_id,
+            parent_span_id=params.parent_span_id,
+            handoff_description=params.handoff_description,
+            handoffs=params.handoffs,
+            model=params.model,
+            model_settings=params.model_settings,
+            tools=params.tools,
+            output_type=params.output_type,
+            tool_use_behavior=params.tool_use_behavior,
+        )
+        return self._to_serializable_run_result(result)
+
+    @activity.defn(name=OpenAIActivityName.RUN_AGENT_STREAMED_AUTO_SEND)
+    async def run_agent_streamed_auto_send(
+        self, params: RunAgentStreamedAutoSendParams
+    ) -> SerializableRunResultStreaming:
+        """Run an agent with streaming and automatic TaskMessage creation."""
+        result = await self._openai_service.run_agent_streamed_auto_send(
+            task_id=params.task_id,
+            input_list=params.input_list,
+            mcp_server_params=params.mcp_server_params,
+            agent_name=params.agent_name,
+            agent_instructions=params.agent_instructions,
+            trace_id=params.trace_id,
+            parent_span_id=params.parent_span_id,
+            handoff_description=params.handoff_description,
+            handoffs=params.handoffs,
+            model=params.model,
+            model_settings=params.model_settings,
+            tools=params.tools,
+            output_type=params.output_type,
+            tool_use_behavior=params.tool_use_behavior,
+        )
+        return self._to_serializable_run_result_streaming(result)
+
+    @staticmethod
+    def _to_serializable_run_result(result: RunResult) -> SerializableRunResult:
+        """Convert RunResult to SerializableRunResult."""
+        return SerializableRunResult(
+            final_output=result.final_output,
+            final_input_list=result.to_input_list(),
+        )
+
+    @staticmethod
+    def _to_serializable_run_result_streaming(
+        result: RunResultStreaming,
+    ) -> SerializableRunResultStreaming:
+        """Convert RunResultStreaming to SerializableRunResultStreaming."""
+        return SerializableRunResultStreaming(
+            final_output=result.final_output,
+            final_input_list=result.to_input_list(),
+        )

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

@@ -0,0 +1,42 @@
+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
+
+logger = make_logger(__name__)
+
+
+class SGPActivityName(str, Enum):
+    DOWNLOAD_FILE_CONTENT = "download-file-content"
+
+
+class DownloadFileParams(BaseModelWithTraceParams):
+    file_id: str
+    filename: str
+
+
+class SGPActivities:
+    def __init__(self, sgp_service: SGPService):
+        self.sgp_service = sgp_service
+
+    @activity.defn(name=SGPActivityName.DOWNLOAD_FILE_CONTENT)
+    async def download_file_content(self, params: DownloadFileParams) -> FileContentResponse:
+        """
+        Download file content from SGP.
+
+        Args:
+            params: DownloadFileParams containing file_id and filename.
+
+        Returns:
+            FileContentResponse with mime_type and base64_content for constructing LLM input.
+        """
+        return await self.sgp_service.download_file_content(
+            file_id=params.file_id,
+            filename=params.filename,
+            trace_id=params.trace_id,
+            parent_span_id=params.parent_span_id,
+        )

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

@@ -0,0 +1,85 @@
+from enum import Enum
+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
+
+logger = make_logger(__name__)
+
+
+class StateActivityName(str, Enum):
+    CREATE_STATE = "create-state"
+    GET_STATE = "get-state"
+    UPDATE_STATE = "update-state"
+    DELETE_STATE = "delete-state"
+
+
+class CreateStateParams(BaseModelWithTraceParams):
+    task_id: str
+    agent_id: str
+    state: dict[str, Any]
+
+
+class GetStateParams(BaseModelWithTraceParams):
+    state_id: str | None = None
+    task_id: str | None = None
+    agent_id: str | None = None
+
+
+class UpdateStateParams(BaseModelWithTraceParams):
+    state_id: str
+    task_id: str
+    agent_id: str
+    state: dict[str, Any]
+
+
+class DeleteStateParams(BaseModelWithTraceParams):
+    state_id: str
+
+
+class StateActivities:
+    def __init__(self, state_service: StateService):
+        self._state_service = state_service
+
+    @activity.defn(name=StateActivityName.CREATE_STATE)
+    async def create_state(self, params: CreateStateParams) -> State:
+        return await self._state_service.create_state(
+            task_id=params.task_id,
+            agent_id=params.agent_id,
+            state=params.state,
+            trace_id=params.trace_id,
+            parent_span_id=params.parent_span_id,
+        )
+
+    @activity.defn(name=StateActivityName.GET_STATE)
+    async def get_state(self, params: GetStateParams) -> State | None:
+        return await self._state_service.get_state(
+            state_id=params.state_id,
+            task_id=params.task_id,
+            agent_id=params.agent_id,
+            trace_id=params.trace_id,
+            parent_span_id=params.parent_span_id,
+        )
+
+    @activity.defn(name=StateActivityName.UPDATE_STATE)
+    async def update_state(self, params: UpdateStateParams) -> State:
+        return await self._state_service.update_state(
+            state_id=params.state_id,
+            task_id=params.task_id,
+            agent_id=params.agent_id,
+            state=params.state,
+            trace_id=params.trace_id,
+            parent_span_id=params.parent_span_id,
+        )
+
+    @activity.defn(name=StateActivityName.DELETE_STATE)
+    async def delete_state(self, params: DeleteStateParams) -> State:
+        return await self._state_service.delete_state(
+            state_id=params.state_id,
+            trace_id=params.trace_id,
+            parent_span_id=params.parent_span_id,
+        )

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

@@ -0,0 +1,33 @@
+from enum import Enum
+
+from temporalio import activity
+
+from agentex.lib.core.services.adk.streaming import StreamingService
+from agentex.lib.types.task_message_updates import TaskMessageUpdate
+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
+
+logger = make_logger(__name__)
+
+
+class StreamingActivityName(str, Enum):
+    STREAM_UPDATE = "stream-update"
+
+
+class StreamUpdateParams(BaseModel):
+    update: TaskMessageUpdate
+
+
+class StreamingActivities:
+    """
+    Temporal activities for streaming events to clients (ADK pattern).
+    """
+
+    def __init__(self, streaming_service: StreamingService):
+        self._streaming_service = streaming_service
+
+    @activity.defn(name=StreamingActivityName.STREAM_UPDATE)
+    async def stream_update(self, params: StreamUpdateParams) -> TaskMessageUpdate | None:
+        heartbeat_if_in_workflow("stream update")
+        return await self._streaming_service.stream_update(update=params.update)

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

@@ -0,0 +1,48 @@
+from enum import Enum
+
+from temporalio import activity
+
+from agentex.lib.core.services.adk.tasks import TasksService
+from agentex.types.task import Task
+from agentex.lib.types.tracing import BaseModelWithTraceParams
+from agentex.lib.utils.logging import make_logger
+
+logger = make_logger(__name__)
+
+
+class TasksActivityName(str, Enum):
+    GET_TASK = "get-task"
+    DELETE_TASK = "delete-task"
+
+
+class GetTaskParams(BaseModelWithTraceParams):
+    task_id: str | None = None
+    task_name: str | None = None
+
+
+class DeleteTaskParams(BaseModelWithTraceParams):
+    task_id: str | None = None
+    task_name: str | None = None
+
+
+class TasksActivities:
+    def __init__(self, tasks_service: TasksService):
+        self._tasks_service = tasks_service
+
+    @activity.defn(name=TasksActivityName.GET_TASK)
+    async def get_task(self, params: GetTaskParams) -> Task | None:
+        return await self._tasks_service.get_task(
+            task_id=params.task_id,
+            task_name=params.task_name,
+            trace_id=params.trace_id,
+            parent_span_id=params.parent_span_id,
+        )
+
+    @activity.defn(name=TasksActivityName.DELETE_TASK)
+    async def delete_task(self, params: DeleteTaskParams) -> Task:
+        return await self._tasks_service.delete_task(
+            task_id=params.task_id,
+            task_name=params.task_name,
+            trace_id=params.trace_id,
+            parent_span_id=params.parent_span_id,
+        )

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

@@ -0,0 +1,55 @@
+from enum import Enum
+from typing import Any
+
+from temporalio import activity
+
+from agentex.lib.core.services.adk.tracing import TracingService
+from agentex.types.span import Span
+from agentex.lib.utils.logging import make_logger
+from agentex.lib.utils.model_utils import BaseModel
+
+logger = make_logger(__name__)
+
+
+class TracingActivityName(str, Enum):
+    START_SPAN = "start-span"
+    END_SPAN = "end-span"
+
+
+class StartSpanParams(BaseModel):
+    trace_id: str
+    parent_id: str | None = None
+    name: str
+    input: list[Any] | dict[str, Any] | BaseModel | None = None
+    data: list[Any] | dict[str, Any] | BaseModel | None = None
+
+
+class EndSpanParams(BaseModel):
+    trace_id: str
+    span: Span
+
+
+class TracingActivities:
+    """
+    Temporal activities for tracing (spans), ADK pattern.
+    """
+
+    def __init__(self, tracing_service: TracingService):
+        self._tracing_service = tracing_service
+
+    @activity.defn(name=TracingActivityName.START_SPAN)
+    async def start_span(self, params: StartSpanParams) -> Span | None:
+        return await self._tracing_service.start_span(
+            trace_id=params.trace_id,
+            parent_id=params.parent_id,
+            name=params.name,
+            input=params.input,
+            data=params.data,
+        )
+
+    @activity.defn(name=TracingActivityName.END_SPAN)
+    async def end_span(self, params: EndSpanParams) -> Span:
+        return await self._tracing_service.end_span(
+            trace_id=params.trace_id,
+            span=params.span,
+        )

agentex/lib/core/temporal/activities/adk/utils/templating_activities.py

@@ -0,0 +1,41 @@
+from enum import Enum
+from typing import Any
+
+from temporalio import activity
+
+from agentex.lib.core.services.adk.utils.templating import TemplatingService
+from agentex.lib.types.tracing import BaseModelWithTraceParams
+
+
+class JinjaActivityName(str, Enum):
+    RENDER_JINJA = "render-jinja"
+
+
+class RenderJinjaParams(BaseModelWithTraceParams):
+    """Parameters for the Jinja activity"""
+
+    template: str
+    variables: dict[str, Any]
+
+
+class TemplatingActivities:
+    def __init__(self, templating_service: TemplatingService):
+        self.templating_service = templating_service
+
+    @activity.defn(name=JinjaActivityName.RENDER_JINJA)
+    async def render_jinja(self, params: RenderJinjaParams) -> str:
+        """
+        Activity that renders a Jinja template with the provided data.
+
+        Args:
+            params: JinjaParams containing the data and template string
+
+        Returns:
+            The rendered template as a string
+        """
+        return await self.templating_service.render_jinja(
+            template=params.template,
+            variables=params.variables,
+            trace_id=params.trace_id,
+            parent_span_id=params.parent_span_id,
+        )

agentex/lib/core/temporal/services/temporal_task_service.py

@@ -0,0 +1,69 @@
+from agentex.lib.core.clients.temporal.temporal_client import TemporalClient
+from agentex.lib.core.clients.temporal.types import WorkflowState
+from agentex.lib.core.temporal.types.workflow import SignalName
+from agentex.lib.environment_variables import EnvironmentVariables
+from agentex.lib.types.acp import CreateTaskParams
+from agentex.lib.types.acp import SendEventParams
+from agentex.types.agent import Agent
+from agentex.types.event import Event
+from agentex.types.task import Task
+
+
+class TemporalTaskService:
+    """
+    Submits Agent agent_tasks to the async runtime for execution.
+    """
+
+    def __init__(
+        self,
+        temporal_client: TemporalClient,
+        env_vars: EnvironmentVariables,
+    ):
+        self._temporal_client = temporal_client
+        self._env_vars = env_vars
+
+    async def submit_task(self, agent: Agent, task: Task) -> str:
+        """
+        Submit a task to the async runtime for execution.
+
+        returns the workflow ID of the temporal workflow
+        """
+        return await self._temporal_client.start_workflow(
+            workflow=self._env_vars.WORKFLOW_NAME,
+            arg=CreateTaskParams(
+                agent=agent,
+                task=task,
+                params=None,
+            ),
+            id=task.id,
+            task_queue=self._env_vars.WORKFLOW_TASK_QUEUE,
+        )
+
+    async def get_state(self, task_id: str) -> WorkflowState:
+        """
+        Get the task state from the async runtime.
+        """
+        return await self._temporal_client.get_workflow_status(
+            workflow_id=task_id,
+        )
+
+    async def send_event(self, agent: Agent, task: Task, event: Event) -> None:
+        return await self._temporal_client.send_signal(
+            workflow_id=task.id,
+            signal=SignalName.RECEIVE_EVENT.value,
+            payload=SendEventParams(
+                agent=agent,
+                task=task,
+                event=event,
+            ).model_dump(),
+        )
+
+    async def cancel(self, task_id: str) -> None:
+        return await self._temporal_client.cancel_workflow(
+            workflow_id=task_id,
+        )
+
+    async def terminate(self, task_id: str) -> None:
+        return await self._temporal_client.terminate_workflow(
+            workflow_id=task_id,
+        )

agentex/lib/core/temporal/types/workflow.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+
+class SignalName(str, Enum):
+    RECEIVE_EVENT = "receive_event"