@yrpri/api 9.0.109 → 9.0.111

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

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

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

@@ -0,0 +1,10 @@
+import { YpAgentAssistant } from "../agentAssistant.js";
+export declare class BaseAssistantMode {
+    protected assistant: YpAgentAssistant;
+    constructor(assistant: YpAgentAssistant);
+    protected get memory(): YpBaseAssistantMemoryData;
+    renderSimplifiedWorkflowStep(step: YpAgentRunWorkflowStep | undefined): string;
+    renderSimplifiedWorkflow(workflow: YpAgentRunWorkflowConfiguration): string;
+    renderSimplifiedAgentRun(agentRun: YpAgentProductRunAttributes | undefined): string;
+    renderCommon(): Promise<"" | undefined>;
+}

package/agents/assistants/modes/tools/agentTools.d.ts

@@ -0,0 +1,100 @@
+import { YpAgentAssistant } from "../../agentAssistant.js";
+import { BaseAssistantTools } from "./baseTools.js";
+import { AgentModels } from "./models/agents.js";
+export declare class AgentTools extends BaseAssistantTools {
+    agentModels: AgentModels;
+    constructor(assistant: YpAgentAssistant);
+    get showAgentWorkflowOverviewWidget(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentEmptyProperties;
+        };
+        handler: (params: YpAgentEmptyProperties) => Promise<ToolExecutionResult>;
+    };
+    showAgentWorkflowOverviewWidgetHandler(params: YpAgentEmptyProperties): Promise<ToolExecutionResult>;
+    get showAgentRunWidget(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentEmptyProperties;
+        };
+        handler: (params: YpAgentEmptyProperties) => Promise<ToolExecutionResult>;
+    };
+    showAgentRunWidgetHandler(params: YpAgentEmptyProperties): Promise<ToolExecutionResult>;
+    get createNewAgentRunReadyToRunFirstWorkflowStep(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentRunStartProperties;
+            required: readonly ["hasVerballyConfirmedTheRun"];
+        };
+        handler: (params: YpAgentRunStartParams) => Promise<ToolExecutionResult>;
+    };
+    createNewAgentRunReadyToRunFirstWorkflowStepHandler(params: YpAgentRunStartParams): Promise<ToolExecutionResult>;
+    startCurrentRunAgentNextWorkflowStep(): Promise<{
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentRunStartNextWorkflowStepProperties;
+            required: readonly ["userHasVerballyConfirmedStartOfNextWorkflowStepWithTheAgentName"];
+        };
+        handler: (params: YpAgentRunStartNextWorkflowStepParams) => Promise<ToolExecutionResult>;
+    }>;
+    startCurrentRunAgentNextWorkflowStepHandler(params: YpAgentRunStartNextWorkflowStepParams): Promise<ToolExecutionResult>;
+    get stopCurrentAgentWorkflow(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentRunStopCurrentWorkflowStepProperties;
+            required: readonly ["userHasVerballyConfirmedStopCurrentWorkflowStepWithTheAgentName"];
+        };
+        handler: (params: YpAgentRunStopCurrentWorkflowStepParams) => Promise<ToolExecutionResult>;
+    };
+    stopCurrentAgentWorkflowHandler(params: YpAgentRunStopCurrentWorkflowStepParams): Promise<ToolExecutionResult>;
+    get deactivateAgent(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentEmptyProperties;
+        };
+        handler: (params: YpAgentEmptyProperties) => Promise<ToolExecutionResult>;
+    };
+    deactivateAgentHandler(params: YpAgentEmptyProperties): Promise<ToolExecutionResult>;
+    get showConfigurationWidget(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentEmptyProperties;
+        };
+        handler: (params: YpAgentEmptyProperties) => Promise<ToolExecutionResult>;
+    };
+    showConfigurationWidgetHandler(params: YpAgentEmptyProperties): Promise<ToolExecutionResult>;
+    get submitConfiguration(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentEmptyProperties;
+        };
+        handler: (params: YpAgentEmptyProperties) => Promise<ToolExecutionResult>;
+    };
+    submitConfigurationHandler(params: YpAgentEmptyProperties): Promise<ToolExecutionResult>;
+    getSimpleWorkflow(workflow: YpAgentRunWorkflowConfiguration): YpAgentRunWorkflowConfiguration;
+    private renderAgentRunWidget;
+}

