#![forbid(unsafe_code)]
#![warn(missing_docs)]
#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
pub mod agent;
pub mod background;
pub mod code_mode;
pub mod compaction;
pub mod fs_events;
pub mod hooks;
pub mod mcp;
pub mod middleware;
pub mod pool;
#[cfg(unix)]
mod process_tree;
pub mod protocol;
pub mod replay;
pub mod session;
pub use agent::{Agent, AgentError, AgentEvent, AgentStream, TurnError, TurnResult};
pub use hooks::HookRegistry;
pub use mcp::{SdkMcpServer, SdkTool, ToolContent, ToolContext, ToolResult};
#[cfg(feature = "macros")]
pub use claude_code_agent_macros::claude_tool;
pub use pool::{Checkout, PoolConfig, PooledSession, SessionPool};
pub use protocol::{
Initialize, UserMessage, ContentBlock, Priority,
Autocompact, Effort, PermissionMode, PermissionPrompts, Thinking, ThinkingDisplay,
InboundMessage, SystemMessage, AssistantMessage, ResultMessage, UsageSummary,
BackgroundTask, TurnErrorKind,
ToolDecision, HookOutput, HookDecision, ControlRequest, ControlRequestBody,
ControlResponse, CanUseToolRequest, ElicitationRequest, ElicitationResponse, UserDialogBehavior, UserDialogRequest, UserDialogResponse,
HookEventKind, HookEventPayload, HookCallbackRequest,
ToolDef, ToolAnnotations, McpManifest,
BackgroundTasksRequest,
};
pub use session::{
CanUseTool, McpCall, OnElicitation, OnStderr, OnUserDialog, ReloadPlugins, Session, SessionError,
SessionOptions, WeakSession,
};
#[doc(hidden)]
pub mod __private {
pub use serde_json;
pub mod ret {
use crate::ToolResult;
use serde::Serialize;
use std::fmt::Display;
pub struct ResultTag;
pub struct PlainTag;
pub struct ToolResultTag;
pub struct UnitTag;
pub struct SerializeTag;
pub trait ResultKind {
#[inline]
fn __claude_tool_unwrap_kind(&self) -> ResultTag {
ResultTag
}
}
impl<T, E> ResultKind for Result<T, E> {}
pub trait PlainKind {
#[inline]
fn __claude_tool_unwrap_kind(&self) -> PlainTag {
PlainTag
}
}
impl<T: ?Sized> PlainKind for &T {}
pub trait ToolResultKind {
#[inline]
fn __claude_tool_kind(&self) -> ToolResultTag {
ToolResultTag
}
}
impl ToolResultKind for ToolResult {}
pub trait UnitKind {
#[inline]
fn __claude_tool_kind(&self) -> UnitTag {
UnitTag
}
}
impl UnitKind for () {}
pub trait SerializeKind {
#[inline]
fn __claude_tool_kind(&self) -> SerializeTag {
SerializeTag
}
}
impl<T: ?Sized> SerializeKind for &T {}
fn serialize<T: Serialize + ?Sized>(value: &T) -> ToolResult {
match serde_json::to_value(value) {
Ok(v) => ToolResult::from_value(v),
Err(e) => ToolResult::error(e.to_string()),
}
}
impl ResultTag {
pub fn unwrap<T, E: Display>(self, value: Result<T, E>) -> Result<T, ToolResult> {
value.map_err(|e| ToolResult::error(e.to_string()))
}
}
impl PlainTag {
pub fn unwrap<T>(self, value: T) -> Result<T, ToolResult> {
Ok(value)
}
}
impl ToolResultTag {
pub fn convert(self, value: ToolResult) -> ToolResult {
value
}
}
impl UnitTag {
pub fn convert(self, _: ()) -> ToolResult {
ToolResult::text("ok")
}
}
impl SerializeTag {
pub fn convert<T: Serialize>(self, value: T) -> ToolResult {
serialize(&value)
}
}
}
}