Merge branch 'main' of https://github.com/scalarian/openai-agents-rust

Author: chai1any

README.md

@@ -1,43 +1,10 @@
 # openai-agents-rust
 
-![CI](https://github.com/scalarian/openai-agents-rust/actions/workflows/ci.yml/badge.svg)
-[![License](https://img.shields.io/badge/license-Apache--2.0-4B5563.svg)](LICENSE)
+Rust-native agents runtime with a single ergonomic facade, async-first execution, OpenAI integrations, MCP, realtime sessions, voice workflows, and extension hooks.
 
-Rust-native agents runtime for OpenAI-style agent systems: typed agents, tools, sessions, MCP, realtime, voice, and extensions.
+![Runtime overview](docs/assets/runtime-overview.svg)
 
-This repository is for teams that want native Rust building blocks for agent workflows without wrapping another SDK and without giving up typed runtime control.
-
-## Why This Project
-
-- async-first runtime with a small facade and lower-level primitives
-- one-shot, session-backed, and streamed execution paths
-- OpenAI Responses and Chat Completions integrations
-- MCP tools and resources
-- realtime sessions and voice workflows
-- extensions for transports, adapters, and optional backends
-
-## Quick Start
-
-```toml
-[dependencies]
-openai-agents = { package = "openai-agents-rs", version = "0.1.2" }
-tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
-```
-
-```rust
-use openai_agents::{run, Agent};
-
-#[tokio::main]
-async fn main() -> Result<(), openai_agents::AgentsError> {
-    let agent = Agent::builder("assistant")
-        .instructions("Be concise, practical, and structured.")
-        .build();
-
-    let result = run(&agent, "Give me three production readiness checks.").await?;
-    println!("{}", result.final_output.unwrap_or_default());
-    Ok(())
-}
-```
+This repository is for teams that want to build agent systems in Rust without wrapping another SDK and without giving up typed runtime building blocks.
 
 ## Start Here
 
@@ -151,7 +118,4 @@ The project is pre-1.0. The runtime is already broad, but APIs may still tighten
 
 ## License
 
-Apache-2.0. See [LICENSE](LICENSE).
-
-> [!WARNING]
-> This project is not an official OpenAI product. It is not affiliated with, endorsed by, or maintained by OpenAI.
+MIT. See [LICENSE](LICENSE).

crates/agents-core/src/agent.rs

@@ -514,6 +514,7 @@ impl Agent {
                 }
                 let resolved_max_turns = nested_run_config.max_turns;
                 let mut nested_context = tool_context.run_context.clone();
+                nested_context.approvals.clear();
                 if should_capture_tool_input {
                     nested_context.tool_input = Some(params_value.clone());
                 } else {
@@ -757,7 +758,7 @@ mod tests {
     use crate::agent_tool_state::{
         drop_agent_tool_run_result, peek_agent_tool_run_result, set_agent_tool_state_scope,
     };
-    use crate::run_context::RunContext;
+    use crate::run_context::{ApprovalRecord, RunContext};
     use crate::tool::Tool;
     use crate::tool::function_tool;
 
@@ -829,6 +830,13 @@ mod tests {
             .expect("agent tool should build");
         let mut run_context = RunContextWrapper::new(RunContext::default());
         set_agent_tool_state_scope(&mut run_context, Some("scope-a".to_owned()));
+        run_context.approvals.insert(
+            "call-123".to_owned(),
+            ApprovalRecord {
+                approved: true,
+                reason: Some("approved in parent".to_owned()),
+            },
+        );
         run_context.tool_input = Some(json!({"stale": true}));
 
         let output = tool
@@ -853,6 +861,7 @@ mod tests {
             stored.context_snapshot.agent_tool_state_scope.as_deref(),
             Some("scope-a")
         );
+        assert!(stored.context_snapshot.approvals.is_empty());
         assert!(stored.context_snapshot.tool_input.is_none());
 
         drop_agent_tool_run_result("call-123", Some("scope-a".to_owned()));

crates/agents-core/src/internal/tool_execution.rs

@@ -108,6 +108,30 @@ pub(crate) async fn execute_local_function_tools(
                     });
                     break;
                 }
+                Some(approval)
+                    if approval.tool_name.as_deref() != Some(tool_call.name.as_str()) =>
+                {
+                    provider.finish_span(&mut span, true);
+                    if let Some(recorder) = stream_recorder {
+                        recorder
+                            .push_lifecycle(
+                                "tool_approval_required",
+                                Some(serde_json::json!({
+                                    "tool_name": tool_call.name.clone(),
+                                    "call_id": tool_call.id.clone(),
+                                    "namespace": tool_call.namespace.clone(),
+                                })),
+                            )
+                            .await;
+                    }
+                    interruptions.push(RunInterruption {
+                        kind: Some(RunInterruptionKind::ToolApproval),
+                        call_id: Some(tool_call.id.clone()),
+                        tool_name: Some(tool_call.name.clone()),
+                        reason: Some("tool approval required".to_owned()),
+                    });
+                    break;
+                }
                 Some(approval) if !approval.approved => {
                     append_approval_error_output(
                         &mut new_items,

crates/agents-core/src/run.rs

@@ -1080,6 +1080,15 @@ impl Runner {
         let approval = state.approval(&call_id).cloned().ok_or_else(|| UserError {
             message: format!("approval decision for `{call_id}` is missing"),
         })?;
+        if approval.tool_name.as_deref() != Some(tool_call.name.as_str()) {
+            return Err(UserError {
+                message: format!(
+                    "approval decision for `{call_id}` is not bound to tool `{}`",
+                    tool_call.name
+                ),
+            }
+            .into());
+        }
 
         let context = state.restore_context::<crate::run_context::RunContext>()?;
         let tool_outcome = internal_tool_execution::execute_local_function_tools(
@@ -2638,7 +2647,11 @@ mod tests {
             .durable_state()
             .cloned()
             .expect("state should exist");
-        state.approve("call-1", Some("approved".to_owned()));
+        state.approve_for_tool(
+            "call-1",
+            Some("search".to_owned()),
+            Some("approved".to_owned()),
+        );
 
         let resumed = Runner::new()
             .with_model_provider(provider)
@@ -2659,6 +2672,44 @@ mod tests {
         }));
     }
 
+    #[tokio::test]
+    async fn runner_rejects_unbound_tool_approval_on_resume() {
+        let provider = Arc::new(FakeProvider {
+            model: Arc::new(FakeModel::default()),
+        });
+        let search_tool = function_tool(
+            "search",
+            "Search documents",
+            |_ctx, args: SearchArgs| async move {
+                Ok::<_, AgentsError>(format!("result:{}", args.query))
+            },
+        )
+        .expect("function tool should build")
+        .with_needs_approval(true);
+        let agent = Agent::builder("assistant")
+            .function_tool(search_tool)
+            .build();
+
+        let initial = Runner::new()
+            .with_model_provider(provider.clone())
+            .run(&agent, "hello")
+            .await
+            .expect("initial run should succeed");
+
+        let mut state = initial
+            .durable_state()
+            .cloned()
+            .expect("state should exist");
+        state.approve("call-1", Some("approved".to_owned()));
+
+        let resumed = Runner::new()
+            .with_model_provider(provider)
+            .resume_with_agent(&state, &agent)
+            .await;
+
+        assert!(matches!(resumed, Err(AgentsError::User(_))));
+    }
+
     #[tokio::test]
     async fn runner_follows_runtime_handoffs() {
         let provider = Arc::new(FakeHandoffProvider {

crates/agents-core/src/run_context.rs

@@ -19,6 +19,7 @@ pub struct RunContext {
 pub struct ApprovalRecord {
     pub approved: bool,
     pub reason: Option<String>,
+    pub tool_name: Option<String>,
 }
 
 /// Runtime context wrapper shared across callbacks.

crates/agents-core/src/run_state.rs

@@ -210,21 +210,41 @@ impl RunState {
     }
 
     pub fn approve(&mut self, id: impl Into<String>, reason: Option<String>) {
+        self.approve_for_tool(id, None, reason);
+    }
+
+    pub fn approve_for_tool(
+        &mut self,
+        id: impl Into<String>,
+        tool_name: Option<String>,
+        reason: Option<String>,
+    ) {
         self.context_snapshot.approvals.insert(
             id.into(),
             ApprovalRecord {
                 approved: true,
                 reason,
+                tool_name,
             },
         );
     }
 
     pub fn reject(&mut self, id: impl Into<String>, reason: Option<String>) {
+        self.reject_for_tool(id, None, reason);
+    }
+
+    pub fn reject_for_tool(
+        &mut self,
+        id: impl Into<String>,
+        tool_name: Option<String>,
+        reason: Option<String>,
+    ) {
         self.context_snapshot.approvals.insert(
             id.into(),
             ApprovalRecord {
                 approved: false,
                 reason,
+                tool_name,
             },
         );
     }