Skip to main content

​
Overview

The create_execution_context function creates a new execution context for AI operations, establishing a session for agent interactions.

​
Function Signature

pub async fn create_execution_context(
    request: CreateAiExecutionContextRequest
) -> Result<AiExecutionContext>

​
Parameters

​
request
CreateAiExecutionContextRequest
required
The execution context configuration including:
  • agent_id: ID of the AI agent to use (required)
  • workflow_id: ID of the workflow (optional)
  • user_id: ID of the user initiating the context (optional)
  • session_id: Unique session identifier (optional)
  • context: Custom context data as JSON (optional)

​
Return Value

Returns Result<AiExecutionContext> containing the created execution context details.

​
Basic Usage

use wacht::api::execution_context::*;
use wacht::models::CreateAiExecutionContextRequest;

let mut context_request = CreateAiExecutionContextRequest::new("agent_123".to_string());
context_request.session_id = Some("session_789".to_string());
context_request.context = Some(serde_json::json!({
    "source": "web_app",
    "version": "1.0.0"
}));

let context = create_execution_context(context_request).await?;
println!("Created execution context: {}", context.id.unwrap_or_default());
println!("Session: {}", context.session_id.unwrap_or_default());

​
Advanced Usage

use wacht::api::execution_context::*;
use wacht::models::CreateAiExecutionContextRequest;
use uuid::Uuid;

async fn start_ai_session(agent_id: &str, workflow_id: Option<&str>) -> Result<AiExecutionContext> {
    let session_id = Uuid::new_v4().to_string();

    let mut request = CreateAiExecutionContextRequest::new(agent_id.to_string());
    request.workflow_id = workflow_id.map(|w| w.to_string());
    request.session_id = Some(session_id.clone());
    request.context = Some(serde_json::json!({
        "platform": std::env::consts::OS,
        "timestamp": chrono::Utc::now().to_rfc3339(),
        "user_agent": "rust-sdk/1.0",
        "initial_state": "ready"
    }));

    let context = create_execution_context(request).await?;

    println!("AI session started");
    println!("Context ID: {}", context.id.unwrap_or_default());
    println!("Agent: {}", context.agent_id.unwrap_or_default());
    println!("Session: {}", context.session_id.unwrap_or_default());

    Ok(context)
}

// Create context with workflow
let context = start_ai_session("agent_123", Some("workflow_456")).await?;

​
Error Handling

match create_execution_context(request).await {
    Ok(context) => {
        println!("Successfully created execution context");
        println!("Context ID: {}", context.id.unwrap_or_default());
        println!("Ready for AI operations");
    }
    Err(Error::Api { status, message, .. }) => {
        match status.as_u16() {
            404 => println!("Agent not found: {}", message),
            403 => println!("Access denied: {}", message),
            400 => println!("Invalid request: {}", message),
            _ => println!("API error {}: {}", status, message),
        }
    }
    Err(e) => println!("Failed to create context: {}", e),
}

​
Important Notes

  • Execution contexts are required for agent interactions
  • Contexts maintain conversation state and history
  • Each context is tied to a specific agent and user
  • Contexts expire after a period of inactivity

​
Rate Limits

  • Create operations: 100 requests per minute per user
  • Burst limit: 10 requests per second