Remove wrapping function decorator (#948)

* Remove wrapping function decorator

* Linting

Author: tconley1428

temporalio/contrib/openai_agents/temporal_openai_agents.py

@@ -266,69 +266,3 @@ async def run_activity(ctx: RunContextWrapper[Any], input: str) -> Any:
             on_invoke_tool=run_activity,
             strict_json_schema=True,
         )
-
-    @classmethod
-    @overload
-    def tool(
-        cls,
-        *,
-        name_override: Union[str, None] = None,
-        description_override: Union[str, None] = None,
-        docstring_style: Union[DocstringStyle, None] = None,
-        use_docstring_info: bool = True,
-        failure_error_function: Union[
-            ToolErrorFunction, None
-        ] = default_tool_error_function,
-        strict_mode: bool = True,
-        is_enabled: Union[
-            bool, Callable[[RunContextWrapper[Any], Agent[Any]], MaybeAwaitable[bool]]
-        ] = True,
-    ) -> Callable[[ToolFunction[ToolParams]], FunctionTool]: ...
-
-    @classmethod
-    @overload
-    def tool(
-        cls,
-        func: ToolFunction[ToolParams],
-        *,
-        name_override: Union[str, None] = None,
-        description_override: Union[str, None] = None,
-        docstring_style: Union[DocstringStyle, None] = None,
-        use_docstring_info: bool = True,
-        failure_error_function: Union[
-            ToolErrorFunction, None
-        ] = default_tool_error_function,
-        strict_mode: bool = True,
-        is_enabled: Union[
-            bool, Callable[[RunContextWrapper[Any], Agent[Any]], MaybeAwaitable[bool]]
-        ] = True,
-    ) -> FunctionTool: ...
-
-    @classmethod
-    def tool(
-        cls,
-        func: Union[ToolFunction[ToolParams], None] = None,
-        *,
-        name_override: Union[str, None] = None,
-        description_override: Union[str, None] = None,
-        docstring_style: Union[DocstringStyle, None] = None,
-        use_docstring_info: bool = True,
-        failure_error_function: Union[
-            ToolErrorFunction, None
-        ] = default_tool_error_function,
-        strict_mode: bool = True,
-        is_enabled: Union[
-            bool, Callable[[RunContextWrapper[Any], Agent[Any]], MaybeAwaitable[bool]]
-        ] = True,
-    ) -> Union[FunctionTool, Callable[[ToolFunction[ToolParams]], FunctionTool]]:
-        """A temporal specific wrapper for OpenAI's @function_tool. This exists to ensure the user is aware that the function tool is workflow level code and must be deterministic."""
-        return function_tool(
-            func,  # type: ignore
-            name_override=name_override,
-            description_override=description_override,
-            docstring_style=docstring_style,
-            use_docstring_info=use_docstring_info,
-            failure_error_function=failure_error_function,
-            strict_mode=strict_mode,
-            is_enabled=is_enabled,
-        )

tests/contrib/openai_agents/test_openai.py

@@ -13,8 +13,6 @@
     InputGuardrailTripwireTriggered,
     ItemHelpers,
     MessageOutputItem,
-    Model,
-    ModelProvider,
     ModelResponse,
     ModelSettings,
     ModelTracing,
@@ -25,6 +23,7 @@
     Tool,
     TResponseInputItem,
     Usage,
+    function_tool,
     handoff,
     input_guardrail,
     output_guardrail,
@@ -779,7 +778,7 @@ class AirlineAgentContext(BaseModel):
     flight_number: Optional[str] = None
 
 
-@openai_agents.workflow.tool(
+@function_tool(
     name_override="faq_lookup_tool",
     description_override="Lookup frequently asked questions.",
 )
@@ -801,7 +800,7 @@ async def faq_lookup_tool(question: str) -> str:
     return "I'm sorry, I don't know the answer to that question."
 
 
-@openai_agents.workflow.tool
+@function_tool
 async def update_seat(
     context: RunContextWrapper[AirlineAgentContext],
     confirmation_number: str,
@@ -1503,3 +1502,83 @@ async def test_output_guardrail(client: Client, use_local_model: bool):
 
             if use_local_model:
                 assert not result
+
+
+class WorkflowToolModel(StaticTestModel):
+    responses = [
+        ModelResponse(
+            output=[
+                ResponseFunctionToolCall(
+                    arguments="{}",
+                    call_id="call",
+                    name="run_tool",
+                    type="function_call",
+                    id="id",
+                    status="completed",
+                )
+            ],
+            usage=Usage(),
+            response_id=None,
+        ),
+        ModelResponse(
+            output=[
+                ResponseOutputMessage(
+                    id="",
+                    content=[
+                        ResponseOutputText(
+                            text="",
+                            annotations=[],
+                            type="output_text",
+                        )
+                    ],
+                    role="assistant",
+                    status="completed",
+                    type="message",
+                )
+            ],
+            usage=Usage(),
+            response_id=None,
+        ),
+    ]
+
+
+@workflow.defn
+class WorkflowToolWorkflow:
+    @workflow.run
+    async def run(self) -> None:
+        agent: Agent = Agent(
+            name="Assistant",
+            instructions="You are a helpful assistant.",
+            tools=[function_tool(self.run_tool)],
+        )
+        await Runner.run(
+            agent,
+            "My phone number is 650-123-4567. Where do you think I live?",
+        )
+
+    async def run_tool(self):
+        print("Tool ran with self:", self)
+        workflow.logger.info("Tool ran with self: %s", self)
+        return None
+
+
+async def test_workflow_method_tools(client: Client):
+    new_config = client.config()
+    new_config["data_converter"] = pydantic_data_converter
+    client = Client(**new_config)
+
+    with set_open_ai_agent_temporal_overrides():
+        model_activity = ModelActivity(TestModelProvider(WorkflowToolModel()))
+        async with new_worker(
+            client,
+            WorkflowToolWorkflow,
+            activities=[model_activity.invoke_model_activity],
+            interceptors=[OpenAIAgentsTracingInterceptor()],
+        ) as worker:
+            workflow_handle = await client.start_workflow(
+                WorkflowToolWorkflow.run,
+                id=f"workflow-tool-{uuid.uuid4()}",
+                task_queue=worker.task_queue,
+                execution_timeout=timedelta(seconds=10),
+            )
+            await workflow_handle.result()