package/agents/assistants/modes/tools/baseTools.d.ts

@@ -0,0 +1,21 @@
+import { YpAgentAssistant } from "agents/assistants/agentAssistant.js";
+export declare class BaseAssistantTools {
+    protected assistant: YpAgentAssistant;
+    constructor(assistant: YpAgentAssistant);
+    waitTick(): Promise<void>;
+    updateCurrentAgentProductPlan(plan: YpSubscriptionPlanAttributes, subscription: YpSubscriptionAttributes | null, options?: {
+        sendEvent: boolean;
+    }): Promise<void>;
+    updateAgentProductRun(agentRun: YpAgentProductRunAttributes, options?: {
+        sendEvent: boolean;
+    }): Promise<void>;
+    updateShownConfigurationWidget(options?: {
+        sendEvent: boolean;
+    }): Promise<void>;
+    updateHaveShownLoginWidget(options?: {
+        sendEvent: boolean;
+    }): Promise<void>;
+    clearCurrentAgentProduct(options?: {
+        sendEvent: boolean;
+    }): Promise<void>;
+}

package/agents/assistants/modes/tools/loginTools.d.ts

@@ -0,0 +1,51 @@
+import { YpAgentAssistant } from "../../agentAssistant.js";
+import { BaseAssistantTools } from "./baseTools.js";
+export declare class LoginAssistantTools extends BaseAssistantTools {
+    constructor(assistant: YpAgentAssistant);
+    showLogin(description: string): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentEmptyProperties;
+            required: readonly [];
+        };
+        handler: (params: {}) => Promise<ToolExecutionResult>;
+    };
+    showLoginHandler(params: {}): Promise<ToolExecutionResult>;
+    get clickMainLoginButton(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentEmptyProperties;
+        };
+        handler: (params: {}) => Promise<ToolExecutionResult>;
+    };
+    clickMainLoginButtonHandler(params: {}): Promise<ToolExecutionResult>;
+    get clickGoogleLoginButton(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentEmptyProperties;
+        };
+        handler: (params: {}) => Promise<ToolExecutionResult>;
+    };
+    clickGoogleLoginButtonHandler(params: {}): Promise<ToolExecutionResult>;
+    get logout(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAssistantLogoutProperties;
+            required: readonly ["confirmLogout"];
+        };
+        handler: (params: YpAssistantLogoutParams) => Promise<ToolExecutionResult>;
+    };
+    logoutHandler(params: YpAssistantLogoutParams): Promise<ToolExecutionResult>;
+}

package/agents/assistants/modes/tools/models/agents.d.ts

@@ -0,0 +1,27 @@
+import { SubscriptionModels } from "./subscriptions.js";
+import { YpAgentAssistant } from "../../../../assistants/agentAssistant.js";
+export declare class AgentModels {
+    subscriptionModels: SubscriptionModels;
+    assistant: YpAgentAssistant;
+    private queueManager;
+    constructor(assistant: YpAgentAssistant);
+    getCurrentAgentAndWorkflow(): Promise<{
+        agent: YpAgentProductAttributes;
+        run: YpAgentProductRunAttributes | undefined;
+    }>;
+    convertToUnderscoresWithMaxLength(str: string): string;
+    startCurrentWorkflowStep(agentRunId: number, structuredAnswersOverrides?: YpStructuredAnswer[]): Promise<{
+        agentRun: YpAgentProductRunAttributes;
+        previousStep: YpAgentRunWorkflowStep;
+        currentStep: YpAgentRunWorkflowStep;
+        message: string;
+    }>;
+    getCurrentWorkflowStep(): Promise<YpAgentRunWorkflowStep>;
+    getNextWorkflowStep(): Promise<YpAgentRunWorkflowStep | undefined>;
+    stopCurrentWorkflowStep(): Promise<{
+        agent: YpAgentProductAttributes;
+        run: YpAgentProductRunAttributes;
+        message: string;
+    }>;
+    checkAgentStatus(): Promise<PsAgentStatus | null>;
+}

