Go SDK

go get github.com/camb-ai/cambai-go-sdk

import (
	"github.com/camb-ai/cambai-go-sdk/client"
	"github.com/camb-ai/cambai-go-sdk/option"
)

c := client.NewClient(option.WithAPIKey(os.Getenv("CAMB_API_KEY")))

package main

import (
	"context"
	"io"
	"os"

	"github.com/camb-ai/cambai-go-sdk"
	"github.com/camb-ai/cambai-go-sdk/client"
	"github.com/camb-ai/cambai-go-sdk/option"
)

func main() {
	c := client.NewClient(option.WithAPIKey(os.Getenv("CAMB_API_KEY")))

	stream, err := c.TextToSpeech.Tts(
		context.Background(),
		&cambai.CreateStreamTtsRequestPayload{
			Text:        "Hello from the Camb.ai Go SDK.",
			VoiceID:     147320,
			Language:    cambai.CreateStreamTtsRequestPayloadLanguageEnUs,
			SpeechModel: cambai.CreateStreamTtsRequestPayloadSpeechModelMarsFlash.Ptr(),
			OutputConfiguration: &cambai.StreamTtsOutputConfiguration{
				Format: cambai.OutputFormatWav.Ptr(),
			},
		},
	)
	if err != nil {
		panic(err)
	}

	out, err := os.Create("output.wav")
	if err != nil {
		panic(err)
	}
	defer out.Close()

	if _, err := io.Copy(out, stream); err != nil {
		panic(err)
	}
}

voices, err := c.VoiceCloning.ListVoices(ctx, &cambai.ListVoicesListVoicesGetRequest{})
if err != nil {
	panic(err)
}
for _, item := range voices {
	// item is a discriminated union; visit to get the typed Voice value.
	if v := item.Voice; v != nil {
		fmt.Println(v.ID, v.VoiceName)
	}
}

source, err := c.Languages.GetSourceLanguages(ctx, &cambai.GetSourceLanguagesSourceLanguagesGetRequest{})
if err != nil {
	panic(err)
}
targets, err := c.Languages.GetTargetLanguages(ctx, &cambai.GetTargetLanguagesTargetLanguagesGetRequest{})
if err != nil {
	panic(err)
}
fmt.Println(len(source), len(targets))

resp, err := c.Dub.EndToEndDubbing(ctx, &cambai.EndToEndDubbingRequestPayload{
	VideoURL:       "https://example.com/video.mp4",
	SourceLanguage: cambai.LanguagesEnUs,
	TargetLanguage: cambai.LanguagesFrFr.Ptr(),
})
if err != nil {
	panic(err)
}
taskID := *resp.TaskID

// runID comes from GetEndToEndDubbingStatus after the job succeeds.
txt := cambai.TranscriptFileFormatTxt
transcript, err := c.Dub.GetDubbedRunTranscript(
	ctx,
	&runID,
	cambai.LanguagesFrFr,
	&cambai.GetDubbedRunTranscriptTranscriptRunIDLanguageGetRequest{
		FormatType: txt.Ptr(),
	},
)
if err != nil {
	panic(err)
}
fmt.Println(transcript)

raw, err := c.Translation.CreateTranslation(ctx, &cambai.CreateTranslationRequestPayload{
	Texts:          []string{"Hello, how are you?", "Welcome to Camb.ai."},
	SourceLanguage: cambai.LanguagesEnUs,
	TargetLanguage: cambai.LanguagesFrFr,
})
if err != nil {
	panic(err)
}

// CreateTranslation returns interface{}; round-trip through JSON to read task_id.
b, _ := json.Marshal(raw)
var started cambai.OrchestratorPipelineCallResult
json.Unmarshal(b, &started)
taskID := *started.TaskID

for {
	time.Sleep(2 * time.Second)
	status, err := c.Translation.GetTranslationTaskStatus(
		ctx, taskID, &cambai.GetTranslationTaskStatusTranslateTaskIDGetRequest{},
	)
	if err != nil {
		panic(err)
	}
	if status.Status == cambai.TaskStatusSuccess && status.RunID != nil {
		result, err := c.Translation.GetTranslationResult(
			ctx, status.RunID, &cambai.GetTranslationResultTranslationResultRunIDGetRequest{},
		)
		if err != nil {
			panic(err)
		}
		fmt.Println(result.Texts)
		return
	}
	if status.Status == cambai.TaskStatusError {
		panic("translation failed")
	}
}

resp, err := c.Transcription.CreateTranscription(ctx, &cambai.BodyCreateTranscriptionTranscribePost{
	Language: cambai.LanguagesEnUs,
	MediaURL: cambai.String("https://example.com/audio.mp3"),
})
if err != nil {
	panic(err)
}
taskID := *resp.TaskID

