Rhone AI Gateway

runStream is the hero

Streaming runs are the primary execution path. Five lines to stream text from any model. Sugar fields (model, input, system) keep the common path flat.

Session-first, session-optional

Sessions are the durable continuity container, but explicit session creation is optional. Omit session_id and the gateway creates one automatically.

Any model, any provider

Use canonical model IDs (gpt-5.4, claude-sonnet-4-6), project aliases, or pin to a specific provider. The gateway normalizes model params across providers.

Rhone as product DB

Hosted history, timeline reads, summaries, assessments, and structured data queries are first-party SDK surfaces, not afterthoughts.

Getting Started

Install, configure, and stream your first run in five lines.

Installation

1go get github.com/vango-go/vai-go

Client Configuration

One reusable client for all execution, history, data, evals, realtime, and live. No session required for the simple path.

1import "github.com/vango-go/vai-go"
2
3client := vai.NewClient()  // reads VAI_API_KEY from env

Stream a Run

The most capable interactive path. Sugar fields (model, input, system) keep it flat. textDeltas() yields only the text. No session needed — the gateway creates one automatically when sessionId is omitted.

1stream := client.Runs.Stream(ctx, vai.RunCreateParams{
2    Model: "gpt-5.4",
3    Input: "Explain the likely root cause of this auth redirect bug.",
4})
5defer stream.Close()
6
7for deltas := stream.TextDeltas(); deltas.Next(); {
8    fmt.Print(deltas.Value())
9}

With model parameters

1stream := client.Runs.Stream(ctx, vai.RunCreateParams{
2    Model:     "gpt-5.4",
3    System:    "You are a senior engineer. Be thorough.",
4    Input:     "Investigate this race condition and fix it.",
5    Thinking:  vai.ThinkingHigh,
6    MaxTokens: vai.Int(8192),
7})

Cross-provider with provider constraint

Use provider to constrain routing to a specific provider while keeping a portable model identifier. This is a hard constraint — the request fails if the provider cannot serve it.

1// Claude via Google Vertex
2stream := client.Runs.Stream(ctx, vai.RunCreateParams{
3    Model:    vai.ModelClaudeSonnet4_6,
4    Provider: "vertex",
5    Input:    "Fix the bug",
6})

Sessions & Continuity

Sessions are the durable continuity container. When you omit sessionId, the gateway creates one automatically. Create a session explicitly when you need multi-turn continuity.

1session, _ := client.Sessions.Create(ctx, vai.SessionCreateParams{
2    Defaults: &vai.SessionDefaults{
3        Routing: &vai.RoutingParam{Model: "gpt-5.4"},
4    },
5})
6
7chat := client.WithSession(session.ID)
8
9chat.Runs.Execute(ctx, vai.RunCreateParams{Input: "My order has not arrived yet."})
10followup, _ := chat.Runs.Execute(ctx, vai.RunCreateParams{Input: "What are my options now?"})
11
12fmt.Println(followup.Text())

Coding Agent Demo

A complete CLI coding agent in under 60 lines. Uses a session with a harness ref, typed client tools (exec_command, apply_patch), gateway-hosted web_search and web_fetch, and streamed responses with auto-managed tool continuation.