package/agents/assistants/modes/tools/models/subscriptions.d.ts

@@ -0,0 +1,13 @@
+import { YpAgentAssistant } from "../../../../assistants/agentAssistant.js";
+export declare class SubscriptionModels {
+    assistant: YpAgentAssistant;
+    constructor(assistant: YpAgentAssistant);
+    loadAgentSubscriptionPlans(): Promise<AssistantAgentPlanStatus>;
+    loadAgentProductPlanAndSubscription(subscriptionPlanId: number): Promise<{
+        plan: YpSubscriptionPlanAttributes | null;
+        subscription: YpSubscriptionAttributes | null;
+    }>;
+    loadUserAgentSubscriptions(): Promise<AssistantAgentSubscriptionStatus>;
+    unsubscribeFromAgentPlan(subscriptionId: number): Promise<UnsubscribeResult>;
+    subscribeToAgentPlan(agentProductId: number, subscriptionPlanId: number, returnCurrentSubscription?: boolean): Promise<SubscribeResult>;
+}

package/agents/assistants/modes/tools/models/users.d.ts

@@ -0,0 +1,7 @@
+import { YpAgentAssistant } from "agents/assistants/agentAssistant.js";
+export declare class UserModels {
+    assistant: YpAgentAssistant;
+    constructor(assistant: YpAgentAssistant);
+    loginUser(): Promise<void>;
+    logoutUser(): Promise<void>;
+}

package/agents/assistants/modes/tools/navigationTools.d.ts

@@ -0,0 +1,33 @@
+import { YpAgentAssistant } from "../../agentAssistant.js";
+import { AgentModels } from "./models/agents.js";
+import { SubscriptionModels } from "./models/subscriptions.js";
+import { BaseAssistantTools } from "./baseTools.js";
+export declare class NavigationTools extends BaseAssistantTools {
+    protected agentModels: AgentModels;
+    protected subscriptionModels: SubscriptionModels;
+    constructor(assistant: YpAgentAssistant);
+    goBackToMainAssistant(): Promise<ToolExecutionResult>;
+    get connectDirectlyToAgent(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentSelectProperties;
+            required: readonly ["subscriptionPlanId"];
+        };
+        handler: (params: YpAgentSelectParams) => Promise<ToolExecutionResult>;
+    };
+    connectToOneOfTheAgentsHandler(params: YpAgentSelectParams): Promise<ToolExecutionResult>;
+    get listAllAgentsAvailableForConnection(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentEmptyProperties;
+        };
+        handler: (params: YpAgentEmptyProperties) => Promise<ToolExecutionResult>;
+    };
+    listAllAgentsAvailableForConnectionsHandler(params: YpAgentEmptyProperties): Promise<ToolExecutionResult>;
+}

package/agents/assistants/modes/tools/subscriptionTools.d.ts

