Struct CopilotSession 

pub struct CopilotSession { /* private fields */ }

Represents a single conversation session with the Copilot CLI.

A session maintains conversation state, handles events, and manages tool execution.

Examples

let client = CopilotClient::new(CopilotClientOptions::default());
let session = client.create_session(SessionConfig::default()).await?;

// Subscribe to events
let sub = session.on(|event| {
    if event.is_assistant_message() {
        if let Some(content) = event.assistant_message_content() {
            println!("Assistant: {}", content);
        }
    }
}).await;

// Send a message and wait for completion
let response = session.send_and_wait(
    MessageOptions { prompt: "Hello!".into(), attachments: None, mode: None },
    None,
).await?;

// Clean up
session.destroy().await?;

Implementations

impl CopilotSession

pub fn session_id(&self) -> &str

Returns the session ID.

pub fn workspace_path(&self) -> Option<&str>

Returns the workspace path (when infinite sessions are enabled).

pub async fn send( &self, options: MessageOptions, ) -> Result<String, CopilotError>

Sends a message to this session.

The message is processed asynchronously. Subscribe to events via on() to receive streaming responses and other session events.

Returns the message ID.

pub async fn send_and_wait( &self, options: MessageOptions, timeout: Option<u64>, ) -> Result<Option<SessionEvent>, CopilotError>

Sends a message and waits until the session becomes idle.

This combines send() with waiting for the session.idle event. Returns the last assistant.message event received, or None.

Arguments

• options - The message options
• timeout - Optional timeout in milliseconds (defaults to 60000)

pub async fn on<F>(&self, handler: F) -> Subscription

where F: Fn(SessionEvent) + Send + Sync + 'static,

Subscribes to all events from this session.

Returns a Subscription that unsubscribes when dropped or when unsubscribe() is called.

pub async fn on_event<F>(&self, event_type: &str, handler: F) -> Subscription

where F: Fn(SessionEvent) + Send + Sync + 'static,

Subscribes to a specific event type from this session.

Arguments

• event_type - The event type string (e.g., “assistant.message”, “session.idle”)
• handler - The callback function

pub async fn register_tool(&self, name: &str, handler: ToolHandler)

Registers a tool handler.

pub async fn register_tools(&self, tools: Vec<(String, ToolHandler)>)

Registers multiple tool handlers.

pub async fn register_permission_handler(&self, handler: PermissionHandlerFn)

Registers a permission request handler.

pub async fn register_user_input_handler(&self, handler: UserInputHandlerFn)

Registers a user input request handler.

pub async fn register_hooks_handler(&self, handler: HooksHandlerFn)

Registers a hooks handler for all hook types.

pub async fn get_messages(&self) -> Result<Vec<SessionEvent>, CopilotError>

Retrieves all events and messages from this session’s history.

pub async fn destroy(&self) -> Result<(), CopilotError>

Destroys this session and releases all associated resources.

After calling this method, the session can no longer be used.

pub async fn abort(&self) -> Result<(), CopilotError>

Aborts the currently processing message in this session.