1package main
2
3import (
4    "bufio"
5    "context"
6    "fmt"
7    "os"
8    "os/exec"
9    "strings"
10
11    "github.com/vango-go/vai-go"
12)
13
14func main() {
15    ctx := context.Background()
16    client := vai.NewClient()
17
18    session, _ := client.Sessions.Create(ctx, vai.SessionCreateParams{
19        HarnessRef: &vai.HarnessRef{ID: "demos/coding-agent", Version: "1.0.0"},
20        Defaults:   &vai.SessionDefaults{Routing: &vai.RoutingParam{Model: "gpt-5.4"}},
21    })
22
23    execCmd := vai.MakeClientTool("exec_command", "Execute a shell command",
24        func(ctx context.Context, in struct {
25            Command string `json:"command" desc:"Shell command to run"`
26        }) (string, error) {
27            out, err := exec.CommandContext(ctx, "sh", "-c", in.Command).CombinedOutput()
28            if err != nil {
29                return string(out) + "\n" + err.Error(), nil
30            }
31            return string(out), nil
32        },
33    )
34
35    applyPatch := vai.MakeClientTool("apply_patch", "Apply a unified diff patch",
36        func(ctx context.Context, in struct {
37            Patch string `json:"patch" desc:"Unified diff to apply"`
38        }) (string, error) {
39            cmd := exec.CommandContext(ctx, "patch", "-p1")
40            cmd.Stdin = strings.NewReader(in.Patch)
41            out, err := cmd.CombinedOutput()
42            if err != nil {
43                return string(out) + "\n" + err.Error(), nil
44            }
45            return "Patch applied.\n" + string(out), nil
46        },
47    )
48
49    tools := vai.NewClientToolSet(execCmd, applyPatch)
50    agent := client.WithSession(session.ID)
51    scanner := bufio.NewScanner(os.Stdin)
52    fmt.Println("Coding agent ready. Type your request:")
53
54    for {
55        fmt.Print("\n> ")
56        if !scanner.Scan() {
57            break
58        }
59
60        stream := agent.Runs.Stream(ctx, vai.RunCreateParams{
61            Blocks:      []vai.BlockParam{vai.TextInput(scanner.Text())},
62            ClientTools: tools.Definitions(),
63            Tools:       []vai.ToolParam{vai.WebSearch.Auto(), vai.WebFetch.Auto()},
64        }, tools.HandlerOptions()...)
65
66        for stream.Next() {
67            switch e := stream.Event().(type) {
68            case *vai.ResponseDeltaEvent:
69                fmt.Print(e.Delta)
70            case *vai.ToolCallCompletedEvent:
71                fmt.Printf("\n[tool: %s]\n", vai.StringValue(e.Block.ToolName))
72            }
73        }
74        stream.Close()
75        fmt.Println()
76    }
77}

Core

Blocking runs, calls, structured output, tools, and model parameters.

Blocking Runs

Same power as runStream, but waits for completion. Use sugar fields for the common path, canonical fields for full control.

1result, err := client.Runs.Execute(ctx, vai.RunCreateParams{
2    Model: "gpt-5.4",
3    Input: "Summarize the diff in src/auth.go",
4})
5
6fmt.Println(result.Text())

Calls

Calls are single logical model invocations — lighter weight than runs, with no checkpoint or interrupt support. Use them for translation, extraction, and other one-shot tasks.

1result, err := client.Calls.Execute(ctx, vai.CallCreateParams{
2    Model: "gpt-5.4",
3    Input: "Translate this error: 接続がタイムアウトしました",
4})
5
6fmt.Println(result.Text())

Stateful vs Stateless

By default, the gateway manages full session history internally (stateful). The SDK sends only incremental new blocks per request. In stateless mode, the caller supplies full context in every request.

Stateful (default)

Previous context is retained by the gateway. Send only new input.

1// First message
2stream1 := client.Runs.Stream(ctx, vai.RunCreateParams{
3    SessionID: vai.String(session.ID),
4    Blocks: []vai.BlockParam{
5        vai.TextInput("What Go web framework should I use?"),
6    },
7})
8
9// Follow-up — previous context is retained automatically
10stream2 := client.Runs.Stream(ctx, vai.RunCreateParams{
11    SessionID: vai.String(session.ID),
12    Blocks: []vai.BlockParam{
13        vai.TextInput("Show me a hello world with that framework."),
14    },
15})

Stateless (explicit)

Caller supplies the full transcript. Gateway does not mutate session history by default.

1result, err := client.Runs.Execute(ctx, vai.RunCreateParams{
2    SessionID:   vai.String("sess_123"),
3    ContextMode: vai.Ptr(vai.ContextModeStateless),
4    Blocks: []vai.BlockParam{
5        vai.SystemBlock("You are a concise translator."),
6        vai.TextInput("Translate: Hello world"),
7    },
8})

Structured Output

Request typed JSON responses using output schemas. The SDK carries the parsed type through .output() or UnmarshalOutput().

1type Analysis struct {
2    Steps   []string `json:"steps"`
3    Verdict string   `json:"verdict"`
4}
5
6result, _ := client.Runs.Execute(ctx, vai.RunCreateParams{
7    Blocks: []vai.BlockParam{vai.TextInput("Analyze this code for bugs")},
8    Routing: &vai.RoutingParam{Model: "gpt-5.4"},
9})
10
11var output Analysis
12if err := result.UnmarshalOutput(&output); err != nil {
13    log.Fatal(err)
14}
15fmt.Printf("Verdict: %s\n", output.Verdict)

Tools

Client-side tool handlers and gateway-hosted native tools.

Client Tools

Go uses MakeClientTool and ClientToolSet for typed tool definitions with automatic schema generation. TypeScript uses makeClientTool from vai/zod for schema-validated tool handlers.

