@serenity-star/sdk 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,757 @@
+declare class EventEmitter<T extends Record<string, (...args: any[]) => void>> {
+    private listeners;
+    on<K extends keyof T>(eventName: K, listener: T[K]): this;
+    emit<K extends keyof T>(eventName: K, ...args: Parameters<T[K]>): void;
+}
+
+declare enum VendorEnum {
+    OpenAI = 0,
+    Azure = 1,
+    Mistral = 2,
+    HuggingFace = 3,
+    Together = 4,
+    Groq = 5,
+    Anthropic = 6,
+    Google = 7,
+    Mock = 8,
+    Serenity = 9,
+    Cerebras = 10,
+    Replicate = 11,
+    AmazonBedrock = 12,
+    GoogleVertex = 13,
+    OpenRouter = 14,
+    xAI = 15,
+    IBM = 16,
+    DeepSeek = 17,
+    Nvidia = 18
+}
+type ProxyExecutionMessage = {
+    /** The role of the message sender (e.g., 'system', 'user', 'assistant') */
+    role: "system" | "user" | "assistant";
+    /** The actual message content */
+    content: string;
+    /** Array of unique ids for volatile knowledge files */
+    volatileKnowledgeIds?: string[];
+};
+type ProxyExecutionOptions = {
+    /** The identifier of the AI model to use (e.g., 'gpt-4', 'claude-2')
+     * @see https://docs.serenitystar.ai/docs/serenity-aihub/ai-models/available-models/ for available models
+     */
+    model: string;
+    /** Array of messages representing the conversation history */
+    messages: ProxyExecutionMessage[];
+    /** Reduces repetition by lowering the likelihood of using tokens that have appeared recently. Range: -2.0 to 2.0 */
+    frequency_penalty?: number;
+    /** The maximum number of tokens to generate in the response */
+    max_tokens?: number;
+    /** Increases diversity by penalizing tokens that have appeared in the text at all. Range: -2.0 to 2.0 */
+    presence_penalty?: number;
+    /** Controls randomness in the output. Higher values (e.g., 0.8) make output more random, lower values (e.g., 0.2) make it more focused. Range: 0-1 */
+    temperature?: number;
+    /** Alternative to temperature. Limits cumulative probability of tokens considered. Range: 0-1 */
+    top_p?: number;
+    /** Limits the number of tokens to consider at each step. Used by some models */
+    top_k?: number;
+    /** The AI vendor/provider to use for this request */
+    vendor?: VendorEnum;
+    /** Identifier for the user making the request */
+    userIdentifier?: string;
+    /** Identifier for the user's group or organization */
+    groupIdentifier?: string;
+    /** Whether to enable vision/image understanding capabilities */
+    useVision?: boolean;
+};
+
+/**
+ * Options for configuring the Serenity client.
+ */
+type SerenityClientOptions = {
+    /**
+     * The API key used for authenticating requests to the Serenity API.
+     */
+    apiKey: string;
+    /**
+     * The base URL of the Serenity API.
+     */
+    baseUrl?: string;
+};
+/**
+ * Base options for executing any type of agent.
+ */
+type AgentExecutionOptions = {
+    /**
+     * Optional identifier for the user initiating the execution.
+     */
+    userIdentifier?: string;
+    /**
+     * Optional version number of the agent to execute.
+     */
+    agentVersion?: number;
+    /**
+     * Optional channel identifier where the execution is taking place.
+     */
+    channel?: string;
+    /**
+     * Optional array of volatile knowledge IDs to include in the execution context.
+     */
+    volatileKnowledgeIds?: string[];
+};
+/**
+ * Extends AgentExecutionOptions to include input parameters for agents that support them.
+ */
+type AgentExecutionOptionsWithParameters = AgentExecutionOptions & {
+    /**
+     * Optional key-value pairs of input parameters specific to the agent.
+     */
+    inputParameters?: {
+        [key: string]: any;
+    };
+};
+/**
+ * Maps agent types to their specific execution options for conversational agents.
+ *
+ * @remarks
+ * Both assistant and copilot agents support input parameters in addition to base execution options.
+ */
+type ConversationalAgentExecutionOptionsMap = {
+    "assistant": AgentExecutionOptionsWithParameters;
+    "copilot": AgentExecutionOptionsWithParameters;
+};
+/**
+ * Maps agent types to their specific execution options for system agents.
+ *
+ * @remarks
+ * - Chat-completion agents require message content
+ * - Proxy agents have specific proxy execution options
+ */
+type SystemAgentExecutionOptionsMap = {
+    "activity": AgentExecutionOptionsWithParameters;
+    "plan": AgentExecutionOptionsWithParameters;
+    "chat-completion": AgentExecutionOptionsWithParameters & {
+        /** The single message content for the chat completion */
+        message: string;
+        /** Optional array of message objects representing the conversation history */
+        messages?: {
+            role: string;
+            content: string;
+        }[];
+    };
+    "proxy": AgentExecutionOptions & ProxyExecutionOptions;
+};
+type AgentResult = {
+    content: string;
+    instance_id: string;
+    json_content?: any;
+    meta_analysis?: MetaAnalysisRes;
+    completion_usage?: CompletionUsageRes;
+    time_to_first_token?: number;
+    executor_task_logs?: ExecutorTaskLogsRes;
+    action_results?: {
+        [key: string]: PluginExecutionResult;
+    };
+};
+/**
+ * Represents the events that can occur during a realtime session.
+ *
+ * @remarks
+ * The SSEStreamEvents type defines all possible events that can be emitted during
+ * a Server-Sent Events (SSE) streaming session. These events help track the lifecycle
+ * of a streaming response, from initiation to completion, including error handling
+ * and data chunk processing.
+ *
+ * @example
+ * ```typescript
+ * const eventHandler = {
+ *   start: () => console.log('Stream started'),
+ *   content: (chunk) => console.log('Received chunk:', chunk),
+ *   error: (error) => console.error('Stream error:', error?.message),
+ *   stop: (message) => console.log('Stream completed:', message)
+ * };
+ *
+ * // Using with a stream
+ * stream.on('start', eventHandler.start);
+ * stream.on('content', eventHandler.content);
+ * ```
+ */
+type SSEStreamEvents = {
+    /**
+     * Event triggered when the server starts streaming a new response.
+     */
+    start: () => void;
+    /**
+     * Event triggered when an error occurs.
+     * @param error - The error object. May contain a message.
+     */
+    error: (error?: {
+        message?: string;
+    }) => void;
+    /**
+     * Event triggered when there is a new chunk of data available.
+     * @param data - The data chunk.
+     */
+    content: (data: string) => void;
+    /**
+     * Event triggered when the server stops streaming a response.
+     * @param message - The final message object.
+     * @param message.sender - The sender of the message, either "user" or "bot".
+     * @param message.createdAt - The date when the message was created.
+     * @param message.type - The type of the message, e.g., "text", "image", or "error".
+     * @param message.value - The content of the message.
+     * @param message.meta_analysis - Optional meta-analysis results.
+     * @param message.completion_usage - Optional completion usage information.
+     * @param message.time_to_first_token - Optional time to first token.
+     * @param message.executor_task_logs - Optional executor task logs.
+     * @param message.attachedVolatileKnowledges - Optional attached volatile knowledges.
+     * @param message.action_results - Optional action results.
+     */
+    stop: (message: AgentResult) => void;
+};
+type ExecuteBodyParams = Array<{
+    Key: string;
+    Value: any;
+}>;
+type MetaAnalysisRes = {
+    [key: string]: any;
+} & {
+    policy_compliance?: {
+        compliance_score?: number;
+        explanation?: string;
+        policy_violations?: {
+            source_id?: string;
+            source_document_name: string;
+            chunk_id?: string;
+            section_number?: string;
+            section?: string;
+            policy?: string;
+            policy_name: string;
+            policy_id?: string;
+        }[];
+    };
+    pii_release_risk?: {
+        risk_score?: number;
+        explanation?: string;
+    };
+    ethics?: {
+        score?: number;
+        explanation?: string;
+        avoid_topics?: {
+            topic: string;
+            reason: string;
+        }[];
+    };
+    deception_estimation?: {
+        deception_score?: number;
+        explanation?: string;
+    };
+    cybersecurity_threat?: {
+        threat_assessment?: number;
+        explanation?: string;
+    };
+    social_content_risk?: {
+        risk_score?: number;
+        explanation?: string;
+    };
+    conversation_analysis?: {
+        emotion_value_estimate?: number;
+        predicted_next_goal?: string;
+        attended_to_features?: string[];
+        topic_area?: string;
+    };
+};
+type CompletionUsageRes = {
+    completion_tokens: number;
+    prompt_tokens: number;
+    total_tokens: number;
+};
+type ExecutorTaskLogsRes = {
+    description: string;
+    duration: number;
+}[];
+type SpeechGenerationResult = {
+    content: string;
+    finish_reason?: string;
+    usage?: {
+        [key: string]: any;
+    };
+};
+type PluginExecutionResult = SpeechGenerationResult;
+
+/**
+ * Events that can be emitted by a realtime session.
+ *
+ * @remarks
+ * The RealtimeSessionEvents type defines all possible events that can be triggered during
+ * a realtime conversation session with Serenity. These events help track the lifecycle
+ * and state of the session, from creation to completion, including speech interactions
+ * and error handling.
+ *
+ * @example
+ * ```typescript
+ * session.on('session.created', () => {
+ *   console.log('Session started');
+ * });
+ * ```
+ */
+type RealtimeSessionEvents = {
+    /**
+     * Triggered when a new session is initialized
+     */
+    "session.created": () => void;
+    /**
+     * Triggered when voice input begins
+     */
+    "speech.started": () => void;
+    /**
+     * Triggered when voice input ends
+     */
+    "speech.stopped": () => void;
+    /**
+     * Triggered when the agent has completed generating a response
+     */
+    "response.done": () => void;
+    /**
+     * Triggered when any error occurs during the session
+     * @param message - Optional error message
+     */
+    error: (message?: string) => void;
+    /**
+     * Triggered when the session is terminated
+     * @param reason - Optional termination reason
+     * @param details - Optional additional details
+     */
+    "session.stopped": (reason?: string, details?: any) => void;
+    /**
+     * Triggered when Serenity processes a response
+     * @param data - The complete response object containing:
+     *   - content: The main text content of the response
+     *   - instance_id: Unique identifier for the response instance
+     *   - json_content?: Optional structured data in JSON format
+     *   - meta_analysis?: Optional metadata analysis results
+     *   - completion_usage?: Optional usage metrics for the completion
+     *   - time_to_first_token?: Optional time taken to receive first token
+     *   - executor_task_logs?: Optional logs from task execution
+     *   - action_results?: Optional results from plugin executions
+     */
+    "response.processed": (data: AgentResult) => void;
+};
+
+declare class RealtimeSession extends EventEmitter<RealtimeSessionEvents> {
+    #private;
+    private agentCode;
+    private apiKey;
+    private baseUrl;
+    private inputParameters?;
+    private userIdentifier?;
+    private agentVersion?;
+    private channel?;
+    private inactivityTimeout?;
+    private timeout;
+    private sessionConfiguration?;
+    private peerConnection?;
+    private localStream?;
+    private dataChannel?;
+    private socket?;
+    constructor(agentCode: string, apiKey: string, baseUrl: string, options?: AgentExecutionOptionsWithParameters);
+    /**
+     * Starts the real-time session.
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the real-time session.
+     */
+    stop(): void;
+    /**
+     * Allows the user to mute the microphone during a real-time voice session.
+     */
+    muteMicrophone(): void;
+    /**
+     * Allows the user to unmute the microphone during a real-time voice session.
+     */
+    unmuteMicrophone(): void;
+}
+
+type MessageOptions = {
+    inputParameters?: {
+        [key: string]: any;
+    };
+    volatileKnowledgeIds?: string[];
+};
+
+declare class Conversation extends EventEmitter<SSEStreamEvents> {
+    #private;
+    private agentCode;
+    private apiKey;
+    private baseUrl;
+    private inputParameters?;
+    private userIdentifier?;
+    private agentVersion?;
+    private channel?;
+    conversationId?: string;
+    private constructor();
+    private static create;
+    streamMessage(message: string, options?: MessageOptions): Promise<AgentResult>;
+    sendMessage(message: string, options?: MessageOptions): Promise<AgentResult>;
+}
+
+declare abstract class SystemAgent<T extends keyof SystemAgentExecutionOptionsMap> extends EventEmitter<SSEStreamEvents> {
+    protected readonly agentCode: string;
+    protected readonly apiKey: string;
+    protected readonly baseUrl: string;
+    protected readonly options?: SystemAgentExecutionOptionsMap[T] | undefined;
+    protected constructor(agentCode: string, apiKey: string, baseUrl: string, options?: SystemAgentExecutionOptionsMap[T] | undefined);
+    stream(): Promise<AgentResult>;
+    protected execute(): Promise<AgentResult>;
+    protected createExecuteBody(stream: boolean): ExecuteBodyParams | {
+        [key: string]: any;
+    };
+    protected appendUserIdentifierIfNeeded(body: ExecuteBodyParams): void;
+    protected appendVolatileKnowledgeIdsIfNeeded(body: ExecuteBodyParams): void;
+    protected appendChannelIfNeeded(body: ExecuteBodyParams): void;
+}
+
+declare class Activity extends SystemAgent<"activity"> {
+    private constructor();
+    static create(agentCode: string, apiKey: string, baseUrl: string, options?: SystemAgentExecutionOptionsMap["activity"]): Activity;
+    static createAndExecute(agentCode: string, apiKey: string, baseUrl: string, options?: SystemAgentExecutionOptionsMap["activity"]): Promise<AgentResult>;
+    protected createExecuteBody(stream: boolean): ExecuteBodyParams | {
+        [key: string]: any;
+    };
+    private appendInputParametersIfNeeded;
+}
+
+declare class ChatCompletion extends SystemAgent<"chat-completion"> {
+    private constructor();
+    static create(agentCode: string, apiKey: string, baseUrl: string, options?: SystemAgentExecutionOptionsMap["chat-completion"]): ChatCompletion;
+    static createAndExecute(agentCode: string, apiKey: string, baseUrl: string, options?: SystemAgentExecutionOptionsMap["chat-completion"]): Promise<AgentResult>;
+    protected createExecuteBody(stream: boolean): ExecuteBodyParams | {
+        [key: string]: any;
+    };
+    private appendMessagesIfNeeded;
+    private appendMessageIfNeeded;
+    private appendInputParametersIfNeeded;
+}
+
+declare class Plan extends SystemAgent<"plan"> {
+    private constructor();
+    static create(agentCode: string, apiKey: string, baseUrl: string, options?: SystemAgentExecutionOptionsMap["plan"]): Plan;
+    static createAndExecute(agentCode: string, apiKey: string, baseUrl: string, options?: SystemAgentExecutionOptionsMap["plan"]): Promise<AgentResult>;
+    protected createExecuteBody(stream: boolean): ExecuteBodyParams | {
+        [key: string]: any;
+    };
+    private appendInputParametersIfNeeded;
+}
+
+declare class Proxy extends SystemAgent<"proxy"> {
+    private constructor();
+    static create(agentCode: string, apiKey: string, baseUrl: string, options?: SystemAgentExecutionOptionsMap["proxy"]): Proxy;
+    static createAndExecute(agentCode: string, apiKey: string, baseUrl: string, options?: SystemAgentExecutionOptionsMap["proxy"]): Promise<AgentResult>;
+    protected createExecuteBody(stream: boolean): ExecuteBodyParams | {
+        [key: string]: any;
+    };
+}
+
+type ConversationalAgentScope<T extends keyof ConversationalAgentExecutionOptionsMap> = {
+    /**
+     * Create a new conversation with an agent.
+     * This allows you to send messages and receive responses.
+     *
+     * ## Regular conversation example:
+     * ```typescript
+     * const conversation = await client.agents.assistants.createConversation("agent-code");
+     * const response = await conversation.sendMessage("Hello!");
+     * console.log(response.content);
+     * ```
+     *
+     * ## Streaming conversation example:
+     * ```typescript
+     * const conversation = await client.agents.assistants
+     *   .createConversation("agent-code")
+     *   .on("start", () => console.log("Started"))
+     *   .on("content", (chunk) => console.log(chunk))
+     *   .on("error", (error) => console.error(error));
+     *
+     * await conversation.streamMessage("Hello!");
+     * ```
+     *
+     * @param agentCode - The unique identifier of the agent
+     * @param options - Additional options for the conversation
+     * @returns A Promise that resolves to a Conversation instance
+     */
+    createConversation: (agentCode: string, options?: ConversationalAgentExecutionOptionsMap[T]) => Promise<Conversation>;
+    /**
+     * Create a real-time session with an agent.
+     * This allows for voice interactions and real-time responses.
+     *
+     * ## Real-time session example:
+     * ```typescript
+     * const session = client.agents.assistants
+     *   .createRealtimeSession("agent-code")
+     *   .on("session.created", () => console.log("Session started"))
+     *   .on("speech.started", () => console.log("User started talking"))
+     *   .on("speech.stopped", () => console.log("User stopped talking"))
+     *   .on("response.done", (response) => console.log("Response:", response))
+     *   .on("session.stopped", () => console.log("Session stopped"));
+     *
+     * await session.start();
+     * // Later: session.stop();
+     * ```
+     *
+     * @param agentCode - The unique identifier of the agent
+     * @param options - Additional options for the real-time session
+     * @returns A RealtimeSession instance
+     */
+    createRealtimeSession: (agentCode: string, options?: ConversationalAgentExecutionOptionsMap[T]) => RealtimeSession;
+};
+type SystemAgentScope<T extends keyof SystemAgentExecutionOptionsMap, TCreateReturn> = {
+    /**
+     * Execute an agent synchronously and get the result.
+     *
+     * ## Example:
+     * ```typescript
+     * const response = await client.agents.activities.execute("agent-code", {
+     *   // Optional parameters specific to the agent type
+     *   inputParameters: {
+     *     param1: "value1",
+     *     param2: "value2"
+     *   }
+     * });
+     * console.log(response.content);
+     * ```
+     *
+     * @param agentCode - The unique identifier of the agent
+     * @param options - Additional options for the execution
+     * @returns A Promise that resolves to an AgentResult
+     */
+    execute: (agentCode: string, options?: SystemAgentExecutionOptionsMap[T]) => Promise<AgentResult>;
+    /**
+     * Create an agent instance for streaming execution.
+     *
+     * ## Streaming example:
+     * ```typescript
+     * const agent = client.agents.activities
+     *   .create("agent-code", {
+     *     // Optional parameters specific to the agent
+     *     inputParameters: {
+     *       param1: "value1",
+     *       param2: "value2"
+     *     }
+     *   })
+     *   .on("start", () => console.log("Started"))
+     *   .on("content", (chunk) => console.log(chunk))
+     *   .on("error", (error) => console.error(error));
+     *
+     * await agent.stream();
+     * ```
+     *
+     * @param agentCode - The unique identifier of the agent
+     * @param options - Additional options for the agent creation
+     * @returns An agent instance ready for streaming
+     */
+    create: (agentCode: string, options?: SystemAgentExecutionOptionsMap[T]) => TCreateReturn;
+};
+
+declare class SerenityClient {
+    private apiKey;
+    private baseUrl;
+    /**
+     * Interact with the different agents available in Serenity Star.
+     * You can choose between assistants, copilots, activities, chat completions, proxies, and plans.
+     */
+    readonly agents: {
+        /**
+         * Interact with Assistant agents available in Serenity Star.
+         * This allows you to create conversations and real-time sessions.
+         *
+         * ## Start a new conversation and send a message:
+         * ```typescript
+         * // Regular text conversation
+         * const conversation = await client.agents.assistants.createConversation("translator-assistant");
+         * const response = await conversation.sendMessage("The sun was beginning to set...");
+         * console.log(response.content);
+         *
+         * ```
+         *
+         * ## Stream message with SSE
+         * ```typescript
+         * const conversation = await client.agents.assistants
+         *   .createConversation("translator-assistant")
+         *   .on("start", () => console.log("Started"))
+         *   .on("content", (chunk) => console.log(chunk))
+         *   .on("error", (error) => console.error(error));
+         *
+         * await conversation.streamMessage("The sun was beginning to set...");
+         *
+         * ```
+         *
+         * ## Real-time voice conversation example:
+         * ```typescript
+         * const session = client.agents.assistants.createRealtimeSession("marketing-assistant")
+         *   .on("session.created", () => console.log("Session started"))
+         *   .on("speech.started", () => console.log("User started talking"))
+         *   .on("speech.stopped", () => console.log("User stopped talking"))
+         *   .on("response.done", (response) => console.log("Response:", response))
+         *   .on("session.stopped", () => console.log("Session stopped"));
+         *
+         * await session.start();
+         * // Later: session.stop();
+         * ```
+         */
+        assistants: ConversationalAgentScope<"assistant">;
+        /**
+         * Interact with Copilot agents available in Serenity Star.
+         * Similar to assistants but allows you to interact with the UI through callbacks.
+         *
+         * Text conversation example:
+         * ```typescript
+         * // Regular conversation
+         * const conversation = await client.agents.copilots.createConversation("app-copilot");
+         * const response = await conversation.sendMessage("How do I create a new support ticket?");
+         * console.log(response.content);
+         *
+         * // Streaming conversation
+         * const conversation = await client.agents.copilots
+         *   .createConversation("app-copilot")
+         *   .on("start", () => console.log("Started"))
+         *   .on("content", (chunk) => console.log(chunk))
+         *   .on("error", (error) => console.error(error));
+         *
+         * await conversation.streamMessage("How do I create a new support ticket?");
+         * ```
+         */
+        copilots: ConversationalAgentScope<"copilot">;
+        /**
+         * Interact with Activity agents available in Serenity Star.
+         * This allows you to execute activities.
+         * It supports streaming.
+         * Execute simple tasks based on the user input.
+         *
+         * ## Regular activity execution:
+         * ```typescript
+         * const response = await client.agents.activities.execute("marketing-campaign")
+         * console.log(response.content);
+         *
+         * // With parameters
+         * const response = await client.agents.activities.execute("cooking-activity", {
+         *   inputParameters: {
+         *     ingredientOne: "chicken",
+         *     ingredientTwo: "onion",
+         *     ingredientThree: "cream",
+         *   }
+         * });
+         * ```
+         *
+         * ## Stream activity with SSE:
+         * ```typescript
+         * const activity = client.agents.activities
+         *   .create("marketing-campaign")
+         *   .on("start", () => console.log("Started"))
+         *   .on("content", (chunk) => console.log(chunk))
+         *   .on("error", (error) => console.error(error));
+         *
+         * await activity.stream();
+         * ```
+         */
+        activities: SystemAgentScope<"activity", Activity>;
+        /**
+         * Interact with Chat Completion agents available in Serenity Star.
+         * This allows you to execute chat completions.
+         * It supports streaming.
+         * Chat completions allows you to fully control the conversation and generate completions.
+         *
+         * ## Regular chat completion:
+         * ```typescript
+         * const response = await client.agents.chatCompletions.execute("Health-Coach", {
+         *   message: "Hello!"
+         * });
+         * console.log(response.content);
+         * ```
+         *
+         * ## Stream chat completion with SSE:
+         * ```typescript
+         * const chatCompletion = client.agents.chatCompletions
+         *   .create("Health-Coach", {
+         *     message: "Hello!"
+         *   })
+         *   .on("start", () => console.log("Started"))
+         *   .on("content", (chunk) => console.log(chunk))
+         *   .on("error", (error) => console.error(error));
+         *
+         * await chatCompletion.stream();
+         * ```
+         */
+        chatCompletions: SystemAgentScope<"chat-completion", ChatCompletion>;
+        /**
+         * Interact with Proxy agents available in Serenity Star.
+         * This allows you to execute proxies.
+         * It supports streaming.
+         * Proxy agents allows you to define a set of parameters dynamically for each request
+         *
+         * ## Regular proxy execution:
+         * ```typescript
+         * const response = await client.agents.proxies.execute("proxy-agent", {
+         *   model: "gpt-4o-mini-2024-07-18",
+         *   messages: [
+         *     {
+         *       role: "system",
+         *       content: "You are a helpful assistant. Always use short and concise responses"
+         *     },
+         *     { role: "user", content: "What is artificial intelligence?" }
+         *   ],
+         *   temperature: 1,
+         *   max_tokens: 250
+         * });
+         * console.log(response.content);
+         * ```
+         *
+         * ## Stream proxy with SSE:
+         * ```typescript
+         * const proxy = client.agents.proxies
+         *   .create("proxy-agent", {
+         *     model: "gpt-4o-mini-2024-07-18",
+         *     messages: [
+         *     {
+         *       role: "system",
+         *       content: "You are a helpful assistant. Always use short and concise responses"
+         *     },
+         *       { role: "user", content: "What is artificial intelligence?" }
+         *     ],
+         *     temperature: 1,
+         *     max_tokens: 250
+         *   })
+         *   .on("start", () => console.log("Started"))
+         *   .on("content", (chunk) => console.log(chunk))
+         *   .on("error", (error) => console.error(error));
+         *
+         * await proxy.stream();
+         * ```
+         */
+        proxies: SystemAgentScope<"proxy", Proxy>;
+        /**
+         * Interact with Plan agents available in Serenity Star.
+         * This allows you to execute plans.
+         * It supports streaming.
+         * Plan agents are capable of building an execution plan based on the user input and execute it.
+         *
+         * ## Regular plan execution:
+         * ```typescript
+         * const response = await client.agents.plans.execute("event-planner");
+         * console.log(response.content);
+         * ```
+         *
+         * ## Stream plan with SSE:
+         * ```typescript
+         * const plan = client.agents.plans
+         *   .create("event-planner")
+         *   .on("start", () => console.log("Started"))
+         *   .on("content", (chunk) => console.log(chunk))
+         *   .on("error", (error) => console.error(error));
+         *
+         * await plan.stream();
+         * ```
+         */
+        plans: SystemAgentScope<"plan", Plan>;
+    };
+    constructor(options: SerenityClientOptions);
+}
+
+export { RealtimeSession, SerenityClient };