@@ -0,0 +1,53 @@
+import { YpAgentAssistant } from "../../agentAssistant.js";
+import { SubscriptionModels } from "./models/subscriptions.js";
+import { BaseAssistantTools } from "./baseTools.js";
+export declare class SubscriptionTools extends BaseAssistantTools {
+    subscriptionModels: SubscriptionModels;
+    constructor(assistant: YpAgentAssistant);
+    get listMyAgentSubscriptions(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentEmptyProperties;
+        };
+        handler: (params: YpAgentEmptyProperties) => Promise<ToolExecutionResult>;
+    };
+    listMyAgentSubscriptionsHandler(params: YpAgentEmptyProperties): Promise<ToolExecutionResult>;
+    get listAllAgentsAvailableForSubscription(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentEmptyProperties;
+        };
+        handler: (params: YpAgentEmptyProperties) => Promise<ToolExecutionResult>;
+    };
+    listAllAgentsAvailableForSubscriptionHandler(params: YpAgentEmptyProperties): Promise<ToolExecutionResult>;
+    get subscribeToCurrentAgentPlan(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentSubscribeProperties;
+            required: readonly ["useHasVerballyConfirmedSubscribeWithTheAgentName"];
+        };
+        handler: (params: YpAgentSubscribeParams) => Promise<ToolExecutionResult>;
+    };
+    subscribeToCurrentAgentPlanHandler(params: YpAgentSubscribeParams): Promise<ToolExecutionResult>;
+    get unsubscribeFromCurrentAgentSubscription(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentUnsubscribeProperties;
+            required: readonly ["useHasVerballyConfirmedUnsubscribeWithTheAgentName"];
+        };
+        handler: (params: YpAgentUnsubscribeParams) => Promise<ToolExecutionResult>;
+    };
+    unsubscribeFromCurrentAgentSubscriptionHandler(params: YpAgentUnsubscribeParams): Promise<ToolExecutionResult>;
+}

package/agents/assistants/modes/tools/workflowConverstationTools.d.ts

@@ -0,0 +1,49 @@
+import { YpAgentAssistant } from "../../agentAssistant.js";
+import { BaseAssistantTools } from "./baseTools.js";
+export declare class WorkflowConversationTools extends BaseAssistantTools {
+    constructor(assistant: YpAgentAssistant);
+    get show_running_workflow_conversations(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentEmptyProperties;
+            required: readonly [];
+        };
+        handler: (params: {}) => Promise<ToolExecutionResult>;
+    };
+    showRunningWorkflowsHandler(params: {}): Promise<ToolExecutionResult>;
+    get show_all_workflow_conversations(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: YpAgentEmptyProperties;
+            required: readonly [];
+        };
+        handler: (params: {}) => Promise<ToolExecutionResult>;
+    };
+    showAllWorkflowsHandler(params: {}): Promise<ToolExecutionResult>;
+    get connect_to_workflow_conversation(): {
+        name: string;
+        description: string;
+        type: string;
+        parameters: {
+            type: string;
+            properties: {
+                workflowId: {
+                    type: string;
+                };
+            };
+            required: readonly ["workflowId"];
+        };
+        handler: (params: {
+            workflowId: number;
+        }) => Promise<ToolExecutionResult>;
+    };
+    connectToWorkflowHandler(params: {
+        workflowId: number;
+    }): Promise<ToolExecutionResult>;
+}

package/agents/assistants/voiceAssistant.d.ts