1readFile := vai.MakeClientTool("read_file", "Read a file from the repository",
2    func(ctx context.Context, in struct {
3        Path string `json:"path" desc:"File path relative to the repo root"`
4    }) (string, error) {
5        data, err := os.ReadFile(in.Path)
6        if err != nil {
7            return "", err
8        }
9        return string(data), nil
10    },
11    vai.WithEffectClass("read_only"),
12)
13
14tools := vai.NewClientToolSet(readFile)
15
16stream := client.Runs.Stream(ctx, vai.RunCreateParams{
17    Blocks:      []vai.BlockParam{vai.TextInput("Read main.go and summarize it")},
18    ClientTools: tools.Definitions(),
19    Routing:     &vai.RoutingParam{Model: "gpt-5.4"},
20}, tools.HandlerOptions()...)

Native Tools

Gateway-hosted tools like web search, web fetch, and image generation run server-side. Use .Auto() / .auto() for the default image-generation path, or pass config when you want auto-selection with an explicit reviewed image model.

1stream := client.Runs.Stream(ctx, vai.RunCreateParams{
2    Blocks: []vai.BlockParam{
3        vai.TextInput("Find recent AI news and summarize"),
4    },
5    Routing: &vai.RoutingParam{Model: "gpt-5.4"},
6    Tools: []vai.ToolParam{
7        vai.WebSearch.Auto(),
8        vai.WebFetch.Auto(),
9        vai.ImageGen.Auto(),
10        vai.ImageGen.AutoWith(map[string]any{"model": vai.ModelGemini3_1FlashImagePreview, "size": "1K"}),
11    },
12})

Transport

REST, SSE, native WebSocket, and live audio share the same session model.

Transport Matrix

Blocking calls	`Go: client.Calls.Create() \| TS/Python/Rust: client.call()`	REST
Blocking runs	`Go: client.Runs.Execute() \| TS/Python/Rust: client.run()`	REST
Streamed execution	`Go: Calls.Stream()/Runs.Stream() \| TS: callStream()/runStream() \| Python/Rust: call_stream()/run_stream()`	SSE
Native realtime	`Go: client.Realtime.Connect() \| TS/Python: client.realtime.connect() \| Rust: client.realtime().connect()`	WebSocket
Live audio	`Go: client.Live.Connect() \| TS/Python: client.live.connect() \| Rust: client.live().connect()`	WebSocket

Native Realtime (WebSocket)

Use native WebSocket for bidirectional session-bound traffic. Bind a session, then run calls and streams over the same connection.

1conn, err := client.Realtime.Connect(ctx)
2if err != nil {
3    log.Fatal(err)
4}
5defer conn.Close()
6
7conn.BindSession(ctx, vai.SessionBindParams{
8    SessionID: vai.String("sess_123"),
9})
10
11stream := conn.RunStream(ctx, vai.RunCreateParams{
12    Blocks: []vai.BlockParam{vai.TextInput("Fix the auth bug")},
13    Routing: &vai.RoutingParam{Model: "gpt-5.4"},
14})
15
16for stream.Next() {
17    switch e := stream.Event().(type) {
18    case *vai.ResponseDeltaEvent:
19        fmt.Print(e.Delta)
20    case *vai.RunCompletedEvent:
21        fmt.Printf("\nDone: %s\n", e.Run.ID)
22    }
23}

Live Audio

Live audio is a transport mode on the same session model, not a separate continuity surface. Open a live connection, stream audio in, and receive text plus audio out.

1live, err := client.Live.Connect(ctx, vai.LiveStartParams{
2    SessionID: vai.String("sess_123"),
3    Voice:     "voice_alloy",
4    Routing:   &vai.RoutingParam{Model: "gpt-5.4"},
5    AudioInput: &vai.LiveAudioFormat{
6        Format: "pcm_s16le", SampleRateHz: 16000,
7    },
8    AudioOutput: &vai.LiveAudioFormat{
9        Format: "pcm_s16le", SampleRateHz: 24000,
10    },
11})
12if err != nil {
13    log.Fatal(err)
14}
15defer live.Stop()
16
17live.SendAudio(audioFromMicrophone)
18
19for live.Next() {
20    switch e := live.Event().(type) {
21    case *vai.LiveResponseAudioEvent:
22        speaker.Write(e.Audio)
23    case *vai.LiveResponseTextEvent:
24        fmt.Print(e.Text)
25    }
26}

