syntax = "proto3";
package streamd;
option go_package = "go/streamd_grpc";

import "player/player.proto";

service StreamD {
    rpc Ping(PingRequest) returns (PingReply) {}
    rpc SetLoggingLevel(SetLoggingLevelRequest) returns (SetLoggingLevelReply) {}
    rpc GetLoggingLevel(GetLoggingLevelRequest) returns (GetLoggingLevelReply) {}
    rpc GetConfig(GetConfigRequest) returns (GetConfigReply) {}
    rpc SetConfig(SetConfigRequest) returns (SetConfigReply) {}
    rpc SaveConfig(SaveConfigRequest) returns (SaveConfigReply) {}
    rpc SubscribeToConfigChanges(SubscribeToConfigChangesRequest) returns (stream ConfigChange) {}
    rpc ResetCache(ResetCacheRequest) returns (ResetCacheReply) {}
    rpc InitCache(InitCacheRequest) returns (InitCacheReply) {}
    rpc StartStream(StartStreamRequest) returns (StartStreamReply) {}
    rpc EndStream(EndStreamRequest) returns (EndStreamReply) {}
    rpc GetStreamStatus(GetStreamStatusRequest) returns (GetStreamStatusReply) {}
    rpc IsBackendEnabled(IsBackendEnabledRequest) returns (IsBackendEnabledReply) {}
    rpc GetBackendInfo(GetBackendInfoRequest) returns (GetBackendInfoReply) {}
    rpc SubscribeToStreamsChanges(SubscribeToStreamsChangesRequest) returns (stream StreamsChange) {}
    rpc Restart(RestartRequest) returns (RestartReply) {}
    rpc SetTitle(SetTitleRequest) returns (SetTitleReply) {}
    rpc SetDescription(SetDescriptionRequest) returns (SetDescriptionReply) {}
    rpc ApplyProfile(ApplyProfileRequest) returns (ApplyProfileReply) {}
    rpc UpdateStream(UpdateStreamRequest) returns (UpdateStreamReply) {}
    rpc GetVariable(GetVariableRequest) returns(GetVariableReply) {}
    rpc GetVariableHash(GetVariableHashRequest) returns(GetVariableHashReply) {}
    rpc SetVariable(SetVariableRequest) returns(SetVariableReply) {}

    rpc EXPERIMENTAL_ReinitStreamControllers(EXPERIMENTAL_ReinitStreamControllersRequest) returns (EXPERIMENTAL_ReinitStreamControllersReply) {}

    rpc SubscribeToOAuthRequests(SubscribeToOAuthRequestsRequest) returns (stream OAuthRequest) {}
    rpc SubmitOAuthCode(SubmitOAuthCodeRequest) returns (SubmitOAuthCodeReply) {}

    rpc ListStreamServers(ListStreamServersRequest) returns (ListStreamServersReply) {}
	rpc StartStreamServer(StartStreamServerRequest) returns (StartStreamServerReply) {}
	rpc StopStreamServer(StopStreamServerRequest) returns (StopStreamServerReply) {}
    rpc SubscribeToStreamServersChanges(SubscribeToStreamServersChangesRequest) returns (stream StreamServersChange) {}
	rpc ListStreamDestinations(ListStreamDestinationsRequest) returns (ListStreamDestinationsReply) {}
	rpc AddStreamDestination(AddStreamDestinationRequest) returns (AddStreamDestinationReply) {}
	rpc UpdateStreamDestination(UpdateStreamDestinationRequest) returns (UpdateStreamDestinationReply) {}
	rpc RemoveStreamDestination(RemoveStreamDestinationRequest) returns (RemoveStreamDestinationReply) {}
    rpc SubscribeToStreamDestinationsChanges(SubscribeToStreamDestinationsChangesRequest) returns (stream StreamDestinationsChange) {}
    rpc AddIncomingStream(AddIncomingStreamRequest) returns (AddIncomingStreamReply) {}
    rpc RemoveIncomingStream(RemoveIncomingStreamRequest) returns (RemoveIncomingStreamReply) {}
    rpc ListIncomingStreams(ListIncomingStreamsRequest) returns (ListIncomingStreamsReply) {}
    rpc SubscribeToIncomingStreamsChanges(SubscribeToIncomingStreamsChangesRequest) returns (stream IncomingStreamsChange) {}
	rpc ListStreamForwards(ListStreamForwardsRequest) returns (ListStreamForwardsReply) {}
	rpc AddStreamForward(AddStreamForwardRequest) returns (AddStreamForwardReply) {}
	rpc UpdateStreamForward(UpdateStreamForwardRequest) returns (UpdateStreamForwardReply) {}
	rpc RemoveStreamForward(RemoveStreamForwardRequest) returns (RemoveStreamForwardReply) {}
    rpc SubscribeToStreamForwardsChanges(SubscribeToStreamForwardsChangesRequest) returns (stream StreamForwardsChange) {}
    rpc WaitForStreamPublisher(WaitForStreamPublisherRequest) returns (stream StreamPublisher) {}
    rpc AddStreamPlayer(AddStreamPlayerRequest) returns (AddStreamPlayerReply) {}
    rpc RemoveStreamPlayer(RemoveStreamPlayerRequest) returns (RemoveStreamPlayerReply) {}
    rpc UpdateStreamPlayer(UpdateStreamPlayerRequest) returns (UpdateStreamPlayerReply) {}
    rpc ListStreamPlayers(ListStreamPlayersRequest) returns (ListStreamPlayersReply) {}
    rpc GetStreamPlayer(GetStreamPlayerRequest) returns (GetStreamPlayerReply) {}
    rpc SubscribeToStreamPlayersChanges(SubscribeToStreamPlayersChangesRequest) returns (stream StreamPlayersChange) {}

    rpc StreamPlayerOpen(StreamPlayerOpenRequest) returns (StreamPlayerOpenReply) {}
    rpc StreamPlayerProcessTitle(StreamPlayerProcessTitleRequest) returns (StreamPlayerProcessTitleReply) {}
	rpc StreamPlayerGetLink(StreamPlayerGetLinkRequest) returns (StreamPlayerGetLinkReply) {}
	rpc StreamPlayerEndChan(StreamPlayerEndChanRequest) returns (stream StreamPlayerEndChanReply) {}
	rpc StreamPlayerIsEnded(StreamPlayerIsEndedRequest) returns (StreamPlayerIsEndedReply) {}
	rpc StreamPlayerGetPosition(StreamPlayerGetPositionRequest) returns (StreamPlayerGetPositionReply) {}
	rpc StreamPlayerGetLength(StreamPlayerGetLengthRequest) returns (StreamPlayerGetLengthReply) {}
	rpc StreamPlayerSetSpeed(StreamPlayerSetSpeedRequest) returns (StreamPlayerSetSpeedReply) {}
	rpc StreamPlayerSetPause(StreamPlayerSetPauseRequest) returns (StreamPlayerSetPauseReply) {}
	rpc StreamPlayerStop(StreamPlayerStopRequest) returns (StreamPlayerStopReply) {}
	rpc StreamPlayerClose(StreamPlayerCloseRequest) returns (StreamPlayerCloseReply) {}

    rpc AddTimer(AddTimerRequest) returns (AddTimerReply) {}
    rpc RemoveTimer(RemoveTimerRequest) returns (RemoveTimerReply) {}
    rpc ListTimers(ListTimersRequest) returns (ListTimersReply) {}

    rpc ListTriggerRules(ListTriggerRulesRequest) returns (ListTriggerRulesReply) {}
    rpc AddTriggerRule(AddTriggerRuleRequest) returns (AddTriggerRuleReply) {}
    rpc RemoveTriggerRule(RemoveTriggerRuleRequest) returns (RemoveTriggerRuleReply) {}
    rpc UpdateTriggerRule(UpdateTriggerRuleRequest) returns (UpdateTriggerRuleReply) {}

    rpc SubmitEvent(SubmitEventRequest) returns (SubmitEventReply) {}

    rpc SubscribeToChatMessages(SubscribeToChatMessagesRequest) returns (stream ChatMessage) {}
    rpc SendChatMessage(SendChatMessageRequest) returns (SendChatMessageReply) {}
    rpc RemoveChatMessage(RemoveChatMessageRequest) returns (RemoveChatMessageReply) {}
    rpc BanUser(BanUserRequest) returns (BanUserReply) {}

    rpc GetPeerIDs(GetPeerIDsRequest) returns (GetPeerIDsReply) {}

    rpc LLMGenerate(LLMGenerateRequest) returns (LLMGenerateReply) {}
}

