Client Wrappers

Sagewai ships client libraries for 17 programming languages. Each wrapper covers the same API surface — Harness, Registry, Observatory, and Gateway — and supports the same three authentication methods.

Supported Languages

Stable wrappers are fully implemented, tested, and published to their package registries. In development wrappers follow the same API surface — install commands will work once those packages are published. Mobile wrappers share their base language (TypeScript for React Native, Dart for Flutter).

Quick Start by Language

Python

from sagewai_client import SagewaiClient

client = SagewaiClient(
    base_url="http://localhost:8100",
    api_key="sk-harness-...",
)

response = client.chat("gpt-4o", "What is Sagewai?")
print(response.content)

TypeScript / JavaScript

import { SagewaiClient } from "sagewai";

const client = new SagewaiClient({
  baseUrl: "http://localhost:8100",
  apiKey: "sk-harness-...",
});

const response = await client.chat({
  model: "gpt-4o",
  messages: [{ role: "user", content: "What is Sagewai?" }],
});
console.log(response.content);

Go

package main

import (
    "context"
    "fmt"
    sagewai "github.com/sagewai/sagewai-go"
)

func main() {
    client := sagewai.NewClient(
        sagewai.WithBaseURL("http://localhost:8100"),
        sagewai.WithAPIKey("sk-harness-..."),
    )

    ctx := context.Background()
    response, err := client.Chat(ctx, &sagewai.ChatRequest{
        Model:    "gpt-4o",
        Messages: []sagewai.Message{{Role: "user", Content: "What is Sagewai?"}},
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(response.Content)
}

Rust

use sagewai::SagewaiClient;

#[tokio::main]
async fn main() -> Result<(), sagewai::Error> {
    let client = SagewaiClient::builder()
        .base_url("http://localhost:8100")
        .api_key("sk-harness-...")
        .build()?;

    let response = client
        .chat("gpt-4o")
        .message("user", "What is Sagewai?")
        .send()
        .await?;

    println!("{}", response.content);
    Ok(())
}

Java

import com.sagecurator.sagewai.SagewaiClient;

var client = SagewaiClient.builder()
    .baseUrl("http://localhost:8100")
    .apiKey("sk-harness-...")
    .build();

var response = client.chat("gpt-4o", "What is Sagewai?");
System.out.println(response.content());

C# / .NET

using Sagewai;

var client = new SagewaiClient("http://localhost:8100", "sk-harness-...");
var response = await client.ChatAsync("gpt-4o", "What is Sagewai?");
Console.WriteLine(response.Content);

Kotlin

import com.sagecurator.sagewai.SagewaiClient

val client = SagewaiClient(
    baseUrl = "http://localhost:8100",
    apiKey = "sk-harness-..."
)

val response = client.chat("gpt-4o", "What is Sagewai?")
println(response.content)

Ruby

require "sagewai"

client = Sagewai::Client.new(
  base_url: "http://localhost:8100",
  api_key: "sk-harness-..."
)

response = client.chat("gpt-4o", "What is Sagewai?")
puts response.content

Swift

import Sagewai

let client = SagewaiClient(
    baseURL: "http://localhost:8100",
    apiKey: "sk-harness-..."
)

let response = try await client.chat(model: "gpt-4o", message: "What is Sagewai?")
print(response.content)

PHP

use Sagewai\Client;

$client = new Client("http://localhost:8100", "sk-harness-...");
$response = $client->chat("gpt-4o", "What is Sagewai?");
echo $response->content;

Dart / Flutter

import 'package:sagewai/sagewai.dart';

final client = SagewaiClient(
  baseUrl: 'http://localhost:8100',
  apiKey: 'sk-harness-...',
);

final response = await client.chat('gpt-4o', 'What is Sagewai?');
print(response.content);

Elixir

client = Sagewai.Client.new(
  base_url: "http://localhost:8100",
  api_key: "sk-harness-..."
)

{:ok, response} = Sagewai.chat(client, "gpt-4o", "What is Sagewai?")
IO.puts(response.content)

Unified API Surface

Every wrapper exposes the same operations:

Harness (LLM Proxy)

Registry (Agent Governance)

Observatory (Cost Tracking)

Gateway (Token Management)

Health

Authentication

All wrappers support three authentication methods.

API Key

Best for scripts, services, and development. Sends X-API-Key with every request.

# Python
client = SagewaiClient(base_url="...", api_key="sk-harness-...")

// TypeScript
const client = new SagewaiClient({ baseUrl: "...", apiKey: "sk-harness-..." });

// Go
client := sagewai.NewClient(sagewai.WithAPIKey("sk-harness-..."))

JWT

Best for authenticated users and service-to-service calls. Sends Authorization: Bearer.

# Python
client = SagewaiClient(base_url="...", jwt="eyJhbGciOi...")

// TypeScript
const client = new SagewaiClient({ baseUrl: "...", auth: { type: "jwt", token: "eyJ..." } });

// Go
client := sagewai.NewClient(sagewai.WithJWT("eyJ..."))

OAuth

Supports automatic token refresh for long-lived applications.

// TypeScript — with auto-refresh
const client = new SagewaiClient({
  baseUrl: "http://localhost:8100",
  auth: {
    type: "oauth",
    accessToken: "ya29...",
    refreshToken: "1//0...",
    refreshUrl: "https://auth.sagewai.ai/token",
  },
});

Response Types

ChatResponse

AgentSummary

SpendSummary

Python SDK vs Client Wrappers

In a typical setup: the Python SDK defines and runs your agents on the server; client wrappers let your TypeScript frontend, Go microservice, or Rust CLI call those agents over HTTP.