Data & History

Hosted history, structured queries, and data export are first-party SDK surfaces.

Hosted History

Exact-detail hosted history with bidirectional paging. Essential for chat UIs, inbox views, and product-facing history review.

Capability	Go
Session detail	`client.History.GetSession(ctx, id, ...)`
Session search	`client.History.SearchSessions(ctx, ...)`
Session summary	`client.History.SessionSummary(ctx, id)`
Run detail	`client.History.GetRun(ctx, id)`

Lineage

Use session lineage for fork and branch graph reads, and block refs for direct provenance on copied, transformed, compacted, and normalized blocks. The SDKs expose typed direct lineage edges plus a one-parent convenience helper for the simple case.

1graph, err := client.Sessions.Lineage(ctx, sessionID)
2if err != nil {
3    log.Fatal(err)
4}
5
6_ = graph // inspect branch/fork relationships on the session graph
7
8blocks := client.Sessions.Blocks(ctx, sessionID, vai.BlocksParams{
9    PageSize: vai.Int(1),
10})
11
12if blocks.Next() {
13    block := blocks.Value()
14    if block.Refs != nil {
15        fmt.Println(block.Refs.ContentParentIDs())
16        fmt.Println(block.Refs.StructuralAnchorIDs())
17
18        if parent := block.Refs.PrimaryDerivedFrom(); parent != nil {
19            fmt.Println(*parent)
20        }
21    }
22}
23if err := blocks.Err(); err != nil {
24    log.Fatal(err)
25}

Data Queries

Query structured data sources with typed filters, sorting, and aggregation. Sources include run_summaries, session_summaries, call_summaries, and tool_execution_summaries.

1iter := client.Data.Sources.Query(ctx, "run_summaries", vai.QueryParams{
2    Filter: vai.And(
3        vai.In("status", "failed", "timed_out"),
4        vai.Gt("cost_micros_usd", 5000000),
5    ),
6    Sort: []vai.SortField{
7        {Field: "cost_micros_usd", Direction: vai.SortDesc},
8    },
9})
10
11for iter.Next() {
12    row := iter.Value()
13    fmt.Printf("Run %s: %s — $%.2f\n",
14        row.Ref("run_id"),
15        row.String("status"),
16        float64(row.Int64("cost_micros_usd"))/1_000_000,
17    )
18}

Pagination

List methods return lazy auto-paginating iterators. Pages are fetched on demand as you iterate. Use listPage() for manual page-by-page control.

1iter := client.Sessions.List(ctx, vai.SessionListParams{
2    Limit: vai.Int(100),
3})
4
5for iter.Next() {
6    session := iter.Value()
7    fmt.Printf("Session: %s — %s\n", session.ID, session.Status)
8}
9if err := iter.Err(); err != nil {
10    log.Fatal(err)
11}

Evals & Feedback

Assessments, feedback signals, and session branching are part of the core SDK surface.

Assessments

Read assessment bundles attached to runs and sessions. Assessment profiles run automatically based on triggers you configure.

Capability	Go
Run assessments	`client.Runs.Assessments(ctx, id, ...)`
Session assessments	`client.Sessions.Assessments(ctx, id, ...)`
Structured data query	`client.Data.Sources.Query(ctx, "run_summaries", ...)`
Assessment rollup	`client.Sessions.AssessmentRollup(ctx, id)`

Feedback

Send end-user feedback signals such as thumbs up, thumbs down, ratings, and comments attached to sessions and runs. Feedback is a top-level resource, separate from assessments.

1// Thumbs up
2signal, _ := client.Feedback.ThumbsUp(ctx, "sess_123", "run_456")
3
4// Thumbs down with comment
5signal, _ = client.Feedback.ThumbsDownWithComment(ctx,
6    "sess_123", "run_456",
7    "Answer missed my billing constraint.",
8)
9fmt.Printf("Feedback ID: %s\n", signal.ID)

Session Branching

Branch a session to create evaluation variants, forks, or subtasks. Optionally apply block-level transforms such as replace, mask, and drop to curate the branched context. Derived blocks keep typed direct provenance in refs.lineage, and branching is the right way to fan out parallel work instead of contending on one session head.

