import promptrails "github.com/promptrails/go-sdk"
 
client := promptrails.NewClient("your-api-key")

import (
    "time"
    promptrails "github.com/promptrails/go-sdk"
)
 
client := promptrails.NewClient("your-api-key",
    promptrails.WithBaseURL("https://api.promptrails.ai"),  // default
    promptrails.WithTimeout(30 * time.Second),               // default
    promptrails.WithMaxRetries(3),                           // default
)

agents, err := client.Agents.List(ctx, &promptrails.ListAgentsParams{
    Page:  1,
    Limit: 20,
})
if err != nil {
    log.Fatal(err)
}
 
for _, agent := range agents.Data {
    fmt.Printf("%s (%s)\n", agent.Name, agent.Type)
}

prompt, err := client.Prompts.Create(ctx, &promptrails.CreatePromptParams{
    Name:        "Summarizer",
    Description: "Summarizes text",
})
if err != nil {
    log.Fatal(err)
}
 
fmt.Println(prompt.Data.ID)

executions, err := client.Executions.List(ctx, &promptrails.ListExecutionsParams{
    Page:  1,
    Limit: 10,
})
if err != nil {
    log.Fatal(err)
}
 
for _, exec := range executions.Data {
    fmt.Printf("ID: %s, Status: %s\n", exec.ID, exec.Status)
}

tree, err := client.Executions.Tree(ctx, "execution-id") // children populated
if err != nil {
    log.Fatal(err)
}
for _, child := range tree.Children {
    fmt.Printf("%s %s $%.6f\n", child.AgentID, child.Status, child.Cost)
}

inbox, err := client.Executions.ApprovalInbox(ctx, nil)
if err != nil {
    log.Fatal(err)
}
for _, exec := range inbox.Data {
    _, _ = client.Executions.Approve(ctx, exec.ID, &promptrails.DecideParams{Reason: "Looks good"})
    // or: client.Executions.Deny(ctx, exec.ID, &promptrails.DecideParams{Reason: "Denied"})
}

session, err := client.Chat.CreateSession(ctx, &promptrails.CreateSessionParams{
    AgentID: "agent-id",
})
if err != nil {
    log.Fatal(err)
}
 
stream, err := client.Chat.SendMessageStream(ctx, session.ID, &promptrails.SendMessageParams{
    Content: "What is PromptRails?",
})
if err != nil {
    log.Fatal(err)
}
defer stream.Close()
 
for stream.Next() {
    switch e := stream.Event().(type) {
    case *promptrails.ExecutionEvent:
        log.Printf("execution_id: %s", e.ExecutionID)
    case *promptrails.ThinkingEvent:
        log.Printf("[thinking] %s", e.Content)
    case *promptrails.ToolStartEvent:
        log.Printf("[tool_start] %s", e.Name)
    case *promptrails.ToolEndEvent:
        log.Printf("[tool_end] %s (%s)", e.Name, e.Summary)
    case *promptrails.ContentEvent:
        fmt.Print(e.Content)
    case *promptrails.DoneEvent:
        fmt.Printf("\n[done] %d tokens\n", e.TokenUsage.TotalTokens)
    case *promptrails.ErrorEvent:
        log.Fatalf("[error] %s", e.Message)
    }
}
if err := stream.Err(); err != nil {
    log.Fatal(err)
}

stream, err := client.Executions.Stream(ctx, executionID)
if err != nil {
    log.Fatal(err)
}
defer stream.Close()
 
for stream.Next() {
    if e, ok := stream.Event().(*promptrails.ContentEvent); ok {
        fmt.Print(e.Content)
    }
}

import promptrails "github.com/promptrails/go-sdk"
 
temp := 0.2
maxCost := 1.0
 
_, err := client.Agents.CreateVersion(ctx, "agent-id", &promptrails.CreateVersionParams{
    Version:     "1.0.0",
    Config:      promptrails.PromptAgentConfig{PromptID: "prompt-id"},
    ModelConfig: &promptrails.ModelConfig{ModelID: "llm-model-id", Temperature: &temp},
    RunBudget:   &promptrails.RunBudget{MaxCost: &maxCost},
    Tools:       []promptrails.ToolAttachment{{MCPToolID: "tool-id", RequiresApproval: true}},
    SubAgents:   []promptrails.SubAgentAttachment{{AgentID: "sub-id", Alias: "researcher"}},
    SetCurrent:  true,
})

import "github.com/promptrails/go-sdk/tracing"
 
tracer := tracing.NewTracer("pr_...")
defer tracer.Shutdown()
 
_ = tracer.Span(ctx, "agent-run", tracing.KindAgent, func(ctx context.Context, root *tracing.Span) error {
    root.SetInput(map[string]any{"q": "weather?"})
    return tracer.Span(ctx, "llm-call", tracing.KindLLM, func(ctx context.Context, llm *tracing.Span) error {
        // SetUsage(promptTokens, completionTokens, totalTokens); pass -1 for an
        // unknown count — total is computed from prompt+completion when it is -1.
        llm.SetModel("gpt-4o").SetUsage(120, 30, -1)
        return nil
    })
})

import promptrails "github.com/promptrails/go-sdk"
 
fmt.Println(promptrails.Version) // "0.7.0"

import "errors"
 
result, err := client.Agents.Execute(ctx, "invalid-id", &promptrails.ExecuteAgentParams{
    Input: map[string]any{},
})
if err != nil {
    var notFound *promptrails.NotFoundError
    var validation *promptrails.ValidationError
    var unauthorized *promptrails.UnauthorizedError
    var forbidden *promptrails.ForbiddenError
    var rateLimit *promptrails.RateLimitError
    var serverErr *promptrails.ServerError
 
    switch {
    case errors.As(err, &notFound):
        fmt.Printf("Agent not found: %s\n", notFound.Message)
    case errors.As(err, &validation):
        fmt.Printf("Invalid input: %s\n", validation.Message)
    case errors.As(err, &unauthorized):
        fmt.Printf("Invalid API key: %s\n", unauthorized.Message)
    case errors.As(err, &forbidden):
        fmt.Printf("Insufficient permissions: %s\n", forbidden.Message)
    case errors.As(err, &rateLimit):
        fmt.Printf("Rate limited: %s\n", rateLimit.Message)
    case errors.As(err, &serverErr):
        fmt.Printf("Server error: %s\n", serverErr.Message)
    default:
        fmt.Printf("Unexpected error: %v\n", err)
    }
}

ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
 
result, err := client.Agents.Execute(ctx, "agent-id", &promptrails.ExecuteAgentParams{
    Input: map[string]any{"message": "Hello"},
    Sync:  true,
})

// Page-based pagination
page1, _ := client.Agents.List(ctx, &promptrails.ListAgentsParams{Page: 1, Limit: 20})
page2, _ := client.Agents.List(ctx, &promptrails.ListAgentsParams{Page: 2, Limit: 20})
 
fmt.Printf("Total: %d, Pages: %d\n", page1.Meta.Total, page1.Meta.Pages)