floopy-go

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/FloopyAI/floopy-go"
	"github.com/openai/openai-go/v3"
)

func main() {
	client, err := floopy.NewClient(os.Getenv("FLOOPY_API_KEY"))
	if err != nil {
		log.Fatal(err)
	}

	resp, err := client.OpenAI().Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
		Model: openai.ChatModelGPT4o,
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.UserMessage("Hello from Floopy!"),
		},
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(resp.Choices[0].Message.Content)
}

client, _ := floopy.NewClient(os.Getenv("FLOOPY_API_KEY"),
	floopy.WithOptions(floopy.Options{
		Cache:              &floopy.CacheOptions{Enabled: floopy.Ptr(true), BucketMaxSize: floopy.Ptr(3)},
		PromptID:           "cd4249d5-44d5-46c8-8961-9eb3861e1f7e",
		PromptVersion:      "1",
		LLMSecurityEnabled: floopy.Ptr(true),
	}),
)

resp, _ := client.OpenAI().Chat.Completions.New(ctx, params)
client.Feedback.Submit(ctx, floopy.FeedbackSubmitParams{Score: 9, Useful: true, SessionID: resp.ID})

d, _ := client.Decisions.Get(ctx, requestID)
page, _ := client.Decisions.List(ctx, floopy.DecisionListParams{From: since, Limit: 50})

for d, err := range client.Decisions.Iterate(ctx, floopy.DecisionListParams{From: since}) { /* one at a time */ }
for p, err := range client.Decisions.Pages(ctx, floopy.DecisionListParams{From: since})   { /* page at a time */ }

exp, _ := client.Experiments.Create(ctx, floopy.ExperimentCreateParams{
	Name:                  "cost-vs-quality",
	VariantARoutingRuleID: ruleA,
	VariantBRoutingRuleID: ruleB,
})
results, _ := client.Experiments.Results(ctx, exp.ID)
client.Experiments.Rollback(ctx, exp.ID)

current, _ := client.Constraints.Get(ctx)
client.Constraints.Put(ctx, floopy.OrgConstraints{CostLimitMonthlyUSD: floopy.Ptr(100.0)})

for row, err := range client.Export.Decisions(ctx, floopy.ExportDecisionsParams{From: start, To: end}) {
	// streamed JSONL, parsed and typed
}

// to also read the trailer (truncation reasons, totals):
stream := client.Export.DecisionsWithTrailer(ctx, floopy.ExportDecisionsParams{From: start, To: end})
for row, err := range stream.Rows { /* ... */ }
fmt.Println(stream.Trailer()) // populated after iteration completes

run, _ := client.Evaluations.Create(ctx, floopy.EvaluationCreateParams{DatasetID: dsID, Model: "gpt-4o"})
status, _ := client.Evaluations.Get(ctx, run.ID)
results, _ := client.Evaluations.Results(ctx, run.ID, 100, "")
client.Evaluations.Cancel(ctx, run.ID)

explain, _ := client.Routing.Explain(ctx, floopy.RoutingExplainParams{Model: "gpt-4o", Messages: messages})
fmt.Println(explain.WouldSelect, explain.FirewallDecision)

session, _ := client.Sessions.Get(ctx, sessionID)
// session.Messages is a drop-in for a follow-up chat completion
client.OpenAI().Chat.Completions.New(ctx, openai.ChatCompletionNewParams{
	Model: openai.ChatModelGPT4o, Messages: session.Messages,
})

file, _ := client.Files.Upload(ctx, floopy.FileUploadParams{
	File: jsonl, Filename: "in.jsonl", Purpose: "batch",
}, floopy.WithProvider("openai"))

batch, _ := client.Batches.Create(ctx, floopy.BatchCreateParams{
	InputFileID:      file.ID,
	Endpoint:         "/v1/chat/completions",
	CompletionWindow: "24h",
}, floopy.WithProvider("openai"))

done, _ := client.Batches.Get(ctx, batch.ID, floopy.WithProvider("openai"))
if done.Status == "completed" && done.OutputFileID != nil {
	out, _ := client.Files.Content(ctx, *done.OutputFileID, floopy.WithProvider("openai"))
	_ = out // raw []byte
}

client.Batches.Cancel(ctx, batch.ID, floopy.WithProvider("openai"))
client.Files.Delete(ctx, file.ID, floopy.WithProvider("openai"))

import "errors"

_, err := client.Decisions.List(ctx, params)
var rl *floopy.RateLimitError
var plan *floopy.PlanError
switch {
case errors.As(err, &rl):
	time.Sleep(time.Duration(max(rl.RetryAfterSeconds, 1)) * time.Second)
case errors.As(err, &plan):
	log.Printf("upgrade plan: feature %s not in current plan", plan.Feature)
}

client, _ := floopy.NewClient(os.Getenv("FLOOPY_API_KEY"),
	floopy.WithBaseURL("https://gateway.internal.acme.com/v1"))