Go

Full API reference for the Agora Conversational AI Go SDK.

client.NewClient

The entry point for the SDK. Creates a new API client with the given request options. All sub-clients share the same configuration.

import (
    "github.com/AgoraIO/agora-agents-go/v2/client"
    "github.com/AgoraIO/agora-agents-go/v2/option"
)

Constructor

func NewClient(opts ...option.RequestOption) *Client

Creates a new API client. All sub-clients share the same configuration. For AgentKit integrations, use agentkit.NewAgoraClient instead.

Request options

Request options configure transport, retries, and advanced authentication behavior. For session integrations, prefer agentkit.NewAgoraClient with AppID and AppCertificate. AgentKit generates Conversational AI REST authentication and RTC join tokens when session methods run.

option.WithArea

func WithArea(area core.Area) *core.AreaRequestOption

Enables regional routing with automatic DNS-based domain selection.

c := client.NewClient(
    option.WithArea(option.AreaUS),
)

option.WithBaseURL

func WithBaseURL(baseURL string) *core.BaseURLOption

Overrides the default API endpoint. Useful for testing.

import Agora "github.com/AgoraIO/agora-agents-go/v2"

c := client.NewClient(
    option.WithBaseURL(Agora.Environments.Default),
)

option.WithHTTPClient

func WithHTTPClient(httpClient core.HTTPClient) *core.HTTPClientOption

Provides a custom *http.Client. Recommended for production to set timeouts.

c := client.NewClient(
    option.WithHTTPClient(&http.Client{
        Timeout: 10 * time.Second,
    }),
)

option.WithMaxAttempts

func WithMaxAttempts(attempts uint) *core.MaxAttemptsOption

Sets the maximum number of retry attempts. Default: 2. Retries use exponential backoff for status codes 408, 429, and 5xx.

c := client.NewClient(
    option.WithMaxAttempts(3),
)

option.WithHTTPHeader

func WithHTTPHeader(httpHeader http.Header) *core.HTTPHeaderOption

Adds custom HTTP headers to every request.

option.WithBodyProperties

func WithBodyProperties(bodyProperties map[string]interface{}) *core.BodyPropertiesOption

Adds extra properties to the JSON request body.

option.WithQueryParameters

func WithQueryParameters(queryParameters url.Values) *core.QueryParametersOption

Adds query parameters to the request URL.

option.WithPool

func WithPool(pool *core.Pool) *core.AreaRequestOption

Uses a pre-configured Pool for regional routing.

Sub-clients

client.NewClient exposes Fern-generated sub-clients for direct REST API access. You typically do not need these when using the agentkit layer.

All sub-client methods take context.Context as their first argument. See the generated reference for full method signatures.

Environments

The root Agora package exposes the default API endpoint:

import Agora "github.com/AgoraIO/agora-agents-go/v2"

Agora.Environments.Default
// "https://api.agora.io/api/conversational-ai-agent"

Pointer helpers

The root Agora package provides helper functions for creating pointers to literal values. These are required for optional fields in Fern-generated request structs, which use pointer types to distinguish between "not set" and "set to zero value".

import Agora "github.com/AgoraIO/agora-agents-go/v2"

agentkit.NewAgoraClient

The AgentKit client. NewAgent requires it, and sessions created from the agent inherit the client's App ID, App Certificate, and REST authentication mode.

import (
    "github.com/AgoraIO/agora-agents-go/v2/agentkit"
    "github.com/AgoraIO/agora-agents-go/v2/option"
)

Constructor

func NewAgoraClient(opts AgoraClientOptions) *AgoraClient

Creates an AgentKit client with the given options.

c := agentkit.NewAgoraClient(agentkit.AgoraClientOptions{
    Area:           option.AreaUS,
    AppID:          "your-app-id",
    AppCertificate: "your-app-certificate",
})

AgoraClientOptions

The authentication mode is AuthModeAppCredentials by default, AuthModeBasic when CustomerID is set, or AuthModeToken when Token is set.

Methods and fields

Methods and fields available on any *AgoraClient instance.

agentkit.NewAgent

Agent is an immutable configuration object. Each vendor chaining method returns a new *Agent — the original is never modified. Define one agent at startup and create sessions from it for each user conversation.

import (
    "github.com/AgoraIO/agora-agents-go/v2/agentkit"
    "github.com/AgoraIO/agora-agents-go/v2/agentkit/vendors"
)

Constructor

func NewAgent(client *AgoraClient, opts ...AgentOption) *Agent

