Go SDK

Installation

go get github.com/archetypal-ai/govern-go

Requires Go 1.21+.

Initialization

package main

import (
    "github.com/archetypal-ai/govern-go"
)

func main() {
    client, err := govern.NewClient(govern.ClientOptions{
        APIKey:    os.Getenv("GOVERN_API_KEY"),
        OrgID:     os.Getenv("GOVERN_ORG_ID"),
        Mode:      govern.ModeFlag,     // ModeLog | ModeFlag | ModeBlock
        FailOpen:  true,                // default: true
        Timeout:   5 * time.Second,
    })
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()
}

Basic assessment

import (
    "context"
    anthropic "github.com/anthropics/anthropic-sdk-go"
    "github.com/archetypal-ai/govern-go"
)

func handleChat(ctx context.Context, userInput string) (string, error) {
    // Call the model
    msg, err := anthropicClient.Messages.New(ctx, anthropic.MessageNewParams{
        Model:     anthropic.ModelClaudeSonnet4_20250514,
        MaxTokens: 1024,
        Messages: []anthropic.MessageParam{
            anthropic.NewUserMessage(anthropic.NewTextBlock(userInput)),
        },
    })
    if err != nil {
        return "", err
    }

    responseText := msg.Content[0].Text

    // Assess the inference
    result, err := governClient.Assess(ctx, govern.AssessInput{
        Model: string(anthropic.ModelClaudeSonnet4_20250514),
        Prompt: []govern.Message{
            {Role: "user", Content: userInput},
        },
        Response: responseText,
        Metadata: map[string]string{
            "user_id": userID,
            "feature": "chat",
        },
    })
    if err != nil {
        // failOpen: true — err means assessment failed, not that response is bad
        log.Printf("govern assess error: %v", err)
        return responseText, nil
    }

    if result.Action == govern.ActionBlock {
        return "", govern.NewPolicyViolationError(result.Violations)
    }

    return responseText, nil
}

Concurrent assessment

import "sync"

func assessBatch(ctx context.Context, inputs []govern.AssessInput) []govern.AssessmentResult {
    results := make([]govern.AssessmentResult, len(inputs))
    var wg sync.WaitGroup

    for i, input := range inputs {
        wg.Add(1)
        go func(idx int, in govern.AssessInput) {
            defer wg.Done()
            result, err := governClient.Assess(ctx, in)
            if err != nil {
                results[idx] = govern.AssessmentResult{Action: govern.ActionPass}
                return
            }
            results[idx] = result
        }(i, input)
    }

    wg.Wait()
    return results
}

HTTP middleware

import (
    "net/http"
    "github.com/archetypal-ai/govern-go/middleware"
)

mux := http.NewServeMux()

// Wrap with GOVERN middleware
handler := middleware.GovernMiddleware(mux, middleware.Options{
    Client: governClient,
    ExtractPrompt: func(r *http.Request) ([]govern.Message, error) {
        // Parse prompt from request body
        ...
    },
    ExtractResponse: func(body []byte) (string, error) {
        // Parse response from response body
        ...
    },
    OnViolation: func(w http.ResponseWriter, r *http.Request, result govern.AssessmentResult) {
        w.WriteHeader(http.StatusUnprocessableEntity)
        json.NewEncoder(w).Encode(map[string]interface{}{
            "error": "policy_violation",
            "violations": result.Violations,
        })
    },
})

http.ListenAndServe(":8080", handler)

Assessment types

type AssessInput struct {
    Model    string
    Prompt   []Message
    Response string
    Metadata map[string]string
}

type AssessmentResult struct {
    AssessmentID string
    Action       Action  // "pass" | "flag" | "block"
    Scores       Scores
    Violations   []Violation
    LatencyMs    int
    Model        string
    Timestamp    time.Time
}

type Scores struct {
    Security float64
    Bias     float64
    Accuracy float64
    Drift    *float64  // nil until baseline established
    Cost     float64
}