@@ -0,0 +1,78 @@
+import { YpBaseChatBot } from "../../active-citizen/llms/baseChatBot.js";
+import { YpBaseAssistant } from "./baseAssistant.js";
+import WebSocket from "ws";
+import ioredis from "ioredis";
+interface VoiceMessage {
+    delta: any;
+    type: string;
+    content?: string;
+    audio?: string;
+    metadata?: any;
+}
+interface VoiceState {
+    speaking: boolean;
+    listening: boolean;
+    processingAudio: boolean;
+    lastAudioTimestamp?: number;
+}
+interface VoiceConnectionConfig {
+    model: string;
+    voice: string;
+    instructions?: string;
+    tools?: AssistantChatbotTool[];
+    modalities: ("text" | "audio")[];
+}
+interface RealtimeVoiceConnection {
+    ws: WebSocket;
+    connected: boolean;
+    model: string;
+    voice: string;
+}
+export declare class YpBaseChatBotWithVoice extends YpBaseChatBot {
+    protected voiceEnabled: boolean;
+    assistantVoiceConnection?: RealtimeVoiceConnection;
+    directAgentVoiceConnection?: RealtimeVoiceConnection;
+    private voiceMainMessageHandler?;
+    private voiceDirectMessageHandler?;
+    protected voiceConfig: VoiceConnectionConfig;
+    protected voiceState: VoiceState;
+    protected readonly VAD_TIMEOUT = 1000;
+    protected vadTimeout?: NodeJS.Timeout;
+    protected parentAssistant: YpBaseAssistant;
+    sendTranscriptsToClient: boolean;
+    isWaitingOnCancelResponseCompleted: boolean;
+    lastNumberOfChatHistoryForInstructions: number;
+    exitMessageFromDirectAgentConversation: string | undefined;
+    DEBUG: boolean;
+    constructor(wsClientId: string, wsClients: Map<string, WebSocket>, redisKey: string, redisConnection: ioredis.Redis, voiceEnabled: boolean | undefined, parentAssistant: YpBaseAssistant);
+    updateAiModelSession(message: string): Promise<void>;
+    initializeMainAssistantVoiceConnection(): Promise<void>;
+    initializeDirectAgentVoiceConnection(): Promise<void>;
+    destroyDirectAgentVoiceConnection(): Promise<void>;
+    destroyAssistantVoiceConnection(): void;
+    protected setupVoiceMessageHandlers(ws: WebSocket, disableWhenAgentIsSpeaking: boolean): void;
+    destroy(): void;
+    handleResponseDone(event: any): Promise<void>;
+    handleAudioTranscriptDone(event: any): Promise<void>;
+    callFunctionHandler(event: any): Promise<void>;
+    getRandomStringAscii(length?: number): string;
+    proxyToClient(event: any): Promise<void>;
+    handleIncomingAudio(audioData: Uint8Array): Promise<void>;
+    private handleVADSilence;
+    private handleSpeechStarted;
+    private handleSpeechStopped;
+    handleAudioDelta(event: VoiceMessage): Promise<void>;
+    private handleTextOutput;
+    sendToVoiceConnection(message: any): void;
+    private handleAudioBufferCommitted;
+    waitForCancelResponseCompleted(): Promise<void>;
+    sendCancelResponse(): Promise<void>;
+    initializeVoiceSession(customResponseMessage?: string): Promise<void>;
+    triggerResponse(message: string, cancelResponse?: boolean): Promise<void>;
+    protected handleVoiceSessionCreated(event: any): Promise<void>;
+    protected handleVoiceSessionError(event: any): Promise<void>;
+    protected handleVoiceResponseStatus(event: any): Promise<void>;
+    streamWebSocketResponses(stream: any): Promise<void>;
+    updateVoiceConfig(config: Partial<VoiceConnectionConfig>): Promise<void>;
+}
+export {};

package/agents/controllers/agentProductController.d.ts

@@ -0,0 +1,23 @@
+import express from 'express';
+interface YpRequest extends express.Request {
+    ypDomain?: any;
+    ypCommunity?: any;
+    sso?: any;
+    redisClient?: any;
+    user?: any;
+}
+export declare class AgentProductController {
+    path: string;
+    router: import("express-serve-static-core").Router;
+    private agentProductManager;
+    constructor();
+    initializeRoutes(): void;
+    getAgentProducts: (req: YpRequest, res: express.Response) => Promise<void>;
+    getAgentProduct: (req: YpRequest, res: express.Response) => Promise<void>;
+    createAgentProduct: (req: YpRequest, res: express.Response) => Promise<void>;
+    updateAgentProduct: (req: YpRequest, res: express.Response) => Promise<void>;
+    deleteAgentProduct: (req: YpRequest, res: express.Response) => Promise<void>;
+    getAgentProductRuns: (req: YpRequest, res: express.Response) => Promise<void>;
+    getAgentProductStatus: (req: YpRequest, res: express.Response) => Promise<void>;
+}
+export {};