Pass an AgoraClient and AgentOption functions to configure the agent's instructions, greeting, and other properties. Panics with NewAgent requires AgoraClient if client is nil. To name an agent instance, set Name in CreateSessionOptions.

agent := agentkit.NewAgent(c,
    agentkit.WithInstructions("You are a helpful voice assistant."), // LLM system prompt
    agentkit.WithGreeting("Hello! How can I help you today?"),       // first words spoken on session start
    agentkit.WithMaxHistory(10),
)

AgentOption functions

AgentOption functions are passed to NewAgent. AgentOption is func(*core.BaseAgent).

Vendor chaining methods

Vendor methods are called on the *Agent returned by NewAgent. Each method returns a new *Agent — the original is never modified.

WithLlm(vendor)

Sets the LLM vendor. Pass an instance of NewOpenAI, NewAzureOpenAI, NewAnthropic, NewGemini, or any other LLM vendor.

func (a *Agent) WithLlm(vendor vendors.LLM) *Agent

WithTts(vendor)

Sets the TTS vendor. Captures the vendor's sample rate for avatar validation. Panics if an avatar is already configured and its required sample rate differs from the TTS sample rate.

func (a *Agent) WithTts(vendor vendors.TTS) *Agent

WithStt(vendor)

Sets the STT vendor. Pass an instance of any STT vendor constructor.

func (a *Agent) WithStt(vendor vendors.STT) *Agent

WithMllm(vendor)

Sets the MLLM vendor for multimodal mode. Pass NewOpenAIRealtime, NewAzureOpenAIRealtime, NewGeminiLive, NewVertexAI, NewXaiGrok, or NewOpenAIGPTLive. Automatically sets mllm.enable = true.

func (a *Agent) WithMllm(vendor vendors.MLLM) *Agent

WithAvatar(vendor)

Sets the avatar vendor. For LiveAvatar and HeyGen avatars, panics if TTS is already configured with a sample rate that doesn't match the avatar's required rate. For other avatars, a mismatch causes WithTts() to panic or Start() to return an error.

func (a *Agent) WithAvatar(vendor vendors.Avatar) *Agent

WithTurnDetection(config)

Configures cascading-flow turn detection. Use Config.StartOfSpeech and Config.EndOfSpeech for SOS/EOS detection. Use interruption config for interruption behavior and MLLM vendor TurnDetection for MLLM turn detection.

func (a *Agent) WithTurnDetection(td *TurnDetectionConfig) *Agent

Other builder methods

The following methods follow the same pattern — each returns a new *Agent with the updated configuration.

ToProperties()

Converts the agent configuration to a *Agora.StartAgentsRequestProperties for direct use with the low-level client. Called internally by AgentSession.Start(). Use this directly when building custom request bodies.

func (a *Agent) ToProperties(opts ToPropertiesOptions) (*Agora.StartAgentsRequestProperties, error)

Returns an error if:

• Neither Token nor AppID + AppCertificate is provided
• AgentUID isn't numeric when a token must be generated
• RemoteUIDs is empty
• ExpiresIn is invalid
• MLLM is combined with an enabled avatar
• In cascading mode: LLM or TTS isn't configured
• Config marshaling fails

ToPropertiesOptions

type ToPropertiesOptions struct {
    Channel         string
    AgentUID        string
    RemoteUIDs      []string
    Token           string
    AppID           string
    AppCertificate  string
    ExpiresIn       int
    IdleTimeout     *int
    EnableStringUID *bool
    SkipVendorValidation           bool
    SkipVendorValidationCategories []string
    AllowMissingVendorCategories   []string
    Warn            func(string)
}

Getters

Read-only methods available on any *Agent instance.

agent.CreateSession

Creates an AgentSession from the agent configuration. This is the recommended way to create a session. The session's REST client, App ID, App Certificate, and REST authentication mode come from the agent's AgoraClient. Call Start() on the returned session to join the agent to the channel.

func (a *Agent) CreateSession(opts CreateSessionOptions) *AgentSession

session := agent.CreateSession(agentkit.CreateSessionOptions{
    Name:       "support-assistant",
    Channel:    "support-room-123",
    AgentUID:   "1",
    RemoteUIDs: []string{"100"},
})

CreateSessionOptions

agentkit.NewAgentSession

AgentSession manages the full lifecycle of a running agent. In most cases, use agent.CreateSession. Use NewAgentSession only when you need to supply the session's clients and agent yourself, then call Start() to join the agent to the channel.

