agent

type AVSynchronizer interface {
	Push(frame interface{}) error
	Close() error
}

type Agent struct {
	ID           string
	Instructions string
	ChatCtx      *llm.ChatContext
	Tools        []interface{}

	TurnDetection TurnDetectionMode
	TurnDetector  TurnDetector
	STT           stt.STT
	VAD           vad.VAD
	LLM           llm.LLM
	TTS           tts.TTS

	LLMNode                 LLMNodeFunc
	TTSNode                 TTSNodeFunc
	STTNode                 STTNodeFunc
	VideoNode               VideoNodeFunc
	TranscriptionNode       TranscriptionNodeFunc
	RealtimeAudioOutputNode RealtimeAudioOutputNodeFunc

	AllowInterruptions        bool
	MinConsecutiveSpeechDelay float64
	UseTTSAlignedTranscript   bool
	MinEndpointingDelay       float64
	MaxEndpointingDelay       float64
	// contains filtered or unexported fields
}

type AgentActivity struct {
	AgentIntf AgentInterface
	Agent     *Agent
	Session   *AgentSession
	// contains filtered or unexported fields
}

type AgentEvent struct {
	Type      string  `json:"type"`
	Timestamp float64 `json:"timestamp"`

	UserStateChanged       *UserStateChangedEvent       `json:"user_state_changed,omitempty"`
	AgentStateChanged      *AgentStateChangedEvent      `json:"agent_state_changed,omitempty"`
	UserInputTranscribed   *UserInputTranscribedEvent   `json:"user_input_transcribed,omitempty"`
	AgentFalseInterruption *AgentFalseInterruptionEvent `json:"agent_false_interruption,omitempty"`
	MetricsCollected       *MetricsCollectedEvent       `json:"metrics_collected,omitempty"`
	ConversationItemAdded  *ConversationItemAddedEvent  `json:"conversation_item_added,omitempty"`
	FunctionToolsExecuted  *FunctionToolsExecutedEvent  `json:"function_tools_executed,omitempty"`
	AgentHandoff           *AgentHandoffEvent           `json:"agent_handoff,omitempty"`
	SpeechCreated          *SpeechCreatedEvent          `json:"speech_created,omitempty"`
	Error                  *ErrorEvent                  `json:"error,omitempty"`
	Close                  *CloseEvent                  `json:"close,omitempty"`
	ParticipantActive      *ParticipantActiveEvent      `json:"participant_active,omitempty"`
}

type AgentFalseInterruptionEvent struct {
	Resumed   bool      `json:"resumed"`
	CreatedAt time.Time `json:"created_at"`
}

type AgentHandoffEvent struct {
	OldAgent   AgentInterface    `json:"-"`
	NewAgent   AgentInterface    `json:"-"`
	OldAgentID string            `json:"old_agent_id"`
	NewAgentID string            `json:"new_agent_id"`
	Handoff    *llm.AgentHandoff `json:"handoff"`
	CreatedAt  time.Time         `json:"created_at"`
}

type AgentHandoffRunEvent struct {
	Item     *llm.AgentHandoff
	OldAgent AgentInterface
	NewAgent AgentInterface
}

type AgentInput struct {
	Audio AudioInput
	Text  TextInput
	Video VideoInput
}

type AgentInterface interface {
	OnEnter(ctx context.Context) error
	OnExit(ctx context.Context) error
	OnUserTurnCompleted(ctx context.Context, chatCtx *llm.ChatContext, newMsg *llm.ChatMessage) error
	GetAgent() *Agent
	GetActivity() *AgentActivity
}

type AgentOutput struct {
	Audio         AudioOutput
	Transcription TextOutput
	Video         VideoOutput
	Publisher     MediaPublisher
}

type AgentSession struct {
	Options AgentSessionOptions

	ChatCtx   *llm.ChatContext
	Agent     AgentInterface
	STT       stt.STT
	VAD       vad.VAD
	LLM       llm.LLM
	TTS       tts.TTS
	Tools     []interface{}
	Assistant *PipelineAgent
	Room      *lksdk.Room

	Input  AgentInput
	Output AgentOutput

	MetricsCollector *telemetry.UsageCollector
	Timeline         *EventTimeline

	UserState  UserState
	AgentState AgentState

	// Transcript attribution — set by RoomIO when tracks are established.
	RemoteUserIdentity string
	RemoteTrackSID     string
	AgentTrackSID      string

	Activity *AgentActivity

	// Event channels
	AgentStateChangedCh chan AgentStateChangedEvent
	UserStateChangedCh  chan UserStateChangedEvent
	// contains filtered or unexported fields
}

