SDK Go

Client Go écrit à la main, n’utilisant que la bibliothèque standard, pour l’API Audact. Il couvre l’API Audact, avec des erreurs typées et context.Context sur chaque appel.

Installation

Le SDK Go n’est pas encore publié. Les instructions d’installation figureront ici lorsqu’il le sera.

Nécessite Go 1.24 ou plus récent. Le module n’a aucune dépendance tierce.

Démarrage rapide

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	audact "github.com/audactai/audact-go-sdk"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	c, err := audact.NewClient("") // reads AUDACT_API_KEY
	if err != nil {
		log.Fatal(err)
	}
	agents, err := c.Agents.List(ctx, &audact.ListAgentsParams{Limit: 10})
	if err != nil {
		log.Fatal(err)
	}
	for _, a := range agents.Agents {
		fmt.Println(a.AgentID, a.Name)
	}
}

Un exemple plus complet se trouve dans examples/quickstart.

URL de base

La valeur par défaut est https://api.audact.ai. Ordre de résolution :

1. audact.WithBaseURL("https://...")
2. la variable d’environnement AUDACT_BASE_URL
3. audact.DefaultBaseURL

Un / final et un /v1 final sont supprimés ; le chemin de chaque requête est préfixé par /v1.

Authentification

NewClient n’échoue pas en l’absence de clé, car certaines opérations sont publiques. Il ne renvoie une erreur que pour une URL de base invalide ou une option nil. Si un identifiant nécessaire est vide, l’en-tête est omis et le 401 du serveur remonte sous la forme audact.ErrUnauthorized.

Erreurs

Les réponses non 2xx renvoient *audact.APIError, qui porte StatusCode, Code, Message, Hint, Details et RequestID.

_, err := c.Calls.Get(ctx, "call_123")
var apiErr *audact.APIError
switch {
case errors.Is(err, audact.ErrNotFound):
	fmt.Println("no such call")
case errors.As(err, &apiErr):
	fmt.Println(apiErr.StatusCode, apiErr.Code, "request_id:", apiErr.RequestID)
case err != nil:
	log.Fatal(err) // transport error, wrapped with %w
}

Erreurs sentinelles : ErrUnauthorized (401), ErrForbidden (403), ErrNotFound (404), ErrConflict (409), ErrRateLimited (429). Un 429 renvoie *audact.RateLimitError ; utilisez RetryAfter pour connaître le délai demandé par le serveur :

var rl *audact.RateLimitError
if errors.As(err, &rl) {
	time.Sleep(rl.RetryAfter)
}

Nouvelles tentatives et idempotence

Le SDK ne réessaie jamais de lui-même. Les écritures qui créent des preuves ou d’autres enregistrements permanents acceptent une clé d’idempotence : transmettez la même clé lorsque vous réessayez, et le serveur rejoue la première réponse au lieu d’agir deux fois. Une clé vide n’envoie aucun en-tête Idempotency-Key.

m, err := c.Evidence.GenerateC2PAManifest(ctx, callID, "c2pa-"+callID)

Les méthodes qui acceptent une clé d’idempotence comprennent Evidence.PostEvent, Evidence.ConfirmDelivery, Evidence.ReconcileTranscript et Evidence.GenerateC2PAManifest. Les manifestes C2PA et les événements de preuve sont en ajout seul : une nouvelle tentative sans clé stocke donc un doublon de façon permanente.

Contexte et délais d’expiration

Chaque méthode prend un context.Context en premier paramètre ; l’annulation et les échéances sont respectées, et errors.Is(err, context.DeadlineExceeded) fonctionne. Le client HTTP par défaut a un délai d’expiration de 30 s. Fournissez le vôtre avec WithHTTPClient :

c, err := audact.NewClient("", audact.WithHTTPClient(&http.Client{Timeout: 10 * time.Second}))

WithUserAgent("myapp/1.0") s’ajoute à l’agent par défaut audact-go/0.3.0.

Streaming

c.LLMProxy.Stream renvoie un *Stream sur des événements envoyés par le serveur (server-sent events). Le proxy valide la réponse phrase par phrase : Current() est le texte de la phrase, et Chunk().AudactValidation porte son verdict (MODIFY signifie que le texte a été réécrit ; un fragment BLOCK porte la phrase de repli et met fin au flux). Les deltas d’appels d’outils arrivent sous forme de fragments sans AudactValidation.

st, err := c.LLMProxy.Stream(ctx, nil, &audact.ChatCompletionRequest{
	Messages: []audact.ChatMessage{{Role: "user", Content: "Hello"}},
})
if err != nil {
	log.Fatal(err)
}
defer st.Close()
for st.Next() {
	if v := st.Chunk().AudactValidation; v != nil && v.Verdict == "BLOCK" {
		log.Println("reply blocked by compliance check")
	}
	fmt.Print(st.Current())
}
if err := st.Err(); err != nil {
	log.Fatal(err)
}

Utilitaires pour les données personnelles

audact.NormalizeIdentifier(typ, value) met sous forme canonique un identifiant de type nom, e-mail ou téléphone, et audact.ClientHash(typ, value) calcule l’empreinte côté client. Les deux concordent avec les SDK TypeScript et Python sur les vecteurs de test partagés.

h, err := audact.ClientHash("email", "Jane@Example.com")

Services

Licence

MIT