import "github.com/AgoraIO/agora-agents-go/v2/agentkit"

Constructor

func NewAgentSession(opts AgentSessionOptions) *AgentSession

If Name is empty, defaults to agent-<unix_timestamp_ms>. The session starts in AgentSessionLifecycleIdle.

AgentSessionOptions

type AgentSessionOptions struct {
    Client                *agents.Client
    HTTPClient            core.HTTPClient
    AgentManagementClient *agentmanagement.Client
    Agent                 agentcore.AgentRuntime
    AppID           string
    AppCertificate  string
    Name            string
    Channel         string
    Token           string
    AgentUID        string
    RemoteUIDs      []string
    IdleTimeout     *int
    EnableStringUID *bool
    ExpiresIn       int
    UseAppCredentialsForREST bool
    Preset          []string
    PipelineID      string
    Debug           bool
    Warn            func(string)
}

PipelineID is sent as the top-level /join field pipeline_id, not inside properties. If not set, AgentSession.Start() uses the agent-level value from WithPipelineID.

State machine

A session progresses through the following states:

         Start()           API success
  ┌──────┐      ┌──────────┐      ┌─────────┐
  │ idle │─────>│ starting │─────>│ running │
  └──┬───┘      └────┬─────┘      └────┬────┘
     │               │                  │
     │               │ error            │ Stop()
     │               ▼                  ▼
     │          ┌─────────┐      ┌──────────┐
     │          │  error  │      │ stopping │
     │          └────┬────┘      └────┬─────┘
     │               │                │
     │               │                │ success
     │               ▼                ▼
     │          ┌──────────┐     ┌─────────┐
     └─────────>│ (restart)│     │ stopped │
                └──────────┘     └─────────┘

Start() can also be called from stopped or error state to restart the session. If you call Start() from an invalid state, or if it fails avatar validation, it returns an error without changing the status or emitting the error event. If Say(), Interrupt(), Update(), or Think() fails, it returns an error but doesn't change the session status.

Methods

All methods take context.Context as the first argument. Register event handlers before calling Start() to avoid missing the started event.

Start(ctx)

Starts the agent session. Validates avatar/TTS configuration, generates a token if not provided, and calls the Agora API. Returns the agent ID.

func (s *AgentSession) Start(ctx context.Context) (string, error)

• Valid from: idle, stopped, error
• Transitions to: starting → running on success, error on failure
• Emits: "started" on success, "error" on failure
• Validates avatar config and avatar/TTS sample rate match before making the API call

agentID, err := session.Start(ctx)
if err != nil {
    log.Fatalf("Failed to start session: %v", err)
}

Stop(ctx)

Stops the running agent and removes it from the channel.

func (s *AgentSession) Stop(ctx context.Context) error

• Valid from: running
• Transitions to: stopping → stopped on success, error on failure
• Emits: "stopped" on success, "error" on failure

err := session.Stop(ctx)
if err != nil {
    log.Fatalf("Failed to stop session: %v", err)
}

Say(ctx, text, priority, interruptable)

Instructs the agent to speak the given text.

func (s *AgentSession) Say(ctx context.Context, text string, priority *Agora.SpeakAgentsRequestPriority, interruptable *bool) error

• Valid from: running
• Pass nil for priority or interruptable to use defaults

err := session.Say(ctx, "One moment while I look that up.", nil, nil)

Interrupt(ctx)

Interrupts the agent's current speech.

func (s *AgentSession) Interrupt(ctx context.Context) error

• Valid from: running

Update(ctx, properties)

Updates the agent's properties mid-session without restarting. Accepts a typed properties struct in REST API format.

func (s *AgentSession) Update(ctx context.Context, properties *Agora.UpdateAgentsRequestProperties) error

• Valid from: running

GetHistory(ctx)

Retrieves the conversation history. Requires a valid agent ID — Start() must have been called successfully.

func (s *AgentSession) GetHistory(ctx context.Context) (*Agora.GetHistoryAgentsResponse, error)

GetTurns(ctx) / GetAllTurns(ctx)

Retrieves turn-by-turn analytics for the session. Requires a valid agent ID — Start() must have been called successfully.

func (s *AgentSession) GetTurns(ctx context.Context, opts ...GetTurnsOptions) (*Agora.GetTurnsAgentsResponse, error)
func (s *AgentSession) GetAllTurns(ctx context.Context, opts ...GetAllTurnsOptions) (*Agora.GetTurnsAgentsResponse, error)

