pip install chucky-sdk

poetry add chucky-sdk

from chucky import Chucky

client = Chucky(
    token: str,
    url: str = 'wss://conjure.chucky.cloud/ws',
    model: str = 'claude-sonnet-4-5-20250929',
    system_prompt: Optional[str] = None,
    max_turns: Optional[int] = None,
    timeout: float = 30.0,
    keepalive_interval: float = 60.0,
)

from chucky import Chucky

client = Chucky(
    token='your-jwt-token',
    model='claude-sonnet-4-5-20250929',
    system_prompt='You are a helpful assistant.',
    timeout=60.0,
)

async def prompt(
    message: str,
    *,
    model: Optional[str] = None,
    system_prompt: Optional[str] = None,
    tools: Optional[List[Tool]] = None,
    max_turns: Optional[int] = None,
) -> PromptResult

result = await client.prompt('What is the capital of France?')
print(result.result)  # "The capital of France is Paris."
print(result.total_cost_usd)  # 0.0012

async def stream(
    message: str,
    *,
    model: Optional[str] = None,
    system_prompt: Optional[str] = None,
    tools: Optional[List[Tool]] = None,
    max_turns: Optional[int] = None,
) -> AsyncGenerator[StreamEvent, None]

async for event in client.stream('Write a poem about coding'):
    if event.type == 'message':
        print(event.data, end='', flush=True)
    elif event.type == 'tool_use':
        print(f'\n[Using tool: {event.name}]')

async def create_session(
    *,
    model: Optional[str] = None,
    system_prompt: Optional[str] = None,
    tools: Optional[List[Tool]] = None,
    mcp_servers: Optional[Dict[str, McpServer]] = None,
    max_turns: Optional[int] = None,
) -> Session

session = await client.create_session(
    model='claude-sonnet-4-5-20250929',
    system_prompt='You are a math tutor.',
)

result = await session.send('What is calculus?')
print(result.result)

def session(
    *,
    model: Optional[str] = None,
    system_prompt: Optional[str] = None,
    tools: Optional[List[Tool]] = None,
    mcp_servers: Optional[Dict[str, McpServer]] = None,
) -> AsyncContextManager[Session]

async with client.session(system_prompt='You are helpful.') as session:
    r1 = await session.send('Hi, I am Alice')
    r2 = await session.send('What is my name?')
    print(r2.result)  # "Your name is Alice."
# Session automatically closed

async def close() -> None

await client.close()

async def send(message: str) -> SessionResult

async def stream(message: str) -> AsyncGenerator[StreamEvent, None]

async def close() -> None

@property
def session_id(self) -> Optional[str]

@dataclass
class PromptResult:
    result: str                      # Response text
    total_cost_usd: Optional[float]  # Total cost in USD
    duration_secs: Optional[float]   # Response time
    session_id: Optional[str]        # Session ID (if applicable)

@dataclass
class SessionResult:
    result: str
    total_cost_usd: Optional[float]
    duration_secs: Optional[float]
    turn_count: Optional[int]
    session_id: Optional[str]

@dataclass
class StreamEvent:
    type: str       # 'message', 'tool_use', 'tool_result', 'error'
    data: Any       # Event-specific data
    name: Optional[str]  # Tool name (for tool_use)

import asyncio
from chucky import Chucky, tool, text_result

# Define a tool
@tool('get_time', 'Get current time')
async def get_time() -> ToolResult:
    from datetime import datetime
    return text_result(datetime.now().isoformat())

async def main():
    # Create client
    client = Chucky(
        token='your-jwt-token',
        model='claude-sonnet-4-5-20250929',
    )

    try:
        # Simple prompt
        result = await client.prompt('What is 2 + 2?')
        print(f'Answer: {result.result}')
        print(f'Cost: ${result.total_cost_usd:.4f}')

        # Streaming
        print('\nStreaming response:')
        async for event in client.stream('Tell me a joke'):
            if event.type == 'message':
                print(event.data, end='')
        print()

        # Session with tools
        async with client.session(tools=[get_time]) as session:
            r = await session.send('What time is it?')
            print(f'\nTime response: {r.result}')

    finally:
        await client.close()

asyncio.run(main())

from chucky import Chucky, BudgetExceededError, AuthenticationError

client = Chucky(token='...')

try:
    result = await client.prompt('Hello')
except BudgetExceededError as e:
    print(f'Budget exceeded: {e}')
except AuthenticationError as e:
    print(f'Auth failed: {e}')
except Exception as e:
    print(f'Error: {e}')