fix: align CAMB AI endpoint responses with SDK expectations

Tested against the real camb-sdk Python package. Fixes:
- list-voices returns flat array (SDK expects list, not wrapped object)
- text-to-sound returns task_id JSON (SDK expects OrchestratorPipelineCallResult)
- translated-tts returns task_id JSON (SDK expects CreateTranslatedTtsOut)
- translation/stream returns JSON (SDK parses response as JSON)
- transcribe accepts media_url form field without requiring file upload

Author: neilruaro-camb

core/http/endpoints/cambai/sound_generation.go

@@ -2,15 +2,13 @@ package cambai
 
 import (
 	"net/http"
-	"path/filepath"
 
 	"github.com/google/uuid"
 	"github.com/labstack/echo/v4"
 	"github.com/mudler/LocalAI/core/backend"
 	"github.com/mudler/LocalAI/core/config"
 	"github.com/mudler/LocalAI/core/http/middleware"
 	"github.com/mudler/LocalAI/core/schema"
-	"github.com/mudler/LocalAI/pkg/audio"
 	"github.com/mudler/LocalAI/pkg/model"
 	"github.com/mudler/xlog"
 )
@@ -30,46 +28,6 @@ func SoundGenerationEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader
 
 		xlog.Debug("CAMB AI text-to-sound request received", "model", input.Model)
 