type AgentSessionOptions struct {
	AllowInterruptions            bool
	DiscardAudioIfUninterruptible bool
	MinInterruptionDuration       float64
	MinInterruptionWords          int
	MinEndpointingDelay           float64
	MaxEndpointingDelay           float64
	MaxToolSteps                  int
	UserAwayTimeout               float64
	FalseInterruptionTimeout      float64
	ResumeFalseInterruption       bool
	MinConsecutiveSpeechDelay     float64
	UseTTSAlignedTranscript       bool
	PreemptiveGeneration          bool
	AECWarmupDuration             float64
	SpeakingRate                  float64
	TranscriptRefreshRate         time.Duration
	LinkedParticipant             lksdk.Participant
	IVRDetection                  bool
}

type AgentState string

type AgentStateChangedEvent struct {
	OldState  AgentState `json:"old_state"`
	NewState  AgentState `json:"new_state"`
	CreatedAt time.Time  `json:"created_at"`
}

type AgentTask[T any] struct {
	Agent
	Result chan T
	Err    chan error
}

type AudioConfig struct {
	Source      AudioSource
	Volume      float64
	Probability float64
}

type AudioInput interface {
	Label() string
	Stream() <-chan *model.AudioFrame
	OnAttached()
	OnDetached()
}

type AudioOutput interface {
	Label() string
	CaptureFrame(frame *model.AudioFrame) error
	Flush()
	WaitForPlayout(ctx context.Context) error
	ClearBuffer()
	OnAttached()
	OnDetached()
	Pause()
	Resume()
	OnPlaybackStarted(func(ev PlaybackStartedEvent))
	OnPlaybackFinished(func(ev PlaybackFinishedEvent))
}

type AudioReceiver interface {
	Start(ctx context.Context) error
	Stream() <-chan *model.AudioFrame
	NotifyPlaybackFinished(playbackPosition time.Duration, interrupted bool) error
	Close() error
}

type AudioRecognition struct {
	// contains filtered or unexported fields
}

type AudioSource interface{} // Can be string, BuiltinAudioClip, or <-chan *model.AudioFrame

type AvatarIO interface {
	SendAvatarData(ctx context.Context, data []byte) error
}

type AvatarOptions struct {
	VideoWidth      int
	VideoHeight     int
	VideoFPS        float64
	AudioSampleRate int
	AudioChannels   int
}

type AvatarRunner struct {
	// contains filtered or unexported fields
}

type BackgroundAudioPlayer struct {
	// contains filtered or unexported fields
}

type BuiltinAudioClip string

type ChatMessageRunEvent struct {
	Item *llm.ChatMessage
}

type ClientEventPayload struct {
	Type  string `json:"type"`
	State string `json:"state,omitempty"`
}

type ClientEventsDispatcher struct {
	// contains filtered or unexported fields
}

type CloseEvent struct {
	Reason    CloseReason `json:"reason"`
	Error     error       `json:"error,omitempty"`
	CreatedAt time.Time   `json:"created_at"`
}

type CloseReason string

type CommitUserTurnOpts struct {
	AudioDetached     bool
	TranscriptTimeout time.Duration
	STTFlushDuration  time.Duration
	SkipReply         bool
}

type ConversationItemAddedEvent struct {
	Item      llm.ChatItem `json:"item"`
	CreatedAt time.Time    `json:"created_at"`
}

type DataStreamIO struct {
	// contains filtered or unexported fields
}

type DtmfEvent struct {
	Digit string
	Time  time.Time
}

type EndOfTurnInfo struct {
	SkipReply            bool
	TranscriptTimeout    time.Duration
	STTFlushDuration     time.Duration
	NewTranscript        string
	TranscriptConfidence float64
	StartedSpeakingAt    *float64
	StoppedSpeakingAt    *float64
}

type ErrorEvent struct {
	Error     error     `json:"error"`
	Source    any       `json:"source,omitempty"`
	CreatedAt time.Time `json:"created_at"`
}

type EvaluationResult struct {
	Judgments map[string]string
}

type Event interface {
	GetType() string
}

type EventTimeline struct {
	OnEvent func(ev *AgentEvent)
	// contains filtered or unexported fields
}

type FunctionCallOutputRunEvent struct {
	Item *llm.FunctionCallOutput
}

type FunctionCallRunEvent struct {
	Item *llm.FunctionCall
}

type FunctionToolsExecutedEvent struct {
	FunctionCalls       []llm.FunctionCall        `json:"function_calls"`
	FunctionCallOutputs []*llm.FunctionCallOutput `json:"function_call_outputs"`
	CreatedAt           time.Time                 `json:"created_at"`
	HasToolReply        bool                      `json:"has_tool_reply"`
	HasAgentHandoff     bool                      `json:"has_agent_handoff"`
}

type GenerateReplyOpts struct {
	AllowInterruptions bool
}