message PingRequest {
    string payloadToReturn = 1;
    string payloadToIgnore = 2;
    int32 requestExtraPayloadSize = 3;
}
message PingReply {
    string payload = 1;
}


enum LoggingLevel {
    none = 0;
    fatal = 1;
    panic = 2;
    error = 3;
    warning = 4;
    info = 5;
    debug = 6;
    trace = 7;
}

message SetLoggingLevelRequest {
    LoggingLevel loggingLevel = 1;
}
message SetLoggingLevelReply {}
message GetLoggingLevelRequest {}
message GetLoggingLevelReply {
    LoggingLevel loggingLevel = 1;
}

message GetConfigRequest {}
message GetConfigReply {
    string config = 1;
}
message SetConfigRequest {
    string config = 1;
}
message SetConfigReply {}
message SaveConfigRequest {}
message SaveConfigReply {}
message ResetCacheRequest {}
message ResetCacheReply {}
message InitCacheRequest {}
message InitCacheReply {}
message StartStreamRequest {
    string platID = 1;
    string title = 2;
    string description = 3;
    string profile = 4;
}
message StartStreamReply {}
message EndStreamRequest {
    string platID = 1;
}
message EndStreamReply {}
message GetStreamStatusRequest {
    string platID = 1;
    bool noCache = 2;
}
message GetStreamStatusReply {
    bool isActive = 1;
    optional int64 started_at = 2;
    string customData = 3;
    optional uint64 viewers_count = 4;
}
message GetBackendInfoRequest {
    string platID = 1;
}
message GetBackendInfoReply {
    bool isInitialized = 1;
    string data = 2;
    repeated Capability capabilities = 3;
}
message IsBackendEnabledRequest {
    string platID = 1;
}
message IsBackendEnabledReply {
    bool isInitialized = 1;
}
enum Capability {
    capabilityUndefined = 0;
    SendChatMessage = 1;
	DeleteChatMessage = 2;
	BanUser = 3;
}
message RestartRequest {}
message RestartReply {}

