import { decodeSpeechPcmRequest } from "@t3tools/shared/speech";
import {
AuthOrchestrationOperateScope,
AuthSettingsWriteScope,
type AuthEnvironmentScope,
EnvironmentHttpApi,
EnvironmentVoiceBodyLimit,
SPEECH_MAX_OPTIONS_BYTES,
} from "@t3tools/contracts";
import * as ByteSize from "effect/ByteSize";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as HttpServerRequest from "effect/http/HttpServerRequest";
import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder";
import {
annotateEnvironmentRequest,
failEnvironmentInternal,
failEnvironmentInvalidRequest,
requireEnvironmentScope,
} from "../auth/http.ts";
import * as SpeechPostProcessing from "./postProcessing.ts";
import * as SpeechService from "./SpeechService.ts";
const MAX_TRANSCRIBE_BODY_BYTES = SpeechService.MAX_SPEECH_BYTES + SPEECH_MAX_OPTIONS_BYTES + 4;
const parseAudio = Option.liftThrowable(decodeSpeechPcmRequest);
const bodyLimit = Layer.succeed(EnvironmentVoiceBodyLimit, (effect) =>
Effect.gen(function* () {
const request = yield* HttpServerRequest.HttpServerRequest;
if (Number(request.headers["content-length"]) > MAX_TRANSCRIBE_BODY_BYTES)
return yield* failEnvironmentInvalidRequest("invalid_audio");
return yield* effect.pipe(
Effect.provideService(
HttpServerRequest.MaxBodySize,
ByteSize.bytes(MAX_TRANSCRIBE_BODY_BYTES),
),
);
}),
);
const mapSpeechError = <A, R>(effect: Effect.Effect<A, SpeechService.SpeechError, R>) =>
effect.pipe(
Effect.catchTags({
SpeechInvalidAudioError: () => failEnvironmentInvalidRequest("invalid_audio"),
SpeechUnsupportedPlatformError: () => failEnvironmentInvalidRequest("speech_unavailable"),
SpeechBusyError: () => failEnvironmentInvalidRequest("speech_busy"),
SpeechDownloadCancelledError: () => failEnvironmentInvalidRequest("speech_busy"),
SpeechModelNotFoundError: () => failEnvironmentInvalidRequest("invalid_command"),
SpeechOperationError: (error) => failEnvironmentInternal("internal_error", error),
}),
);
export const speechHttpApiLayer = HttpApiBuilder.group(
EnvironmentHttpApi,
"voice",
Effect.fnUntraced(function* (handlers) {
const speech = yield* SpeechService.SpeechService;
const postProcessing = yield* SpeechPostProcessing.SpeechPostProcessing;
const guard = Effect.fnUntraced(function* (
endpoint: string,
scope: AuthEnvironmentScope = AuthOrchestrationOperateScope,
) {
yield* annotateEnvironmentRequest(endpoint);
yield* requireEnvironmentScope(scope);
});
return handlers
.handle(
"status",
Effect.fn("environment.voice.status")(function* (args) {
yield* guard(args.endpoint.name);
return yield* speech.status.pipe(mapSpeechError);
}),
)
.handle(
"prepareModel",
Effect.fn("environment.voice.prepareModel")(function* (args) {
yield* guard(args.endpoint.name);
yield* speech.prepareModel.pipe(mapSpeechError);
}),
)
.handle(
"models",
Effect.fn("environment.voice.models")(function* (args) {
yield* guard(args.endpoint.name);
return yield* speech.models(args.query.benchmarks === "1").pipe(mapSpeechError);
}),
)
.handle(
"downloadModel",
Effect.fn("environment.voice.downloadModel")(function* (args) {
yield* guard(args.endpoint.name, AuthSettingsWriteScope);
return yield* speech.downloadModel(args.payload.modelId).pipe(mapSpeechError);
}),
)
.handle(
"selectModel",
Effect.fn("environment.voice.selectModel")(function* (args) {
yield* guard(args.endpoint.name, AuthSettingsWriteScope);
return yield* speech.selectModel(args.payload.modelId).pipe(mapSpeechError);
}),
)
.handle(
"cancelModelDownload",
Effect.fn("environment.voice.cancelModelDownload")(function* (args) {
yield* guard(args.endpoint.name, AuthSettingsWriteScope);
return yield* speech.cancelDownload(args.payload.modelId).pipe(mapSpeechError);
}),
)
.handle(
"removeModel",
Effect.fn("environment.voice.removeModel")(function* (args) {
yield* guard(args.endpoint.name, AuthSettingsWriteScope);
return yield* speech.removeModel(args.payload.modelId).pipe(mapSpeechError);
}),
)
.handle(
"updateAcceleration",
Effect.fn("environment.voice.updateAcceleration")(function* (args) {
yield* guard(args.endpoint.name, AuthSettingsWriteScope);
return yield* speech.updateAcceleration(args.payload.acceleration).pipe(mapSpeechError);
}),
)
.handle(
"updateModelUnloadTimeout",
Effect.fn("environment.voice.updateModelUnloadTimeout")(function* (args) {
yield* guard(args.endpoint.name, AuthSettingsWriteScope);
return yield* speech.updateModelUnloadTimeout(args.payload.timeout).pipe(mapSpeechError);
}),
)
.handle(
"transcribe",
Effect.fn("environment.voice.transcribe")(function* (args) {
yield* guard(args.endpoint.name);
const decoded = parseAudio(args.payload);
if (Option.isNone(decoded)) return yield* failEnvironmentInvalidRequest("invalid_audio");
const text = yield* speech
.transcribe(decoded.value.pcm, decoded.value.options)
.pipe(mapSpeechError);
return { text };
}),
)
.handle(
"postProcess",
Effect.fn("environment.voice.postProcess")(function* (args) {
yield* guard(args.endpoint.name);
return yield* postProcessing
.process(args.payload)
.pipe(Effect.catch((error) => failEnvironmentInternal("internal_error", error)));
}),
);
}),
).pipe(Layer.provide(bodyLimit), Layer.provide(SpeechPostProcessing.layer));