type GetAgentInfoResponse struct {
	ID           string         `json:"id"`
	Instructions string         `json:"instructions,omitempty"`
	Tools        []string       `json:"tools"`
	ChatCtx      []llm.ChatItem `json:"chat_ctx"`
}

type GetChatHistoryResponse struct {
	Items []llm.ChatItem `json:"items"`
}

type GetSessionStateResponse struct {
	AgentState string         `json:"agent_state"`
	UserState  string         `json:"user_state"`
	AgentID    string         `json:"agent_id"`
	Options    map[string]any `json:"options"`
	CreatedAt  float64        `json:"created_at"`
}

type IVRActivity struct {
	AgentIntf AgentInterface
	Agent     *Agent
	// contains filtered or unexported fields
}

type InputDetails struct {
	Modality string
}

type JobResult interface {
	Wait(ctx context.Context) error
	GetEvents() []RunEvent
}

type LLMGenerationData struct {
	TextCh        chan string
	FunctionCh    chan *llm.FunctionToolCall
	FullTextCh    chan string // receives the complete assembled text when streaming is done
	GeneratedText string
	Usage         *llm.CompletionUsage
}

type LLMNodeFunc func(ctx context.Context, l llm.LLM, chatCtx *llm.ChatContext, tools []interface{}) (*LLMGenerationData, error)

type LLMTurnDetector struct {
	// contains filtered or unexported fields
}

type MediaPublisher interface {
	Identity() string
	PublishData(data []byte, topic string, destinationSIDs []string) error
	SetAttributes(attrs map[string]string) error
}

type MetricsCollectedEvent struct {
	Metrics   telemetry.AgentMetrics `json:"metrics"`
	CreatedAt time.Time              `json:"created_at"`
}

type MultimodalAgent struct {
	PublishAudio func(frame *model.AudioFrame) error
	// contains filtered or unexported fields
}

type ParticipantActiveEvent struct {
	ParticipantID string    `json:"participant_id"`
	Identity      string    `json:"identity"`
	Active        bool      `json:"active"`
	CreatedAt     time.Time `json:"created_at"`
}

type ParticipantReference interface {
	Identity() string
	SID() string
}

type PipelineAgent struct {
	LLM llm.LLM
	// contains filtered or unexported fields
}

type PlayHandle struct {
	// contains filtered or unexported fields
}

type PlaybackFinishedEvent struct {
	PlaybackPosition       time.Duration
	Interrupted            bool
	SynchronizedTranscript string
}

type PlaybackStartedEvent struct {
	CreatedAt time.Time
}

type Plugin interface {
	Title() string
	Version() string
	Package() string
	DownloadFiles() error
}

type QueueIO struct {
	// contains filtered or unexported fields
}

type RealtimeAudioOutputNodeFunc func(ctx context.Context, audio <-chan *model.AudioFrame) (<-chan *model.AudioFrame, error)

type RecognitionHooks interface {
	OnStartOfSpeech(ev *vad.VADEvent)
	OnEndOfSpeech(ev *vad.VADEvent)
	OnInterimTranscript(ev *stt.SpeechEvent)
	OnFinalTranscript(ev *stt.SpeechEvent)
}

type RecordingOptions struct {
	Audio      bool `json:"audio"`
	Traces     bool `json:"traces"`
	Logs       bool `json:"logs"`
	Transcript bool `json:"transcript"`
}

type RunAssert struct {
	ChatCtx *llm.ChatContext
	// contains filtered or unexported fields
}

type RunContext struct {
	Session      *AgentSession
	SpeechHandle *SpeechHandle
	FunctionCall *llm.FunctionCall
}

type RunEvent interface {
	RunEventType() string
	GetCreatedAt() time.Time
	GetItem() llm.ChatItem
}

type RunResult[T any] struct {
	ChatCtx   *llm.ChatContext
	Timestamp float64
	Expect    *RunAssert

	FinalOutput T

	Events []RunEvent
	// contains filtered or unexported fields
}

type RunResultInterface interface {
	AddEvent(ev RunEvent)
	WatchTask(done <-chan struct{})
}

type STTNodeFunc func(ctx context.Context, s stt.STT, audio <-chan *model.AudioFrame) (<-chan *stt.SpeechEvent, error)

type SendMessageRequest struct {
	Text string `json:"text"`
}

type SendMessageResponse struct {
	Items []llm.ChatItem `json:"items"`
}

type SessionInfo interface {
	LocalParticipantID() string
}