type GetTurnsOptions struct {
    PageIndex *int
    PageSize  *int
}

type GetAllTurnsOptions struct {
    PageSize *int
}

PageIndex starts at 1. Use GetAllTurns to iterate through every page with a default page size of 50 and return the final response with aggregated Turns.

• Requires: Valid agent ID

When you consume server notifications, event 112 means all turns for the session have finished and are ready to query.

GetInfo(ctx)

Gets the current agent status from the API. Requires a valid agent ID.

func (s *AgentSession) GetInfo(ctx context.Context) (*Agora.GetAgentsResponse, error)

Think(ctx)

Injects a thought or instruction into a running agent. In v2.7, omitting on_listening_action uses the server default interrupt. Set agentkit.ThinkOnListeningActionInject.Ptr() if you need legacy inject behavior. AgentKit also exposes ThinkOnListeningActionInterrupt, ThinkOnListeningActionIgnore, ThinkOnThinkingActionInterrupt, ThinkOnThinkingActionIgnore, ThinkOnSpeakingActionInterrupt, and ThinkOnSpeakingActionIgnore convenience constants.

All three state actions also accept append. Pass Agora.AgentThinkAgentManagementRequestOnListeningActionAppend.Ptr(), Agora.AgentThinkAgentManagementRequestOnThinkingActionAppend.Ptr(), or Agora.AgentThinkAgentManagementRequestOnSpeakingActionAppend.Ptr(). With append, the instruction doesn't interrupt the current interaction. The agent waits for the current user turn, LLM inference, or TTS playback to finish, then appends the instruction to the context as a separate user message and starts a new turn.

func (s *AgentSession) Think(ctx context.Context, text string, onListeningAction *Agora.AgentThinkAgentManagementRequestOnListeningAction, onThinkingAction *Agora.AgentThinkAgentManagementRequestOnThinkingAction, onSpeakingAction *Agora.AgentThinkAgentManagementRequestOnSpeakingAction, interruptable *bool, metadata map[string]string) (*Agora.AgentThinkAgentManagementResponse, error)
func (s *AgentSession) ThinkWithOptions(ctx context.Context, text string, opts *ThinkOptions) (*Agora.AgentThinkAgentManagementResponse, error)

• Valid from: running

On(event, handler)

Registers an event handler. Multiple handlers can be registered for the same event. Handlers run synchronously; panics in handlers are recovered and reported through the session warning sink.

func (s *AgentSession) On(event string, handler EventHandler)

session.On("started", func(data interface{}) {
    info := data.(map[string]string)
    fmt.Println("Agent is live:", info["agent_id"])
})
session.On("stopped", func(data interface{}) {
    fmt.Println("Agent has left")
})
session.On("error", func(data interface{}) {
    log.Println("Session error:", data)
})

Off(event, handler)

Unregisters a previously registered event handler.

func (s *AgentSession) Off(event string, handler EventHandler)

Events

Getters

Read-only methods available on any *AgentSession instance.

Using session.Raw()

Use session.Raw() to call REST API endpoints not yet exposed by the agentkit layer.

response, err := session.Raw().List(ctx, &Agora.ListAgentsRequest{
    Appid: session.AppID(),
})

Thread safety

All state access is protected by sync.RWMutex. The session is safe for concurrent use across go routines.

Vendors

All vendor constructors are in the agentkit/vendors package. Constructors panic if required fields are empty — this is Go-idiomatic behavior for programmer configuration errors.

import "github.com/AgoraIO/agora-agents-go/v2/agentkit/vendors"

Interfaces

type LLM interface {
    ToConfig() map[string]interface{}
}

type TTS interface {
    ToConfig() map[string]interface{}
    GetSampleRate() *SampleRate
}

type STT interface {
    ToConfig() map[string]interface{}
}

type MLLM interface {
    ToConfig() map[string]interface{}
}

type Avatar interface {
    ToConfig() map[string]interface{}
    RequiredSampleRate() SampleRate
}

LLM vendors

Use with WithLlm().

NewOpenAI

func NewOpenAI(opts OpenAIOptions) *OpenAI

Panics if Model is empty. Panics if APIKey is empty unless Model is one of the supported Agora-managed OpenAI models (gpt-4o-mini, gpt-4.1-mini, gpt-5-nano, gpt-5-mini) and BaseURL / Vendor are not set.

NewAzureOpenAI

func NewAzureOpenAI(opts AzureOpenAIOptions) *AzureOpenAI

