let result = session.tool("task", serde_json::json!({
    "agent": "explore",
    "description": "Find auth handlers",
    "prompt": "Search for files that handle user authentication and list them with line numbers."
})).await?;

println!("{}", result.output);

const result = await session.tool('task', {
  agent: 'explore',
  description: 'Find auth handlers',
  prompt: 'Search for files that handle user authentication and list them with line numbers.',
});

console.log(result.output);

result = session.tool("task", {
    "agent": "explore",
    "description": "Find auth handlers",
    "prompt": "Search for files that handle user authentication and list them with line numbers.",
})

print(result.output)

let result = session.tool("parallel_task", serde_json::json!({
    "tasks": [
        {
            "agent": "explore",
            "description": "Find API routes",
            "prompt": "List all API route definitions with their HTTP methods."
        },
        {
            "agent": "explore",
            "description": "Find DB models",
            "prompt": "List all database model definitions with their fields."
        },
        {
            "agent": "security-reviewer",
            "description": "Review auth module",
            "prompt": "Check src/auth/ for security vulnerabilities."
        }
    ]
})).await?;

println!("{}", result.output);
// Each task's result is included with its agent name and success status

const result = await session.tool('parallel_task', {
  tasks: [
    {
      agent: 'explore',
      description: 'Find API routes',
      prompt: 'List all API route definitions with their HTTP methods.',
    },
    {
      agent: 'explore',
      description: 'Find DB models',
      prompt: 'List all database model definitions with their fields.',
    },
    {
      agent: 'security-reviewer',
      description: 'Review auth module',
      prompt: 'Check src/auth/ for security vulnerabilities.',
    },
  ],
});

console.log(result.output);

result = session.tool("parallel_task", {
    "tasks": [
        {
            "agent": "explore",
            "description": "Find API routes",
            "prompt": "List all API route definitions with their HTTP methods.",
        },
        {
            "agent": "explore",
            "description": "Find DB models",
            "prompt": "List all database model definitions with their fields.",
        },
        {
            "agent": "security-reviewer",
            "description": "Review auth module",
            "prompt": "Check src/auth/ for security vulnerabilities.",
        },
    ],
})

print(result.output)

use a3s_code_core::Agent;
use tokio::task::JoinSet;

let agent = Agent::new("agent.hcl").await?;

let workspaces = vec![
    "/repos/service-auth",
    "/repos/service-billing",
    "/repos/service-gateway",
];

// Spawn one session per workspace, all running concurrently
let mut join_set = JoinSet::new();
for workspace in workspaces {
    let agent = agent.clone();
    join_set.spawn(async move {
        let session = agent.session(workspace, None)?;
        let result = session.send("Find all TODO comments and summarize them").await?;
        Ok::<_, a3s_code_core::CodeError>((workspace.to_string(), result.text))
    });
}

// Collect results as they complete
while let Some(result) = join_set.join_next().await {
    match result? {
        Ok((workspace, text)) => println!("=== {workspace} ===\n{text}\n"),
        Err(e) => eprintln!("Error: {e}"),
    }
}

const { Agent } = require('@a3s-lab/code');

const agent = await Agent.create('agent.hcl');

const workspaces = [
  '/repos/service-auth',
  '/repos/service-billing',
  '/repos/service-gateway',
];

// Run all sessions concurrently with Promise.all
const results = await Promise.all(
  workspaces.map(async (workspace) => {
    const session = agent.session(workspace);
    const result = await session.send('Find all TODO comments and summarize them');
    return { workspace, text: result.text };
  })
);

for (const { workspace, text } of results) {
  console.log(`=== ${workspace} ===\n${text}\n`);
}

import asyncio
from a3s_code import Agent

agent = Agent.create("agent.hcl")

workspaces = [
    "/repos/service-auth",
    "/repos/service-billing",
    "/repos/service-gateway",
]

async def analyze(workspace: str) -> tuple[str, str]:
    session = agent.session(workspace)
    result = session.send("Find all TODO comments and summarize them")
    return workspace, result.text

# Run all sessions concurrently
results = asyncio.run(asyncio.gather(*[analyze(ws) for ws in workspaces]))

for workspace, text in results:
    print(f"=== {workspace} ===\n{text}\n")