Go

go get github.com/arouter-ai/arouter-go

package main

import (
    "context"
    "fmt"
    "log"

    arouter "github.com/arouter-ai/arouter-go"
)

func main() {
    client := arouter.NewClient(
        "https://api.arouter.ai",
        "lr_live_xxxx",
    )

    resp, err := client.ChatCompletion(context.Background(), arouter.ChatCompletionRequest{
        Model: "openai/gpt-5.4",
        Messages: []arouter.Message{
            {Role: "user", Content: "Hello!"},
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(resp.Choices[0].Message.Content)
}

// ARouter 経由で Anthropic を使用
resp, _ := client.ChatCompletion(ctx, arouter.ChatCompletionRequest{
    Model: "anthropic/claude-sonnet-4.6",
    Messages: []arouter.Message{
        {Role: "user", Content: "Hello!"},
    },
})

// ARouter 経由で DeepSeek を使用
resp, _ = client.ChatCompletion(ctx, arouter.ChatCompletionRequest{
    Model: "deepseek/deepseek-v3.2",
    Messages: []arouter.Message{
        {Role: "user", Content: "Hello!"},
    },
})

stream, err := client.ChatCompletionStream(context.Background(), arouter.ChatCompletionRequest{
    Model: "openai/gpt-5.4",
    Messages: []arouter.Message{
        {Role: "user", Content: "Go についての俳句を書いてください。"},
    },
})
if err != nil {
    log.Fatal(err)
}
defer stream.Close()

for {
    chunk, err := stream.Recv()
    if err == arouter.ErrStreamDone {
        break
    }
    if err != nil {
        log.Fatal(err)
    }
    fmt.Print(chunk.Choices[0].Delta.Content)
}

mgmtClient := arouter.NewClient("https://api.arouter.ai", "lr_mgmt_xxxx")

key, err := mgmtClient.CreateKey(ctx, &arouter.CreateKeyRequest{
    Name:             "production-backend",
    AllowedProviders: []string{"openai", "anthropic"},
    AllowedModels:    []string{"gpt-5.4", "claude-sonnet-4.6"},
    Limit:            float64Ptr(150),
    LimitReset:       "monthly",
})
if err != nil {
    log.Fatal(err)
}
fmt.Println("API Key:", key.Key)

keys, err := mgmtClient.ListKeys(ctx, &arouter.ListKeysOptions{
    PageSize: 20,
})
if err != nil {
    log.Fatal(err)
}
for _, k := range keys.Data {
    fmt.Printf("- %s (%s) disabled=%t\n", k.Name, k.Hash, k.Disabled)
}

_, err := mgmtClient.UpdateKey(ctx, "KEY_HASH", &arouter.UpdateKeyRequest{
    Disabled: boolPtr(true),
})

err := mgmtClient.DeleteKey(ctx, "KEY_HASH")

resp, err := client.ProxyRequest(ctx, "openai", "v1/chat/completions", map[string]any{
    "model":    "gpt-5.4",
    "messages": []map[string]string{{"role": "user", "content": "Hello!"}},
})

client := arouter.NewClient(
    "https://api.arouter.ai",
    "lr_live_xxxx",
    arouter.WithTimeout(30 * time.Second),
    arouter.WithHTTPClient(customHTTPClient),
)

import (
    "github.com/ethereum/go-ethereum/crypto"
    arouter "github.com/arouter-ai/arouter-go"
)

key, _ := crypto.HexToECDSA("your-private-key-hex")

// 1回の呼び出しでウォレット JWT 更新 + 自動 x402 支払いを設定
client := arouter.NewClient(
    "https://api.arouter.ai",
    "",  // API key 不要
    arouter.WithX402CoinbasePayment(key),
)

resp, err := client.ChatCompletion(ctx, arouter.ChatCompletionRequest{
    Model:    "openai/gpt-5.4",
    Messages: []arouter.Message{{Role: "user", Content: "Hello"}},
})

solanaKey := ed25519.PrivateKey(yourKeyBytes)

client := arouter.NewClient(
    "https://api.arouter.ai",
    "",
    arouter.WithX402SolanaPayment(solanaKey),
)

signer := arouter.NewEvmWalletSigner(privateKey)
result, err := arouter.AuthenticateWithSIWx(ctx, "https://api.arouter.ai", signer, nil)
client := arouter.NewClient("https://api.arouter.ai", result.JWT)

resp, err := client.ChatCompletion(ctx, req)
if err != nil {
    var apiErr *arouter.APIError
    if errors.As(err, &apiErr) {
        switch apiErr.StatusCode {
        case 401:
            log.Fatal("API key が無効です")
        case 429:
            log.Println("レート制限、リトライ中...")
        case 502:
            log.Println("上流プロバイダーエラー")
        }
    }
}