message SetTitleRequest {
    string platID = 1;
    string title = 2;
}
message SetTitleReply {}
message SetDescriptionRequest  {
    string platID = 1;
    string description = 2;
}
message SetDescriptionReply {}
message ApplyProfileRequest {
    string platID = 1;
    string profile = 2;
}
message ApplyProfileReply {}
message UpdateStreamRequest {
    string platID = 1;
    string title = 2;
    string description = 3;
    string profile = 4;
}
message UpdateStreamReply {}


message EXPERIMENTAL_ReinitStreamControllersRequest {}
message EXPERIMENTAL_ReinitStreamControllersReply {}

message OBSOLETE_FetchConfigRequest {}
message OBSOLETE_FetchConfigReply {}
message OBSOLETE_GetGitInfoRequest {}
message OBSOLETE_GetGitInfoReply {
    bool isInitialized = 1;
}
message OBSOLETE_GitReloginRequest {}
message OBSOLETE_GitReloginReply {}


message SubscribeToOAuthRequestsRequest{
    int32 listenPort = 1;
}
message OAuthRequest{
    string platID = 1;
    string authURL = 2;
}

message GetVariableRequest {
    string key =  1;
}
message GetVariableReply {
    string key = 1;
    bytes value = 2;
}
message GetVariableHashRequest {
    string key = 1;
    HashType hashType = 2; 
}
message GetVariableHashReply {
    string key = 1;
    HashType hashType = 2; 
    bytes hash = 3;
}
message SetVariableRequest {
    string key = 1;
    bytes value = 2;
}
message SetVariableReply {}

enum HashType {
    HASH_SHA1 = 0;
}

message SubmitOAuthCodeRequest {
    string platID = 1;
    string code = 2;
}
message SubmitOAuthCodeReply {}

enum StreamServerType {
    Undefined = 0;
    RTSP = 1;
    RTMP = 2;
    SRT = 3;
}

message TLSCertificate {
    oneof TLSCertificateOneOf {
        bytes X509 = 1;
    }
}

message PrivateKey {
    oneof PrivateKeyOneOf {
        bytes PKCS8 = 1;
    }
}

