session := client.CreateSession(&chucky.SessionOptions{
    BaseOptions: chucky.BaseOptions{
        Model:        chucky.ModelClaudeSonnet,
        SystemPrompt: "You are a helpful assistant.",
        MaxTurns:     10,
    },
})
defer session.Close()

func (s *Session) Send(ctx context.Context, message string) error

ctx := context.Background()

if err := session.Send(ctx, "What is the capital of France?"); err != nil {
    log.Fatal(err)
}

// Use Stream() to receive the response
for msg := range session.Stream(ctx) {
    // handle messages
}

func (s *Session) Stream(ctx context.Context) <-chan IncomingMessage

if err := session.Send(ctx, "Tell me a story"); err != nil {
    log.Fatal(err)
}

for msg := range session.Stream(ctx) {
    switch m := msg.(type) {
    case *chucky.SDKSystemMessage:
        fmt.Println("Session:", m.SessionID)
        fmt.Println("Model:", m.Data)
    case *chucky.SDKAssistantMessage:
        text := chucky.GetAssistantText(m)
        if text != "" {
            fmt.Print(text)
        }
    case *chucky.SDKResultMessage:
        fmt.Println("\nResult:", m.Result)
        fmt.Printf("Cost: $%.6f\n", m.TotalCostUsd)
        fmt.Printf("Turns: %d\n", m.NumTurns)
    case *chucky.ErrorEnvelope:
        fmt.Println("Error:", m.Payload.Message)
    }
}

func (s *Session) Receive(ctx context.Context) <-chan IncomingMessage

func (s *Session) Connect(ctx context.Context) error

func (s *Session) Close()

session := client.CreateSession(&chucky.SessionOptions{})

// Use defer for cleanup
defer session.Close()

if err := session.Send(ctx, "Hello"); err != nil {
    log.Fatal(err)
}

for msg := range session.Stream(ctx) {
    // handle messages
}

func (s *Session) On(handlers SessionEventHandlers) *Session

session.On(chucky.SessionEventHandlers{
    OnMessage: func(msg chucky.IncomingMessage) {
        fmt.Printf("Message type: %T\n", msg)
    },
    OnError: func(err error) {
        fmt.Println("Error:", err)
    },
})

func (s *Session) ID() string

func (s *Session) State() SessionState

func GetAssistantText(msg *SDKAssistantMessage) string

for msg := range session.Stream(ctx) {
    if m, ok := msg.(*chucky.SDKAssistantMessage); ok {
        text := chucky.GetAssistantText(m)
        fmt.Println(text)
    }
}

func GetResultText(msg *SDKResultMessage) string

client := chucky.NewClient(chucky.ClientOptions{Token: token})
defer client.Close()

session := client.CreateSession(&chucky.SessionOptions{
    BaseOptions: chucky.BaseOptions{
        Model: chucky.ModelClaudeSonnet,
    },
})
defer session.Close()

ctx := context.Background()

// First turn
session.Send(ctx, "Hi, my name is Alice")
for msg := range session.Stream(ctx) {
    if m, ok := msg.(*chucky.SDKAssistantMessage); ok {
        fmt.Println(chucky.GetAssistantText(m))
    }
    if _, ok := msg.(*chucky.SDKResultMessage); ok {
        break
    }
}

// Second turn (Claude remembers context)
session.Send(ctx, "What is my name?")
for msg := range session.Stream(ctx) {
    if m, ok := msg.(*chucky.SDKAssistantMessage); ok {
        fmt.Println(chucky.GetAssistantText(m)) // "Your name is Alice."
    }
    if _, ok := msg.(*chucky.SDKResultMessage); ok {
        break
    }
}

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
defer cancel()

if err := session.Send(ctx, "Complex query..."); err != nil {
    if errors.Is(err, context.DeadlineExceeded) {
        fmt.Println("Request timed out")
    }
    return
}

for msg := range session.Stream(ctx) {
    // handle messages
}

if err := session.Send(ctx, "Hello"); err != nil {
    switch {
    case errors.As(err, &chucky.BudgetExceededError{}):
        fmt.Println("Budget exceeded")
    case errors.As(err, &chucky.AuthenticationError{}):
        fmt.Println("Authentication failed")
    default:
        fmt.Println("Error:", err)
    }
    return
}

for msg := range session.Stream(ctx) {
    if e, ok := msg.(*chucky.ErrorEnvelope); ok {
        fmt.Println("Server error:", e.Payload.Message)
        break
    }
    if r, ok := msg.(*chucky.SDKResultMessage); ok {
        if r.IsError {
            fmt.Println("Result error:", r.Errors)
        } else {
            fmt.Println("Success:", r.Result)
        }
        break
    }
}