package/agents/controllers/agentSubscriptionController.d.ts

@@ -0,0 +1,30 @@
+import express from "express";
+import WebSocket from "ws";
+interface YpRequest extends express.Request {
+    ypDomain?: any;
+    ypCommunity?: any;
+    sso?: any;
+    redisClient?: any;
+    user?: any;
+}
+export declare class AgentSubscriptionController {
+    path: string;
+    router: import("express-serve-static-core").Router;
+    private subscriptionManager;
+    private wsClients;
+    constructor(wsClients: Map<string, WebSocket>);
+    initializeRoutes(): void;
+    initializeRoutesSecure(): void;
+    getAgentConfigurationAnswers: (req: YpRequest, res: express.Response) => Promise<void>;
+    updateAgentConfiguration: (req: YpRequest, res: express.Response) => Promise<void>;
+    getPlans: (req: YpRequest, res: express.Response) => Promise<void>;
+    createSubscriptions: (req: YpRequest, res: express.Response) => Promise<void>;
+    startAgentRun: (req: YpRequest, res: express.Response) => Promise<void>;
+    stopAgentRun: (req: YpRequest, res: express.Response) => Promise<void>;
+    getSubscriptions: (req: YpRequest, res: express.Response) => Promise<void>;
+    cancelSubscription: (req: YpRequest, res: express.Response) => Promise<void>;
+    updateSubscription: (req: YpRequest, res: express.Response) => Promise<void>;
+    createPaymentIntent: (req: YpRequest, res: express.Response) => Promise<void>;
+    handleWebhook: (req: YpRequest, res: express.Response) => Promise<void>;
+}
+export {};

package/agents/controllers/assistantsController.d.ts

@@ -0,0 +1,47 @@
+import express from "express";
+import WebSocket from "ws";
+import { YpAgentAssistant } from "../assistants/agentAssistant.js";
+interface YpRequest extends express.Request {
+    ypDomain?: any;
+    ypCommunity?: any;
+    sso?: any;
+    redisClient?: any;
+    user?: any;
+    clientAppPath?: string;
+    adminAppPath?: string;
+    dirName?: string;
+    useNewVersion?: boolean;
+}
+export declare class AssistantController {
+    path: string;
+    router: import("express-serve-static-core").Router;
+    wsClients: Map<string, WebSocket>;
+    chatAssistantInstances: Map<string, YpAgentAssistant>;
+    voiceAssistantInstances: Map<string, YpAgentAssistant>;
+    private agentQueueManager;
+    private workflowConversationManager;
+    constructor(wsClients: Map<string, WebSocket>);
+    initializeModels: () => Promise<void>;
+    initializeRoutes(): void;
+    private getLastStatusMessageFromDB;
+    private getDocxReport;
+    private advanceOrStopCurrentWorkflowStep;
+    private startNextWorkflowStep;
+    private stopCurrentWorkflowStep;
+    getAgentConfigurationAnswers: (req: YpRequest, res: express.Response) => Promise<void>;
+    private getUpdatedWorkflow;
+    private startWorkflowAgent;
+    private submitAgentConfiguration;
+    private updateAssistantMemoryLoginStatus;
+    private defaultStartAgentMode;
+    private getMemoryRedisKey;
+    private loadMemoryWithOwnership;
+    private clearChatLog;
+    private getMemory;
+    private startVoiceSession;
+    private sendChatMessage;
+    private getRunningWorkflowConversations;
+    private getAllWorkflowConversations;
+    private connectToWorkflowConversation;
+}
+export {};

package/agents/controllers/policySynthAgents.d.ts