message StreamServer {
    StreamServerType serverType = 1;
    string listenAddr = 2;
    bool IsTLS    = 3;
	uint64 WriteQueueSize = 4;
	uint64 WriteTimeoutNano  = 5;
	uint64 ReadTimeoutNano = 6;
	optional TLSCertificate ServerCert = 7;
	optional PrivateKey ServerKey  = 8;
}

message StreamServerStatistics {
    int64 NumBytesConsumerWrote = 1;
    int64 NumBytesProducerRead = 2;
}

message StreamServerWithStatistics {
    StreamServer config = 1;
    StreamServerStatistics statistics = 2;
}

message ListStreamServersRequest {}
message ListStreamServersReply {
    repeated StreamServerWithStatistics streamServers = 1;
}

message StartStreamServerRequest {
    StreamServer config = 1;
}
message StartStreamServerReply {
}

message StopStreamServerRequest {
    string listenAddr = 1;
}
message StopStreamServerReply {}

message StreamDestination {
    string destinationID = 1;
    string url = 2;
    string streamKey = 3;
}

message ListStreamDestinationsRequest {}
message ListStreamDestinationsReply {
    repeated StreamDestination streamDestinations = 1;
}

message AddStreamDestinationRequest {
    StreamDestination config = 1;
}
message AddStreamDestinationReply {}

message UpdateStreamDestinationRequest {
    StreamDestination config = 1;
}
message UpdateStreamDestinationReply {}

message RemoveStreamDestinationRequest {
    string destinationID = 1;
}
message RemoveStreamDestinationReply {}

message IncomingStream {
    string streamID = 1;
    bool isActive = 2;
}

message AddIncomingStreamRequest {
    string streamID = 1;
}
message AddIncomingStreamReply {}

message RemoveIncomingStreamRequest {
    string streamID = 1;
}
message RemoveIncomingStreamReply {}

message ListIncomingStreamsRequest {}
message ListIncomingStreamsReply {
    repeated IncomingStream incomingStreams = 1;
}

message RestartUntilYoutubeRecognizesStream {
    bool enabled = 1;
	double startTimeout = 2;
    double stopStartDelay = 3;
}

message StartAfterYoutubeRecognizedStream {
    bool enabled = 1;
}

message StreamForwardQuirks {
    RestartUntilYoutubeRecognizesStream restartUntilYoutubeRecognizesStream = 1;
    StartAfterYoutubeRecognizedStream startAfterYoutubeRecognizedStream = 2;
}

message StreamForward {
    string streamID = 1;
    string destinationID = 2;
    bool enabled = 3;
    EncoderConfig encode = 4;
    StreamForwardQuirks quirks = 5;
}

message EncoderConfig {
    bool enable = 1;
    repeated OutputAudioTrack outputAudioTracks = 2;
	repeated OutputVideoTrack outputVideoTracks = 3;
}

message OutputAudioTrack {
    repeated uint64 inputTrackIDs = 1;
    EncodeAudioConfig encode = 2;
}

message EncodeAudioConfig {
    AudioCodec codec = 1;
    AudioQuality quality = 2;
}

enum AudioCodec {
	AudioCodecCopy = 0;
	AudioCodecAAC = 1;
	AudioCodecVorbis = 2;
	AudioCodecOpus = 3;
}

message AudioQuality {
    oneof AudioQuality {
        uint32 constantBitrate = 1;
    }
}

message OutputVideoTrack {
    repeated uint64 inputTrackIDs = 1;
    EncodeVideoConfig encode = 2;
}

message EncodeVideoConfig {
    VideoCodec codec = 1;
    VideoQuality quality = 2;
}

enum VideoCodec {
	VideoCodecCopy = 0;
	VideoCodecH264 = 1;
	VideoCodecHEVC = 2;
	VideoCodecAV1 = 3;
}

message VideoQuality {
    oneof VideoQuality {
        uint32 constantBitrate = 1;
        uint32 constantQuality = 2;
    }
}

message StreamForwardStatistics {
    int64 numBytesWrote = 1;
    int64 numBytesRead = 2;
}

message StreamForwardWithStatistics {
    StreamForward config =  1;
    StreamForwardStatistics statistics = 2;
}

message ListStreamForwardsRequest {}
message ListStreamForwardsReply {
    repeated StreamForwardWithStatistics streamForwards = 1;
}

message AddStreamForwardRequest {
    StreamForward config = 1;
}
message AddStreamForwardReply {}

