meeting

type ActionItem struct {
	// Task is what needs to be done.
	Task string `json:"task"`

	// Owner is who took it on, when the transcript says so.
	Owner string `json:"owner,omitempty"`

	// Due is the deadline as stated in the meeting, when there is one.
	Due string `json:"due,omitempty"`
}

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

type ChatCompleter interface {
	CreateChatCompletion(ctx context.Context, req *provider.ChatCompletionRequest) (*provider.ChatCompletionResponse, error)
}

type Config struct {
	// Name is how the agent introduces itself, for example "OmniAgent".
	Name string

	// OnBehalfOf names the person the agent attends for, if any.
	OnBehalfOf string

	// Names are other names the agent answers to, besides Name, such as a
	// spelling speech to text tends to produce.
	Names []string

	// Announcement is spoken once when the agent is admitted. Empty uses
	// DefaultAnnouncement, followed by an invitation to ask questions when
	// there is a Responder. It is skipped when Speaker is nil or the session
	// cannot send audio.
	Announcement string

	// Transcriber turns the meeting audio into text. Required.
	Transcriber Transcriber

	// TranscriptionConfig sets the model and language. The encoding and
	// sample rate are taken from the session's audio format.
	TranscriptionConfig stt.TranscriptionConfig

	// Speaker synthesizes the announcement and answers. Optional.
	Speaker tts.Provider

	// SynthesisConfig sets the voice. With no OutputFormat, the meeting's
	// own audio format is requested, such as mu-law at 8 kHz on a phone
	// call, which Deepgram, ElevenLabs, and OpenAI produce. Otherwise request
	// raw PCM or mu-law output, since compressed formats cannot be played on
	// a call.
	SynthesisConfig tts.SynthesisConfig

	// Responder answers when someone addresses the agent by name, after
	// it is admitted. Optional: without one, or without a Speaker, the agent
	// stays silent after its announcement. It answers one question at a
	// time; a question asked while it is answering is not answered.
	Responder Responder

	// Summarizer summarizes the transcript when the meeting ends. Optional.
	Summarizer Summarizer

	// OnSegment is called for each finalized transcript segment, for
	// example to print a live transcript. Optional.
	OnSegment func(Segment)

	// Logger receives problems that do not stop attendance. Defaults to
	// slog.Default().
	Logger *slog.Logger
}

type Exchange struct {
	// At is when the answer was spoken, as an offset from when
	// transcription began.
	At time.Duration `json:"at"`

	// Question is what was said to the agent.
	Question string `json:"question"`

	// Answer is what the agent said.
	Answer string `json:"answer"`
}

type LLMResponder struct {
	// Client sends the chat completion request.
	Client ChatCompleter

	// Model is the model name, for example "claude-sonnet-5".
	Model string
}

type LLMSummarizer struct {
	// Client sends the chat completion request.
	Client ChatCompleter

	// Model is the model name, for example "claude-sonnet-5".
	Model string
}

type Record struct {
	// Target is the meeting attended.
	Target attendee.JoinTarget `json:"target"`

	// Started and Ended bound the attendance.
	Started time.Time `json:"started"`
	Ended   time.Time `json:"ended"`

	// FinalState is how the session ended: left, ended, removed, or failed.
	FinalState attendee.State `json:"final_state"`

	// Announced reports whether the announcement was played.
	Announced bool `json:"announced"`

	// Transcript is the meeting's speech. The agent's answers are included
	// with the agent's name as the speaker.
	Transcript Transcript `json:"transcript"`

	// Exchanges are the questions the agent answered.
	Exchanges []Exchange `json:"exchanges,omitempty"`

	// Summary is nil when there is no Summarizer or nothing was said.
	Summary *Summary `json:"summary,omitempty"`
}

type Request struct {
	// Name is the agent's name.
	Name string

	// Question is what was said to the agent, including its name.
	Question string

	// Transcript is the recent meeting speech, oldest first, ending with
	// the question.
	Transcript Transcript
}

type Responder interface {
	Respond(ctx context.Context, req Request) (string, error)
}

type Segment struct {
	// Start and End are offsets from when transcription began.
	Start time.Duration `json:"start"`
	End   time.Duration `json:"end"`

	// Speaker is the speaker label, when the connection provides one.
	// Phone dial-in carries one mixed stream, so it is empty.
	Speaker string `json:"speaker,omitempty"`

	// Text is what was said.
	Text string `json:"text"`
}

type Summarizer interface {
	Summarize(ctx context.Context, transcript Transcript) (*Summary, error)
}

type Summary struct {
	// Overview is a short neutral recap of the discussion.
	Overview string `json:"overview"`

	// Decisions are what the participants agreed on.
	Decisions []string `json:"decisions"`

	// ActionItems are tasks someone took on.
	ActionItems []ActionItem `json:"action_items"`

	// OpenQuestions are questions raised but not resolved.
	OpenQuestions []string `json:"open_questions"`
}

type Transcriber interface {
	TranscribeStream(ctx context.Context, config stt.TranscriptionConfig) (io.WriteCloser, <-chan stt.StreamEvent, error)
}

type Transcript []Segment