Panics if APIKey, Model, Endpoint, or DeploymentName is empty.

NewAnthropic

func NewAnthropic(opts AnthropicOptions) *Anthropic

Panics if APIKey, Model, URL, Headers, or MaxTokens is empty.

NewGemini

func NewGemini(opts GeminiOptions) *Gemini

Panics if APIKey or Model is empty.

Other LLM vendors

The SDK also includes named helpers for the remaining Agora-supported LLM providers. These helpers choose the correct request format internally.

The Tools field in LLM vendor options declares custom tools the LLM can choose to call. Each tool includes a model-visible function definition and the server configuration for a synchronous GET or POST request. WithTools(true) applies to both Tools and McpServers. For more information, see Call custom tools.

TTS vendors

Use with WithTts(). The SampleRate field determines avatar compatibility — see WithAvatar(). Use SampleRate constants for the SampleRate field.

NewElevenLabsTTS

func NewElevenLabsTTS(opts ElevenLabsTTSOptions) *ElevenLabsTTS

Panics if Key, ModelID, VoiceID, or BaseURL is empty.

NewMicrosoftTTS

func NewMicrosoftTTS(opts MicrosoftTTSOptions) *MicrosoftTTS

Panics if Key, Region, or VoiceName is empty.

NewOpenAITTS

Fixed sample rate: SampleRate24kHz.

func NewOpenAITTS(opts OpenAITTSOptions) *OpenAITTS

Panics if Voice is empty. APIKey, Model, and BaseURL are required together for BYOK. APIKey is optional for the Agora-managed tts-1 path. Always returns SampleRate24kHz from GetSampleRate().

NewCartesiaTTS

func NewCartesiaTTS(opts CartesiaTTSOptions) *CartesiaTTS

Panics if APIKey, VoiceID, or ModelID is empty.

NewGoogleTTS

func NewGoogleTTS(opts GoogleTTSOptions) *GoogleTTS

Panics if Key or VoiceName is empty.

NewAmazonTTS

func NewAmazonTTS(opts AmazonTTSOptions) *AmazonTTS

Panics if AccessKey, SecretKey, Region, VoiceID, or Engine is empty.

NewDeepgramTTS

func NewDeepgramTTS(opts DeepgramTTSOptions) *DeepgramTTS

Panics if APIKey or Model is empty.

NewHumeAITTS

func NewHumeAITTS(opts HumeAITTSOptions) *HumeAITTS

Panics if Key, VoiceID, or Provider is empty.

NewRimeTTS

func NewRimeTTS(opts RimeTTSOptions) *RimeTTS

In BYOK mode (default), panics if Key, Speaker, or ModelID is empty. In managed mode, panics if BaseURL or ModelID is empty.

NewFishAudioTTS

func NewFishAudioTTS(opts FishAudioTTSOptions) *FishAudioTTS

Panics if Key, ReferenceID, or Backend is empty.

NewMiniMaxTTS

func NewMiniMaxTTS(opts MiniMaxTTSOptions) *MiniMaxTTS

Panics if Model is empty. Key is optional for supported preset-backed MiniMax models (speech-2.6-turbo, speech_2_6_turbo, speech-2.8-turbo, speech_2_8_turbo). In BYOK mode (Key set), GroupID and URL are also required. In preset-backed mode, don't set GroupID, VoiceID, or URL.

NewMurfTTS

func NewMurfTTS(opts MurfTTSOptions) *MurfTTS

Panics if Key is empty.

NewSarvamTTS

func NewSarvamTTS(opts SarvamTTSOptions) *SarvamTTS

Panics if Key, Speaker, or TargetLanguageCode is empty.

NewTypecastTTS

func NewTypecastTTS(opts TypecastTTSOptions) *TypecastTTS

Panics if APIKey, VoiceID, or Model is empty.

NewGradiumTTS

func NewGradiumTTS(opts GradiumTTSOptions) *GradiumTTS

Panics if APIKey is empty.

NewMistralTTS

func NewMistralTTS(opts MistralTTSOptions) *MistralTTS

Panics if APIKey is empty.

NewGenericTTS

func NewGenericTTS(opts GenericTTSOptions) *GenericTTS

Custom OpenAI-compatible HTTP TTS. URL is required and must be an absolute HTTP or HTTPS address that includes a host — this panics if URL is missing, badly formatted, or uses a non-HTTP(S) scheme such as ws, wss, or ftp. A valid URL is serialized as tts.vendor = "generic_http".