type SessionReport struct {
	RecordingOptions        RecordingOptions    `json:"recording_options"`
	JobID                   string              `json:"job_id"`
	RoomID                  string              `json:"room_id"`
	Room                    string              `json:"room"`
	Options                 AgentSessionOptions `json:"options"`
	Events                  []any               `json:"events"`
	Timeline                []*AgentEvent       `json:"timeline,omitempty"`
	ChatHistory             *llm.ChatContext    `json:"chat_history"`
	AudioRecordingPath      *string             `json:"audio_recording_path,omitempty"`
	AudioRecordingStartedAt *float64            `json:"audio_recording_started_at,omitempty"`
	Duration                *float64            `json:"duration,omitempty"`
	StartedAt               *float64            `json:"started_at,omitempty"`
	Timestamp               float64             `json:"timestamp"`
	// contains filtered or unexported fields
}

type SpeechCreatedEvent struct {
	UserInitiated bool          `json:"user_initiated"`
	Source        string        `json:"source"`
	SpeechHandle  *SpeechHandle `json:"-"`
	ParticipantID string        `json:"participant_id,omitempty"`
	CreatedAt     time.Time     `json:"created_at"`
}

type SpeechHandle struct {
	ID                 string
	AllowInterruptions bool
	InputDetails       InputDetails
	Priority           int
	CreatedAt          time.Time

	FinalOutput any
	ManualText  string

	OnItemAdded func(item llm.ChatItem)
	RunResult   RunResultInterface
	// contains filtered or unexported fields
}

type StreamRequest struct {
	ID      string `json:"id"`
	Method  string `json:"method"`
	Payload string `json:"payload"`
}

type StreamResponse struct {
	ID      string `json:"id"`
	Payload string `json:"payload,omitempty"`
	Error   string `json:"error,omitempty"`
}

type SyncEvent struct {
	Text      string
	Flush     bool
	SegmentID string
}

type SyncedAudioOutput struct {
	// contains filtered or unexported fields
}

type SyncedTextOutput struct {
	// contains filtered or unexported fields
}

type TTSGenerationData struct {
	AudioCh       chan *model.AudioFrame
	AlignedTextCh chan string
	TTFB          time.Duration
}

type TTSNodeFunc func(ctx context.Context, t tts.TTS, textCh <-chan string) (*TTSGenerationData, error)

type Tagger struct {
	// contains filtered or unexported fields
}

type TaskWaiter interface {
	WaitAny(ctx context.Context) (any, error)
}

type TextInput interface {
	Label() string
	OnAttached()
	OnDetached()
}

type TextInputCallback func(s *AgentSession, ev TextInputEvent) error

type TextInputEvent struct {
	Text        string            `json:"text"`
	Participant lksdk.Participant `json:"-"`
}

type TextOutput interface {
	Label() string
	CaptureText(text string) error
	SetSegmentID(id string)
	Flush()
	OnAttached()
	OnDetached()
}

type ToolExecutionOutput struct {
	FncCall       llm.FunctionCall
	FncCallOut    *llm.FunctionCallOutput
	RawOutput     any
	RawError      error
	ReplyRequired bool
	AgentTask     AgentInterface
}

type TranscriptSynchronizer struct {
	// contains filtered or unexported fields
}

type TranscriptionFilter struct {
	SpeakingRate float64
}

type TranscriptionNodeFunc func(ctx context.Context, textCh <-chan string) (<-chan string, error)

type TransitionActivityAction string

type TurnDetectionMode string

type TurnDetector interface {
	PredictEndOfTurn(ctx context.Context, chatCtx *llm.ChatContext) (float64, error)
}

type UpdateAgentOpts struct {
	PreviousActivity TransitionActivityAction
	NewActivity      TransitionActivityAction
}

type UserInputTranscribedEvent struct {
	Transcript string    `json:"transcript"`
	IsFinal    bool      `json:"is_final"`
	SpeakerID  string    `json:"speaker_id,omitempty"`
	Language   string    `json:"language,omitempty"`
	CreatedAt  time.Time `json:"created_at"`
}

type UserState string

type UserStateChangedEvent struct {
	OldState  UserState `json:"old_state"`
	NewState  UserState `json:"new_state"`
	CreatedAt time.Time `json:"created_at"`
}

type VideoGenerator interface {
	PushAudio(frame *model.AudioFrame) error
	Stream() <-chan interface{} // Yields *model.AudioFrame, *model.VideoFrame, or *model.AudioSegmentEnd
	ClearBuffer() error
	Close() error
}

type VideoInput interface {
	Label() string
	Stream() <-chan *model.VideoFrame
	OnAttached()
	OnDetached()
}

type VideoNodeFunc func(ctx context.Context, video <-chan *model.VideoFrame) error

type VideoOutput interface {
	Label() string
	CaptureVideoFrame(frame *model.VideoFrame) error
	Flush()
	OnAttached()
	OnDetached()
}

type VoiceActivityVideoSampler struct {
	// contains filtered or unexported fields
}