@qvac/core 0.0.0 → 0.1.1

package/dist-lib/schema/vendor.d.ts

@@ -0,0 +1,5 @@
+// these builder packages ship no types — blank ambient modules, schema-authoring-time only
+declare module 'hrpc'
+declare module 'hyperdispatch'
+declare module 'hyperschema'
+declare module 'hyperdb/builder'

package/dist-lib/spec/bind.d.ts

@@ -0,0 +1,2 @@
+// Hand-written surface for the generated server binder (see schema/build.ts HAND_WRITTEN).
+export function bindApi(rpc: any, api: any): void

package/dist-lib/spec/bind.js

@@ -0,0 +1,520 @@
+// This file is autogenerated by schema/build.js
+// Do not edit manually.
+
+import { pipeline, Readable } from "streamx";
+
+function noop() {}
+
+export function bindApi(rpc, api) {
+  if (api.configGet) {
+    rpc.onConfigGet((req) => api.configGet(req));
+  }
+  if (api.configSet) {
+    rpc.onConfigSet((req) => api.configSet(req));
+  }
+  if (api.configWatch) {
+    rpc.onConfigWatch((out) => {
+      const src = Readable.from(api.configWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.createAgent) {
+    rpc.onCreateAgent((req) => api.createAgent(req));
+  }
+  if (api.listAgents) {
+    rpc.onListAgents((req) => api.listAgents(req));
+  }
+  if (api.getAgent) {
+    rpc.onGetAgent((req) => api.getAgent(req));
+  }
+  if (api.updateAgent) {
+    rpc.onUpdateAgent((req) => api.updateAgent(req));
+  }
+  if (api.deleteAgent) {
+    rpc.onDeleteAgent((req) => api.deleteAgent(req));
+  }
+  if (api.agentsWatch) {
+    rpc.onAgentsWatch((out) => {
+      const src = Readable.from(api.agentsWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.createChat) {
+    rpc.onCreateChat((req) => api.createChat(req));
+  }
+  if (api.listChats) {
+    rpc.onListChats((req) => api.listChats(req));
+  }
+  if (api.getChat) {
+    rpc.onGetChat((req) => api.getChat(req));
+  }
+  if (api.renameChat) {
+    rpc.onRenameChat((req) => api.renameChat(req));
+  }
+  if (api.setChatRagEnabled) {
+    rpc.onSetChatRagEnabled((req) => api.setChatRagEnabled(req));
+  }
+  if (api.setChatWebSearchEnabled) {
+    rpc.onSetChatWebSearchEnabled((req) => api.setChatWebSearchEnabled(req));
+  }
+  if (api.deleteChat) {
+    rpc.onDeleteChat((req) => api.deleteChat(req));
+  }
+  if (api.chatsWatch) {
+    rpc.onChatsWatch((out) => {
+      const src = Readable.from(api.chatsWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.createChatGroup) {
+    rpc.onCreateChatGroup((req) => api.createChatGroup(req));
+  }
+  if (api.listChatGroups) {
+    rpc.onListChatGroups((req) => api.listChatGroups(req));
+  }
+  if (api.renameChatGroup) {
+    rpc.onRenameChatGroup((req) => api.renameChatGroup(req));
+  }
+  if (api.deleteChatGroup) {
+    rpc.onDeleteChatGroup((req) => api.deleteChatGroup(req));
+  }
+  if (api.setChatGroup) {
+    rpc.onSetChatGroup((req) => api.setChatGroup(req));
+  }
+  if (api.listChatActivity) {
+    rpc.onListChatActivity((req) => api.listChatActivity(req));
+  }
+  if (api.chatActivityWatch) {
+    rpc.onChatActivityWatch((out) => {
+      const src = Readable.from(api.chatActivityWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.listDevices) {
+    rpc.onListDevices((req) => api.listDevices(req));
+  }
+  if (api.devicesWatch) {
+    rpc.onDevicesWatch((out) => {
+      const src = Readable.from(api.devicesWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.saveDeviceCapabilities) {
+    rpc.onSaveDeviceCapabilities((req) => api.saveDeviceCapabilities(req));
+  }
+  if (api.modelDownloadsWatch) {
+    rpc.onModelDownloadsWatch((out) => {
+      const src = Readable.from(api.modelDownloadsWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.setModelDownloadStatus) {
+    rpc.onSetModelDownloadStatus((req) => api.setModelDownloadStatus(req));
+  }
+  if (api.clearModelDownload) {
+    rpc.onClearModelDownload((req) => api.clearModelDownload(req));
+  }
+  if (api.customModelsWatch) {
+    rpc.onCustomModelsWatch((out) => {
+      const src = Readable.from(api.customModelsWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.addCustomModel) {
+    rpc.onAddCustomModel((req) => api.addCustomModel(req));
+  }
+  if (api.removeCustomModel) {
+    rpc.onRemoveCustomModel((req) => api.removeCustomModel(req));
+  }
+  if (api.removeDevice) {
+    rpc.onRemoveDevice((req) => api.removeDevice(req));
+  }
+  if (api.renameDevice) {
+    rpc.onRenameDevice((req) => api.renameDevice(req));
+  }
+  if (api.saveDeviceProfile) {
+    rpc.onSaveDeviceProfile((req) => api.saveDeviceProfile(req));
+  }
+  if (api.appendChunk) {
+    rpc.onAppendChunk((req) => api.appendChunk(req));
+  }
+  if (api.updateChunk) {
+    rpc.onUpdateChunk((req) => api.updateChunk(req));
+  }
+  if (api.resolveApproval) {
+    rpc.onResolveApproval((req) => api.resolveApproval(req));
+  }
+  if (api.listChunks) {
+    rpc.onListChunks((req) => api.listChunks(req));
+  }
+  if (api.chunksWatch) {
+    rpc.onChunksWatch((out) => {
+      const src = Readable.from(api.chunksWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.uploadAttachment) {
+    rpc.onUploadAttachment((stream) => {
+      stream.on("error", noop);
+      (async () => {
+        try {
+          for await (const frame of api.uploadAttachment(stream)) {
+            stream.write(frame);
+          }
+          stream.end();
+        } catch (err) {
+          stream.destroy(err);
+        }
+      })();
+    });
+  }
+  if (api.downloadAttachment) {
+    rpc.onDownloadAttachment((out) => {
+      const src = Readable.from(api.downloadAttachment(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.deleteAttachment) {
+    rpc.onDeleteAttachment((req) => api.deleteAttachment(req));
+  }
+  if (api.uploadKnowledge) {
+    rpc.onUploadKnowledge((stream) => {
+      stream.on("error", noop);
+      (async () => {
+        try {
+          for await (const frame of api.uploadKnowledge(stream)) {
+            stream.write(frame);
+          }
+          stream.end();
+        } catch (err) {
+          stream.destroy(err);
+        }
+      })();
+    });
+  }
+  if (api.listKnowledge) {
+    rpc.onListKnowledge((req) => api.listKnowledge(req));
+  }
+  if (api.knowledgeWatch) {
+    rpc.onKnowledgeWatch((out) => {
+      const src = Readable.from(api.knowledgeWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.removeKnowledge) {
+    rpc.onRemoveKnowledge((req) => api.removeKnowledge(req));
+  }
+  if (api.ragSearch) {
+    rpc.onRagSearch((req) => api.ragSearch(req));
+  }
+  if (api.runAgent) {
+    rpc.onRunAgent((req) => api.runAgent(req));
+  }
+  if (api.sendMessage) {
+    rpc.onSendMessage((req) => api.sendMessage(req));
+  }
+  if (api.stopRun) {
+    rpc.onStopRun((req) => api.stopRun(req));
+  }
+  if (api.meshStatusWatch) {
+    rpc.onMeshStatusWatch((out) => {
+      const src = Readable.from(api.meshStatusWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.networkWatch) {
+    rpc.onNetworkWatch((out) => {
+      const src = Readable.from(api.networkWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.deviceInfo) {
+    rpc.onDeviceInfo((req) => api.deviceInfo(req));
+  }
+  if (api.storeIdentityPhrase) {
+    rpc.onStoreIdentityPhrase((req) => api.storeIdentityPhrase(req));
+  }
+  if (api.leaveMesh) {
+    rpc.onLeaveMesh((req) => api.leaveMesh(req));
+  }
+  if (api.acknowledgeKicked) {
+    rpc.onAcknowledgeKicked((req) => api.acknowledgeKicked(req));
+  }
+  if (api.joinMesh) {
+    rpc.onJoinMesh((req) => api.joinMesh(req));
+  }
+  if (api.cancelMeshJoin) {
+    rpc.onCancelMeshJoin((req) => api.cancelMeshJoin(req));
+  }
+  if (api.suspend) {
+    rpc.onSuspend((req) => api.suspend(req));
+  }
+  if (api.resume) {
+    rpc.onResume((req) => api.resume(req));
+  }
+  if (api.meshInvite) {
+    rpc.onMeshInvite((req) => api.meshInvite(req));
+  }
+  if (api.listApprovalRules) {
+    rpc.onListApprovalRules((req) => api.listApprovalRules(req));
+  }
+  if (api.diagnostics) {
+    rpc.onDiagnostics((req) => api.diagnostics(req));
+  }
+  if (api.diagnosticsWatch) {
+    rpc.onDiagnosticsWatch((out) => {
+      const src = Readable.from(api.diagnosticsWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.runRequestsWatch) {
+    rpc.onRunRequestsWatch((out) => {
+      const src = Readable.from(api.runRequestsWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.listModels) {
+    rpc.onListModels((req) => api.listModels(req));
+  }
+  if (api.deleteModel) {
+    rpc.onDeleteModel((req) => api.deleteModel(req));
+  }
+  if (api.modelCatalogWatch) {
+    rpc.onModelCatalogWatch((out) => {
+      const src = Readable.from(api.modelCatalogWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.skills) {
+    rpc.onSkills((req) => api.skills(req));
+  }
+  if (api.downloadKnowledge) {
+    rpc.onDownloadKnowledge((out) => {
+      const src = Readable.from(api.downloadKnowledge(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.getConfig) {
+    rpc.onGetConfig((req) => api.getConfig(req));
+  }
+  if (api.setConfig) {
+    rpc.onSetConfig((req) => api.setConfig(req));
+  }
+  if (api.setModelPaused) {
+    rpc.onSetModelPaused((req) => api.setModelPaused(req));
+  }
+  if (api.retryModelDownload) {
+    rpc.onRetryModelDownload((req) => api.retryModelDownload(req));
+  }
+  if (api.configWatchTyped) {
+    rpc.onConfigWatchTyped((out) => {
+      const src = Readable.from(api.configWatchTyped(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.logsWatch) {
+    rpc.onLogsWatch((out) => {
+      const src = Readable.from(api.logsWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.writeLog) {
+    rpc.onWriteLog((req) => api.writeLog(req));
+  }
+  if (api.listIndexing) {
+    rpc.onListIndexing((req) => api.listIndexing(req));
+  }
+  if (api.transcribe) {
+    rpc.onTranscribe((req) => api.transcribe(req));
+  }
+  if (api.speak) {
+    rpc.onSpeak((req) => api.speak(req));
+  }
+  if (api.skillCatalog) {
+    rpc.onSkillCatalog((req) => api.skillCatalog(req));
+  }
+  if (api.tools) {
+    rpc.onTools((req) => api.tools(req));
+  }
+  if (api.speakStream) {
+    rpc.onSpeakStream((stream) => {
+      stream.on("error", noop);
+      (async () => {
+        try {
+          for await (const frame of api.speakStream(stream)) {
+            stream.write(frame);
+          }
+          stream.end();
+        } catch (err) {
+          stream.destroy(err);
+        }
+      })();
+    });
+  }
+  if (api.indexingProgressWatch) {
+    rpc.onIndexingProgressWatch((out) => {
+      const src = Readable.from(api.indexingProgressWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.indexingWatch) {
+    rpc.onIndexingWatch((out) => {
+      const src = Readable.from(api.indexingWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.transcodeImage) {
+    rpc.onTranscodeImage((req) => api.transcodeImage(req));
+  }
+  if (api.syncStatusWatch) {
+    rpc.onSyncStatusWatch((out) => {
+      const src = Readable.from(api.syncStatusWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.setToolConfigs) {
+    rpc.onSetToolConfigs((req) => api.setToolConfigs(req));
+  }
+  if (api.deleteToolConfigs) {
+    rpc.onDeleteToolConfigs((req) => api.deleteToolConfigs(req));
+  }
+  if (api.listToolConfigs) {
+    rpc.onListToolConfigs((req) => api.listToolConfigs(req));
+  }
+  if (api.toolConfigsWatch) {
+    rpc.onToolConfigsWatch((out) => {
+      const src = Readable.from(api.toolConfigsWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.listAttachmentsByKind) {
+    rpc.onListAttachmentsByKind((req) => api.listAttachmentsByKind(req));
+  }
+  if (api.searchChats) {
+    rpc.onSearchChats((req) => api.searchChats(req));
+  }
+  if (api.listToolActivity) {
+    rpc.onListToolActivity((req) => api.listToolActivity(req));
+  }
+  if (api.toolActivityWatch) {
+    rpc.onToolActivityWatch((out) => {
+      const src = Readable.from(api.toolActivityWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.recordToolActivity) {
+    rpc.onRecordToolActivity((req) => api.recordToolActivity(req));
+  }
+  if (api.clearKvCache) {
+    rpc.onClearKvCache((req) => api.clearKvCache(req));
+  }
+  if (api.listManagedSkills) {
+    rpc.onListManagedSkills((req) => api.listManagedSkills(req));
+  }
+  if (api.readSkillFile) {
+    rpc.onReadSkillFile((req) => api.readSkillFile(req));
+  }
+  if (api.writeSkillFile) {
+    rpc.onWriteSkillFile((req) => api.writeSkillFile(req));
+  }
+  if (api.copySkillForEdit) {
+    rpc.onCopySkillForEdit((req) => api.copySkillForEdit(req));
+  }
+  if (api.deleteOverlaySkill) {
+    rpc.onDeleteOverlaySkill((req) => api.deleteOverlaySkill(req));
+  }
+  if (api.pushSkillSecret) {
+    rpc.onPushSkillSecret((req) => api.pushSkillSecret(req));
+  }
+  if (api.fileStatusWatch) {
+    rpc.onFileStatusWatch((out) => {
+      const src = Readable.from(api.fileStatusWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.compactChat) {
+    rpc.onCompactChat((req) => api.compactChat(req));
+  }
+  if (api.notificationsWatch) {
+    rpc.onNotificationsWatch((out) => {
+      const src = Readable.from(api.notificationsWatch(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.ackNotification) {
+    rpc.onAckNotification((req) => api.ackNotification(req));
+  }
+  if (api.beginModelTransfer) {
+    rpc.onBeginModelTransfer((req) => api.beginModelTransfer(req));
+  }
+  if (api.completeModelTransfer) {
+    rpc.onCompleteModelTransfer((req) => api.completeModelTransfer(req));
+  }
+  if (api.deleteChatKvCache) {
+    rpc.onDeleteChatKvCache((req) => api.deleteChatKvCache(req));
+  }
+  if (api.fileRead) {
+    rpc.onFileRead((out) => {
+      const src = Readable.from(api.fileRead(out.data));
+      src.on("error", (err) => out.writeStream?.destroy(err));
+      pipeline(src, out, noop);
+      out.writeStream?.on("close", () => src.destroy());
+    });
+  }
+  if (api.filePreview) {
+    rpc.onFilePreview((req) => api.filePreview(req));
+  }
+  if (api.fileRetry) {
+    rpc.onFileRetry((req) => api.fileRetry(req));
+  }
+}

package/dist-lib/spec/calls.d.ts

@@ -0,0 +1,3 @@
+// Hand-written surface for the generated client factory (see schema/build.ts HAND_WRITTEN).
+// The generated .js is untyped; consumers resolved it as any in the monorepo too.
+export function engineClient(rpc: any): any

package/dist-lib/spec/calls.js

@@ -0,0 +1,129 @@
+// This file is autogenerated by schema/build.js
+// Do not edit manually.
+
+function noop() {}
+
+function armed(stream) {
+  stream.on("error", noop);
+  return stream;
+}
+
+export function engineClient(rpc) {
+  return {
+    configGet: (input) => rpc.configGet(input),
+    configSet: (input) => rpc.configSet(input),
+    configWatch: (input) => armed(rpc.configWatch(input)),
+    createAgent: (input) => rpc.createAgent(input),
+    listAgents: (input) => rpc.listAgents(input),
+    getAgent: (input) => rpc.getAgent(input),
+    updateAgent: (input) => rpc.updateAgent(input),
+    deleteAgent: (input) => rpc.deleteAgent(input),
+    agentsWatch: (input) => armed(rpc.agentsWatch(input)),
+    createChat: (input) => rpc.createChat(input),
+    listChats: (input) => rpc.listChats(input),
+    getChat: (input) => rpc.getChat(input),
+    renameChat: (input) => rpc.renameChat(input),
+    setChatRagEnabled: (input) => rpc.setChatRagEnabled(input),
+    setChatWebSearchEnabled: (input) => rpc.setChatWebSearchEnabled(input),
+    deleteChat: (input) => rpc.deleteChat(input),
+    chatsWatch: (input) => armed(rpc.chatsWatch(input)),
+    createChatGroup: (input) => rpc.createChatGroup(input),
+    listChatGroups: (input) => rpc.listChatGroups(input),
+    renameChatGroup: (input) => rpc.renameChatGroup(input),
+    deleteChatGroup: (input) => rpc.deleteChatGroup(input),
+    setChatGroup: (input) => rpc.setChatGroup(input),
+    listChatActivity: (input) => rpc.listChatActivity(input),
+    chatActivityWatch: (input) => armed(rpc.chatActivityWatch(input)),
+    listDevices: (input) => rpc.listDevices(input),
+    devicesWatch: (input) => armed(rpc.devicesWatch(input)),
+    saveDeviceCapabilities: (input) => rpc.saveDeviceCapabilities(input),
+    modelDownloadsWatch: (input) => armed(rpc.modelDownloadsWatch(input)),
+    setModelDownloadStatus: (input) => rpc.setModelDownloadStatus(input),
+    clearModelDownload: (input) => rpc.clearModelDownload(input),
+    customModelsWatch: (input) => armed(rpc.customModelsWatch(input)),
+    addCustomModel: (input) => rpc.addCustomModel(input),
+    removeCustomModel: (input) => rpc.removeCustomModel(input),
+    removeDevice: (input) => rpc.removeDevice(input),
+    renameDevice: (input) => rpc.renameDevice(input),
+    saveDeviceProfile: (input) => rpc.saveDeviceProfile(input),
+    appendChunk: (input) => rpc.appendChunk(input),
+    updateChunk: (input) => rpc.updateChunk(input),
+    resolveApproval: (input) => rpc.resolveApproval(input),
+    listChunks: (input) => rpc.listChunks(input),
+    chunksWatch: (input) => armed(rpc.chunksWatch(input)),
+    uploadAttachment: () => armed(rpc.uploadAttachment()),
+    downloadAttachment: (input) => armed(rpc.downloadAttachment(input)),
+    deleteAttachment: (input) => rpc.deleteAttachment(input),
+    uploadKnowledge: () => armed(rpc.uploadKnowledge()),
+    listKnowledge: (input) => rpc.listKnowledge(input),
+    knowledgeWatch: (input) => armed(rpc.knowledgeWatch(input)),
+    removeKnowledge: (input) => rpc.removeKnowledge(input),
+    ragSearch: (input) => rpc.ragSearch(input),
+    runAgent: (input) => rpc.runAgent(input),
+    sendMessage: (input) => rpc.sendMessage(input),
+    stopRun: (input) => rpc.stopRun(input),
+    meshStatusWatch: (input) => armed(rpc.meshStatusWatch(input)),
+    networkWatch: (input) => armed(rpc.networkWatch(input)),
+    deviceInfo: (input) => rpc.deviceInfo(input),
+    storeIdentityPhrase: (input) => rpc.storeIdentityPhrase(input),
+    leaveMesh: (input) => rpc.leaveMesh(input),
+    acknowledgeKicked: (input) => rpc.acknowledgeKicked(input),
+    joinMesh: (input) => rpc.joinMesh(input),
+    cancelMeshJoin: (input) => rpc.cancelMeshJoin(input),
+    suspend: (input) => rpc.suspend(input),
+    resume: (input) => rpc.resume(input),
+    meshInvite: (input) => rpc.meshInvite(input),
+    listApprovalRules: (input) => rpc.listApprovalRules(input),
+    diagnostics: (input) => rpc.diagnostics(input),
+    diagnosticsWatch: (input) => armed(rpc.diagnosticsWatch(input)),
+    runRequestsWatch: (input) => armed(rpc.runRequestsWatch(input)),
+    listModels: (input) => rpc.listModels(input),
+    deleteModel: (input) => rpc.deleteModel(input),
+    modelCatalogWatch: (input) => armed(rpc.modelCatalogWatch(input)),
+    skills: (input) => rpc.skills(input),
+    downloadKnowledge: (input) => armed(rpc.downloadKnowledge(input)),
+    getConfig: (input) => rpc.getConfig(input),
+    setConfig: (input) => rpc.setConfig(input),
+    setModelPaused: (input) => rpc.setModelPaused(input),
+    retryModelDownload: (input) => rpc.retryModelDownload(input),
+    configWatchTyped: (input) => armed(rpc.configWatchTyped(input)),
+    logsWatch: (input) => armed(rpc.logsWatch(input)),
+    writeLog: (input) => rpc.writeLog(input),
+    listIndexing: (input) => rpc.listIndexing(input),
+    transcribe: (input) => rpc.transcribe(input),
+    speak: (input) => rpc.speak(input),
+    skillCatalog: (input) => rpc.skillCatalog(input),
+    tools: (input) => rpc.tools(input),
+    speakStream: () => armed(rpc.speakStream()),
+    indexingProgressWatch: (input) => armed(rpc.indexingProgressWatch(input)),
+    indexingWatch: (input) => armed(rpc.indexingWatch(input)),
+    transcodeImage: (input) => rpc.transcodeImage(input),
+    syncStatusWatch: (input) => armed(rpc.syncStatusWatch(input)),
+    setToolConfigs: (input) => rpc.setToolConfigs(input),
+    deleteToolConfigs: (input) => rpc.deleteToolConfigs(input),
+    listToolConfigs: (input) => rpc.listToolConfigs(input),
+    toolConfigsWatch: (input) => armed(rpc.toolConfigsWatch(input)),
+    listAttachmentsByKind: (input) => rpc.listAttachmentsByKind(input),
+    searchChats: (input) => rpc.searchChats(input),
+    listToolActivity: (input) => rpc.listToolActivity(input),
+    toolActivityWatch: (input) => armed(rpc.toolActivityWatch(input)),
+    recordToolActivity: (input) => rpc.recordToolActivity(input),
+    clearKvCache: (input) => rpc.clearKvCache(input),
+    listManagedSkills: (input) => rpc.listManagedSkills(input),
+    readSkillFile: (input) => rpc.readSkillFile(input),
+    writeSkillFile: (input) => rpc.writeSkillFile(input),
+    copySkillForEdit: (input) => rpc.copySkillForEdit(input),
+    deleteOverlaySkill: (input) => rpc.deleteOverlaySkill(input),
+    pushSkillSecret: (input) => rpc.pushSkillSecret(input),
+    fileStatusWatch: (input) => armed(rpc.fileStatusWatch(input)),
+    compactChat: (input) => rpc.compactChat(input),
+    notificationsWatch: (input) => armed(rpc.notificationsWatch(input)),
+    ackNotification: (input) => rpc.ackNotification(input),
+    beginModelTransfer: (input) => rpc.beginModelTransfer(input),
+    completeModelTransfer: (input) => rpc.completeModelTransfer(input),
+    deleteChatKvCache: (input) => rpc.deleteChatKvCache(input),
+    fileRead: (input) => armed(rpc.fileRead(input)),
+    filePreview: (input) => rpc.filePreview(input),
+    fileRetry: (input) => rpc.fileRetry(input),
+  };
+}