for {
	time.Sleep(3 * time.Second)
	status, err := c.Transcription.GetTranscriptionTaskStatus(
		ctx, taskID, &cambai.GetTranscriptionTaskStatusTranscribeTaskIDGetRequest{},
	)
	if err != nil {
		panic(err)
	}
	if status.Status == cambai.TaskStatusSuccess && status.RunID != nil {
		wl := true
		result, err := c.Transcription.GetTranscriptionResult(
			ctx, status.RunID,
			&cambai.GetTranscriptionResultTranscriptionResultRunIDGetRequest{WordLevelTimestamps: &wl},
		)
		if err != nil {
			panic(err)
		}
		fmt.Println(result)
		return
	}
	if status.Status == cambai.TaskStatusError {
		panic("transcription failed")
	}
}

resp, err := c.TextToVoice.CreateTextToVoice(ctx, &cambai.CreateTextToVoiceRequestPayload{
	Text:             "A confident narrator introducing a documentary.",
	VoiceDescription: "Deep, measured baritone with a slight gravel. Calm and authoritative.",
})
if err != nil {
	panic(err)
}
taskID := *resp.TaskID

for {
	time.Sleep(2 * time.Second)
	status, err := c.TextToVoice.GetTextToVoiceStatus(
		ctx, taskID, &cambai.GetTextToVoiceStatusTextToVoiceTaskIDGetRequest{},
	)
	if err != nil {
		panic(err)
	}
	if status.Status == cambai.TaskStatusSuccess && status.RunID != nil {
		runID := *status.RunID
		out, err := c.TextToVoice.GetTextToVoiceResult(
			ctx, &runID, &cambai.GetTextToVoiceResultTextToVoiceResultRunIDGetRequest{},
		)
		if err != nil {
			panic(err)
		}
		fmt.Println(out.Previews)
		return
	}
	if status.Status == cambai.TaskStatusError {
		panic("text-to-voice failed")
	}
}

resp, err := c.TextToAudio.CreateTextToAudio(ctx, &cambai.CreateTextToAudioRequestPayload{
	Prompt:    "Heavy rain on a tin roof at night with distant thunder.",
	Duration:  cambai.Float64(15),
	AudioType: cambai.TextToAudioTypeSound.Ptr(),
})
if err != nil {
	panic(err)
}
taskID := *resp.TaskID

for {
	time.Sleep(3 * time.Second)
	status, err := c.TextToAudio.GetTextToAudioStatus(
		ctx, taskID, &cambai.GetTextToAudioStatusTextToSoundTaskIDGetRequest{},
	)
	if err != nil {
		panic(err)
	}
	if status.Status == cambai.TaskStatusSuccess && status.RunID != nil {
		runID := *status.RunID
		stream, err := c.TextToAudio.GetTextToAudioResult(
			ctx, &runID, &cambai.GetTextToAudioResultTextToSoundResultRunIDGetRequest{},
		)
		if err != nil {
			panic(err)
		}
		out, _ := os.Create("soundscape.wav")
		defer out.Close()
		io.Copy(out, stream)
		return
	}
	if status.Status == cambai.TaskStatusError {
		panic("text-to-audio failed")
	}
}

// storyKickoff implements CreateStoryStoryPostResponseVisitor to extract either
// a task_id (async) or an immediate run_id (sync setup response).
type storyKickoff struct {
	taskID string
	runID  int
	mode   string
}

func (v *storyKickoff) VisitOrchestratorPipelineCallResult(r *cambai.OrchestratorPipelineCallResult) error {
	v.taskID = *r.TaskID
	v.mode = "async"
	return nil
}

func (v *storyKickoff) VisitGetSetupStoryResultResponse(r *cambai.GetSetupStoryResultResponse) error {
	v.runID = r.RunID
	v.mode = "sync"
	return nil
}

created, err := c.Story.CreateStory(ctx, &cambai.BodyCreateStoryStoryPost{
	SourceLanguage: cambai.LanguagesEnUs,
	Title:          cambai.String("My story"),
})
if err != nil {
	panic(err)
}

var kick storyKickoff
if err := created.Accept(&kick); err != nil {
	panic(err)
}

if kick.mode == "async" {
	for {
		time.Sleep(5 * time.Second)
		status, err := c.Story.GetStoryStatus(ctx, kick.taskID, &cambai.GetStoryStatusStoryTaskIDGetRequest{})
		if err != nil {
			panic(err)
		}
		if status.Status == cambai.TaskStatusSuccess && status.RunID != nil {
			runID := *status.RunID
			info, err := c.Story.GetStoryRunInfo(ctx, &runID, &cambai.GetStoryRunInfoStoryResultRunIDGetRequest{})
			if err != nil {
				panic(err)
			}
			fmt.Println(info)
			return
		}
		if status.Status == cambai.TaskStatusError {
			panic("story failed")
		}
	}
}

out, err := c.TranslatedTts.CreateTranslatedTts(ctx, &cambai.CreateTranslatedTtsRequestPayload{
	Text:           "Good morning, welcome to our service.",
	VoiceID:        147320,
	SourceLanguage: cambai.LanguagesEnUs,
	TargetLanguage: cambai.LanguagesHiIn,
})
if err != nil {
	panic(err)
}

