rapida-react
Version:
An easy to use react client for building generative ai application using Rapida platform.
1,494 lines (1,492 loc) • 81.5 kB
JavaScript
import {
useObservableState,
useSelectInputDeviceAgent
} from "./chunk-KTKQT72B.mjs";
import {
AgentLiveTranscript
} from "./chunk-CCCU2XI4.mjs";
import {
AgentMultibandAudioVisualizer
} from "./chunk-3YJ3G4GZ.mjs";
import {
Conversation
} from "./chunk-RWLMLTQ5.mjs";
import {
Channel,
ConnectionState,
DEBUGGER_SOURCE,
Feedback,
GOSDK_SOURCE,
GetDeployment,
HEADER_API_KEY,
HEADER_AUTH_ID,
HEADER_COLOR_DEPTH,
HEADER_CONNECTION_EFFECTIVE_TYPE,
HEADER_CONNECTION_TYPE,
HEADER_COOKIES_ENABLED,
HEADER_DEVICE_MEMORY,
HEADER_DO_NOT_TRACK,
HEADER_ENVIRONMENT_KEY,
HEADER_HARDWARE_CONCURRENCY,
HEADER_LANGUAGE,
HEADER_LATITUDE,
HEADER_LONGITUDE,
HEADER_PLATFORM,
HEADER_PROJECT_ID,
HEADER_REFERRER,
HEADER_REGION_KEY,
HEADER_REMOTE_URL,
HEADER_SCREEN_HEIGHT,
HEADER_SCREEN_WIDTH,
HEADER_SOURCE_KEY,
HEADER_TIMEZONE,
HEADER_USER_AGENT,
HEADER_WINDOW_HEIGHT,
HEADER_WINDOW_WIDTH,
JAVASDK_SOURCE,
MessageRole,
MessageStatus,
NODESDK_SOURCE,
PHPSDK_SOURCE,
PYTHONSDK_SOURCE,
RAPIDA_APP_SOURCE,
REACTNATIVESDK_SOURCE,
REACTSDK_SOURCE,
RUSTSDK_SOURCE,
TYPESCRIPTSDK_SOURCE,
VoiceAgent,
VoiceAgentContext,
WEB_PLUGIN_SOURCE,
agentConnectionStateObservable,
agentInitializeObservable,
agentInputObservable,
agentMessageChangeEventObserver,
fromStr,
getClientInfo,
getRapidaSourceValue,
require_assistant_api_pb,
require_common_pb,
require_talk_api_pb,
toContentText,
toStreamAudioContent,
toTextContent,
useEnsureVoiceAgent,
useMaybeVoiceAgent
} from "./chunk-H6YM5LDX.mjs";
import {
__commonJS,
__require,
__toESM
} from "./chunk-32YFHJN5.mjs";
// src/clients/protos/talk-api_pb_service.js
var require_talk_api_pb_service = __commonJS({
"src/clients/protos/talk-api_pb_service.js"(exports) {
"use strict";
var talk_api_pb = require_talk_api_pb();
var common_pb = require_common_pb();
var grpc2 = __require("@improbable-eng/grpc-web").grpc;
var TalkService = function() {
function TalkService2() {
}
TalkService2.serviceName = "talk_api.TalkService";
return TalkService2;
}();
TalkService.AssistantMessaging = {
methodName: "AssistantMessaging",
service: TalkService,
requestStream: false,
responseStream: true,
requestType: talk_api_pb.AssistantMessagingRequest,
responseType: talk_api_pb.AssistantMessagingResponse
};
TalkService.AssistantTalk = {
methodName: "AssistantTalk",
service: TalkService,
requestStream: true,
responseStream: true,
requestType: talk_api_pb.AssistantMessagingRequest,
responseType: talk_api_pb.AssistantMessagingResponse
};
TalkService.GetAllAssistantConversation = {
methodName: "GetAllAssistantConversation",
service: TalkService,
requestStream: false,
responseStream: false,
requestType: common_pb.GetAllAssistantConversationRequest,
responseType: common_pb.GetAllAssistantConversationResponse
};
TalkService.GetAllConversationMessage = {
methodName: "GetAllConversationMessage",
service: TalkService,
requestStream: false,
responseStream: false,
requestType: common_pb.GetAllConversationMessageRequest,
responseType: common_pb.GetAllConversationMessageResponse
};
TalkService.CreateMessageMetric = {
methodName: "CreateMessageMetric",
service: TalkService,
requestStream: false,
responseStream: false,
requestType: talk_api_pb.CreateMessageMetricRequest,
responseType: talk_api_pb.CreateMessageMetricResponse
};
TalkService.CreateConversationMetric = {
methodName: "CreateConversationMetric",
service: TalkService,
requestStream: false,
responseStream: false,
requestType: talk_api_pb.CreateConversationMetricRequest,
responseType: talk_api_pb.CreateConversationMetricResponse
};
TalkService.InitiateAssistantTalk = {
methodName: "InitiateAssistantTalk",
service: TalkService,
requestStream: false,
responseStream: false,
requestType: talk_api_pb.InitiateAssistantTalkRequest,
responseType: talk_api_pb.InitiateAssistantTalkResponse
};
TalkService.InitiateBulkAssistantTalk = {
methodName: "InitiateBulkAssistantTalk",
service: TalkService,
requestStream: false,
responseStream: false,
requestType: talk_api_pb.InitiateBulkAssistantTalkRequest,
responseType: talk_api_pb.InitiateBulkAssistantTalkResponse
};
exports.TalkService = TalkService;
function TalkServiceClient2(serviceHost, options) {
this.serviceHost = serviceHost;
this.options = options || {};
}
TalkServiceClient2.prototype.assistantMessaging = function assistantMessaging(requestMessage, metadata) {
var listeners = {
data: [],
end: [],
status: []
};
var client = grpc2.invoke(TalkService.AssistantMessaging, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onMessage: function(responseMessage) {
listeners.data.forEach(function(handler) {
handler(responseMessage);
});
},
onEnd: function(status, statusMessage, trailers) {
listeners.status.forEach(function(handler) {
handler({ code: status, details: statusMessage, metadata: trailers });
});
listeners.end.forEach(function(handler) {
handler({ code: status, details: statusMessage, metadata: trailers });
});
listeners = null;
}
});
return {
on: function(type, handler) {
listeners[type].push(handler);
return this;
},
cancel: function() {
listeners = null;
client.close();
}
};
};
TalkServiceClient2.prototype.assistantTalk = function assistantTalk(metadata) {
var listeners = {
data: [],
end: [],
status: []
};
var client = grpc2.client(TalkService.AssistantTalk, {
host: this.serviceHost,
metadata,
transport: this.options.transport
});
client.onEnd(function(status, statusMessage, trailers) {
listeners.status.forEach(function(handler) {
handler({ code: status, details: statusMessage, metadata: trailers });
});
listeners.end.forEach(function(handler) {
handler({ code: status, details: statusMessage, metadata: trailers });
});
listeners = null;
});
client.onMessage(function(message) {
listeners.data.forEach(function(handler) {
handler(message);
});
});
client.start(metadata);
return {
on: function(type, handler) {
listeners[type].push(handler);
return this;
},
write: function(requestMessage) {
client.send(requestMessage);
return this;
},
end: function() {
client.finishSend();
},
cancel: function() {
listeners = null;
client.close();
}
};
};
TalkServiceClient2.prototype.getAllAssistantConversation = function getAllAssistantConversation(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(TalkService.GetAllAssistantConversation, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
TalkServiceClient2.prototype.getAllConversationMessage = function getAllConversationMessage(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(TalkService.GetAllConversationMessage, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
TalkServiceClient2.prototype.createMessageMetric = function createMessageMetric(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(TalkService.CreateMessageMetric, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
TalkServiceClient2.prototype.createConversationMetric = function createConversationMetric(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(TalkService.CreateConversationMetric, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
TalkServiceClient2.prototype.initiateAssistantTalk = function initiateAssistantTalk(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(TalkService.InitiateAssistantTalk, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
TalkServiceClient2.prototype.initiateBulkAssistantTalk = function initiateBulkAssistantTalk(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(TalkService.InitiateBulkAssistantTalk, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
exports.TalkServiceClient = TalkServiceClient2;
}
});
// src/clients/protos/assistant-api_pb_service.js
var require_assistant_api_pb_service = __commonJS({
"src/clients/protos/assistant-api_pb_service.js"(exports) {
"use strict";
var assistant_api_pb = require_assistant_api_pb();
var common_pb = require_common_pb();
var grpc2 = __require("@improbable-eng/grpc-web").grpc;
var AssistantService = function() {
function AssistantService2() {
}
AssistantService2.serviceName = "assistant_api.AssistantService";
return AssistantService2;
}();
AssistantService.GetAssistant = {
methodName: "GetAssistant",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.GetAssistantRequest,
responseType: assistant_api_pb.GetAssistantResponse
};
AssistantService.GetAllAssistant = {
methodName: "GetAllAssistant",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.GetAllAssistantRequest,
responseType: assistant_api_pb.GetAllAssistantResponse
};
AssistantService.GetAllAssistantProviderModel = {
methodName: "GetAllAssistantProviderModel",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.GetAllAssistantProviderModelRequest,
responseType: assistant_api_pb.GetAllAssistantProviderModelResponse
};
AssistantService.CreateAssistant = {
methodName: "CreateAssistant",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.CreateAssistantRequest,
responseType: assistant_api_pb.GetAssistantResponse
};
AssistantService.CreateAssistantProviderModel = {
methodName: "CreateAssistantProviderModel",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.CreateAssistantProviderModelRequest,
responseType: assistant_api_pb.GetAssistantProviderModelResponse
};
AssistantService.CreateAssistantKnowledgeConfiguration = {
methodName: "CreateAssistantKnowledgeConfiguration",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.CreateAssistantKnowledgeConfigurationRequest,
responseType: assistant_api_pb.GetAssistantResponse
};
AssistantService.CreateAssistantTag = {
methodName: "CreateAssistantTag",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.CreateAssistantTagRequest,
responseType: assistant_api_pb.GetAssistantResponse
};
AssistantService.UpdateAssistantVersion = {
methodName: "UpdateAssistantVersion",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.UpdateAssistantVersionRequest,
responseType: assistant_api_pb.GetAssistantResponse
};
AssistantService.UpdateAssistantDetail = {
methodName: "UpdateAssistantDetail",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.UpdateAssistantDetailRequest,
responseType: assistant_api_pb.GetAssistantResponse
};
AssistantService.GetAllAssistantMessage = {
methodName: "GetAllAssistantMessage",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.GetAllAssistantMessageRequest,
responseType: assistant_api_pb.GetAllAssistantMessageResponse
};
AssistantService.GetAllAssistantConversation = {
methodName: "GetAllAssistantConversation",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: common_pb.GetAllAssistantConversationRequest,
responseType: common_pb.GetAllAssistantConversationResponse
};
AssistantService.GetAllConversationMessage = {
methodName: "GetAllConversationMessage",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: common_pb.GetAllConversationMessageRequest,
responseType: common_pb.GetAllConversationMessageResponse
};
AssistantService.CreateAssistantToolConfiguration = {
methodName: "CreateAssistantToolConfiguration",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.CreateAssistantToolConfigurationRequest,
responseType: assistant_api_pb.GetAssistantResponse
};
AssistantService.GetAllAssistantTool = {
methodName: "GetAllAssistantTool",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.GetAllAssistantToolRequest,
responseType: assistant_api_pb.GetAllAssistantToolResponse
};
AssistantService.GetAssistantConversation = {
methodName: "GetAssistantConversation",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.GetAssistantConversationRequest,
responseType: assistant_api_pb.GetAssistantConversationResponse
};
AssistantService.DeleteAssistant = {
methodName: "DeleteAssistant",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.DeleteAssistantRequest,
responseType: assistant_api_pb.GetAssistantResponse
};
AssistantService.GetAssistantWebhookLog = {
methodName: "GetAssistantWebhookLog",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.GetAssistantWebhookLogRequest,
responseType: assistant_api_pb.GetAssistantWebhookLogResponse
};
AssistantService.GetAllAssistantWebhookLog = {
methodName: "GetAllAssistantWebhookLog",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.GetAllAssistantWebhookLogRequest,
responseType: assistant_api_pb.GetAllAssistantWebhookLogResponse
};
AssistantService.GetAllAssistantWebhook = {
methodName: "GetAllAssistantWebhook",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.GetAllAssistantWebhookRequest,
responseType: assistant_api_pb.GetAllAssistantWebhookResponse
};
AssistantService.GetAssistantWebhook = {
methodName: "GetAssistantWebhook",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.GetAssistantWebhookRequest,
responseType: assistant_api_pb.GetAssistantWebhookResponse
};
AssistantService.CreateAssistantWebhook = {
methodName: "CreateAssistantWebhook",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.CreateAssistantWebhookRequest,
responseType: assistant_api_pb.GetAssistantWebhookResponse
};
AssistantService.UpdateAssistantWebhook = {
methodName: "UpdateAssistantWebhook",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.UpdateAssistantWebhookRequest,
responseType: assistant_api_pb.GetAssistantWebhookResponse
};
AssistantService.DeleteAssistantWebhook = {
methodName: "DeleteAssistantWebhook",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.DeleteAssistantWebhookRequest,
responseType: assistant_api_pb.GetAssistantWebhookResponse
};
AssistantService.GetAssistantAnalysis = {
methodName: "GetAssistantAnalysis",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.GetAssistantAnalysisRequest,
responseType: assistant_api_pb.GetAssistantAnalysisResponse
};
AssistantService.UpdateAssistantAnalysis = {
methodName: "UpdateAssistantAnalysis",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.UpdateAssistantAnalysisRequest,
responseType: assistant_api_pb.GetAssistantAnalysisResponse
};
AssistantService.CreateAssistantAnalysis = {
methodName: "CreateAssistantAnalysis",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.CreateAssistantAnalysisRequest,
responseType: assistant_api_pb.GetAssistantAnalysisResponse
};
AssistantService.DeleteAssistantAnalysis = {
methodName: "DeleteAssistantAnalysis",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.DeleteAssistantAnalysisRequest,
responseType: assistant_api_pb.GetAssistantAnalysisResponse
};
AssistantService.GetAllAssistantAnalysis = {
methodName: "GetAllAssistantAnalysis",
service: AssistantService,
requestStream: false,
responseStream: false,
requestType: assistant_api_pb.GetAllAssistantAnalysisRequest,
responseType: assistant_api_pb.GetAllAssistantAnalysisResponse
};
exports.AssistantService = AssistantService;
function AssistantServiceClient2(serviceHost, options) {
this.serviceHost = serviceHost;
this.options = options || {};
}
AssistantServiceClient2.prototype.getAssistant = function getAssistant(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.GetAssistant, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.getAllAssistant = function getAllAssistant(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.GetAllAssistant, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.getAllAssistantProviderModel = function getAllAssistantProviderModel(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.GetAllAssistantProviderModel, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.createAssistant = function createAssistant(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.CreateAssistant, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.createAssistantProviderModel = function createAssistantProviderModel(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.CreateAssistantProviderModel, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.createAssistantKnowledgeConfiguration = function createAssistantKnowledgeConfiguration(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.CreateAssistantKnowledgeConfiguration, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.createAssistantTag = function createAssistantTag(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.CreateAssistantTag, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.updateAssistantVersion = function updateAssistantVersion(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.UpdateAssistantVersion, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.updateAssistantDetail = function updateAssistantDetail(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.UpdateAssistantDetail, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.getAllAssistantMessage = function getAllAssistantMessage(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.GetAllAssistantMessage, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.getAllAssistantConversation = function getAllAssistantConversation(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.GetAllAssistantConversation, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.getAllConversationMessage = function getAllConversationMessage(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.GetAllConversationMessage, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.createAssistantToolConfiguration = function createAssistantToolConfiguration(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.CreateAssistantToolConfiguration, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.getAllAssistantTool = function getAllAssistantTool(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.GetAllAssistantTool, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.getAssistantConversation = function getAssistantConversation(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.GetAssistantConversation, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.deleteAssistant = function deleteAssistant(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.DeleteAssistant, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.getAssistantWebhookLog = function getAssistantWebhookLog(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.GetAssistantWebhookLog, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.getAllAssistantWebhookLog = function getAllAssistantWebhookLog(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.GetAllAssistantWebhookLog, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.getAllAssistantWebhook = function getAllAssistantWebhook(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.GetAllAssistantWebhook, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.getAssistantWebhook = function getAssistantWebhook(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.GetAssistantWebhook, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.createAssistantWebhook = function createAssistantWebhook(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.CreateAssistantWebhook, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.updateAssistantWebhook = function updateAssistantWebhook(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.UpdateAssistantWebhook, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.deleteAssistantWebhook = function deleteAssistantWebhook(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.DeleteAssistantWebhook, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.getAssistantAnalysis = function getAssistantAnalysis(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.GetAssistantAnalysis, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.updateAssistantAnalysis = function updateAssistantAnalysis(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.UpdateAssistantAnalysis, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.createAssistantAnalysis = function createAssistantAnalysis(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.CreateAssistantAnalysis, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.deleteAssistantAnalysis = function deleteAssistantAnalysis(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.DeleteAssistantAnalysis, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.status !== grpc2.Code.OK) {
var err = new Error(response.statusMessage);
err.code = response.status;
err.metadata = response.trailers;
callback(err, null);
} else {
callback(null, response.message);
}
}
}
});
return {
cancel: function() {
callback = null;
client.close();
}
};
};
AssistantServiceClient2.prototype.getAllAssistantAnalysis = function getAllAssistantAnalysis(requestMessage, metadata, callback) {
if (arguments.length === 2) {
callback = arguments[1];
}
var client = grpc2.unary(AssistantService.GetAllAssistantAnalysis, {
request: requestMessage,
host: this.serviceHost,
metadata,
transport: this.options.transport,
debug: this.options.debug,
onEnd: function(response) {
if (callback) {
if (response.s