@@ -0,0 +1,49 @@
+import express from "express";
+import WebSocket from "ws";
+interface YpRequest extends express.Request {
+    ypDomain?: any;
+    ypCommunity?: any;
+    sso?: any;
+    redisClient?: any;
+    user?: any;
+}
+export declare class PolicySynthAgentsController {
+    path: string;
+    router: import("express-serve-static-core").Router;
+    wsClients: Map<string, WebSocket>;
+    private agentQueueManager;
+    private agentCostManager;
+    private agentManager;
+    private agentConnectorManager;
+    private agentRegistryManager;
+    constructor(wsClients: Map<string, WebSocket>);
+    /**
+     * A proxy for setting up API keys for a group.
+     * @param group The group instance to configure
+     */
+    static setupApiKeysForGroup(group: any): Promise<void>;
+    initializeRoutes(): void;
+    replaceAgentMemory: (req: YpRequest, res: express.Response) => Promise<void>;
+    addExistingConnector: (req: YpRequest, res: express.Response) => Promise<void>;
+    getAgentMemory: (req: YpRequest, res: express.Response) => Promise<void>;
+    getAgent: (req: express.Request, res: express.Response) => Promise<void>;
+    getAgentAiModels: (req: express.Request, res: express.Response) => Promise<void>;
+    removeAgentAiModel: (req: express.Request, res: express.Response) => Promise<void>;
+    addAgentAiModel: (req: express.Request, res: express.Response) => Promise<void>;
+    updateNodeConfiguration: (req: express.Request, res: express.Response) => Promise<void>;
+    createInputConnector: (req: express.Request, res: express.Response) => Promise<void>;
+    createOutputConnector: (req: express.Request, res: express.Response) => Promise<void>;
+    createConnector: (req: YpRequest, res: express.Response, type: "input" | "output") => Promise<express.Response<any, Record<string, any>> | undefined>;
+    getActiveAiModels: (req: express.Request, res: express.Response) => Promise<void>;
+    getActiveAgentClasses: (req: YpRequest, res: express.Response) => Promise<void>;
+    getActiveConnectorClasses: (req: YpRequest, res: express.Response) => Promise<void>;
+    createAgent: (req: YpRequest, res: express.Response) => Promise<void>;
+    controlAgent: (req: express.Request, res: express.Response) => Promise<void>;
+    getAgentStatus: (req: express.Request, res: express.Response) => Promise<void>;
+    updateAgentStatus: (req: express.Request, res: express.Response) => Promise<void>;
+    startAgentProcessing: (req: express.Request, res: express.Response) => Promise<void>;
+    pauseAgentProcessing: (req: express.Request, res: express.Response) => Promise<void>;
+    getAgentCosts: (req: express.Request, res: express.Response) => Promise<void>;
+    getAgentCostsDetail: (req: express.Request, res: express.Response) => Promise<void>;
+}
+export {};

package/agents/managers/agentProductManager.d.ts

@@ -0,0 +1,12 @@
+import { YpAgentProduct } from '../models/agentProduct.js';
+import { YpAgentProductRun } from '../models/agentProductRun.js';
+export declare class AgentProductManager {
+    constructor();
+    getAgentProducts(filters?: any): Promise<YpAgentProduct[]>;
+    getAgentProduct(agentProductId: number): Promise<YpAgentProduct | null>;
+    createAgentProduct(data: any): Promise<YpAgentProduct>;
+    updateAgentProduct(agentProductId: number, updates: any): Promise<YpAgentProduct>;
+    deleteAgentProduct(agentProductId: number): Promise<void>;
+    getAgentProductRuns(agentProductId: number): Promise<YpAgentProductRun[]>;
+    getAgentProductStatus(agentProductId: number): Promise<any>;
+}

package/agents/managers/emailInvitesManager.d.ts

@@ -0,0 +1,6 @@
+export declare class AgentInviteManager {
+    /**
+     * Send a notification email to group admins about the current workflow step or completion.
+     */
+    static sendInviteEmail(link: string, agentRunId: number, groupId: number, senderUser: UserClass, inviteeEmail: string): Promise<void>;
+}