1branched, err := client.Sessions.Branch(ctx, "sess_123", vai.SessionBranchParams{
2    AtRunID:          vai.String("run_789"),
3    RelationshipKind: vai.Ptr(vai.RelationshipKindEval),
4    Label:            vai.String("alternative-approach"),
5})
6if err != nil {
7    log.Fatal(err)
8}
9
10// Run on the branched session
11stream := client.Runs.Stream(ctx, vai.RunCreateParams{
12    SessionID: vai.String(branched.ID),
13    Blocks: []vai.BlockParam{
14        vai.TextInput("Continue with the new approach"),
15    },
16})

Browser Automation

Hosted browser automation is session-scoped. Enable a browser binding on a session, run native browser tools through browser_navigate, browser_observe, browser_extract, and browser_act, and inspect browser state through exact reads. Local browser mode uses the same logical tool names but remains on the client_tools trust boundary.

Hosted Browser Run

1const session = await client.sessions.create({
2  defaults: {
3    browser: {
4      mode: "hosted",
5      capture: { screenshotAfterAct: true },
6      persistence: { kind: "session" },
7    },
8  },
9});
10
11await client.sessions.enableBrowser(session.id, { mode: "hosted" });
12
13const result = await client.run({
14  sessionId: session.id,
15  browser: {
16    mode: "hosted",
17    binding: { create: "if_missing" },
18    policy: { checkpointOn: ["credential_entry", "payment", "destructive"] },
19  },
20  tools: [{ kind: "browser_navigate" }, { kind: "browser_observe" }, { kind: "browser_act" }],
21  input: "Open https://example.com and summarize the page.",
22});
23
24const binding = await client.sessions.browser(session.id);
25const tabs = await client.sessions.browserTabs(session.id).toArray();

Handoff And Checkpoints

When hosted browser policy requires human action, Rhone creates a canonical checkpoint and browser handoff. Completing the handoff only returns browser control to the agent; workflow continuation still requires resolving the checkpoint and resuming the run.

typescript

1const handoff = await client.sessions.browserHandoff(session.id, {
2  runId: run.id,
3  reason: "Review the destructive browser action.",
4  checkpoint: {
5    kind: "approval",
6    title: "Approve browser action",
7    prompt: "Review the hosted browser, then resolve the checkpoint.",
8    options: [{ id: "continue", label: "Continue" }],
9  },
10});
11
12await client.checkpoints.resolve(run.checkpoint.id, { optionId: "continue" });
13await client.runs.resume(run.id);

Assets, Uploads, And Downloads

Hosted browser uploads use Rhone assets. Upload the file first and pass the resulting asset ID as upload_asset_ids on browser_act; Rhone materializes a temporary hosted file path for the provider. Downloads and screenshots surface Rhone asset_ids, never raw provider URLs.

typescript

1const upload = await client.assets.upload({
2  filename: "receipt.pdf",
3  mediaType: "application/pdf",
4  body: fileBytes,
5});
6
7const result = await client.run({
8  sessionId: session.id,
9  browser: { mode: "hosted", binding: { create: "if_missing" } },
10  tools: [{ kind: "browser_act" }],
11  blocks: [{
12    kind: "input",
13    content: [{
14      type: "structured",
15      value: {
16        instruction: "Attach the receipt file.",
17        action_class: "file_upload",
18        upload_asset_ids: [upload.id],
19      },
20    }],
21  }],
22});

Local Browser Mode

Local mode does not run in Rhone-hosted Browserbase. It routes browser tools as client tools with actual_delivery = "client_local_browser" so your companion process can attach to a local CDP browser and submit normal tool results.

The Go SDK includes an optional CDP companion for local browser execution. It attaches to a user-owned browser debug endpoint, enforces local domain/action policy, and registers the canonical browser tools as client-tool handlers.

1companion := localbrowser.New("http://127.0.0.1:9222", localbrowser.Policy{
2    AllowedDomains: []string{"*.example.com"},
3    RequireConsent: true,
4    Consent: func(ctx context.Context, request localbrowser.ConsentRequest) error {
5        return promptUserForBrowserAction(request)
6    },
7})
8companion.AllowedUploadRoots = []string{"/Users/alex/Documents/browser-uploads"}
9companion.DownloadDir = "/Users/alex/Downloads/rhone-browser"
10
11result, err := client.Runs.Execute(ctx, vai.RunCreateParams{
12    Browser: &vai.BrowserRequestConfig{Mode: vai.BrowserModeClientLocal},
13    Tools: []vai.ToolParam{{Kind: "browser_navigate"}, {Kind: "browser_observe"}, {Kind: "browser_act"}},
14    Input: "Use my local browser to inspect the staging dashboard.",
15}, vai.WithClientToolSet(companion.ToolSet()))