NewXaiTTS

func NewXaiTTS(opts XaiTTSOptions) *XaiTTS

Panics if APIKey or Language is empty.

NewSmallestAITTS

func NewSmallestAITTS(opts SmallestAITTSOptions) *SmallestAITTS

Panics if APIKey is empty.

Voice identifiers are model-specific, so VoiceID must belong to the model set in Model. For details, see Smallest AI.

STT vendors

Use with WithStt().

NewDeepgramSTT

func NewDeepgramSTT(opts DeepgramSTTOptions) *DeepgramSTT

Panics if APIKey is empty unless Model is one of the supported Agora-managed Deepgram models (nova-2, nova-3).

NewSpeechmaticsSTT

func NewSpeechmaticsSTT(opts SpeechmaticsSTTOptions) *SpeechmaticsSTT

Panics if Key or Language is empty.

NewMicrosoftSTT

func NewMicrosoftSTT(opts MicrosoftSTTOptions) *MicrosoftSTT

Panics if Key, Region, or Language is empty.

NewOpenAISTT

func NewOpenAISTT(opts OpenAISTTOptions) *OpenAISTT

Panics if APIKey is empty. WithStt() also panics if the transcription prompt or language isn't set through the Prompt and Language fields or within InputAudioTranscription. model defaults to gpt-4o-mini-transcribe.

NewGoogleSTT

func NewGoogleSTT(opts GoogleSTTOptions) *GoogleSTT

Panics if ProjectID, Location, ADCCredentialsString, or Language is empty.

NewAmazonSTT

func NewAmazonSTT(opts AmazonSTTOptions) *AmazonSTT

Panics if AccessKey, SecretKey, Region, or Language is empty.

NewAssemblyAISTT

func NewAssemblyAISTT(opts AssemblyAISTTOptions) *AssemblyAISTT

Panics if APIKey or Language is empty.

NewGeminiSTT

func NewGeminiSTT(opts GeminiSTTOptions) *GeminiSTT

Panics if APIKey is empty, if Mode is set to a value other than SMART or VERBATIM, if CustomVocabulary is combined with WordTimestamp, or if SMART mode is combined with WordTimestamp or Diarization.

NewXaiSTT

func NewXaiSTT(opts XaiSTTOptions) *XaiSTT

Panics if APIKey is empty.

NewAresSTT

func NewAresSTT(options ...AresSTTOptions) *AresSTT

Agora-managed global ASR provider. options is variadic so callers can select Ares without configuring keyword hints; panics if more than one options value is passed.

NewSarvamSTT

func NewSarvamSTT(opts SarvamSTTOptions) *SarvamSTT

Panics if APIKey or Language is empty.

NewSmallestAISTT

func NewSmallestAISTT(opts SmallestAISTTOptions) *SmallestAISTT

Panics if APIKey is empty.

Boolean options are serialized as the strings "true" or "false" for the Smallest AI wire protocol. Unlike the other SDKs, these fields are plain bool rather than pointers, so every one of them is sent on each request. For details, see Smallest AI.

MLLM vendors

Use with WithMllm() for multimodal end-to-end audio processing without separate STT, LLM, or TTS steps. WithMllm() automatically sets mllm.enable = true; you do not need to set the deprecated AdvancedFeatures.EnableMllm flag.

NewOpenAIRealtime

func NewOpenAIRealtime(opts OpenAIRealtimeOptions) *OpenAIRealtime

Panics if APIKey is empty.

NewAzureOpenAIRealtime

func NewAzureOpenAIRealtime(opts AzureOpenAIRealtimeOptions) *AzureOpenAIRealtime

Panics if APIKey, URL, or TurnDetection is empty.

NewGeminiLive

func NewGeminiLive(opts GeminiLiveOptions) *GeminiLive

Panics if APIKey or Model is empty.

NewVertexAI

func NewVertexAI(opts VertexAIOptions) *VertexAI

Panics if ProjectID or ADCredentialsString is empty.

NewXaiGrok

func NewXaiGrok(opts XaiGrokOptions) *XaiGrok

xAI Grok MLLM vendor (mllm.vendor: "xai"). Panics if APIKey is empty. Defaults URL to wss://api.x.ai/v1/realtime.

XaiGrokOptions

Same fields as XAIGrokOptions below.

NewXAIGrok (deprecated)

func NewXAIGrok(opts XAIGrokOptions) *XAIGrok

Deprecated. Use NewXaiGrok instead.

XAIGrokOptions