for {
	time.Sleep(3 * time.Second)
	status, err := c.TranslatedTts.GetTranslatedTtsTaskStatus(
		ctx, out.TaskID, &cambai.GetTranslatedTtsTaskStatusTranslatedTtsTaskIDGetRequest{},
	)
	if err != nil {
		panic(err)
	}
	if status.Status == cambai.TaskStatusSuccess {
		fmt.Println(status)
		return
	}
	if status.Status == cambai.TaskStatusError {
		panic("translated tts failed")
	}
}

dicts, err := c.Dictionaries.GetDictionaries(ctx, &cambai.GetDictionariesDictionariesGetRequest{})
if err != nil {
	panic(err)
}
dictionaryID := dicts[0].ID

_, err = c.Dictionaries.AddTermToDictionary(ctx, dictionaryID, &cambai.AddDictionaryTermPayload{
	Translations: []*cambai.TermTranslationInput{
		{Translation: "कैम्ब.एआई", Language: cambai.LanguagesHiIn},
	},
})
if err != nil {
	panic(err)
}

package main

import (
	"context"
	"errors"
	"fmt"
	"io"
	"os"

	"github.com/camb-ai/cambai-go-sdk"
	"github.com/camb-ai/cambai-go-sdk/client"
	"github.com/camb-ai/cambai-go-sdk/core"
	"github.com/camb-ai/cambai-go-sdk/option"
)

func main() {
	c := client.NewClient(option.WithAPIKey(os.Getenv("CAMB_API_KEY")))
	ctx := context.Background()

	request := &cambai.CreateStreamTtsRequestPayload{
		Text:        "Hello world.",
		VoiceID:     147320,
		Language:    cambai.CreateStreamTtsRequestPayloadLanguageEnUs,
		SpeechModel: cambai.CreateStreamTtsRequestPayloadSpeechModelMarsFlash.Ptr(),
		OutputConfiguration: &cambai.StreamTtsOutputConfiguration{
			Format: cambai.OutputFormatWav.Ptr(),
		},
	}

	stream, err := c.TextToSpeech.Tts(ctx, request)
	if err != nil {
		var validation *cambai.UnprocessableEntityError
		if errors.As(err, &validation) {
			fmt.Println("validation:", validation.Body)
			os.Exit(1)
		}
		var apiErr *core.APIError
		if errors.As(err, &apiErr) {
			fmt.Println("status:", apiErr.StatusCode)
			os.Exit(1)
		}
		panic(err)
	}
	_, _ = io.Copy(io.Discard, stream)
}

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"strings"

	cambai "github.com/camb-ai/cambai-go-sdk"
	"github.com/camb-ai/cambai-go-sdk/provider"
)

// BasetenProvider implements provider.TtsProvider for the Baseten Mars8-Flash model.
// API reference: https://www.baseten.co/library/mars8-flash/
type BasetenProvider struct {
	APIKey            string
	URL               string
	ReferenceAudio    string
	ReferenceLanguage string
}

// CreateTts is a stub because Baseten does not support async TTS.
func (b *BasetenProvider) CreateTts(ctx context.Context, request *cambai.CreateTtsRequestPayload) (*cambai.CreateTtsOut, error) {
	return nil, fmt.Errorf("Baseten custom hosting provider does not support async CreateTts; use Tts (streaming) instead")
}

// Tts calls the Baseten Mars8-Flash endpoint and returns the audio as an io.Reader.
func (b *BasetenProvider) Tts(ctx context.Context, request *cambai.CreateStreamTtsRequestPayload) (io.Reader, error) {
	langStr := strings.ToLower(strings.ReplaceAll(string(request.Language), "_", "-"))

	payload := map[string]interface{}{
		"text":               request.Text,
		"language":           langStr,
		"output_duration":    nil,
		"reference_audio":    b.ReferenceAudio,
		"reference_language": b.ReferenceLanguage,
		"output_format":      "flac",
		"apply_ner_nlp":      false,
	}

	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		return nil, fmt.Errorf("failed to marshal payload: %w", err)
	}

	req, err := http.NewRequestWithContext(ctx, "POST", b.URL, bytes.NewBuffer(payloadBytes))
	if err != nil {
		return nil, fmt.Errorf("failed to create request: %w", err)
	}
	req.Header.Set("Authorization", "Api-Key "+b.APIKey)
	req.Header.Set("Content-Type", "application/json")

	httpClient := &http.Client{}
	resp, err := httpClient.Do(req)
	if err != nil {
		return nil, fmt.Errorf("request failed: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		body, _ := io.ReadAll(resp.Body)
		return nil, fmt.Errorf("baseten error (%d): %s", resp.StatusCode, string(body))
	}

	var buf bytes.Buffer
	if _, err = io.Copy(&buf, resp.Body); err != nil {
		return nil, fmt.Errorf("failed to read response body: %w", err)
	}

	return &buf, nil
}

var _ provider.TtsProvider = (*BasetenProvider)(nil)