For local uploads, the companion accepts explicit local_file_paths on browser_act and only permits files under AllowedUploadRoots when that allowlist is configured. Local downloads stay on the user's machine by default; setting DownloadDir asks Chrome to save downloads there and returns local_downloads paths in the tool result. These paths are not promoted to Rhone assets unless the application explicitly uploads them through the asset API.

typescript

1const result = await client.run({
2  browser: { mode: "client_local" },
3  clientTools: [
4    {
5      name: "browser_navigate",
6      inputSchema: { type: "object" },
7      handler: async (input) => localCompanion.navigate(input),
8    },
9  ],
10  input: "Use my local browser to open the staging site.",
11});

Errors & Retry

Typed error hierarchies, canonical error codes, and automatic retry.

Safety SDKs

The Go and TypeScript SDKs expose runtime safety profiles and decision reads through first-party resources. Safety decisions are read-only runtime records; clients manage profiles and resolve checkpoints with reviewer identity.

Capability Detection

1ok, err := client.SupportsSafety(ctx)
2if err != nil {
3    return err
4}
5if !ok {
6    return errors.New("runtime safety is not enabled")
7}

List Safety Decisions

1iter := client.Runs.SafetyDecisions(ctx, runID, vai.SafetyDecisionListParams{
2    ActiveOnly: vai.Bool(true),
3})
4
5for iter.Next() {
6    decision := iter.Value()
7    fmt.Println(decision.Disposition)
8}
9if err := iter.Err(); err != nil {
10    return err
11}

Manage Safety Profiles

1profile, err := client.Safety.Profiles.Create(ctx, vai.SafetyProfileCreateParams{
2    Name: "default-runtime-safety",
3    Mode: vai.SafetyProfileModeEnforce,
4    StagePolicies: map[string]vai.SafetyStagePolicy{
5        "pre_tool_execution": {
6            Enabled:                    true,
7            DefaultActionOnUnavailable: vai.SafetyDefaultActionCheckpoint,
8        },
9    },
10    CapturePolicy: &vai.SafetyCapturePolicy{
11        StoreInputExcerpts:     "minimal",
12        StoreAssetRefs:         true,
13        StoreRawVendorPayloads: false,
14    },
15})

Resolve Safety Checkpoints

1checkpoint, err := client.Checkpoints.Resolve(ctx, checkpointID, vai.CheckpointResolveParams{
2    OptionID: "approve",
3    ReviewNote: "Approved after checking tool action.",
4    ReviewLabels: map[string]any{"risk": "low"},
5}, vai.WithReviewer("user_123", "human"))

See Safety & Guardrails for operator workflows and investigation guidance.

Error Handling

Match on canonical error codes rather than string messages. The four official SDKs preserve server error identity instead of flattening it into generic transport failures. The SDK automatically retries network failures, 429s, and 5xx responses with configurable backoff. Conflicting session mutations fail with session.writer_conflict; the SDK does not silently queue them locally.

1result, err := client.Runs.Execute(ctx, params)
2if err != nil {
3    var apiErr *vai.APIError
4    if errors.As(err, &apiErr) {
5        fmt.Println(apiErr.Code, apiErr.Message)
6        if apiErr.Code == "session.writer_conflict" {
7            fmt.Println("branch for parallel work or retry after the active writer finishes")
8        }
9        if apiErr.Code == vai.ErrCodeRateLimited && apiErr.RetryAfter != nil {
10            time.Sleep(*apiErr.RetryAfter)
11        }
12    }
13}

VAI SDK

runStream is the hero

Session-first, session-optional

Any model, any provider

Rhone as product DB

On this page

Getting Started

Installation

Client Configuration

Stream a Run

With model parameters

Cross-provider with provider constraint

Sessions & Continuity

Coding Agent Demo

Core

Blocking Runs

Calls

Stateful vs Stateless

Stateful (default)

Stateless (explicit)

Structured Output

Tools

Client Tools

Native Tools

Transport

Transport Matrix

Native Realtime (WebSocket)

Live Audio

Data & History

Hosted History

Lineage

Data Queries

Pagination

Evals & Feedback

Assessments

Feedback

Session Branching

Browser Automation

Hosted Browser Run

Handoff And Checkpoints

Assets, Uploads, And Downloads

Local Browser Mode

Errors & Retry

Safety SDKs

Capability Detection

List Safety Decisions

Manage Safety Profiles

Resolve Safety Checkpoints

Error Handling