message UpdateStreamForwardRequest {
    StreamForward config = 1;
}
message UpdateStreamForwardReply {}

message RemoveStreamForwardRequest {
    StreamForward config = 1;
}
message RemoveStreamForwardReply {}

message WaitForStreamPublisherRequest {
    optional string streamID = 1;
    bool waitForNext = 2;
}
message StreamPublisher {}

enum PlayerType {
    PlayerTypeAuto = 0;
    PlayerTypeLibVLC = 1;
    PlayerTypeMPV = 2;
}

message StreamPlaybackConfig {
    double JitterBufDurationSecs = 1;
	double CatchupMaxSpeedFactor = 2;
	double MaxCatchupAtLagSecs   = 3;
	double StartTimeoutSecs      = 4;
	double ReadTimeoutSecs       = 5;
    string overriddenURL         = 6;
    bool   forceWaitForPublisher = 7;
    bool   enableObserver        = 8;
}
message StreamPlayerConfig {
    string streamID = 1;
	PlayerType playerType = 2;
	bool disabled = 3;
	StreamPlaybackConfig streamPlaybackConfig = 4;
}
message AddStreamPlayerRequest {
    StreamPlayerConfig config = 1;
}
message AddStreamPlayerReply {}
message RemoveStreamPlayerRequest {
    string streamID = 1;
}
message RemoveStreamPlayerReply {}
message UpdateStreamPlayerRequest {
    StreamPlayerConfig config = 1;
}
message UpdateStreamPlayerReply {}

message ListStreamPlayersRequest {}
message ListStreamPlayersReply {
    repeated StreamPlayerConfig players = 1;
}
message GetStreamPlayerRequest {
    string streamID = 1;
}
message GetStreamPlayerReply {
    StreamPlayerConfig config = 1;
}

message StreamPlayerOpenRequest {
    string streamID = 1;
    player.OpenRequest request = 2;
}
message StreamPlayerOpenReply {
    player.OpenReply reply = 1;
}
message StreamPlayerProcessTitleRequest  {
    string streamID = 1;
    player.ProcessTitleRequest request = 2;
}
message StreamPlayerProcessTitleReply {
    player.ProcessTitleReply reply = 1;    
}
message StreamPlayerGetLinkRequest {
    string streamID = 1;
    player.GetLinkRequest request = 2;
}
message StreamPlayerGetLinkReply {
    player.GetLinkReply reply = 1;
}
message StreamPlayerEndChanRequest {
    string streamID = 1;
    player.EndChanRequest request = 2;
}
message StreamPlayerEndChanReply {
    player.EndChanReply reply = 1;
}
message StreamPlayerIsEndedRequest {
    string streamID = 1;
    player.IsEndedRequest request = 2;
}
message StreamPlayerIsEndedReply {
    player.IsEndedReply reply = 1;
}
message StreamPlayerGetPositionRequest {
    string streamID = 1;
    player.GetPositionRequest request = 2;
}
message StreamPlayerGetPositionReply {
    player.GetPositionReply reply = 1;
}
message StreamPlayerGetLengthRequest {
    string streamID = 1;
    player.GetLengthRequest request = 2;
}
message StreamPlayerGetLengthReply {
    player.GetLengthReply reply = 1;
}
message StreamPlayerSetSpeedRequest {
    string streamID = 1;
    player.SetSpeedRequest request = 2;
}
message StreamPlayerSetSpeedReply {
    player.SetSpeedReply reply = 1;
}
message StreamPlayerSetPauseRequest {
    string streamID = 1;
    player.SetPauseRequest request = 2;
}
message StreamPlayerSetPauseReply {
    player.SetPauseReply reply = 1;
}
message StreamPlayerStopRequest {
    string streamID = 1;
    player.StopRequest request = 2;
}
message StreamPlayerStopReply {
    player.StopReply reply = 1;
}
message StreamPlayerCloseRequest {
    string streamID = 1;
    player.CloseRequest request = 2;
}
message StreamPlayerCloseReply {
    player.CloseReply reply = 1;
}

