Skip to content

Commit 1ab0763

Browse files
AlexMikhalevAlexMikhalev
committed
Fix #1497: replace unsafe ptr::read with arc_memory_only() in multi_agent examples (#1502)
1 parent 0ed88a8 commit 1ab0763

6 files changed

Lines changed: 36 additions & 212 deletions

File tree

‎crates/terraphim_multi_agent/examples/agent_workflow_patterns.rs‎

Lines changed: 5 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -29,17 +29,10 @@ async fn demonstrate_prompt_chaining() -> MultiAgentResult<()> {
2929
println!("Sequential software development workflow with 6 steps");
3030

3131
// Initialize storage
32-
DeviceStorage::init_memory_only()
33-
.await
34-
.map_err(|e| MultiAgentError::PersistenceError(e.to_string()))?;
35-
let storage_ref = DeviceStorage::instance()
32+
let persistence = DeviceStorage::arc_memory_only()
3633
.await
3734
.map_err(|e| MultiAgentError::PersistenceError(e.to_string()))?;
3835

39-
use std::ptr;
40-
let storage_copy = unsafe { ptr::read(storage_ref) };
41-
let persistence = Arc::new(storage_copy);
42-
4336
// Create a software development role
4437
let dev_role = create_software_development_role();
4538
let dev_agent = TerraphimAgent::new(dev_role, persistence.clone(), None).await?;
@@ -125,17 +118,10 @@ async fn demonstrate_routing() -> MultiAgentResult<()> {
125118
println!("Smart task distribution with model selection");
126119

127120
// Initialize storage
128-
DeviceStorage::init_memory_only()
129-
.await
130-
.map_err(|e| MultiAgentError::PersistenceError(e.to_string()))?;
131-
let storage_ref = DeviceStorage::instance()
121+
let persistence = DeviceStorage::arc_memory_only()
132122
.await
133123
.map_err(|e| MultiAgentError::PersistenceError(e.to_string()))?;
134124

135-
use std::ptr;
136-
let storage_copy = unsafe { ptr::read(storage_ref) };
137-
let persistence = Arc::new(storage_copy);
138-
139125
// Create different agent roles for different complexity levels
140126
// Simple tasks agent (fast, low cost)
141127
let simple_role = create_simple_task_role();
@@ -213,17 +199,10 @@ async fn demonstrate_parallelization() -> MultiAgentResult<()> {
213199
println!("Multi-perspective analysis with parallel execution");
214200

215201
// Initialize storage
216-
DeviceStorage::init_memory_only()
217-
.await
218-
.map_err(|e| MultiAgentError::PersistenceError(e.to_string()))?;
219-
let storage_ref = DeviceStorage::instance()
202+
let persistence = DeviceStorage::arc_memory_only()
220203
.await
221204
.map_err(|e| MultiAgentError::PersistenceError(e.to_string()))?;
222205

223-
use std::ptr;
224-
let storage_copy = unsafe { ptr::read(storage_ref) };
225-
let persistence = Arc::new(storage_copy);
226-
227206
// Create 6 different perspective agents
228207
let perspectives = vec![
229208
("analytical", "Provide analytical, data-driven insights"),
@@ -342,17 +321,10 @@ async fn demonstrate_orchestrator_workers() -> MultiAgentResult<()> {
342321
println!("Hierarchical data science pipeline with specialized workers");
343322

344323
// Initialize storage
345-
DeviceStorage::init_memory_only()
346-
.await
347-
.map_err(|e| MultiAgentError::PersistenceError(e.to_string()))?;
348-
let storage_ref = DeviceStorage::instance()
324+
let persistence = DeviceStorage::arc_memory_only()
349325
.await
350326
.map_err(|e| MultiAgentError::PersistenceError(e.to_string()))?;
351327

352-
use std::ptr;
353-
let storage_copy = unsafe { ptr::read(storage_ref) };
354-
let persistence = Arc::new(storage_copy);
355-
356328
// Create orchestrator agent
357329
let orchestrator_role = create_orchestrator_role();
358330
let orchestrator = TerraphimAgent::new(orchestrator_role, persistence.clone(), None).await?;
@@ -542,16 +514,9 @@ async fn demonstrate_evaluator_optimizer() -> MultiAgentResult<()> {
542514
println!("Iterative content improvement with quality evaluation");
543515

544516
// Initialize storage
545-
DeviceStorage::init_memory_only()
517+
let persistence = DeviceStorage::arc_memory_only()
546518
.await
547519
.map_err(|e| MultiAgentError::PersistenceError(e.to_string()))?;
548-
let storage_ref = DeviceStorage::instance()
549-
.await
550-
.map_err(|e| MultiAgentError::PersistenceError(e.to_string()))?;
551-
552-
use std::ptr;
553-
let storage_copy = unsafe { ptr::read(storage_ref) };
554-
let persistence = Arc::new(storage_copy);
555520

556521
// Create content generator agent
557522
let generator_role = create_content_generator_role();

‎crates/terraphim_multi_agent/examples/enhanced_atomic_server_example.rs‎

Lines changed: 12 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,6 @@
55
//! configurations to intelligent autonomous agents.
66
77
use ahash::AHashMap;
8-
use std::sync::Arc;
98
use terraphim_config::{ConfigBuilder, Haystack, Role, ServiceType};
109
use terraphim_multi_agent::{
1110
CommandInput, CommandType, MultiAgentError, MultiAgentResult, TerraphimAgent,
@@ -32,12 +31,14 @@ fn create_atomic_server_agent_role() -> Role {
3231
llm_context_window: Some(16000),
3332
llm_router_enabled: false,
3433
llm_router_config: None,
35-
haystacks: vec![Haystack::new(
36-
"http://localhost:9883".to_string(), // Atomic server URL
37-
ServiceType::Atomic,
38-
true, // read-only
39-
)
40-
.with_atomic_secret(Some("your-base64-secret-here".to_string()))],
34+
haystacks: vec![
35+
Haystack::new(
36+
"http://localhost:9883".to_string(), // Atomic server URL
37+
ServiceType::Atomic,
38+
true, // read-only
39+
)
40+
.with_atomic_secret(Some("your-base64-secret-here".to_string())),
41+
],
4142
extra: {
4243
let mut extra = AHashMap::new();
4344
// Multi-agent specific configuration
@@ -98,18 +99,10 @@ async fn demonstrate_config_evolution() -> MultiAgentResult<()> {
9899
println!("\n2️⃣ Step 2: Multi-Agent System Evolution");
99100

100101
// Initialize storage
101-
DeviceStorage::init_memory_only()
102+
let persistence = DeviceStorage::arc_memory_only()
102103
.await
103104
.map_err(|e| MultiAgentError::PersistenceError(e.to_string()))?;
104105

105-
let storage_ref = DeviceStorage::instance()
106-
.await
107-
.map_err(|e| MultiAgentError::PersistenceError(e.to_string()))?;
108-
109-
use std::ptr;
110-
let storage_copy = unsafe { ptr::read(storage_ref) };
111-
let persistence = Arc::new(storage_copy);
112-
113106
// Transform role into intelligent agent
114107
let role = create_atomic_server_agent_role();
115108
let agent = TerraphimAgent::new(role, persistence, None).await?;
@@ -130,18 +123,10 @@ async fn demonstrate_intelligent_queries() -> MultiAgentResult<()> {
130123
println!("==================================");
131124

132125
// Initialize agent
133-
DeviceStorage::init_memory_only()
126+
let persistence = DeviceStorage::arc_memory_only()
134127
.await
135128
.map_err(|e| MultiAgentError::PersistenceError(e.to_string()))?;
136129

137-
let storage_ref = DeviceStorage::instance()
138-
.await
139-
.map_err(|e| MultiAgentError::PersistenceError(e.to_string()))?;
140-
141-
use std::ptr;
142-
let storage_copy = unsafe { ptr::read(storage_ref) };
143-
let persistence = Arc::new(storage_copy);
144-
145130
let role = create_atomic_server_agent_role();
146131
let agent = TerraphimAgent::new(role, persistence, None).await?;
147132
agent.initialize().await?;
@@ -195,18 +180,10 @@ async fn demonstrate_context_integration() -> MultiAgentResult<()> {
195180
println!("===================================");
196181

197182
// Initialize agent
198-
DeviceStorage::init_memory_only()
183+
let persistence = DeviceStorage::arc_memory_only()
199184
.await
200185
.map_err(|e| MultiAgentError::PersistenceError(e.to_string()))?;
201186

202-
let storage_ref = DeviceStorage::instance()
203-
.await
204-
.map_err(|e| MultiAgentError::PersistenceError(e.to_string()))?;
205-
206-
use std::ptr;
207-
let storage_copy = unsafe { ptr::read(storage_ref) };
208-
let persistence = Arc::new(storage_copy);
209-
210187
let role = create_atomic_server_agent_role();
211188
let agent = TerraphimAgent::new(role, persistence, None).await?;
212189
agent.initialize().await?;
@@ -263,18 +240,10 @@ async fn demonstrate_evolution_comparison() -> MultiAgentResult<()> {
263240
println!(" • Cost and performance tracking");
264241

265242
// Initialize intelligent agent
266-
DeviceStorage::init_memory_only()
243+
let persistence = DeviceStorage::arc_memory_only()
267244
.await
268245
.map_err(|e| MultiAgentError::PersistenceError(e.to_string()))?;
269246

270-
let storage_ref = DeviceStorage::instance()
271-
.await
272-
.map_err(|e| MultiAgentError::PersistenceError(e.to_string()))?;
273-
274-
use std::ptr;
275-
let storage_copy = unsafe { ptr::read(storage_ref) };
276-
let persistence = Arc::new(storage_copy);
277-
278247
let role = create_atomic_server_agent_role();
279248
let agent = TerraphimAgent::new(role, persistence, None).await?;
280249
agent.initialize().await?;

‎crates/terraphim_multi_agent/examples/knowledge_graph_integration.rs‎

Lines changed: 6 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -6,10 +6,9 @@
66
//! - Query-specific context injection
77
//! - Multi-layered context assembly
88
9-
use std::sync::Arc;
109
use terraphim_config::Role;
1110
use terraphim_multi_agent::{
12-
test_utils::create_test_role, CommandInput, CommandType, MultiAgentResult, TerraphimAgent,
11+
CommandInput, CommandType, MultiAgentResult, TerraphimAgent, test_utils::create_test_role,
1312
};
1413
use terraphim_persistence::DeviceStorage;
1514

@@ -48,17 +47,10 @@ async fn example_context_enrichment() -> MultiAgentResult<()> {
4847
println!("===============================================");
4948

5049
// Initialize storage
51-
DeviceStorage::init_memory_only()
52-
.await
53-
.map_err(|e| terraphim_multi_agent::MultiAgentError::PersistenceError(e.to_string()))?;
54-
let storage = DeviceStorage::instance()
50+
let persistence = DeviceStorage::arc_memory_only()
5551
.await
5652
.map_err(|e| terraphim_multi_agent::MultiAgentError::PersistenceError(e.to_string()))?;
5753

58-
use std::ptr;
59-
let storage_copy = unsafe { ptr::read(storage) };
60-
let persistence = Arc::new(storage_copy);
61-
6254
// Create knowledge graph enabled agent
6355
let role = create_knowledge_graph_role();
6456
let agent = TerraphimAgent::new(role, persistence, None).await?;
@@ -101,17 +93,10 @@ async fn example_semantic_relationships() -> MultiAgentResult<()> {
10193
println!("===============================================");
10294

10395
// Initialize storage and agent
104-
DeviceStorage::init_memory_only()
105-
.await
106-
.map_err(|e| terraphim_multi_agent::MultiAgentError::PersistenceError(e.to_string()))?;
107-
let storage = DeviceStorage::instance()
96+
let persistence = DeviceStorage::arc_memory_only()
10897
.await
10998
.map_err(|e| terraphim_multi_agent::MultiAgentError::PersistenceError(e.to_string()))?;
11099

111-
use std::ptr;
112-
let storage_copy = unsafe { ptr::read(storage) };
113-
let persistence = Arc::new(storage_copy);
114-
115100
let role = create_knowledge_graph_role();
116101
let agent = TerraphimAgent::new(role, persistence, None).await?;
117102
agent.initialize().await?;
@@ -154,17 +139,10 @@ async fn example_multilayer_context() -> MultiAgentResult<()> {
154139
println!("==============================================");
155140

156141
// Initialize storage and agent
157-
DeviceStorage::init_memory_only()
158-
.await
159-
.map_err(|e| terraphim_multi_agent::MultiAgentError::PersistenceError(e.to_string()))?;
160-
let storage = DeviceStorage::instance()
142+
let persistence = DeviceStorage::arc_memory_only()
161143
.await
162144
.map_err(|e| terraphim_multi_agent::MultiAgentError::PersistenceError(e.to_string()))?;
163145

164-
use std::ptr;
165-
let storage_copy = unsafe { ptr::read(storage) };
166-
let persistence = Arc::new(storage_copy);
167-
168146
let mut role = create_knowledge_graph_role();
169147

170148
// Add haystack configuration to demonstrate multi-layered context
@@ -235,17 +213,10 @@ async fn example_context_aware_commands() -> MultiAgentResult<()> {
235213
println!("===============================================");
236214

237215
// Initialize storage and agent
238-
DeviceStorage::init_memory_only()
239-
.await
240-
.map_err(|e| terraphim_multi_agent::MultiAgentError::PersistenceError(e.to_string()))?;
241-
let storage = DeviceStorage::instance()
216+
let persistence = DeviceStorage::arc_memory_only()
242217
.await
243218
.map_err(|e| terraphim_multi_agent::MultiAgentError::PersistenceError(e.to_string()))?;
244219

245-
use std::ptr;
246-
let storage_copy = unsafe { ptr::read(storage) };
247-
let persistence = Arc::new(storage_copy);
248-
249220
let role = create_knowledge_graph_role();
250221
let agent = TerraphimAgent::new(role, persistence, None).await?;
251222
agent.initialize().await?;
@@ -296,16 +267,9 @@ async fn example_performance_analysis() -> MultiAgentResult<()> {
296267
println!("=================================================");
297268

298269
// Initialize storage and agent
299-
DeviceStorage::init_memory_only()
270+
let persistence = DeviceStorage::arc_memory_only()
300271
.await
301272
.map_err(|e| terraphim_multi_agent::MultiAgentError::PersistenceError(e.to_string()))?;
302-
let storage = DeviceStorage::instance()
303-
.await
304-
.map_err(|e| terraphim_multi_agent::MultiAgentError::PersistenceError(e.to_string()))?;
305-
306-
use std::ptr;
307-
let storage_copy = unsafe { ptr::read(storage) };
308-
let persistence = Arc::new(storage_copy);
309273

310274
let role = create_knowledge_graph_role();
311275
let agent = TerraphimAgent::new(role, persistence, None).await?;

‎crates/terraphim_multi_agent/examples/multi_agent_coordination.rs‎

Lines changed: 5 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@ use ahash::AHashMap;
1010
use std::sync::Arc;
1111
use terraphim_config::Role;
1212
use terraphim_multi_agent::{
13-
test_utils::create_test_role, CommandInput, CommandType, MultiAgentResult, TerraphimAgent,
13+
CommandInput, CommandType, MultiAgentResult, TerraphimAgent, test_utils::create_test_role,
1414
};
1515
use terraphim_persistence::DeviceStorage;
1616
use terraphim_types::RelevanceFunction;
@@ -156,16 +156,9 @@ async fn example_agent_registry() -> MultiAgentResult<()> {
156156
println!("==========================================");
157157

158158
// Initialize storage
159-
DeviceStorage::init_memory_only()
159+
let persistence = DeviceStorage::arc_memory_only()
160160
.await
161161
.map_err(|e| terraphim_multi_agent::MultiAgentError::PersistenceError(e.to_string()))?;
162-
let storage = DeviceStorage::instance()
163-
.await
164-
.map_err(|e| terraphim_multi_agent::MultiAgentError::PersistenceError(e.to_string()))?;
165-
166-
use std::ptr;
167-
let storage_copy = unsafe { ptr::read(storage) };
168-
let persistence = Arc::new(storage_copy);
169162

170163
// Create registry
171164
// TODO: Migrate to KnowledgeGraphAgentRegistry
@@ -201,16 +194,9 @@ async fn example_coordinated_execution() -> MultiAgentResult<()> {
201194
println!("=====================================================");
202195

203196
// Initialize storage
204-
DeviceStorage::init_memory_only()
197+
let persistence = DeviceStorage::arc_memory_only()
205198
.await
206199
.map_err(|e| terraphim_multi_agent::MultiAgentError::PersistenceError(e.to_string()))?;
207-
let storage = DeviceStorage::instance()
208-
.await
209-
.map_err(|e| terraphim_multi_agent::MultiAgentError::PersistenceError(e.to_string()))?;
210-
211-
use std::ptr;
212-
let storage_copy = unsafe { ptr::read(storage) };
213-
let persistence = Arc::new(storage_copy);
214200

215201
// Create specialized agents (registry temporarily disabled during migration)
216202
let roles = create_specialized_roles();
@@ -288,16 +274,9 @@ async fn example_parallel_processing() -> MultiAgentResult<()> {
288274
println!("=======================================");
289275

290276
// Initialize storage
291-
DeviceStorage::init_memory_only()
277+
let persistence = DeviceStorage::arc_memory_only()
292278
.await
293279
.map_err(|e| terraphim_multi_agent::MultiAgentError::PersistenceError(e.to_string()))?;
294-
let storage = DeviceStorage::instance()
295-
.await
296-
.map_err(|e| terraphim_multi_agent::MultiAgentError::PersistenceError(e.to_string()))?;
297-
298-
use std::ptr;
299-
let storage_copy = unsafe { ptr::read(storage) };
300-
let persistence = Arc::new(storage_copy);
301280

302281
// Create multiple instances of the same agent for parallel processing
303282
let mut agents = Vec::new();
@@ -360,16 +339,9 @@ async fn example_performance_comparison() -> MultiAgentResult<()> {
360339
println!("==========================================");
361340

362341
// Initialize storage
363-
DeviceStorage::init_memory_only()
342+
let persistence = DeviceStorage::arc_memory_only()
364343
.await
365344
.map_err(|e| terraphim_multi_agent::MultiAgentError::PersistenceError(e.to_string()))?;
366-
let storage = DeviceStorage::instance()
367-
.await
368-
.map_err(|e| terraphim_multi_agent::MultiAgentError::PersistenceError(e.to_string()))?;
369-
370-
use std::ptr;
371-
let storage_copy = unsafe { ptr::read(storage) };
372-
let persistence = Arc::new(storage_copy);
373345

374346
// Create agents with different configurations
375347
let roles = create_specialized_roles();

0 commit comments

Comments
 (0)