@yrpri/api 9.0.109 → 9.0.111

package/active-citizen/workers/delayed_jobs.d.cts

@@ -0,0 +1,16 @@
+declare const _exports: DelayedJobWorker;
+export = _exports;
+/**
+ * @class DelayedJobWorker
+ * @constructor
+ */
+declare function DelayedJobWorker(): void;
+declare class DelayedJobWorker {
+    /**
+     * Processes a delayed job.
+     * @param {object} workPackage - The work package for the delayed job.
+     * @param {(error?: any) => void} callback - The callback function.
+     * @memberof DelayedJobWorker
+     */
+    process(workPackage: object, callback: (error?: any) => void): void;
+}

package/active-citizen/workers/deletions.cjs

@@ -11,7 +11,11 @@ let airbrake = null;
 if (process.env.AIRBRAKE_PROJECT_ID) {
     airbrake = require('../utils/airbrake.cjs');
 }
-let DeletionWorker = function () { };
+/**
+ * @class DeletionWorker
+ * @constructor
+ */
+function DeletionWorker() { }
 const getGroupAndUser = (groupId, userId, userEmail, callback) => {
     var user, group;
     async.series([
@@ -401,7 +405,7 @@ const recountCommunity = (workPackage, callback) => {
                             log.info("Community recounted", { context: 'ac-delete', communityId: workPackage.communityId });
                             innerCallback();
                         }).catch((error) => {
-                            innerCallback(error);
+                            innerCallback();
                         });
                     }).catch((error) => {
                         innerCallback();
@@ -1825,7 +1829,13 @@ const removeManyDomainUsersAndDeleteContent = (workPackage, callback) => {
         callback("No userIds for removeManyDomainUsersAndDeleteContent");
     }
 };
-DeletionWorker.prototype.process = (workPackage, callback) => {
+/**
+ * Processes a deletion work package.
+ * @param {object} workPackage - The work package containing details for the deletion.
+ * @param {(error?: any) => void} callback - The callback function.
+ * @memberof DeletionWorker
+ */
+DeletionWorker.prototype.process = function (workPackage, callback) {
     getAnonymousUser((error, anonymousUser) => {
         if (error) {
             callback(error);
@@ -1908,4 +1918,5 @@ DeletionWorker.prototype.process = (workPackage, callback) => {
         }
     });
 };
+/** @type {DeletionWorker} */
 module.exports = new DeletionWorker();

package/active-citizen/workers/deletions.d.cts

@@ -0,0 +1,16 @@
+declare const _exports: DeletionWorker;
+export = _exports;
+/**
+ * @class DeletionWorker
+ * @constructor
+ */
+declare function DeletionWorker(): void;
+declare class DeletionWorker {
+    /**
+     * Processes a deletion work package.
+     * @param {object} workPackage - The work package containing details for the deletion.
+     * @param {(error?: any) => void} callback - The callback function.
+     * @memberof DeletionWorker
+     */
+    process(workPackage: object, callback: (error?: any) => void): void;
+}

package/active-citizen/workers/email.cjs

@@ -1,9 +1,20 @@
 "use strict";
 // https://gist.github.com/mojodna/1251812
 var log = require('../utils/logger.cjs');
-var EmailWorker = function () { };
+/**
+ * @class EmailWorker
+ * @constructor
+ */
+function EmailWorker() { }
+/**
+ * Sends a single email.
+ * @param {object} emailLocals - Locals for the email template.
+ * @param {(error?: any) => void} callback - The callback function.
+ * @memberof EmailWorker
+ */
 EmailWorker.prototype.sendOne = function (emailLocals, callback) {
     var sendOneEmail = require('../engine/notifications/emails_utils.cjs').sendOneEmail;
     sendOneEmail(emailLocals, callback);
 };
+/** @type {EmailWorker} */
 module.exports = new EmailWorker();

package/active-citizen/workers/email.d.cts

@@ -0,0 +1,16 @@
+declare const _exports: EmailWorker;
+export = _exports;
+/**
+ * @class EmailWorker
+ * @constructor
+ */
+declare function EmailWorker(): void;
+declare class EmailWorker {
+    /**
+     * Sends a single email.
+     * @param {object} emailLocals - Locals for the email template.
+     * @param {(error?: any) => void} callback - The callback function.
+     * @memberof EmailWorker
+     */
+    sendOne(emailLocals: object, callback: (error?: any) => void): void;
+}

package/active-citizen/workers/fraud_management.cjs

@@ -20,7 +20,11 @@ let airbrake = null;
 if (process.env.AIRBRAKE_PROJECT_ID) {
     airbrake = require('../utils/airbrake.cjs');
 }
-let FraudManagementWorker = function () { };
+/**
+ * @class FraudManagementWorker
+ * @constructor
+ */
+function FraudManagementWorker() { }
 const ProcessFraudGet = async (workPackage, done) => {
     let fraudGetEngine;
     try {
@@ -89,7 +93,13 @@ const ProcessFraudDelete = async (workPackage, done) => {
         done(error);
     }
 };
-FraudManagementWorker.prototype.process = async (workPackage, callback) => {
+/**
+ * Processes a fraud management work package.
+ * @param {object} workPackage - The work package for fraud management.
+ * @param {(error?: any) => void} callback - The callback function.
+ * @memberof FraudManagementWorker
+ */
+FraudManagementWorker.prototype.process = async function (workPackage, callback) {
     switch (workPackage.type) {
         case 'delete-one-item':
         case 'delete-items':
@@ -106,4 +116,5 @@ FraudManagementWorker.prototype.process = async (workPackage, callback) => {
             callback("Unknown type for workPackage: " + workPackage.type);
     }
 };
+/** @type {FraudManagementWorker} */
 module.exports = new FraudManagementWorker();

package/active-citizen/workers/fraud_management.d.cts

@@ -0,0 +1,16 @@
+declare const _exports: FraudManagementWorker;
+export = _exports;
+/**
+ * @class FraudManagementWorker
+ * @constructor
+ */
+declare function FraudManagementWorker(): void;
+declare class FraudManagementWorker {
+    /**
+     * Processes a fraud management work package.
+     * @param {object} workPackage - The work package for fraud management.
+     * @param {(error?: any) => void} callback - The callback function.
+     * @memberof FraudManagementWorker
+     */
+    process(workPackage: object, callback: (error?: any) => void): Promise<void>;
+}

package/active-citizen/workers/generativeAi.d.ts

@@ -0,0 +1,3 @@
+export declare class GenerativeAiWorker {
+    process(workPackage: YpGenerativeAiWorkPackageData, callback: any): Promise<void>;
+}

package/active-citizen/workers/main.d.cts

@@ -0,0 +1 @@
+export {};

package/active-citizen/workers/marketing.cjs

@@ -12,8 +12,18 @@ let airbrake = null;
 if (process.env.AIRBRAKE_PROJECT_ID) {
     airbrake = require('../utils/airbrake.cjs');
 }
-let MarketingWorker = function () { };
-MarketingWorker.prototype.process = (workPackage, callback) => {
+/**
+ * @class MarketingWorker
+ * @constructor
+ */
+function MarketingWorker() { }
+/**
+ * Processes a marketing work package.
+ * @param {object} workPackage - The work package for marketing.
+ * @param {(error?: any) => void} callback - The callback function.
+ * @memberof MarketingWorker
+ */
+MarketingWorker.prototype.process = function (workPackage, callback) {
     switch (workPackage.type) {
         case 'send-campaign':
             sendCampaign(workPackage, callback);
@@ -22,4 +32,5 @@ MarketingWorker.prototype.process = (workPackage, callback) => {
             callback("Unknown type for workPackage: " + workPackage.type);
     }
 };
+/** @type {MarketingWorker} */
 module.exports = new MarketingWorker();

package/active-citizen/workers/marketing.d.cts

@@ -0,0 +1,16 @@
+declare const _exports: MarketingWorker;
+export = _exports;
+/**
+ * @class MarketingWorker
+ * @constructor
+ */
+declare function MarketingWorker(): void;
+declare class MarketingWorker {
+    /**
+     * Processes a marketing work package.
+     * @param {object} workPackage - The work package for marketing.
+     * @param {(error?: any) => void} callback - The callback function.
+     * @memberof MarketingWorker
+     */
+    process(workPackage: object, callback: (error?: any) => void): void;
+}

package/active-citizen/workers/moderation.cjs

@@ -19,8 +19,18 @@ let airbrake = null;
 if (process.env.AIRBRAKE_PROJECT_ID) {
     airbrake = require('../utils/airbrake.cjs');
 }
-let ModerationWorker = function () { };
-ModerationWorker.prototype.process = async (workPackage, callback) => {
+/**
+ * @class ModerationWorker
+ * @constructor
+ */
+function ModerationWorker() { }
+/**
+ * Processes a moderation work package.
+ * @param {object} workPackage - The work package for moderation.
+ * @param {(error?: any) => void} callback - The callback function.
+ * @memberof ModerationWorker
+ */
+ModerationWorker.prototype.process = async function (workPackage, callback) {
     switch (workPackage.type) {
         case 'estimate-post-toxicity':
             estimateToxicityScoreForPost(workPackage, callback);
@@ -70,4 +80,5 @@ ModerationWorker.prototype.process = async (workPackage, callback) => {
             callback("Unknown type for workPackage: " + workPackage.type);
     }
 };
+/** @type {ModerationWorker} */
 module.exports = new ModerationWorker();

package/active-citizen/workers/moderation.d.cts

@@ -0,0 +1,16 @@
+declare const _exports: ModerationWorker;
+export = _exports;
+/**
+ * @class ModerationWorker
+ * @constructor
+ */
+declare function ModerationWorker(): void;
+declare class ModerationWorker {
+    /**
+     * Processes a moderation work package.
+     * @param {object} workPackage - The work package for moderation.
+     * @param {(error?: any) => void} callback - The callback function.
+     * @memberof ModerationWorker
+     */
+    process(workPackage: object, callback: (error?: any) => void): Promise<void>;
+}

package/active-citizen/workers/notification_delivery.cjs

@@ -13,7 +13,17 @@ var airbrake = null;
 if (process.env.AIRBRAKE_PROJECT_ID) {
     airbrake = require('../utils/airbrake.cjs');
 }
-var NotificationDeliveryWorker = function () { };
+/**
+ * @class NotificationDeliveryWorker
+ * @constructor
+ */
+function NotificationDeliveryWorker() { }
+/**
+ * Processes a notification for delivery.
+ * @param {object} notificationJson - The notification JSON object.
+ * @param {(error?: any) => void} callback - The callback function.
+ * @memberof NotificationDeliveryWorker
+ */
 NotificationDeliveryWorker.prototype.process = function (notificationJson, callback) {
     var user;
     var notification;
@@ -365,4 +375,5 @@ NotificationDeliveryWorker.prototype.process = function (notificationJson, callb
         }
     });
 };
+/** @type {NotificationDeliveryWorker} */
 module.exports = new NotificationDeliveryWorker();

package/active-citizen/workers/notification_delivery.d.cts

@@ -0,0 +1,16 @@
+declare const _exports: NotificationDeliveryWorker;
+export = _exports;
+/**
+ * @class NotificationDeliveryWorker
+ * @constructor
+ */
+declare function NotificationDeliveryWorker(): void;
+declare class NotificationDeliveryWorker {
+    /**
+     * Processes a notification for delivery.
+     * @param {object} notificationJson - The notification JSON object.
+     * @param {(error?: any) => void} callback - The callback function.
+     * @memberof NotificationDeliveryWorker
+     */
+    process(notificationJson: object, callback: (error?: any) => void): void;
+}

package/active-citizen/workers/notification_news_feed.cjs

@@ -11,7 +11,17 @@ if (process.env.AIRBRAKE_PROJECT_ID) {
     airbrake = require('../utils/airbrake.cjs');
 }
 var GenerateNewsFeedFromNotifications = require('../engine/news_feeds/generate_from_notifications.cjs');
-var NotificationNewsFeedWorker = function () { };
+/**
+ * @class NotificationNewsFeedWorker
+ * @constructor
+ */
+function NotificationNewsFeedWorker() { }
+/**
+ * Processes a notification to generate a news feed item.
+ * @param {object} notificationJson - The notification JSON object.
+ * @param {(error?: any) => void} callback - The callback function.
+ * @memberof NotificationNewsFeedWorker
+ */
 NotificationNewsFeedWorker.prototype.process = function (notificationJson, callback) {
     var user;
     var notification;
@@ -139,4 +149,5 @@ NotificationNewsFeedWorker.prototype.process = function (notificationJson, callb
         }
     });
 };
+/** @type {NotificationNewsFeedWorker} */
 module.exports = new NotificationNewsFeedWorker();

package/active-citizen/workers/notification_news_feed.d.cts

@@ -0,0 +1,16 @@
+declare const _exports: NotificationNewsFeedWorker;
+export = _exports;
+/**
+ * @class NotificationNewsFeedWorker
+ * @constructor
+ */
+declare function NotificationNewsFeedWorker(): void;
+declare class NotificationNewsFeedWorker {
+    /**
+     * Processes a notification to generate a news feed item.
+     * @param {object} notificationJson - The notification JSON object.
+     * @param {(error?: any) => void} callback - The callback function.
+     * @memberof NotificationNewsFeedWorker
+     */
+    process(notificationJson: object, callback: (error?: any) => void): void;
+}

package/active-citizen/workers/queue.d.cts

@@ -0,0 +1,21 @@
+declare const _exports: YpQueue;
+export = _exports;
+declare class YpQueue {
+    get defaultQueueOptions(): {
+        redis: {
+            tls: {
+                rejectUnauthorized: boolean;
+            };
+        } | undefined;
+        defaultJobOptions: {
+            attempts: number;
+            removeOnComplete: boolean;
+            removeOnFail: boolean;
+        };
+    };
+    process(name: any, concurrency: any, processor: any): void;
+    add(name: any, workPackage: any, priority: any, options: any): void;
+    createQueues(): void;
+    mainQueue: BullQueue.Queue<any> | undefined;
+}
+import BullQueue = require("bull");

package/active-citizen/workers/recount.d.cts

@@ -0,0 +1 @@
+export function recountGroupFolder(workPackage: any, callback: any): Promise<void>;

package/active-citizen/workers/reports.d.cts

@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;

package/active-citizen/workers/similarities.cjs

@@ -8,8 +8,18 @@ const toJson = require('../utils/to_json.cjs');
 const _ = require('lodash');
 const fs = require('fs');
 const updateSimilaritiesCollection = require('../engine/analytics/manager.cjs').updateCollection;
-let SimilaritiesWorker = function () { };
-SimilaritiesWorker.prototype.process = (workPackage, callback) => {
+/**
+ * @class SimilaritiesWorker
+ * @constructor
+ */
+function SimilaritiesWorker() { }
+/**
+ * Processes a similarities work package.
+ * @param {object} workPackage - The work package for similarities.
+ * @param {(error?: any) => void} callback - The callback function.
+ * @memberof SimilaritiesWorker
+ */
+SimilaritiesWorker.prototype.process = function (workPackage, callback) {
     switch (workPackage.type) {
         case 'update-collection':
             updateSimilaritiesCollection(workPackage, callback);
@@ -18,4 +28,5 @@ SimilaritiesWorker.prototype.process = (workPackage, callback) => {
             callback("Unknown type for workPackage: " + workPackage.type);
     }
 };
+/** @type {SimilaritiesWorker} */
 module.exports = new SimilaritiesWorker();

package/active-citizen/workers/similarities.d.cts

@@ -0,0 +1,16 @@
+declare const _exports: SimilaritiesWorker;
+export = _exports;
+/**
+ * @class SimilaritiesWorker
+ * @constructor
+ */
+declare function SimilaritiesWorker(): void;
+declare class SimilaritiesWorker {
+    /**
+     * Processes a similarities work package.
+     * @param {object} workPackage - The work package for similarities.
+     * @param {(error?: any) => void} callback - The callback function.
+     * @memberof SimilaritiesWorker
+     */
+    process(workPackage: object, callback: (error?: any) => void): void;
+}

package/active-citizen/workers/speech_to_text.cjs

@@ -24,7 +24,11 @@ let airbrake = null;
 if (process.env.AIRBRAKE_PROJECT_ID) {
     airbrake = require('../utils/airbrake.cjs');
 }
-let VoiceToTextWorker = function () { };
+/**
+ * @class VoiceToTextWorker
+ * @constructor
+ */
+function VoiceToTextWorker() { }
 const supportedGoogleLanguges = [
     ['af-ZA', true, false],
     ['am-ET', true, false],
@@ -467,7 +471,13 @@ const createTranscriptForAudio = (workPackage, callback) => {
         callback(error);
     });
 };
-VoiceToTextWorker.prototype.process = (workPackage, callback) => {
+/**
+ * Processes a speech-to-text work package.
+ * @param {object} workPackage - The work package for speech-to-text.
+ * @param {(error?: any) => void} callback - The callback function.
+ * @memberof VoiceToTextWorker
+ */
+VoiceToTextWorker.prototype.process = function (workPackage, callback) {
     switch (workPackage.type) {
         case 'create-video-transcript':
             createTranscriptForVideo(workPackage, callback);
@@ -479,4 +489,5 @@ VoiceToTextWorker.prototype.process = (workPackage, callback) => {
             callback("Unknown type for workPackage: " + workPackage.type);
     }
 };
+/** @type {VoiceToTextWorker} */
 module.exports = new VoiceToTextWorker();

package/active-citizen/workers/speech_to_text.d.cts

@@ -0,0 +1,16 @@
+declare const _exports: VoiceToTextWorker;
+export = _exports;
+/**
+ * @class VoiceToTextWorker
+ * @constructor
+ */
+declare function VoiceToTextWorker(): void;
+declare class VoiceToTextWorker {
+    /**
+     * Processes a speech-to-text work package.
+     * @param {object} workPackage - The work package for speech-to-text.
+     * @param {(error?: any) => void} callback - The callback function.
+     * @memberof VoiceToTextWorker
+     */
+    process(workPackage: object, callback: (error?: any) => void): void;
+}

package/agents/assistants/agentAssistant.d.ts

@@ -0,0 +1,27 @@
+import { YpBaseAssistantWithVoice } from "./baseAssistantWithVoice.js";
+import { PsAgent } from "@policysynth/agents/dbModels/agent.js";
+import WebSocket from "ws";
+import ioredis from "ioredis";
+import { SubscriptionManager } from "../managers/subscriptionManager.js";
+export declare class YpAgentAssistant extends YpBaseAssistantWithVoice {
+    availableAgents: PsAgent[];
+    runningAgents: PsAgent[];
+    private agentSelectionMode;
+    private directConversationMode;
+    subscriptionManager: SubscriptionManager;
+    constructor(wsClientId: string, wsClients: Map<string, WebSocket>, redis: ioredis.Redis, voiceEnabled: boolean, redisKey: string, domainId: number);
+    defineAvailableModes(): Promise<AssistantChatbotMode[]>;
+    get simplifiedMemory(): Partial<YpBaseAssistantMemoryData>;
+    handleMemoryChanged(memory: YpBaseAssistantMemoryData): void;
+    get isLoggedIn(): boolean;
+    get isSubscribedToCurrentAgentProduct(): boolean;
+    get hasConfiguredcurrentAgentProduct(): boolean;
+    isCurrentAgentRunning(): Promise<boolean>;
+    isCurrentAgentActive(): Promise<boolean>;
+    get haveShownConfigurationWidget(): boolean;
+    get haveShownLoginWidget(): boolean;
+    getCurrentAgentWorkflow(): Promise<YpAgentRunWorkflowConfiguration | undefined>;
+    getCurrentAgentWorkflowCurrentStep(): Promise<YpAgentRunWorkflowStep | undefined>;
+    isCurrentAgentWaitingOnUserInput(): Promise<boolean>;
+    triggerResponseIfNeeded(message: string): void;
+}

package/agents/assistants/baseAssistant.d.ts

@@ -0,0 +1,115 @@
+import { OpenAI } from "openai";
+import WebSocket from "ws";
+import ioredis from "ioredis";
+import { type ChatCompletionMessageParam } from "openai/resources/chat/completions";
+import { YpBaseChatBot } from "../../active-citizen/llms/baseChatBot.js";
+import { YpAgentProduct } from "../models/agentProduct.js";
+/**
+ * Common modes that implementations might use
+ */
+export declare enum CommonModes {
+    ErrorRecovery = "error_recovery"
+}
+export declare abstract class YpBaseAssistant extends YpBaseChatBot {
+    protected voiceEnabled: boolean;
+    openaiClient: OpenAI;
+    memory: YpBaseAssistantMemoryData;
+    private eventEmitter;
+    persistMemory: boolean;
+    domainId: number;
+    DEBUG: boolean;
+    protected modes: Map<YpAssistantMode, AssistantChatbotMode>;
+    protected availableTools: Map<string, AssistantChatbotTool>;
+    protected toolCallTimeout: number;
+    protected maxModeTransitions: number;
+    private clientSystemMessageListener;
+    redis: ioredis.Redis;
+    modelName: string;
+    constructor(wsClientId: string, wsClients: Map<string, WebSocket>, redis: ioredis.Redis, redisKey: string, domainId: number);
+    destroy(): void;
+    removeClientSystemMessageListener(): void;
+    handleClientSystemMessage(data: Buffer): void;
+    setupClientSystemMessageListener(): void;
+    getCurrentAgentProduct(): Promise<YpAgentProductAttributes | undefined>;
+    getCurrentSubscriptionPlan(): Promise<YpSubscriptionPlanAttributes | undefined>;
+    getCurrentSubscription(): Promise<YpSubscriptionAttributes | undefined>;
+    getCurrentAgentRun(): Promise<YpAgentProductRunAttributes | undefined>;
+    updateAiModelSession(message: string): Promise<void>;
+    maybeSendTextResponse(message: string): Promise<void>;
+    processClientSystemMessage(clientEvent: YpAssistantClientSystemMessage): Promise<void>;
+    emit(event: string, ...args: any[]): boolean;
+    on(event: string, listener: (...args: any[]) => void): void;
+    updateCurrentAgentProductPlan(subscriptionPlanId: number, subscriptionId: number | null): Promise<void>;
+    /**
+     * Convert tool result to message format
+     */
+    protected convertToolResultToMessage(toolCall: ToolCall, result: ToolExecutionResult): ToolResponseMessage;
+    /**
+     * Handle executing tool calls with results
+     */
+    handleToolCalls(toolCalls: Map<string, ToolCall>): Promise<void>;
+    /**
+     * Handle tool responses by creating a new completion
+     */
+    handleToolResponses(toolResponses: ToolResponseMessage[]): Promise<void>;
+    /**
+     * Abstract method that subclasses must implement to define their modes
+     */
+    abstract defineAvailableModes(): Promise<AssistantChatbotMode[]>;
+    setupMemoryAsync(): Promise<void>;
+    loadMemoryAsync(): Promise<void>;
+    getCleanedParams<T extends object>(params: string | T): T;
+    setCurrentMode(mode: YpAssistantMode): Promise<void>;
+    /**
+     * Initialize modes from subclass definitions
+     */
+    initializeModes(): Promise<void>;
+    /**
+     * Get current mode's functions
+     */
+    getCurrentModeFunctions(): AssistantChatbotTool[];
+    get isLoggedIn(): boolean;
+    renderLoginStatus(): string;
+    defaultSystemPrompt: string;
+    /**
+     * Get current mode's system prompt
+     */
+    getCurrentSystemPrompt(): string;
+    sendAvatarUrlChange(url: string | null, avatarName: string | null): void;
+    /**
+     * Validate mode transition
+     */
+    protected validateModeTransition(fromMode: YpAssistantMode, toMode: YpAssistantMode): boolean;
+    /**
+     * Clean up mode-specific resources
+     */
+    protected cleanupMode(mode: YpAssistantMode): Promise<void>;
+    /**
+     * Set mode data with type safety
+     */
+    setModeData<T>(type: string, data: T): Promise<void>;
+    /**
+     * Get mode data with type safety
+     */
+    protected getModeData<T>(): T | undefined;
+    /**
+     * Main conversation handler with updated function handling
+     */
+    conversation(chatLog: YpSimpleChatLog[]): Promise<void>;
+    getAgentProduct(agentProductId: number): Promise<YpAgentProduct | null>;
+    /**
+     * Convert chat log to OpenAI message format
+     */
+    protected convertToOpenAIMessages(chatLog: YpSimpleChatLog[]): ChatCompletionMessageParam[];
+    /**
+     * Handle mode switching
+     */
+    handleModeSwitch(newMode: YpAssistantMode, reason: string, params: any): Promise<void>;
+    addUserMessage(message: string): Promise<void>;
+    addAssistantMessage(message: string): Promise<void>;
+    addAssistantHtmlMessage(html: string, uniqueToken?: string): Promise<void>;
+    /**
+     * Handle streaming responses and function calls with comprehensive debugging
+     */
+    streamWebSocketResponses(stream: AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>): Promise<void>;
+}

package/agents/assistants/baseAssistantWithVoice.d.ts

@@ -0,0 +1,18 @@
+import { WebSocket } from "ws";
+import { YpBaseAssistant } from "./baseAssistant.js";
+import { YpBaseChatBotWithVoice } from "./voiceAssistant.js";
+import ioredis from "ioredis";
+export declare abstract class YpBaseAssistantWithVoice extends YpBaseAssistant {
+    protected voiceBot: YpBaseChatBotWithVoice | undefined;
+    private mainBotWsHandler?;
+    private forwardEventHandler?;
+    constructor(wsClientId: string, wsClients: Map<string, WebSocket>, redis: ioredis.Redis, voiceEnabled: boolean, redisKey: string, domainId: number);
+    destroy(): void;
+    initialize(): Promise<void>;
+    createVoiceBot(): Promise<void>;
+    destroyVoiceBot(): void;
+    private setupVoiceEventForwarder;
+    setVoiceMode(enabled: boolean): Promise<void>;
+    handleModeSwitch(newMode: YpAssistantMode, reason: string, params: any): Promise<void>;
+    conversation(chatLog: YpSimpleChatLog[]): Promise<void>;
+}

package/agents/assistants/modes/agentDirectConnection.d.ts

@@ -0,0 +1,16 @@
+import { BaseAssistantMode } from "./baseAssistantMode.js";
+import { YpAgentAssistant } from "../agentAssistant.js";
+import { SubscriptionTools } from "./tools/subscriptionTools.js";
+import { NavigationTools } from "./tools/navigationTools.js";
+import { LoginAssistantTools } from "./tools/loginTools.js";
+import { AgentTools } from "./tools/agentTools.js";
+export declare class DirectConversationMode extends BaseAssistantMode {
+    constructor(assistant: YpAgentAssistant);
+    subscriptionTools: SubscriptionTools;
+    navigationTools: NavigationTools;
+    loginTools: LoginAssistantTools;
+    agentTools: AgentTools;
+    protected getCurrentModeSystemPrompt(): Promise<string>;
+    protected getCurrentModeTools(): Promise<AssistantChatbotTool[]>;
+    getMode(): Promise<AssistantChatbotMode>;
+}