message SubscribeToConfigChangesRequest {}
message ConfigChange {}
message SubscribeToStreamsChangesRequest {}
message StreamsChange {}
message SubscribeToStreamServersChangesRequest {}
message StreamServersChange {}
message SubscribeToStreamDestinationsChangesRequest {}
message StreamDestinationsChange {}
message SubscribeToIncomingStreamsChangesRequest {}
message IncomingStreamsChange {}
message SubscribeToStreamForwardsChangesRequest {}
message StreamForwardsChange {}
message SubscribeToStreamPlayersChangesRequest {}
message StreamPlayersChange {}

message NoopRequest {}

message OBSActionItemShowHide {
    optional string itemName =  1;
    optional string itemUUID =  2;
    string valueExpression = 3;
}

message OBSActionWindowCaptureSetSource {
    optional string itemName =  1;
    optional string itemUUID =  2;
    string valueExpression = 3;
}

message OBSAction {
    oneof OBSActionOneOf {
        OBSActionItemShowHide itemShowHide = 1;
        OBSActionWindowCaptureSetSource windowCaptureSetSource = 2;
    }
}

message Action {
    oneof ActionOneof {
        NoopRequest noopRequest = 1;
        StartStreamRequest startStreamRequest = 2;
        EndStreamRequest endStreamRequest = 3;
        OBSAction obsAction = 4;
    }
}

message AddTimerRequest {
    int64 triggerAtUnixNano = 1;
    Action action = 2;
}
message AddTimerReply {
    int64 timerID = 1;
}

message RemoveTimerRequest {
    int64 timerID = 1;
}
message RemoveTimerReply {}

message Timer {
    int64 timerID = 1;
    int64 triggerAtUnixNano = 2;
    Action action = 3;
}

message ListTimersRequest {}
message ListTimersReply {
    repeated Timer timers = 1;
}

message EventQueryAnd {
    repeated Event queries = 1;
}

message EventQueryOr {
    repeated Event queries =  1;
}

message EventQueryNot {
    Event query = 1;
}

message EventOBSSceneChange {
    string sceneName =  1;
}

message EventWindowFocusChange {
    optional string host = 1;
    optional uint64 windowID = 2;
    optional string windowTitle = 3;
    optional uint64 processID = 4;
    optional string processName = 5;
    optional uint64 userID = 6;
    optional bool isFocused = 7;
}

message EventQuery {
    oneof EventQueryOneOf {
        EventQueryAnd and = 1;
        EventQueryOr or = 2;
        EventQueryNot not = 3;
        EventType eventType = 4;
        Event event = 5;
    }
}

enum EventType {
    eventWindowFocusChange = 0;
    eventOBSSceneChange = 1;
}

message Event {
    oneof EventOneOf {
        EventOBSSceneChange obsSceneChange = 1;
        EventWindowFocusChange windowFocusChange = 2;
    }
}

message TriggerRule {
    string Description = 1;
    EventQuery eventQuery = 2;
    Action action = 3;
}

message ListTriggerRulesRequest {}
message ListTriggerRulesReply {
    repeated TriggerRule rules = 1;
}
message AddTriggerRuleRequest {
    TriggerRule rule = 1;
}
message AddTriggerRuleReply {
    uint64 ruleID =  1;
}
message RemoveTriggerRuleRequest  {
    uint64 ruleID =  1;
}
message RemoveTriggerRuleReply {}
message UpdateTriggerRuleRequest  {
    uint64 ruleID = 1;
    TriggerRule rule = 2;
}
message UpdateTriggerRuleReply {}

message SubmitEventRequest {
    Event event = 1;
}
message SubmitEventReply {}

message SubscribeToChatMessagesRequest {
    uint64 sinceUNIXNano = 1;
}
message ChatMessage {
	uint64 createdAtUNIXNano  = 1;
    string platID = 2;
    string userID = 3;
    string username = 4;
    string messageID = 5;
    string message = 6;
}

message SendChatMessageRequest {
    string platID = 1;
    string message = 2;
}
message SendChatMessageReply {}

message RemoveChatMessageRequest {
    string platID = 1;
    string messageID = 2;
}
message RemoveChatMessageReply {}
message BanUserRequest {
    string platID = 1;
    string userID = 2;
    string reason = 3;
	optional int64 deadlineUnixNano  = 4;
}
message BanUserReply {}

message GetPeerIDsRequest {}
message GetPeerIDsReply {
    repeated string peerIDs = 1;
}


message LLMGenerateRequest {
    string prompt = 1;
}
message LLMGenerateReply {
    string response = 1;
}