-		filePath, _, err := backend.SoundGeneration(
-			input.Prompt, input.Duration, nil, nil,
-			nil, nil,
-			nil, "", "", nil, "",
-			"", "",
-			nil,
-			ml, appConfig, *cfg)
-		if err != nil {
-			return err
-		}
-
-		filePath, contentType := audio.NormalizeAudioFile(filePath)
-
-		taskID := uuid.New().String()
-
-		// Return audio file directly with task metadata headers
-		c.Response().Header().Set("X-Task-ID", taskID)
-		c.Response().Header().Set("X-Task-Status", "SUCCESS")
-		if contentType != "" {
-			c.Response().Header().Set("Content-Type", contentType)
-		}
-		return c.Attachment(filePath, filepath.Base(filePath))
-	}
-}
-
-// SoundGenerationAsyncEndpoint returns results in CAMB AI async task format.
-func SoundGenerationAsyncEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, appConfig *config.ApplicationConfig) echo.HandlerFunc {
-	return func(c echo.Context) error {
-		input, ok := c.Get(middleware.CONTEXT_LOCALS_KEY_LOCALAI_REQUEST).(*schema.CambAITextToSoundRequest)
-		if !ok {
-			return echo.ErrBadRequest
-		}
-
-		cfg, ok := c.Get(middleware.CONTEXT_LOCALS_KEY_MODEL_CONFIG).(*config.ModelConfig)
-		if !ok || cfg == nil {
-			return echo.ErrBadRequest
-		}
-
-		xlog.Debug("CAMB AI text-to-sound async request received", "model", input.Model)
-
 		_, _, err := backend.SoundGeneration(
 			input.Prompt, input.Duration, nil, nil,
 			nil, nil,

core/http/endpoints/cambai/transcription.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"path"
 	"path/filepath"
+	"sync"
 
 	"github.com/google/uuid"
 	"github.com/labstack/echo/v4"
@@ -17,8 +18,11 @@ import (
 	"github.com/mudler/xlog"
 )
 
+var transcriptionTaskResults = sync.Map{}
+
 // TranscriptionEndpoint handles CAMB AI transcription (POST /apis/transcribe).
-// Runs synchronously but returns results in CAMB AI's async task format.
+// The SDK sends multipart form with optional file upload and/or media_url.
+// Returns {"task_id": "..."} matching OrchestratorPipelineCallResult.
 func TranscriptionEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, appConfig *config.ApplicationConfig) echo.HandlerFunc {
 	return func(c echo.Context) error {
 		cfg, ok := c.Get(middleware.CONTEXT_LOCALS_KEY_MODEL_CONFIG).(*config.ModelConfig)
@@ -32,54 +36,79 @@ func TranscriptionEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader,
 		if input != nil && input.LanguageID > 0 {
 			language = schema.CambAILanguageCodeFromID(input.LanguageID)
 		}
-
-		file, err := c.FormFile("file")
-		if err != nil {
-			return c.JSON(http.StatusBadRequest, schema.CambAIErrorResponse{
-				Detail: "Audio file is required. Upload as multipart form field 'file'.",
-			})
+		// SDK sends language as multipart form field too
+		if language == "" {
+			if langField := c.FormValue("language"); langField != "" {
+				language = langField
+			}
 		}
 
-		f, err := file.Open()
-		if err != nil {
-			return err
-		}
-		defer f.Close()
+		// Try file upload first (field "file" or "media_file")
+		var audioPath string
+		for _, fieldName := range []string{"file", "media_file"} {
+			file, err := c.FormFile(fieldName)
+			if err != nil {
+				continue
+			}
 
-		dir, err := os.MkdirTemp("", "cambai-transcribe")
-		if err != nil {
-			return err
+			f, err := file.Open()
+			if err != nil {
+				return err
+			}
+			defer f.Close()
+
+			dir, err := os.MkdirTemp("", "cambai-transcribe")
+			if err != nil {
+				return err
+			}
+			defer os.RemoveAll(dir)
+
+			dst := filepath.Join(dir, path.Base(file.Filename))
+			dstFile, err := os.Create(dst)
+			if err != nil {
+				return err
+			}
+
+			if _, err := io.Copy(dstFile, f); err != nil {
+				dstFile.Close()
+				return err
+			}
+			dstFile.Close()
+			audioPath = dst
+			break
 		}
-		defer os.RemoveAll(dir)
 
-		dst := filepath.Join(dir, path.Base(file.Filename))
-		dstFile, err := os.Create(dst)
-		if err != nil {
-			return err
+		// Fall back to media_url form field
+		if audioPath == "" {
+			mediaURL := c.FormValue("media_url")
+			if mediaURL == "" {
+				mediaURL = c.FormValue("audio_url")
+			}
+			if mediaURL != "" {
+				audioPath = mediaURL
+			}
 		}
 
-		if _, err := io.Copy(dstFile, f); err != nil {
-			xlog.Debug("Audio file copying error", "filename", file.Filename, "dst", dst, "error", err)
-			return err
+		if audioPath == "" {
+			return c.JSON(http.StatusBadRequest, schema.CambAIErrorResponse{
+				Detail: "Either a file upload or media_url is required.",
+			})
 		}
-		dstFile.Close()
 
-		xlog.Debug("CAMB AI transcription request", "file", dst, "language", language)
+		xlog.Debug("CAMB AI transcription request", "path", audioPath, "language", language)
 
-		tr, err := backend.ModelTranscription(dst, language, false, false, "", ml, *cfg, appConfig)
+		tr, err := backend.ModelTranscription(audioPath, language, false, false, "", ml, *cfg, appConfig)
 		if err != nil {
 			return err
 		}
 
 		taskID := uuid.New().String()
+		transcriptionTaskResults.Store(taskID, tr.Text)
 
-		return c.JSON(http.StatusOK, schema.CambAITaskStatusResponse{
+		return c.JSON(http.StatusOK, schema.CambAITaskResponse{
+			TaskID: taskID,
 			Status: "SUCCESS",
 			RunID:  taskID,
-			Output: schema.CambAITranscriptionResponse{
-				Text:     tr.Text,
-				Language: language,
-			},
 		})
 	}
 }

core/http/endpoints/cambai/translation.go

@@ -95,31 +95,24 @@ func TranslationStreamEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoad
 		targetLang := schema.CambAILanguageCodeFromID(input.TargetLanguageID)
 		prompt := buildTranslationPrompt(input.Text, sourceLang, targetLang)
 
-		c.Response().Header().Set("Content-Type", "text/plain; charset=utf-8")
-		c.Response().Header().Set("Transfer-Encoding", "chunked")
-		c.Response().Header().Set("Cache-Control", "no-cache")
-		c.Response().Header().Set("Connection", "keep-alive")
-
 		fn, err := backend.ModelInference(
 			context.Background(), prompt, nil, nil, nil, nil,
-			ml, cfg, cl, appConfig,
-			func(token string, _ backend.TokenUsage) bool {
-				_, writeErr := c.Response().Write([]byte(token))
-				if writeErr != nil {
-					return true
-				}
-				c.Response().Flush()
-				return true
-			},
-			"", "", nil, nil, nil,
+			ml, cfg, cl, appConfig, nil, "", "", nil, nil, nil,
 		)
 		if err != nil {
 			return err
 		}
 
-		// Call fn to complete inference
-		_, err = fn()
-		return err
+		resp, err := fn()
+		if err != nil {
+			return err
+		}
+
+		return c.JSON(http.StatusOK, map[string]any{
+			"translation":     strings.TrimSpace(resp.Response),
+			"source_language": input.SourceLanguageID,
+			"target_language": input.TargetLanguageID,
+		})
 	}
 }
 
@@ -178,14 +171,12 @@ func TranslatedTTSEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader,
 		}
 
 		taskID := uuid.New().String()
+		ttsTaskResults.Store(taskID, filePath)
 
-		return c.JSON(http.StatusOK, schema.CambAITaskStatusResponse{
+		return c.JSON(http.StatusOK, schema.CambAITaskResponse{
+			TaskID: taskID,
 			Status: "SUCCESS",
 			RunID:  taskID,
-			Output: map[string]string{
-				"translation": translatedText,
-				"audio_path":  filePath,
-			},
 		})
 	}
 }

core/http/endpoints/cambai/voice.go

@@ -22,18 +22,16 @@ func ListVoicesEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoader, app
 		voices := make([]schema.CambAIVoice, 0)
 		for i, cfg := range ttsConfigs {
 			voice := schema.CambAIVoice{
-				VoiceID: i + 1,
-				Name:    cfg.Name,
+				ID:   i + 1,
+				Name: cfg.Name,
 			}
 			if cfg.Voice != "" {
 				voice.Name = fmt.Sprintf("%s (%s)", cfg.Name, cfg.Voice)
 			}
 			voices = append(voices, voice)
 		}
 
-		return c.JSON(http.StatusOK, schema.CambAIListVoicesResponse{
-			Voices: voices,
-		})
+		return c.JSON(http.StatusOK, voices)
 	}
 }
 
@@ -85,9 +83,8 @@ func CreateCustomVoiceEndpoint(cl *config.ModelConfigLoader, ml *model.ModelLoad
 
 		xlog.Info("Custom voice audio saved", "name", voiceName, "path", dstPath)
 
-		return c.JSON(http.StatusOK, schema.CambAIVoice{
+		return c.JSON(http.StatusOK, schema.CambAICreateCustomVoiceResponse{
 			VoiceID: 0,
-			Name:    voiceName,
 		})
 	}
 }

core/schema/cambai.go

@@ -147,16 +147,20 @@ type CambAITaskStatusResponse struct {
 }
 
 type CambAIVoice struct {
-	VoiceID int    `json:"voice_id"`
-	Name    string `json:"voice_name"`
-	Gender  string `json:"gender,omitempty"`
-	Age     string `json:"age,omitempty"`
+	ID     int    `json:"id"`
+	Name   string `json:"voice_name"`
+	Gender string `json:"gender,omitempty"`
+	Age    string `json:"age,omitempty"`
 }
 
 type CambAIListVoicesResponse struct {
 	Voices []CambAIVoice `json:"voices"`
 }
 
+type CambAICreateCustomVoiceResponse struct {
+	VoiceID int `json:"voice_id"`
+}
+
 type CambAIErrorResponse struct {
 	Detail string `json:"detail"`
 }

tests/e2e/cambai_test.go

@@ -160,7 +160,7 @@ var _ = Describe("CAMB AI API Compatibility Tests", Label("CambAI"), func() {
 			Expect(result.Output).ToNot(BeNil())
 		})
 
-		It("should stream translation via /apis/translation/stream", func() {
+		It("should translate via /apis/translation/stream", func() {
 			body := `{
 				"text": "Hello world",
 				"source_language": 1,
@@ -176,9 +176,10 @@ var _ = Describe("CAMB AI API Compatibility Tests", Label("CambAI"), func() {
 
 			Expect(resp.StatusCode).To(Equal(200))
 
-			data, err := io.ReadAll(resp.Body)
+			var result map[string]any
+			err = json.NewDecoder(resp.Body).Decode(&result)
 			Expect(err).ToNot(HaveOccurred())
-			Expect(len(data)).To(BeNumerically(">", 0), "Stream should return some text")
+			Expect(result["translation"]).ToNot(BeEmpty())
 		})
 	})
 
@@ -196,11 +197,12 @@ var _ = Describe("CAMB AI API Compatibility Tests", Label("CambAI"), func() {
 			defer resp.Body.Close()
 
 			Expect(resp.StatusCode).To(Equal(200))
-			Expect(resp.Header.Get("Content-Type")).To(HavePrefix("audio/"))
 
-			data, err := io.ReadAll(resp.Body)
+			var taskResp schema.CambAITaskResponse
+			err = json.NewDecoder(resp.Body).Decode(&taskResp)
 			Expect(err).ToNot(HaveOccurred())
-			Expect(len(data)).To(BeNumerically(">", 0))
+			Expect(taskResp.TaskID).ToNot(BeEmpty())
+			Expect(taskResp.Status).To(Equal("SUCCESS"))
 		})
 	})
 
@@ -215,11 +217,10 @@ var _ = Describe("CAMB AI API Compatibility Tests", Label("CambAI"), func() {
 
 			Expect(resp.StatusCode).To(Equal(200))
 
-			var result schema.CambAIListVoicesResponse
+			var result []schema.CambAIVoice
 			err = json.NewDecoder(resp.Body).Decode(&result)
 			Expect(err).ToNot(HaveOccurred())
-			// voices list may be empty if no TTS models are flagged, but the endpoint should work
-			Expect(result.Voices).ToNot(BeNil())
+			Expect(result).ToNot(BeNil())
 		})
 	})