@chilkat/react-native 11.6.1

package/cpp/HybridAi.cpp

@@ -0,0 +1,660 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridAi.hpp"
+#include "HybridBinData.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridMcp.hpp"
+#include "HybridSocket.hpp"
+#include "HybridStringBuilder.hpp"
+#include "HybridStringTable.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridAi::HybridAi()
+    : HybridObject(HybridAiSpec::TAG), ChilkatObject<CkAi>("Ai", CkAi::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridAi::HybridAi(CkAi* owned)
+    : HybridObject(HybridAiSpec::TAG), ChilkatObject<CkAi>("Ai", owned) {
+  init();
+}
+
+void HybridAi::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridAi::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridAi::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridAi::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridAi::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridAi::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridAi::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridAi::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridAi::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridAi::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridAi::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridAi::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridAi::getProvider() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Provider(_s);
+  return rt::stdString(_s);
+}
+void HybridAi::setProvider(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "provider");
+  this->ck().put_Provider(value.c_str());
+}
+std::string HybridAi::getSelectedConvo() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SelectedConvo(_s);
+  return rt::stdString(_s);
+}
+void HybridAi::setSelectedConvo(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "selectedConvo");
+  this->ck().put_SelectedConvo(value.c_str());
+}
+std::string HybridAi::getApiKey() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ApiKey(_s);
+  return rt::stdString(_s);
+}
+void HybridAi::setApiKey(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "apiKey");
+  this->ck().put_ApiKey(value.c_str());
+}
+std::string HybridAi::getModel() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Model(_s);
+  return rt::stdString(_s);
+}
+void HybridAi::setModel(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "model");
+  this->ck().put_Model(value.c_str());
+}
+bool HybridAi::getFullTranscript() {
+  this->beginCall();
+  return this->ck().get_FullTranscript();
+}
+void HybridAi::setFullTranscript(bool value) {
+  this->beginCall();
+  this->ck().put_FullTranscript(value);
+}
+bool HybridAi::getStreaming() {
+  this->beginCall();
+  return this->ck().get_Streaming();
+}
+void HybridAi::setStreaming(bool value) {
+  this->beginCall();
+  this->ck().put_Streaming(value);
+}
+double HybridAi::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridAi::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+bool HybridAi::getHostedConvo() {
+  this->beginCall();
+  return this->ck().get_HostedConvo();
+}
+void HybridAi::setHostedConvo(bool value) {
+  this->beginCall();
+  this->ck().put_HostedConvo(value);
+}
+std::string HybridAi::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridAi::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+double HybridAi::getIdleTimeoutMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_IdleTimeoutMs());
+}
+void HybridAi::setIdleTimeoutMs(double value) {
+  this->beginCall();
+  this->ck().put_IdleTimeoutMs(rt::toInt(value, "idleTimeoutMs"));
+}
+double HybridAi::getResponseStatusCode() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ResponseStatusCode());
+}
+std::string HybridAi::getApiSpec() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ApiSpec(_s);
+  return rt::stdString(_s);
+}
+void HybridAi::setApiSpec(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "apiSpec");
+  this->ck().put_ApiSpec(value.c_str());
+}
+std::string HybridAi::getBaseUrl() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_BaseUrl(_s);
+  return rt::stdString(_s);
+}
+void HybridAi::setBaseUrl(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "baseUrl");
+  this->ck().put_BaseUrl(value.c_str());
+}
+std::string HybridAi::getApiKeyHeader() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ApiKeyHeader(_s);
+  return rt::stdString(_s);
+}
+void HybridAi::setApiKeyHeader(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "apiKeyHeader");
+  this->ck().put_ApiKeyHeader(value.c_str());
+}
+bool HybridAi::getHasFunctionCalls() {
+  this->beginCall();
+  return this->ck().get_HasFunctionCalls();
+}
+double HybridAi::getJsToolTimeout() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_JsToolTimeout());
+}
+void HybridAi::setJsToolTimeout(double value) {
+  this->beginCall();
+  this->ck().put_JsToolTimeout(rt::toInt(value, "jsToolTimeout"));
+}
+bool HybridAi::getEnableSecrets() {
+  this->beginCall();
+  return this->ck().get_EnableSecrets();
+}
+void HybridAi::setEnableSecrets(bool value) {
+  this->beginCall();
+  this->ck().put_EnableSecrets(value);
+}
+bool HybridAi::getLastResponseRefused() {
+  this->beginCall();
+  return this->ck().get_LastResponseRefused();
+}
+std::string HybridAi::getRefusalText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_RefusalText(_s);
+  return rt::stdString(_s);
+}
+
+// ---- Methods ----
+
+void HybridAi::newConvo(const std::string& name, const std::string& sysMsg, const std::string& devMsg) {
+  this->beginCall();
+  newConvo_impl(name, sysMsg, devMsg);
+}
+void HybridAi::newConvo_impl(const std::string& name, const std::string& sysMsg, const std::string& devMsg) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(sysMsg, "sysMsg");
+  rt::checkNoNul(devMsg, "devMsg");
+  if (!this->ck().NewConvo(name.c_str(), sysMsg.c_str(), devMsg.c_str())) throw this->fail("newConvo");
+}
+
+void HybridAi::exportConvo(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  exportConvo_impl(name, json);
+}
+void HybridAi::exportConvo_impl(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().ExportConvo(name.c_str(), rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("exportConvo");
+}
+
+void HybridAi::importConvo(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  importConvo_impl(name, json);
+}
+void HybridAi::importConvo_impl(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().ImportConvo(name.c_str(), rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("importConvo");
+}
+
+void HybridAi::listConvos(const std::shared_ptr<HybridStringTableSpec>& st) {
+  this->beginCall();
+  listConvos_impl(st);
+}
+void HybridAi::listConvos_impl(const std::shared_ptr<HybridStringTableSpec>& st) {
+  if (!this->ck().ListConvos(rt::implOf<HybridStringTable>(st, "st").ck())) throw this->fail("listConvos");
+}
+
+void HybridAi::deleteConvo(const std::string& name) {
+  this->beginCall();
+  deleteConvo_impl(name);
+}
+void HybridAi::deleteConvo_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().DeleteConvo(name.c_str())) throw this->fail("deleteConvo");
+}
+
+void HybridAi::setConnectionSettings(const std::shared_ptr<HybridSocketSpec>& sock) {
+  this->beginCall();
+  setConnectionSettings_impl(sock);
+}
+void HybridAi::setConnectionSettings_impl(const std::shared_ptr<HybridSocketSpec>& sock) {
+  if (!this->ck().SetConnectionSettings(rt::implOf<HybridSocket>(sock, "sock").ck())) throw this->fail("setConnectionSettings");
+}
+
+void HybridAi::ask(const std::string& outputType) {
+  this->beginCall();
+  ask_impl(outputType);
+}
+void HybridAi::ask_impl(const std::string& outputType) {
+  rt::checkNoNul(outputType, "outputType");
+  if (!this->ck().Ask(outputType.c_str())) throw this->fail("ask");
+}
+std::shared_ptr<Promise<void>> HybridAi::askAsync(const std::string& outputType) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridAi>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ai.askAsync", std::move(_parts), [_self, outputType]() {
+    _self->ask_impl(outputType);
+  });
+}
+
+void HybridAi::getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getLastJsonData_impl(json);
+}
+void HybridAi::getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->ck().GetLastJsonData(rt::implOf<HybridJsonObject>(json, "json").ck());
+}
+
+void HybridAi::getModels(const std::shared_ptr<HybridStringTableSpec>& st) {
+  this->beginCall();
+  getModels_impl(st);
+}
+void HybridAi::getModels_impl(const std::shared_ptr<HybridStringTableSpec>& st) {
+  if (!this->ck().GetModels(rt::implOf<HybridStringTable>(st, "st").ck())) throw this->fail("getModels");
+}
+std::shared_ptr<Promise<void>> HybridAi::getModelsAsync(const std::shared_ptr<HybridStringTableSpec>& st) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridAi>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(st);
+  return rt::runAsync<void>("Ai.getModelsAsync", std::move(_parts), [_self, st]() {
+    _self->getModels_impl(st);
+  });
+}
+
+void HybridAi::inputAddText(const std::string& text) {
+  this->beginCall();
+  inputAddText_impl(text);
+}
+void HybridAi::inputAddText_impl(const std::string& text) {
+  rt::checkNoNul(text, "text");
+  if (!this->ck().InputAddText(text.c_str())) throw this->fail("inputAddText");
+}
+
+std::string HybridAi::getOutputText() {
+  this->beginCall();
+  return getOutputText_impl();
+}
+std::string HybridAi::getOutputText_impl() {
+  CkString _out;
+  if (!this->ck().GetOutputText(_out)) throw this->fail("getOutputText");
+  return rt::stdString(_out);
+}
+
+void HybridAi::getOutputTextSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  getOutputTextSb_impl(sb);
+}
+void HybridAi::getOutputTextSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().GetOutputTextSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("getOutputTextSb");
+}
+
+void HybridAi::inputClear() {
+  this->beginCall();
+  inputClear_impl();
+}
+void HybridAi::inputClear_impl() {
+  this->ck().InputClear();
+}
+
+void HybridAi::inputAddTextSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  inputAddTextSb_impl(sb);
+}
+void HybridAi::inputAddTextSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().InputAddTextSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("inputAddTextSb");
+}
+
+void HybridAi::inputAddImageData(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& summary) {
+  this->beginCall();
+  inputAddImageData_impl(bd, summary);
+}
+void HybridAi::inputAddImageData_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& summary) {
+  rt::checkNoNul(summary, "summary");
+  if (!this->ck().InputAddImageData(rt::implOf<HybridBinData>(bd, "bd").ck(), summary.c_str())) throw this->fail("inputAddImageData");
+}
+
+void HybridAi::inputAddImageUrl(const std::string& url, const std::string& summary) {
+  this->beginCall();
+  inputAddImageUrl_impl(url, summary);
+}
+void HybridAi::inputAddImageUrl_impl(const std::string& url, const std::string& summary) {
+  rt::checkNoNul(url, "url");
+  rt::checkNoNul(summary, "summary");
+  if (!this->ck().InputAddImageUrl(url.c_str(), summary.c_str())) throw this->fail("inputAddImageUrl");
+}
+
+void HybridAi::inputAddFileData(const std::string& filename, const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& summary) {
+  this->beginCall();
+  inputAddFileData_impl(filename, bd, summary);
+}
+void HybridAi::inputAddFileData_impl(const std::string& filename, const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& summary) {
+  rt::checkNoNul(filename, "filename");
+  rt::checkNoNul(summary, "summary");
+  if (!this->ck().InputAddFileData(filename.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck(), summary.c_str())) throw this->fail("inputAddFileData");
+}
+
+void HybridAi::inputAddFileUrl(const std::string& url, const std::string& summary) {
+  this->beginCall();
+  inputAddFileUrl_impl(url, summary);
+}
+void HybridAi::inputAddFileUrl_impl(const std::string& url, const std::string& summary) {
+  rt::checkNoNul(url, "url");
+  rt::checkNoNul(summary, "summary");
+  if (!this->ck().InputAddFileUrl(url.c_str(), summary.c_str())) throw this->fail("inputAddFileUrl");
+}
+
+double HybridAi::pollAi(bool abort) {
+  this->beginCall();
+  return pollAi_impl(abort);
+}
+double HybridAi::pollAi_impl(bool abort) {
+  return static_cast<double>(this->ck().PollAi(abort));
+}
+
+void HybridAi::nextAiEvent(double maxWaitMs, const std::shared_ptr<HybridStringBuilderSpec>& sbName, const std::shared_ptr<HybridStringBuilderSpec>& sbDelta) {
+  this->beginCall();
+  nextAiEvent_impl(maxWaitMs, sbName, sbDelta);
+}
+void HybridAi::nextAiEvent_impl(double maxWaitMs, const std::shared_ptr<HybridStringBuilderSpec>& sbName, const std::shared_ptr<HybridStringBuilderSpec>& sbDelta) {
+  if (!this->ck().NextAiEvent(rt::toInt(maxWaitMs, "maxWaitMs"), rt::implOf<HybridStringBuilder>(sbName, "sbName").ck(), rt::implOf<HybridStringBuilder>(sbDelta, "sbDelta").ck())) throw this->fail("nextAiEvent");
+}
+
+void HybridAi::sleepMs(double millisec) {
+  this->beginCall();
+  sleepMs_impl(millisec);
+}
+void HybridAi::sleepMs_impl(double millisec) {
+  this->ck().SleepMs(rt::toInt(millisec, "millisec"));
+}
+
+void HybridAi::setProviderParams(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  setProviderParams_impl(json);
+}
+void HybridAi::setProviderParams_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().SetProviderParams(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("setProviderParams");
+}
+
+void HybridAi::setAskParams(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  setAskParams_impl(json);
+}
+void HybridAi::setAskParams_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().SetAskParams(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("setAskParams");
+}
+
+void HybridAi::registerManualTools(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  registerManualTools_impl(json);
+}
+void HybridAi::registerManualTools_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().RegisterManualTools(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("registerManualTools");
+}
+
+void HybridAi::getFunctionCalls(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getFunctionCalls_impl(json);
+}
+void HybridAi::getFunctionCalls_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().GetFunctionCalls(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("getFunctionCalls");
+}
+
+void HybridAi::getSearchResults(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getSearchResults_impl(json);
+}
+void HybridAi::getSearchResults_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().GetSearchResults(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("getSearchResults");
+}
+
+void HybridAi::useMcp(const std::shared_ptr<HybridMcpSpec>& cMcp, const std::string& namePrefix) {
+  this->beginCall();
+  useMcp_impl(cMcp, namePrefix);
+}
+void HybridAi::useMcp_impl(const std::shared_ptr<HybridMcpSpec>& cMcp, const std::string& namePrefix) {
+  rt::checkNoNul(namePrefix, "namePrefix");
+  if (!this->ck().UseMcp(rt::implOf<HybridMcp>(cMcp, "cMcp").ck(), namePrefix.c_str())) throw this->fail("useMcp");
+}
+std::shared_ptr<Promise<void>> HybridAi::useMcpAsync(const std::shared_ptr<HybridMcpSpec>& cMcp, const std::string& namePrefix) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridAi>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(cMcp);
+  return rt::runAsync<void>("Ai.useMcpAsync", std::move(_parts), [_self, cMcp, namePrefix]() {
+    _self->useMcp_impl(cMcp, namePrefix);
+  });
+}
+
+void HybridAi::setOutputSchema(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& schema, bool strict) {
+  this->beginCall();
+  setOutputSchema_impl(name, schema, strict);
+}
+void HybridAi::setOutputSchema_impl(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& schema, bool strict) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().SetOutputSchema(name.c_str(), rt::implOf<HybridJsonObject>(schema, "schema").ck(), strict)) throw this->fail("setOutputSchema");
+}
+
+void HybridAi::getOutputJson(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getOutputJson_impl(json);
+}
+void HybridAi::getOutputJson_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().GetOutputJson(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("getOutputJson");
+}
+
+void HybridAi::inputAddFnResult(const std::string& callId, const std::string& fnResult) {
+  this->beginCall();
+  inputAddFnResult_impl(callId, fnResult);
+}
+void HybridAi::inputAddFnResult_impl(const std::string& callId, const std::string& fnResult) {
+  rt::checkNoNul(callId, "callId");
+  rt::checkNoNul(fnResult, "fnResult");
+  if (!this->ck().InputAddFnResult(callId.c_str(), fnResult.c_str())) throw this->fail("inputAddFnResult");
+}
+
+void HybridAi::registerJsTools(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool evalOnly, bool allowAllKeyword) {
+  this->beginCall();
+  registerJsTools_impl(sb, evalOnly, allowAllKeyword);
+}
+void HybridAi::registerJsTools_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool evalOnly, bool allowAllKeyword) {
+  if (!this->ck().RegisterJsTools(rt::implOf<HybridStringBuilder>(sb, "sb").ck(), evalOnly, allowAllKeyword)) throw this->fail("registerJsTools");
+}
+
+void HybridAi::streamingJsToolCall(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  streamingJsToolCall_impl(sb);
+}
+void HybridAi::streamingJsToolCall_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().StreamingJsToolCall(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("streamingJsToolCall");
+}
+std::shared_ptr<Promise<void>> HybridAi::streamingJsToolCallAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridAi>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  return rt::runAsync<void>("Ai.streamingJsToolCallAsync", std::move(_parts), [_self, sb]() {
+    _self->streamingJsToolCall_impl(sb);
+  });
+}
+
+void HybridAi::inputAddFileId(const std::string& fileId, const std::string& mimeType) {
+  this->beginCall();
+  inputAddFileId_impl(fileId, mimeType);
+}
+void HybridAi::inputAddFileId_impl(const std::string& fileId, const std::string& mimeType) {
+  rt::checkNoNul(fileId, "fileId");
+  rt::checkNoNul(mimeType, "mimeType");
+  if (!this->ck().InputAddFileId(fileId.c_str(), mimeType.c_str())) throw this->fail("inputAddFileId");
+}
+
+void HybridAi::getOutputBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  getOutputBd_impl(bd);
+}
+void HybridAi::getOutputBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().GetOutputBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("getOutputBd");
+}
+
+std::string HybridAi::uploadFile(const std::string& path, const std::string& mimeType) {
+  this->beginCall();
+  return uploadFile_impl(path, mimeType);
+}
+std::string HybridAi::uploadFile_impl(const std::string& path, const std::string& mimeType) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(mimeType, "mimeType");
+  CkString _out;
+  if (!this->ck().UploadFile(path.c_str(), mimeType.c_str(), _out)) throw this->fail("uploadFile");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridAi::uploadFileAsync(const std::string& path, const std::string& mimeType) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridAi>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ai.uploadFileAsync", std::move(_parts), [_self, path, mimeType]() {
+    return _self->uploadFile_impl(path, mimeType);
+  });
+}
+
+std::string HybridAi::uploadFileBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& filename, const std::string& mimeType) {
+  this->beginCall();
+  return uploadFileBd_impl(bd, filename, mimeType);
+}
+std::string HybridAi::uploadFileBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& filename, const std::string& mimeType) {
+  rt::checkNoNul(filename, "filename");
+  rt::checkNoNul(mimeType, "mimeType");
+  CkString _out;
+  if (!this->ck().UploadFileBd(rt::implOf<HybridBinData>(bd, "bd").ck(), filename.c_str(), mimeType.c_str(), _out)) throw this->fail("uploadFileBd");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridAi::uploadFileBdAsync(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& filename, const std::string& mimeType) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridAi>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  return rt::runAsync<std::string>("Ai.uploadFileBdAsync", std::move(_parts), [_self, bd, filename, mimeType]() {
+    return _self->uploadFileBd_impl(bd, filename, mimeType);
+  });
+}
+
+std::string HybridAi::uploadFileSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& filename, const std::string& mimeType) {
+  this->beginCall();
+  return uploadFileSb_impl(sb, filename, mimeType);
+}
+std::string HybridAi::uploadFileSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& filename, const std::string& mimeType) {
+  rt::checkNoNul(filename, "filename");
+  rt::checkNoNul(mimeType, "mimeType");
+  CkString _out;
+  if (!this->ck().UploadFileSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck(), filename.c_str(), mimeType.c_str(), _out)) throw this->fail("uploadFileSb");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridAi::uploadFileSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& filename, const std::string& mimeType) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridAi>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  return rt::runAsync<std::string>("Ai.uploadFileSbAsync", std::move(_parts), [_self, sb, filename, mimeType]() {
+    return _self->uploadFileSb_impl(sb, filename, mimeType);
+  });
+}
+
+void HybridAi::inputAddImageFileId(const std::string& fileId, const std::string& mimeType) {
+  this->beginCall();
+  inputAddImageFileId_impl(fileId, mimeType);
+}
+void HybridAi::inputAddImageFileId_impl(const std::string& fileId, const std::string& mimeType) {
+  rt::checkNoNul(fileId, "fileId");
+  rt::checkNoNul(mimeType, "mimeType");
+  if (!this->ck().InputAddImageFileId(fileId.c_str(), mimeType.c_str())) throw this->fail("inputAddImageFileId");
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridAi::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridAi::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridAi::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridAi::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridAi::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat