Connect

package main

import (
	"context"
	"fmt"
	openai "github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/live"
	"log"
	"time"
)

func main() {
	if err := observe(); err != nil {
		log.Fatal(err)
	}
}

func observe() error {
	// Stop waiting if the peer never sends the expected events.
	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
	defer cancel()
	client := openai.NewClient()
	// Use the ID of a stored, closed session whose recording has finalized.
	connection, err := client.Live.Forks.Connect(ctx, "sess_123", live.ForkConnectionOptions{})
	if err != nil {
		return err
	}
	// Release the transport after the terminal event or an error.
	defer connection.Close()

	if err := connection.Send(ctx, live.ForkClientEventParamOfSessionStart(live.ForkSessionConfigParam{})); err != nil {
		return err
	}
	closeRequested := false
	for {
		received, err := connection.Recv(ctx)
		if err != nil {
			return fmt.Errorf("disconnected before session.closed; final usage unconfirmed: %w", err)
		}
		switch event := received.AsAny().(type) {
		case live.ErrorEvent:
			return fmt.Errorf("Live reported a session error.")
		case live.SessionStartedEvent:
			// Wait for startup before closing the session this example owns.
			fmt.Println("Session ready:", event.Session.ID, event.Session.Model)
			err = connection.Send(ctx, live.ForkClientEventUnionParam{OfSessionClose: &live.SessionCloseEventParam{}})
			closeRequested = err == nil
		case live.SessionClosedEvent:
			if !closeRequested || event.Reason != "close_requested" {
				return fmt.Errorf("session ended unexpectedly: %s; usage=%v", event.Reason, event.Usage)
			}
			fmt.Println("Final usage:", event.Usage)
			return nil
		}
		if err != nil {
			return err
		}
	}
}