@yrpri/api 9.0.108 → 9.0.110

package/agents/assistants/assistant.d.ts

@@ -0,0 +1,156 @@
+
+interface UnsubscribeResult {
+  success: boolean;
+  error?: string;
+  subscriptionId?: number;
+}
+
+interface SubscribeResult {
+  success: boolean;
+  error?: string;
+  plan?: YpSubscriptionPlanAttributes;
+  subscription?: YpSubscriptionAttributes;
+}
+
+interface AssistantAgent {
+  subscriptionId: number;
+  subscriptionPlanId: number;
+  name: string;
+  description: string;
+  imageUrl: string;
+  isRunning: boolean;
+}
+
+interface AssistantAgentRun {
+  runId: number;
+  agentProductId: number;
+  agentRunId: number;
+  status: string;
+  agentName: string;
+  workflow: any;
+  subscriptionId: number;
+}
+
+interface AssistantAgentSubscriptionStatus {
+  availableSubscriptions: Array<YpSubscriptionAttributes>;
+  runningAgents: Array<AssistantAgentRun>;
+  systemStatus: {
+    healthy: boolean;
+    lastUpdated: Date;
+    error?: string;
+  };
+}
+
+interface AssistantAgentBundle {
+  agentBundleId: number;
+  name: string;
+  description: string;
+  imageUrl: string;
+}
+
+interface AssistantAgentPlan {
+  subscriptionPlanId: number;
+  name: string;
+  type: YpSubscriptionPlanType;
+  description: string;
+  imageUrl: string;
+  price?: number;
+  currency?: string;
+  maxRunsPerCycle?: number;
+}
+
+interface AssistantAgentPlanStatus {
+  availablePlans: Array<AssistantAgentPlan>;
+  availableBundle: AssistantAgentBundle | string;
+  systemStatus: {
+    healthy: boolean;
+    lastUpdated: Date;
+    error?: string;
+  };
+}
+
+interface ToolClientEvent {
+  name: YpAssistantMessageType;
+  details: any;
+}
+
+interface ToolClientEventUiClick {
+  name: "ui_click";
+  details: YpAssistantUiClickTypes;
+}
+
+interface ToolExecutionResult<T = unknown> {
+  success: boolean;
+  data?: T;
+  html?: string;
+  uniqueToken?: string;
+  clientEvents?: ToolClientEvent[];
+  error?: string;
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Enhanced AssistantChatbotTool interface with result type
+ */
+interface AssistantChatbotTool {
+  name: string;
+  description: string;
+  type?: string;
+  parameters: ToolDefinition["parameters"];
+  handler: (params: any) => Promise<ToolExecutionResult>;
+  resultSchema?: ToolDefinition["parameters"];
+}
+
+/**
+ * Message format for tool results
+ */
+interface ToolResponseMessage {
+  role: "tool";
+  content: string;
+  tool_call_id: string;
+  name: string;
+}
+
+interface ToolCall {
+  id: string;
+  name: string;
+  arguments: string;
+  startTime?: number; // For timeout tracking
+}
+
+interface AssistantChatbotMode {
+  name: YpAssistantMode;
+  description: string;
+  systemPrompt: string;
+  tools: AssistantChatbotTool[];
+  routingRules?: string[];
+  allowedTransitions?: YpAssistantMode[];
+  cleanup?: () => Promise<void>;
+}
+
+interface YpBaseAssistantMemoryData extends YpBaseChatBotMemoryData {
+  redisKey: string;
+  currentMode: YpAssistantMode;
+  currentUser?: YpUserData;
+  haveShownLoginWidget?: boolean;
+  haveShownConfigurationWidget?: boolean;
+  currentAgentStatus?: {
+    subscriptionPlanId: number;
+    activeAgentRunId?: number;
+    subscriptionId: number | null;
+    subscriptionState: YpAssistantAgentSubscriptionState;
+    configurationState: YpAssistantAgentConfigurationState;
+  };
+
+  allChatLogs?: YpSimpleChatLog[];
+
+  loginState?: YpAssistantLoginState;
+
+  modeData?: AssistantModeData;
+  modeHistory?: Array<{
+    mode: YpAssistantMode;
+    timestamp: number;
+    reason?: string;
+  }>;
+}
+

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>;
+}

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>;
+}