@elizaos/core 1.0.1 → 1.0.3

package/dist/index-Cy9ZgQIe.d.ts

@@ -0,0 +1,1678 @@
+import { Readable } from 'stream';
+import { S as State$2, A as ActionExample$2, C as Content$1, P as Provider$2 } from './types-DzoA9aTJ.js';
+
+/**
+ * Represents a UUID string in the format "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
+ */
+type UUID$1 = `${string}-${string}-${string}-${string}-${string}`;
+/**
+ * Represents the content of a message or communication
+ */
+interface Content {
+    /** The main text content */
+    text: string;
+    /** Optional action associated with the message */
+    action?: string;
+    /** Optional source/origin of the content */
+    source?: string;
+    /** URL of the original message/post (e.g. tweet URL, Discord message link) */
+    url?: string;
+    /** UUID of parent message if this is a reply/thread */
+    inReplyTo?: UUID$1;
+    /** Array of media attachments */
+    attachments?: Media[];
+    /** Additional dynamic properties */
+    [key: string]: unknown;
+}
+/**
+ * Example content with associated user for demonstration purposes
+ */
+interface ActionExample$1 {
+    /** User associated with the example */
+    user: string;
+    /** Content of the example */
+    content: Content;
+}
+/**
+ * Example conversation content with user ID
+ */
+interface ConversationExample {
+    /** UUID of user in conversation */
+    userId: UUID$1;
+    /** Content of the conversation */
+    content: Content;
+}
+/**
+ * Represents an actor/participant in a conversation
+ */
+interface Actor {
+    /** Display name */
+    name: string;
+    /** Username/handle */
+    username: string;
+    /** Additional profile details */
+    details: {
+        /** Short profile tagline */
+        tagline: string;
+        /** Longer profile summary */
+        summary: string;
+        /** Favorite quote */
+        quote: string;
+    };
+    /** Unique identifier */
+    id: UUID$1;
+}
+/**
+ * Represents a single objective within a goal
+ */
+interface Objective {
+    /** Optional unique identifier */
+    id?: string;
+    /** Description of what needs to be achieved */
+    description: string;
+    /** Whether objective is completed */
+    completed: boolean;
+}
+/**
+ * Status enum for goals
+ */
+declare enum GoalStatus {
+    DONE = "DONE",
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS"
+}
+/**
+ * Represents a high-level goal composed of objectives
+ */
+interface Goal {
+    /** Optional unique identifier */
+    id?: UUID$1;
+    /** Room ID where goal exists */
+    roomId: UUID$1;
+    /** User ID of goal owner */
+    userId: UUID$1;
+    /** Name/title of the goal */
+    name: string;
+    /** Current status */
+    status: GoalStatus;
+    /** Component objectives */
+    objectives: Objective[];
+}
+/**
+ * Model size/type classification
+ */
+declare enum ModelClass {
+    SMALL = "small",
+    MEDIUM = "medium",
+    LARGE = "large",
+    EMBEDDING = "embedding",
+    IMAGE = "image"
+}
+/**
+ * Model settings
+ */
+type ModelSettings = {
+    /** Model name */
+    name: string;
+    /** Maximum input tokens */
+    maxInputTokens: number;
+    /** Maximum output tokens */
+    maxOutputTokens: number;
+    /** Optional frequency penalty */
+    frequency_penalty?: number;
+    /** Optional presence penalty */
+    presence_penalty?: number;
+    /** Optional repetition penalty */
+    repetition_penalty?: number;
+    /** Stop sequences */
+    stop: string[];
+    /** Temperature setting */
+    temperature: number;
+    /** Optional telemetry configuration (experimental) */
+    experimental_telemetry?: TelemetrySettings;
+};
+/** Image model settings */
+type ImageModelSettings = {
+    name: string;
+    steps?: number;
+};
+/** Embedding model settings */
+type EmbeddingModelSettings = {
+    name: string;
+    dimensions?: number;
+};
+/**
+ * Configuration for an AI model
+ */
+type Model = {
+    /** Optional API endpoint */
+    endpoint?: string;
+    /** Model names by size class */
+    model: {
+        [ModelClass.SMALL]?: ModelSettings;
+        [ModelClass.MEDIUM]?: ModelSettings;
+        [ModelClass.LARGE]?: ModelSettings;
+        [ModelClass.EMBEDDING]?: EmbeddingModelSettings;
+        [ModelClass.IMAGE]?: ImageModelSettings;
+    };
+};
+/**
+ * Model configurations by provider
+ */
+type Models = {
+    [ModelProviderName.OPENAI]: Model;
+    [ModelProviderName.ETERNALAI]: Model;
+    [ModelProviderName.ANTHROPIC]: Model;
+    [ModelProviderName.GROK]: Model;
+    [ModelProviderName.GROQ]: Model;
+    [ModelProviderName.LLAMACLOUD]: Model;
+    [ModelProviderName.TOGETHER]: Model;
+    [ModelProviderName.LLAMALOCAL]: Model;
+    [ModelProviderName.LMSTUDIO]: Model;
+    [ModelProviderName.GOOGLE]: Model;
+    [ModelProviderName.MISTRAL]: Model;
+    [ModelProviderName.CLAUDE_VERTEX]: Model;
+    [ModelProviderName.REDPILL]: Model;
+    [ModelProviderName.OPENROUTER]: Model;
+    [ModelProviderName.OLLAMA]: Model;
+    [ModelProviderName.HEURIST]: Model;
+    [ModelProviderName.GALADRIEL]: Model;
+    [ModelProviderName.FAL]: Model;
+    [ModelProviderName.GAIANET]: Model;
+    [ModelProviderName.ALI_BAILIAN]: Model;
+    [ModelProviderName.VOLENGINE]: Model;
+    [ModelProviderName.NANOGPT]: Model;
+    [ModelProviderName.HYPERBOLIC]: Model;
+    [ModelProviderName.VENICE]: Model;
+    [ModelProviderName.NVIDIA]: Model;
+    [ModelProviderName.NINETEEN_AI]: Model;
+    [ModelProviderName.AKASH_CHAT_API]: Model;
+    [ModelProviderName.LIVEPEER]: Model;
+    [ModelProviderName.DEEPSEEK]: Model;
+    [ModelProviderName.INFERA]: Model;
+    [ModelProviderName.BEDROCK]: Model;
+    [ModelProviderName.ATOMA]: Model;
+    [ModelProviderName.SECRETAI]: Model;
+    [ModelProviderName.NEARAI]: Model;
+};
+/**
+ * Available model providers
+ */
+declare enum ModelProviderName {
+    OPENAI = "openai",
+    ETERNALAI = "eternalai",
+    ANTHROPIC = "anthropic",
+    GROK = "grok",
+    GROQ = "groq",
+    LLAMACLOUD = "llama_cloud",
+    TOGETHER = "together",
+    LLAMALOCAL = "llama_local",
+    LMSTUDIO = "lmstudio",
+    GOOGLE = "google",
+    MISTRAL = "mistral",
+    CLAUDE_VERTEX = "claude_vertex",
+    REDPILL = "redpill",
+    OPENROUTER = "openrouter",
+    OLLAMA = "ollama",
+    HEURIST = "heurist",
+    GALADRIEL = "galadriel",
+    FAL = "falai",
+    GAIANET = "gaianet",
+    ALI_BAILIAN = "ali_bailian",
+    VOLENGINE = "volengine",
+    NANOGPT = "nanogpt",
+    HYPERBOLIC = "hyperbolic",
+    VENICE = "venice",
+    NVIDIA = "nvidia",
+    NINETEEN_AI = "nineteen_ai",
+    AKASH_CHAT_API = "akash_chat_api",
+    LIVEPEER = "livepeer",
+    LETZAI = "letzai",
+    DEEPSEEK = "deepseek",
+    INFERA = "infera",
+    BEDROCK = "bedrock",
+    ATOMA = "atoma",
+    SECRETAI = "secret_ai",
+    NEARAI = "nearai"
+}
+/**
+ * Represents the current state/context of a conversation
+ */
+interface State$1 {
+    /** ID of user who sent current message */
+    userId?: UUID$1;
+    /** ID of agent in conversation */
+    agentId?: UUID$1;
+    /** Agent's biography */
+    bio?: string;
+    /** Agent's background lore */
+    lore?: string;
+    /** Message handling directions */
+    messageDirections?: string;
+    /** Post handling directions */
+    postDirections?: string;
+    /** Current room/conversation ID */
+    roomId?: UUID$1;
+    /** Optional agent name */
+    agentName?: string;
+    /** Optional message sender name */
+    senderName?: string;
+    /** String representation of conversation actors */
+    actors?: string;
+    /** Optional array of actor objects */
+    actorsData?: Actor[];
+    /** Optional string representation of goals */
+    goals?: string;
+    /** Optional array of goal objects */
+    goalsData?: Goal[];
+    /** Recent message history as string */
+    recentMessages?: string;
+    /** Recent message objects */
+    recentMessagesData?: Memory[];
+    /** Optional valid action names */
+    actionNames?: string;
+    /** Optional action descriptions */
+    actions?: string;
+    /** Optional action objects */
+    actionsData?: Action[];
+    /** Optional action examples */
+    actionExamples?: string;
+    /** Optional provider descriptions */
+    providers?: string;
+    /** Optional response content */
+    responseData?: Content;
+    /** Optional recent interaction objects */
+    recentInteractionsData?: Memory[];
+    /** Optional recent interactions string */
+    recentInteractions?: string;
+    /** Optional formatted conversation */
+    formattedConversation?: string;
+    /** Optional formatted knowledge */
+    knowledge?: string;
+    /** Optional knowledge data */
+    knowledgeData?: KnowledgeItem[];
+    /** Optional knowledge data */
+    ragKnowledgeData?: RAGKnowledgeItem[];
+    /** Optional text content */
+    text?: string;
+    /** Additional dynamic properties */
+    [key: string]: unknown;
+}
+/**
+ * Represents a stored memory/message
+ */
+interface Memory {
+    /** Optional unique identifier */
+    id?: UUID$1;
+    /** Associated user ID */
+    userId: UUID$1;
+    /** Associated agent ID */
+    agentId: UUID$1;
+    /** Optional creation timestamp */
+    createdAt?: number;
+    /** Memory content */
+    content: Content;
+    /** Optional embedding vector */
+    embedding?: number[];
+    /** Associated room ID */
+    roomId: UUID$1;
+    /** Whether memory is unique */
+    unique?: boolean;
+    /** Embedding similarity score */
+    similarity?: number;
+}
+/**
+ * Example message for demonstration
+ */
+interface MessageExample {
+    /** Associated user */
+    user: string;
+    /** Message content */
+    content: Content;
+}
+/**
+ * Handler function type for processing messages
+ */
+type Handler = (runtime: IAgentRuntime, message: Memory, state?: State$1, options?: {
+    [key: string]: unknown;
+}, callback?: HandlerCallback) => Promise<unknown>;
+/**
+ * Callback function type for handlers
+ */
+type HandlerCallback = (response: Content, files?: any) => Promise<Memory[]>;
+/**
+ * Validator function type for actions/evaluators
+ */
+type Validator = (runtime: IAgentRuntime, message: Memory, state?: State$1) => Promise<boolean>;
+/**
+ * Represents an action the agent can perform
+ */
+interface Action {
+    /** Similar action descriptions */
+    similes: string[];
+    /** Detailed description */
+    description: string;
+    /** Example usages */
+    examples: ActionExample$1[][];
+    /** Handler function */
+    handler: Handler;
+    /** Action name */
+    name: string;
+    /** Validation function */
+    validate: Validator;
+    /** Whether to suppress the initial message when this action is used */
+    suppressInitialMessage?: boolean;
+}
+/**
+ * Example for evaluating agent behavior
+ */
+interface EvaluationExample {
+    /** Evaluation context */
+    context: string;
+    /** Example messages */
+    messages: Array<ActionExample$1>;
+    /** Expected outcome */
+    outcome: string;
+}
+/**
+ * Evaluator for assessing agent responses
+ */
+interface Evaluator {
+    /** Whether to always run */
+    alwaysRun?: boolean;
+    /** Detailed description */
+    description: string;
+    /** Similar evaluator descriptions */
+    similes: string[];
+    /** Example evaluations */
+    examples: EvaluationExample[];
+    /** Handler function */
+    handler: Handler;
+    /** Evaluator name */
+    name: string;
+    /** Validation function */
+    validate: Validator;
+}
+/**
+ * Provider for external data/services
+ */
+interface Provider$1 {
+    /** Provider name */
+    name?: string;
+    /** Description of the provider */
+    description?: string;
+    /** Whether the provider is dynamic */
+    dynamic?: boolean;
+    /** Position of the provider in the provider list */
+    position?: number;
+    /** Whether the provider is private */
+    private?: boolean;
+    /** Data retrieval function */
+    get: (runtime: IAgentRuntime, message: Memory, state?: State$1) => Promise<any>;
+}
+/**
+ * Represents a relationship between users
+ */
+interface Relationship {
+    /** Unique identifier */
+    id: UUID$1;
+    /** First user ID */
+    userA: UUID$1;
+    /** Second user ID */
+    userB: UUID$1;
+    /** Primary user ID */
+    userId: UUID$1;
+    /** Associated room ID */
+    roomId: UUID$1;
+    /** Relationship status */
+    status: string;
+    /** Optional creation timestamp */
+    createdAt?: string;
+}
+/**
+ * Represents a user account
+ */
+interface Account {
+    /** Unique identifier */
+    id: UUID$1;
+    /** Display name */
+    name: string;
+    /** Username */
+    username: string;
+    /** Optional additional details */
+    details?: {
+        [key: string]: any;
+    };
+    /** Optional email */
+    email?: string;
+    /** Optional avatar URL */
+    avatarUrl?: string;
+}
+/**
+ * Room participant with account details
+ */
+interface Participant {
+    /** Unique identifier */
+    id: UUID$1;
+    /** Associated account */
+    account: Account;
+}
+/**
+ * Represents a conversation room
+ */
+interface Room {
+    /** Unique identifier */
+    id: UUID$1;
+    /** Room participants */
+    participants: Participant[];
+}
+/**
+ * Represents a media attachment
+ */
+type Media = {
+    /** Unique identifier */
+    id: string;
+    /** Media URL */
+    url: string;
+    /** Media title */
+    title: string;
+    /** Media source */
+    source: string;
+    /** Media description */
+    description: string;
+    /** Text content */
+    text: string;
+    /** Content type */
+    contentType?: string;
+};
+/**
+ * Client instance
+ */
+type ClientInstance = {
+    /** Client name */
+    /** Stop client connection */
+    stop: (runtime: IAgentRuntime) => Promise<unknown>;
+};
+/**
+ * Client interface for platform connections
+ */
+type Client = {
+    /** Client name */
+    name: string;
+    /** Client configuration */
+    config?: {
+        [key: string]: any;
+    };
+    /** Start client connection */
+    start: (runtime: IAgentRuntime) => Promise<ClientInstance>;
+};
+/**
+ * Database adapter initialization
+ */
+type Adapter = {
+    /** Initialize the adapter */
+    init: (runtime: IAgentRuntime) => IDatabaseAdapter & IDatabaseCacheAdapter;
+};
+/**
+ * Plugin for extending agent functionality
+ */
+type Plugin = {
+    /** Plugin name */
+    name: string;
+    /** Plugin npm name */
+    npmName?: string;
+    /** Plugin configuration */
+    config?: {
+        [key: string]: any;
+    };
+    /** Plugin description */
+    description: string;
+    /** Optional actions */
+    actions?: Action[];
+    /** Optional providers */
+    providers?: Provider$1[];
+    /** Optional evaluators */
+    evaluators?: Evaluator[];
+    /** Optional services */
+    services?: Service[];
+    /** Optional clients */
+    clients?: Client[];
+    /** Optional adapters */
+    adapters?: Adapter[];
+    /** Optional post charactor processor handler */
+    handlePostCharacterLoaded?: (char: Character) => Promise<Character>;
+};
+interface IAgentConfig {
+    [key: string]: string;
+}
+type TelemetrySettings = {
+    /**
+     * Enable or disable telemetry. Disabled by default while experimental.
+     */
+    isEnabled?: boolean;
+    /**
+     * Enable or disable input recording. Enabled by default.
+     *
+     * You might want to disable input recording to avoid recording sensitive
+     * information, to reduce data transfers, or to increase performance.
+     */
+    recordInputs?: boolean;
+    /**
+     * Enable or disable output recording. Enabled by default.
+     *
+     * You might want to disable output recording to avoid recording sensitive
+     * information, to reduce data transfers, or to increase performance.
+     */
+    recordOutputs?: boolean;
+    /**
+     * Identifier for this function. Used to group telemetry data by function.
+     */
+    functionId?: string;
+};
+interface ModelConfiguration {
+    temperature?: number;
+    maxOutputTokens?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    maxInputTokens?: number;
+    experimental_telemetry?: TelemetrySettings;
+}
+type TemplateType$1 = string | ((options: {
+    state: State$1;
+}) => string);
+/**
+ * Configuration for an agent character
+ */
+type Character = {
+    /** Optional unique identifier */
+    id?: UUID$1;
+    /** Character name */
+    name: string;
+    /** Optional username */
+    username?: string;
+    /** Optional email */
+    email?: string;
+    /** Optional system prompt */
+    system?: string;
+    /** Model provider to use */
+    modelProvider: ModelProviderName;
+    /** Image model provider to use, if different from modelProvider */
+    imageModelProvider?: ModelProviderName;
+    /** Image Vision model provider to use, if different from modelProvider */
+    imageVisionModelProvider?: ModelProviderName;
+    /** Optional model endpoint override */
+    modelEndpointOverride?: string;
+    /** Optional prompt templates */
+    templates?: {
+        goalsTemplate?: TemplateType$1;
+        factsTemplate?: TemplateType$1;
+        messageHandlerTemplate?: TemplateType$1;
+        shouldRespondTemplate?: TemplateType$1;
+        continueMessageHandlerTemplate?: TemplateType$1;
+        evaluationTemplate?: TemplateType$1;
+        twitterSearchTemplate?: TemplateType$1;
+        twitterActionTemplate?: TemplateType$1;
+        twitterPostTemplate?: TemplateType$1;
+        twitterMessageHandlerTemplate?: TemplateType$1;
+        twitterShouldRespondTemplate?: TemplateType$1;
+        twitterVoiceHandlerTemplate?: TemplateType$1;
+        instagramPostTemplate?: TemplateType$1;
+        instagramMessageHandlerTemplate?: TemplateType$1;
+        instagramShouldRespondTemplate?: TemplateType$1;
+        farcasterPostTemplate?: TemplateType$1;
+        lensPostTemplate?: TemplateType$1;
+        farcasterMessageHandlerTemplate?: TemplateType$1;
+        lensMessageHandlerTemplate?: TemplateType$1;
+        farcasterShouldRespondTemplate?: TemplateType$1;
+        lensShouldRespondTemplate?: TemplateType$1;
+        telegramMessageHandlerTemplate?: TemplateType$1;
+        telegramShouldRespondTemplate?: TemplateType$1;
+        telegramAutoPostTemplate?: string;
+        telegramPinnedMessageTemplate?: string;
+        discordAutoPostTemplate?: string;
+        discordAnnouncementHypeTemplate?: string;
+        discordVoiceHandlerTemplate?: TemplateType$1;
+        discordShouldRespondTemplate?: TemplateType$1;
+        discordMessageHandlerTemplate?: TemplateType$1;
+        slackMessageHandlerTemplate?: TemplateType$1;
+        slackShouldRespondTemplate?: TemplateType$1;
+        jeeterPostTemplate?: string;
+        jeeterSearchTemplate?: string;
+        jeeterInteractionTemplate?: string;
+        jeeterMessageHandlerTemplate?: string;
+        jeeterShouldRespondTemplate?: string;
+        devaPostTemplate?: string;
+    };
+    /** Character biography */
+    bio: string | string[];
+    /** Character background lore */
+    lore: string[];
+    /** Example messages */
+    messageExamples: MessageExample[][];
+    /** Example posts */
+    postExamples: string[];
+    /** Known topics */
+    topics: string[];
+    /** Character traits */
+    adjectives: string[];
+    /** Optional knowledge base */
+    knowledge?: (string | {
+        path: string;
+        shared?: boolean;
+    } | {
+        directory: string;
+        shared?: boolean;
+    })[];
+    /** Available plugins */
+    plugins: Plugin[];
+    /** Character Processor Plugins */
+    postProcessors?: Pick<Plugin, 'name' | 'description' | 'handlePostCharacterLoaded'>[];
+    /** Optional configuration */
+    settings?: {
+        secrets?: {
+            [key: string]: string;
+        };
+        intiface?: boolean;
+        imageSettings?: {
+            steps?: number;
+            width?: number;
+            height?: number;
+            cfgScale?: number;
+            negativePrompt?: string;
+            numIterations?: number;
+            guidanceScale?: number;
+            seed?: number;
+            modelId?: string;
+            jobId?: string;
+            count?: number;
+            stylePreset?: string;
+            hideWatermark?: boolean;
+            safeMode?: boolean;
+        };
+        voice?: {
+            model?: string;
+            url?: string;
+            elevenlabs?: {
+                voiceId: string;
+                model?: string;
+                stability?: string;
+                similarityBoost?: string;
+                style?: string;
+                useSpeakerBoost?: string;
+            };
+        };
+        model?: string;
+        modelConfig?: ModelConfiguration;
+        embeddingModel?: string;
+        chains?: {
+            evm?: any[];
+            solana?: any[];
+            [key: string]: any[] | string | undefined;
+        };
+        transcription?: TranscriptionProvider;
+        ragKnowledge?: boolean;
+    };
+    /** Optional client-specific config */
+    clientConfig?: {
+        discord?: {
+            shouldIgnoreBotMessages?: boolean;
+            shouldIgnoreDirectMessages?: boolean;
+            shouldRespondOnlyToMentions?: boolean;
+            messageSimilarityThreshold?: number;
+            isPartOfTeam?: boolean;
+            teamAgentIds?: string[];
+            teamLeaderId?: string;
+            teamMemberInterestKeywords?: string[];
+            allowedChannelIds?: string[];
+            autoPost?: {
+                enabled?: boolean;
+                monitorTime?: number;
+                inactivityThreshold?: number;
+                mainChannelId?: string;
+                announcementChannelIds?: string[];
+                minTimeBetweenPosts?: number;
+            };
+        };
+        telegram?: {
+            shouldIgnoreBotMessages?: boolean;
+            shouldIgnoreDirectMessages?: boolean;
+            shouldRespondOnlyToMentions?: boolean;
+            shouldOnlyJoinInAllowedGroups?: boolean;
+            allowedGroupIds?: string[];
+            messageSimilarityThreshold?: number;
+            isPartOfTeam?: boolean;
+            teamAgentIds?: string[];
+            teamLeaderId?: string;
+            teamMemberInterestKeywords?: string[];
+            autoPost?: {
+                enabled?: boolean;
+                monitorTime?: number;
+                inactivityThreshold?: number;
+                mainChannelId?: string;
+                pinnedMessagesGroups?: string[];
+                minTimeBetweenPosts?: number;
+            };
+        };
+        slack?: {
+            shouldIgnoreBotMessages?: boolean;
+            shouldIgnoreDirectMessages?: boolean;
+        };
+        gitbook?: {
+            keywords?: {
+                projectTerms?: string[];
+                generalQueries?: string[];
+            };
+            documentTriggers?: string[];
+        };
+    };
+    /** Writing style guides */
+    style: {
+        all: string[];
+        chat: string[];
+        post: string[];
+    };
+    /** Optional Twitter profile */
+    twitterProfile?: {
+        id: string;
+        username: string;
+        screenName: string;
+        bio: string;
+        nicknames?: string[];
+    };
+    /** Optional Instagram profile */
+    instagramProfile?: {
+        id: string;
+        username: string;
+        bio: string;
+        nicknames?: string[];
+    };
+    /** Optional SimsAI profile */
+    simsaiProfile?: {
+        id: string;
+        username: string;
+        screenName: string;
+        bio: string;
+    };
+    /** Optional NFT prompt */
+    nft?: {
+        prompt: string;
+    };
+    /**Optinal Parent characters to inherit information from */
+    extends?: string[];
+    twitterSpaces?: TwitterSpaceDecisionOptions;
+};
+interface TwitterSpaceDecisionOptions {
+    maxSpeakers?: number;
+    topics?: string[];
+    typicalDurationMinutes?: number;
+    idleKickTimeoutMs?: number;
+    minIntervalBetweenSpacesMinutes?: number;
+    businessHoursOnly?: boolean;
+    randomChance?: number;
+    enableIdleMonitor?: boolean;
+    enableSttTts?: boolean;
+    enableRecording?: boolean;
+    voiceId?: string;
+    sttLanguage?: string;
+    speakerMaxDurationMs?: number;
+}
+/**
+ * Interface for database operations
+ */
+interface IDatabaseAdapter {
+    /** Database instance */
+    db: any;
+    /** Optional initialization */
+    init(): Promise<void>;
+    /** Close database connection */
+    close(): Promise<void>;
+    /** Get account by ID */
+    getAccountById(userId: UUID$1): Promise<Account | null>;
+    /** Create new account */
+    createAccount(account: Account): Promise<boolean>;
+    /** Get memories matching criteria */
+    getMemories(params: {
+        roomId: UUID$1;
+        count?: number;
+        unique?: boolean;
+        tableName: string;
+        agentId: UUID$1;
+        start?: number;
+        end?: number;
+    }): Promise<Memory[]>;
+    getMemoryById(id: UUID$1): Promise<Memory | null>;
+    getMemoriesByIds(ids: UUID$1[], tableName?: string): Promise<Memory[]>;
+    getMemoriesByRoomIds(params: {
+        tableName: string;
+        agentId: UUID$1;
+        roomIds: UUID$1[];
+        limit?: number;
+    }): Promise<Memory[]>;
+    getCachedEmbeddings(params: {
+        query_table_name: string;
+        query_threshold: number;
+        query_input: string;
+        query_field_name: string;
+        query_field_sub_name: string;
+        query_match_count: number;
+    }): Promise<{
+        embedding: number[];
+        levenshtein_score: number;
+    }[]>;
+    log(params: {
+        body: {
+            [key: string]: unknown;
+        };
+        userId: UUID$1;
+        roomId: UUID$1;
+        type: string;
+    }): Promise<void>;
+    getActorDetails(params: {
+        roomId: UUID$1;
+    }): Promise<Actor[]>;
+    searchMemories(params: {
+        tableName: string;
+        agentId: UUID$1;
+        roomId: UUID$1;
+        embedding: number[];
+        match_threshold: number;
+        match_count: number;
+        unique: boolean;
+    }): Promise<Memory[]>;
+    updateGoalStatus(params: {
+        goalId: UUID$1;
+        status: GoalStatus;
+    }): Promise<void>;
+    searchMemoriesByEmbedding(embedding: number[], params: {
+        match_threshold?: number;
+        count?: number;
+        roomId?: UUID$1;
+        agentId?: UUID$1;
+        unique?: boolean;
+        tableName: string;
+    }): Promise<Memory[]>;
+    createMemory(memory: Memory, tableName: string, unique?: boolean): Promise<void>;
+    removeMemory(memoryId: UUID$1, tableName: string): Promise<void>;
+    removeAllMemories(roomId: UUID$1, tableName: string): Promise<void>;
+    countMemories(roomId: UUID$1, unique?: boolean, tableName?: string): Promise<number>;
+    getGoals(params: {
+        agentId: UUID$1;
+        roomId: UUID$1;
+        userId?: UUID$1 | null;
+        onlyInProgress?: boolean;
+        count?: number;
+    }): Promise<Goal[]>;
+    updateGoal(goal: Goal): Promise<void>;
+    createGoal(goal: Goal): Promise<void>;
+    removeGoal(goalId: UUID$1): Promise<void>;
+    removeAllGoals(roomId: UUID$1): Promise<void>;
+    getRoom(roomId: UUID$1): Promise<UUID$1 | null>;
+    createRoom(roomId?: UUID$1): Promise<UUID$1>;
+    removeRoom(roomId: UUID$1): Promise<void>;
+    getRoomsForParticipant(userId: UUID$1): Promise<UUID$1[]>;
+    getRoomsForParticipants(userIds: UUID$1[]): Promise<UUID$1[]>;
+    addParticipant(userId: UUID$1, roomId: UUID$1): Promise<boolean>;
+    removeParticipant(userId: UUID$1, roomId: UUID$1): Promise<boolean>;
+    getParticipantsForAccount(userId: UUID$1): Promise<Participant[]>;
+    getParticipantsForRoom(roomId: UUID$1): Promise<UUID$1[]>;
+    getParticipantUserState(roomId: UUID$1, userId: UUID$1): Promise<'FOLLOWED' | 'MUTED' | null>;
+    setParticipantUserState(roomId: UUID$1, userId: UUID$1, state: 'FOLLOWED' | 'MUTED' | null): Promise<void>;
+    createRelationship(params: {
+        userA: UUID$1;
+        userB: UUID$1;
+    }): Promise<boolean>;
+    getRelationship(params: {
+        userA: UUID$1;
+        userB: UUID$1;
+    }): Promise<Relationship | null>;
+    getRelationships(params: {
+        userId: UUID$1;
+    }): Promise<Relationship[]>;
+    getKnowledge(params: {
+        id?: UUID$1;
+        agentId: UUID$1;
+        limit?: number;
+        query?: string;
+        conversationContext?: string;
+    }): Promise<RAGKnowledgeItem[]>;
+    searchKnowledge(params: {
+        agentId: UUID$1;
+        embedding: Float32Array;
+        match_threshold: number;
+        match_count: number;
+        searchText?: string;
+    }): Promise<RAGKnowledgeItem[]>;
+    createKnowledge(knowledge: RAGKnowledgeItem): Promise<void>;
+    removeKnowledge(id: UUID$1): Promise<void>;
+    clearKnowledge(agentId: UUID$1, shared?: boolean): Promise<void>;
+}
+interface IDatabaseCacheAdapter {
+    getCache(params: {
+        agentId: UUID$1;
+        key: string;
+    }): Promise<string | undefined>;
+    setCache(params: {
+        agentId: UUID$1;
+        key: string;
+        value: string;
+    }): Promise<boolean>;
+    deleteCache(params: {
+        agentId: UUID$1;
+        key: string;
+    }): Promise<boolean>;
+}
+interface IMemoryManager {
+    runtime: IAgentRuntime;
+    tableName: string;
+    constructor: Function;
+    addEmbeddingToMemory(memory: Memory): Promise<Memory>;
+    getMemories(opts: {
+        roomId: UUID$1;
+        count?: number;
+        unique?: boolean;
+        start?: number;
+        end?: number;
+    }): Promise<Memory[]>;
+    getCachedEmbeddings(content: string): Promise<{
+        embedding: number[];
+        levenshtein_score: number;
+    }[]>;
+    getMemoryById(id: UUID$1): Promise<Memory | null>;
+    getMemoriesByRoomIds(params: {
+        roomIds: UUID$1[];
+        limit?: number;
+    }): Promise<Memory[]>;
+    searchMemoriesByEmbedding(embedding: number[], opts: {
+        match_threshold?: number;
+        count?: number;
+        roomId: UUID$1;
+        unique?: boolean;
+    }): Promise<Memory[]>;
+    createMemory(memory: Memory, unique?: boolean): Promise<void>;
+    removeMemory(memoryId: UUID$1): Promise<void>;
+    removeAllMemories(roomId: UUID$1): Promise<void>;
+    countMemories(roomId: UUID$1, unique?: boolean): Promise<number>;
+}
+interface IRAGKnowledgeManager {
+    runtime: IAgentRuntime;
+    tableName: string;
+    getKnowledge(params: {
+        query?: string;
+        id?: UUID$1;
+        limit?: number;
+        conversationContext?: string;
+        agentId?: UUID$1;
+    }): Promise<RAGKnowledgeItem[]>;
+    createKnowledge(item: RAGKnowledgeItem): Promise<void>;
+    removeKnowledge(id: UUID$1): Promise<void>;
+    searchKnowledge(params: {
+        agentId: UUID$1;
+        embedding: Float32Array | number[];
+        match_threshold?: number;
+        match_count?: number;
+        searchText?: string;
+    }): Promise<RAGKnowledgeItem[]>;
+    clearKnowledge(shared?: boolean): Promise<void>;
+    processFile(file: {
+        path: string;
+        content: string;
+        type: 'pdf' | 'md' | 'txt';
+        isShared: boolean;
+    }): Promise<void>;
+    cleanupDeletedKnowledgeFiles(): Promise<void>;
+    generateScopedId(path: string, isShared: boolean): UUID$1;
+}
+type CacheOptions = {
+    expires?: number;
+};
+declare enum CacheStore {
+    REDIS = "redis",
+    DATABASE = "database",
+    FILESYSTEM = "filesystem"
+}
+interface ICacheManager {
+    get<T = unknown>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, options?: CacheOptions): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+declare abstract class Service {
+    private static instance;
+    static get serviceType(): ServiceType;
+    static getInstance<T extends Service>(): T;
+    get serviceType(): ServiceType;
+    abstract initialize(runtime: IAgentRuntime): Promise<void>;
+}
+interface IAgentRuntime {
+    agentId: UUID$1;
+    serverUrl: string;
+    databaseAdapter: IDatabaseAdapter;
+    token: string | null;
+    modelProvider: ModelProviderName;
+    imageModelProvider: ModelProviderName;
+    imageVisionModelProvider: ModelProviderName;
+    character: Character;
+    providers: Provider$1[];
+    actions: Action[];
+    evaluators: Evaluator[];
+    plugins: Plugin[];
+    fetch?: typeof fetch | null;
+    messageManager: IMemoryManager;
+    descriptionManager: IMemoryManager;
+    documentsManager: IMemoryManager;
+    knowledgeManager: IMemoryManager;
+    ragKnowledgeManager: IRAGKnowledgeManager;
+    loreManager: IMemoryManager;
+    cacheManager: ICacheManager;
+    services: Map<ServiceType, Service>;
+    clients: ClientInstance[];
+    initialize(): Promise<void>;
+    registerMemoryManager(manager: IMemoryManager): void;
+    getMemoryManager(name: string): IMemoryManager | null;
+    getService<T extends Service>(service: ServiceType): T | null;
+    registerService(service: Service): void;
+    getSetting(key: string): string | null;
+    getConversationLength(): number;
+    processActions(message: Memory, responses: Memory[], state?: State$1, callback?: HandlerCallback): Promise<void>;
+    evaluate(message: Memory, state?: State$1, didRespond?: boolean, callback?: HandlerCallback): Promise<string[] | null>;
+    ensureParticipantExists(userId: UUID$1, roomId: UUID$1): Promise<void>;
+    ensureUserExists(userId: UUID$1, userName: string | null, name: string | null, source: string | null): Promise<void>;
+    registerAction(action: Action): void;
+    ensureConnection(userId: UUID$1, roomId: UUID$1, userName?: string, userScreenName?: string, source?: string): Promise<void>;
+    ensureParticipantInRoom(userId: UUID$1, roomId: UUID$1): Promise<void>;
+    ensureRoomExists(roomId: UUID$1): Promise<void>;
+    composeState(message: Memory, additionalKeys?: {
+        [key: string]: unknown;
+    }): Promise<State$1>;
+    updateRecentMessageState(state: State$1): Promise<State$1>;
+}
+interface IImageDescriptionService extends Service {
+    describeImage(imageUrl: string): Promise<{
+        title: string;
+        description: string;
+    }>;
+}
+interface ITranscriptionService extends Service {
+    transcribeAttachment(audioBuffer: ArrayBuffer): Promise<string | null>;
+    transcribeAttachmentLocally(audioBuffer: ArrayBuffer): Promise<string | null>;
+    transcribe(audioBuffer: ArrayBuffer): Promise<string | null>;
+    transcribeLocally(audioBuffer: ArrayBuffer): Promise<string | null>;
+}
+interface IVideoService extends Service {
+    isVideoUrl(url: string): boolean;
+    fetchVideoInfo(url: string): Promise<Media>;
+    downloadVideo(videoInfo: Media): Promise<string>;
+    processVideo(url: string, runtime: IAgentRuntime): Promise<Media>;
+}
+interface ITextGenerationService extends Service {
+    initializeModel(): Promise<void>;
+    queueMessageCompletion(context: string, temperature: number, stop: string[], frequency_penalty: number, presence_penalty: number, max_tokens: number): Promise<any>;
+    queueTextCompletion(context: string, temperature: number, stop: string[], frequency_penalty: number, presence_penalty: number, max_tokens: number): Promise<string>;
+    getEmbeddingResponse(input: string): Promise<number[] | undefined>;
+}
+interface IBrowserService extends Service {
+    closeBrowser(): Promise<void>;
+    getPageContent(url: string, runtime: IAgentRuntime): Promise<{
+        title: string;
+        description: string;
+        bodyContent: string;
+    }>;
+}
+interface ISpeechService extends Service {
+    getInstance(): ISpeechService;
+    generate(runtime: IAgentRuntime, text: string): Promise<Readable>;
+}
+interface IPdfService extends Service {
+    getInstance(): IPdfService;
+    convertPdfToText(pdfBuffer: Buffer): Promise<string>;
+}
+interface IAwsS3Service extends Service {
+    uploadFile(imagePath: string, subDirectory: string, useSignedUrl: boolean, expiresIn: number): Promise<{
+        success: boolean;
+        url?: string;
+        error?: string;
+    }>;
+    generateSignedUrl(fileName: string, expiresIn: number): Promise<string>;
+}
+interface UploadIrysResult {
+    success: boolean;
+    url?: string;
+    error?: string;
+    data?: any;
+}
+interface DataIrysFetchedFromGQL {
+    success: boolean;
+    data: any;
+    error?: string;
+}
+interface GraphQLTag {
+    name: string;
+    values: any[];
+}
+declare enum IrysMessageType {
+    REQUEST = "REQUEST",
+    DATA_STORAGE = "DATA_STORAGE",
+    REQUEST_RESPONSE = "REQUEST_RESPONSE"
+}
+declare enum IrysDataType {
+    FILE = "FILE",
+    IMAGE = "IMAGE",
+    OTHER = "OTHER"
+}
+interface IrysTimestamp {
+    from: number;
+    to: number;
+}
+interface IIrysService extends Service {
+    getDataFromAnAgent(agentsWalletPublicKeys: string[], tags: GraphQLTag[], timestamp: IrysTimestamp): Promise<DataIrysFetchedFromGQL>;
+    workerUploadDataOnIrys(data: any, dataType: IrysDataType, messageType: IrysMessageType, serviceCategory: string[], protocol: string[], validationThreshold: number[], minimumProviders: number[], testProvider: boolean[], reputation: number[]): Promise<UploadIrysResult>;
+    providerUploadDataOnIrys(data: any, dataType: IrysDataType, serviceCategory: string[], protocol: string[]): Promise<UploadIrysResult>;
+}
+interface ITeeLogService extends Service {
+    getInstance(): ITeeLogService;
+    log(agentId: string, roomId: string, userId: string, type: string, content: string): Promise<boolean>;
+}
+declare enum ServiceType {
+    IMAGE_DESCRIPTION = "image_description",
+    TRANSCRIPTION = "transcription",
+    VIDEO = "video",
+    TEXT_GENERATION = "text_generation",
+    BROWSER = "browser",
+    SPEECH_GENERATION = "speech_generation",
+    PDF = "pdf",
+    INTIFACE = "intiface",
+    AWS_S3 = "aws_s3",
+    BUTTPLUG = "buttplug",
+    SLACK = "slack",
+    VERIFIABLE_LOGGING = "verifiable_logging",
+    IRYS = "irys",
+    TEE_LOG = "tee_log",
+    GOPLUS_SECURITY = "goplus_security",
+    WEB_SEARCH = "web_search",
+    EMAIL_AUTOMATION = "email_automation",
+    NKN_CLIENT_SERVICE = "nkn_client_service"
+}
+declare enum LoggingLevel {
+    DEBUG = "debug",
+    VERBOSE = "verbose",
+    NONE = "none"
+}
+type KnowledgeItem = {
+    id: UUID$1;
+    content: Content;
+};
+interface RAGKnowledgeItem {
+    id: UUID$1;
+    agentId: UUID$1;
+    content: {
+        text: string;
+        metadata?: {
+            isMain?: boolean;
+            isChunk?: boolean;
+            originalId?: UUID$1;
+            chunkIndex?: number;
+            source?: string;
+            type?: string;
+            isShared?: boolean;
+            [key: string]: unknown;
+        };
+    };
+    embedding?: Float32Array;
+    createdAt?: number;
+    similarity?: number;
+    score?: number;
+}
+interface ActionResponse {
+    like: boolean;
+    retweet: boolean;
+    quote?: boolean;
+    reply?: boolean;
+}
+interface ISlackService extends Service {
+    client: any;
+}
+declare enum TokenizerType {
+    Auto = "auto",
+    TikToken = "tiktoken"
+}
+declare enum TranscriptionProvider {
+    OpenAI = "openai",
+    Deepgram = "deepgram",
+    Local = "local"
+}
+declare enum ActionTimelineType {
+    ForYou = "foryou",
+    Following = "following"
+}
+declare enum KnowledgeScope {
+    SHARED = "shared",
+    PRIVATE = "private"
+}
+declare enum CacheKeyPrefix {
+    KNOWLEDGE = "knowledge"
+}
+interface DirectoryItem {
+    directory: string;
+    shared?: boolean;
+}
+interface ChunkRow {
+    id: string;
+}
+
+/**
+ * Get details for a list of actors.
+ */
+declare function getActorDetails({ runtime, roomId, }: {
+    runtime: IAgentRuntime;
+    roomId: UUID$1;
+}): Promise<void>;
+/**
+ * Format actors into a string
+ * @param actors - list of actors
+ * @returns string
+ */
+declare function formatActors({ actors }: {
+    actors: Actor[];
+}): string;
+/**
+ * Format messages into a string
+ * @param messages - list of messages
+ * @param actors - list of actors
+ * @returns string
+ */
+declare const formatMessages: ({ messages, actors }: {
+    messages: Memory[];
+    actors: Actor[];
+}) => string;
+declare const formatTimestamp: (messageDate: number) => string;
+
+declare const formatPosts: ({ messages, actors, conversationHeader, }: {
+    messages: Memory[];
+    actors: Actor[];
+    conversationHeader?: boolean;
+}) => string;
+
+declare class AgentRuntime implements IAgentRuntime {
+    private _runtime;
+    get agentId(): UUID$1;
+    get serverUrl(): string;
+    get databaseAdapter(): IDatabaseAdapter;
+    get token(): string;
+    get character(): Character;
+    get actions(): Action[];
+    get evaluators(): Evaluator[];
+    get providers(): Provider$1[];
+    get plugins(): Plugin[];
+    get modelProvider(): any;
+    get imageModelProvider(): any;
+    get imageVisionModelProvider(): any;
+    get messageManager(): any;
+    get routes(): any;
+    get services(): any;
+    get events(): any;
+    get descriptionManager(): any;
+    get documentsManager(): any;
+    get knowledgeManager(): any;
+    get ragKnowledgeManager(): any;
+    get loreManager(): any;
+    get cacheManager(): any;
+    get clients(): any;
+    registerMemoryManager(manager: IMemoryManager): void;
+    getMemoryManager(tableName: string): any;
+    getService<T extends Service>(service: ServiceType): T | null;
+    registerService(service: Service): Promise<void>;
+    /**
+     * Creates an instance of AgentRuntime.
+     * @param opts - The options for configuring the AgentRuntime.
+     * @param opts.conversationLength - The number of messages to hold in the recent message cache.
+     * @param opts.token - The JWT token, can be a JWT token if outside worker, or an OpenAI token if inside worker.
+     * @param opts.serverUrl - The URL of the worker.
+     * @param opts.actions - Optional custom actions.
+     * @param opts.evaluators - Optional custom evaluators.
+     * @param opts.services - Optional custom services.
+     * @param opts.memoryManagers - Optional custom memory managers.
+     * @param opts.providers - Optional context providers.
+     * @param opts.model - The model to use for generateText.
+     * @param opts.embeddingModel - The model to use for embedding.
+     * @param opts.agentId - Optional ID of the agent.
+     * @param opts.databaseAdapter - The database adapter used for interacting with the database.
+     * @param opts.fetch - Custom fetch function to use for making requests.
+     */
+    constructor(opts: {
+        conversationLength?: number;
+        agentId?: UUID$1;
+        character?: Character;
+        token: string;
+        serverUrl?: string;
+        actions?: Action[];
+        evaluators?: Evaluator[];
+        plugins?: Plugin[];
+        providers?: Provider$1[];
+        modelProvider: ModelProviderName;
+        services?: Service[];
+        managers?: IMemoryManager[];
+        databaseAdapter?: IDatabaseAdapter;
+        fetch?: typeof fetch | unknown;
+        speechModelPath?: string;
+        cacheManager?: ICacheManager;
+        logging?: boolean;
+    });
+    initialize(): Promise<any>;
+    stop(): Promise<any>;
+    getSetting(key: string): any;
+    /**
+     * Get the number of messages that are kept in the conversation buffer.
+     * @returns The number of recent messages to be kept in memory.
+     */
+    getConversationLength(): any;
+    /**
+     * Register an action for the agent to perform.
+     * @param action The action to register.
+     */
+    registerAction(action: Action): any;
+    /**
+     * Register an evaluator to assess and guide the agent's responses.
+     * @param evaluator The evaluator to register.
+     */
+    registerEvaluator(evaluator: Evaluator): any;
+    /**
+     * Register a context provider to provide context for message generation.
+     * @param provider The context provider to register.
+     */
+    registerContextProvider(provider: Provider$1): any;
+    /**
+     * Register an adapter for the agent to use.
+     * @param adapter The adapter to register.
+     */
+    registerAdapter(adapter: Adapter): void;
+    /**
+     * Process the actions of a message.
+     * @param message The message to process.
+     * @param content The content of the message to process actions from.
+     */
+    processActions(message: Memory, responses: Memory[], state?: State$1, callback?: HandlerCallback): Promise<void>;
+    /**
+     * Evaluate the message and state using the registered evaluators.
+     * @param message The message to evaluate.
+     * @param state The state of the agent.
+     * @param didRespond Whether the agent responded to the message.~
+     * @param callback The handler callback
+     * @returns The results of the evaluation.
+     */
+    evaluate(message: Memory, state: State$1, didRespond?: boolean, callback?: HandlerCallback): Promise<any>;
+    /**
+     * Ensure the existence of a participant in the room. If the participant does not exist, they are added to the room.
+     * @param userId - The user ID to ensure the existence of.
+     * @throws An error if the participant cannot be added.
+     */
+    ensureParticipantExists(userId: UUID$1, roomId: UUID$1): Promise<void>;
+    /**
+     * Ensure the existence of a user in the database. If the user does not exist, they are added to the database.
+     * @param userId - The user ID to ensure the existence of.
+     * @param userName - The user name to ensure the existence of.
+     * @returns
+     */
+    ensureUserExists(userId: UUID$1, userName: string | null, name: string | null, email?: string | null, source?: string | null): Promise<void>;
+    ensureParticipantInRoom(userId: UUID$1, roomId: UUID$1): Promise<any>;
+    ensureConnection(userId: UUID$1, roomId: UUID$1, userName?: string, userScreenName?: string, source?: string): Promise<any>;
+    /**
+     * Ensure the existence of a room between the agent and a user. If no room exists, a new room is created and the user
+     * and agent are added as participants. The room ID is returned.
+     * @param roomId - The room ID to create a room with.
+     * @returns The room ID of the room between the agent and the user.
+     * @throws An error if the room cannot be created.
+     */
+    ensureRoomExists(roomId: UUID$1): Promise<any>;
+    /**
+     * Compose the state of the agent into an object that can be passed or used for response generation.
+     * @param message The message to compose the state from.
+     * @returns The state of the agent.
+     */
+    composeState(message: Memory, additionalKeys?: {
+        [key: string]: unknown;
+    }): Promise<any>;
+    updateRecentMessageState(state: State$1): Promise<State$1>;
+}
+
+/**
+ * Represents the state of a conversation or context
+ * This is a v1 compatibility wrapper for v2 State
+ */
+type State = State$1;
+/**
+ * Converts v2 State to v1 compatible State
+ * Uses the V2 State interface from core-plugin-v2
+ */
+declare function fromV2State(stateV2: State$2): State;
+/**
+ * Converts v1 State to v2 State
+ * Creates a state object conforming to V2 State interface
+ */
+declare function toV2State(state: State): State$2;
+
+/**
+ * Represents a UUID string in the format "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
+ * This is a v1 compatibility wrapper for v2 UUID
+ */
+type UUID = UUID$1;
+/**
+ * Helper function to safely cast a string to strongly typed UUID
+ * Wraps V2's validateUuid function
+ *
+ * @param id The string UUID to validate and cast
+ * @returns The same UUID with branded type information
+ * @throws Error if the UUID format is invalid
+ */
+declare function asUUID(id: string): UUID;
+/**
+ * Generates a UUID from a string input
+ * Wraps V2's stringToUuid function
+ *
+ * @param input The string to convert to a UUID
+ * @returns A UUID generated from the input string
+ */
+declare function generateUuidFromString(input: string): UUID;
+
+/**
+ * Example content with associated user for demonstration purposes
+ * This is exported from types.ts in v1, but we're recreating it here for the adapter
+ */
+type ActionExample = ActionExample$1;
+/**
+ * Safely converts a V2 content object to a V1 Content type
+ * Maps known properties and preserves additional ones
+ *
+ * @param content V2 content object
+ * @returns Content compatible with V1
+ */
+declare function convertContentToV1(content: Content$1): Content;
+/**
+ * Safely converts a V1 Content object to a V2 compatible content type
+ * Maps known properties and preserves additional ones
+ *
+ * @param content V1 Content object
+ * @returns Content compatible with V2
+ */
+declare function convertContentToV2(content: Content): Content$1;
+/**
+ * Converts v2 ActionExample to v1 compatible ActionExample
+ *
+ * @param exampleV2 The V2 action example to convert
+ * @returns V1 compatible ActionExample
+ */
+declare function fromV2ActionExample(exampleV2: ActionExample$2): ActionExample;
+/**
+ * Converts v1 ActionExample to v2 ActionExample
+ *
+ * @param example The V1 action example to convert
+ * @returns V2 compatible ActionExample
+ */
+declare function toV2ActionExample(example: ActionExample): ActionExample$2;
+
+/**
+ * Provider for external data/services
+ * This is a v1 compatibility wrapper for v2 Provider
+ */
+type Provider = Provider$1;
+/**
+ * Converts v2 Provider to v1 compatible Provider
+ * Uses the V2 Provider interface to ensure proper optional field handling
+ */
+declare function fromV2Provider(providerV2: Provider$2): Provider;
+/**
+ * Converts v1 Provider to v2 Provider
+ * Creates a Provider object conforming to V2 Provider interface
+ */
+declare function toV2Provider(provider: Provider): Provider$2;
+
+/**
+ * Template type definition for v1 compatibility
+ * A template can be either a string or a function that takes state and returns a string
+ * This aligns with V2's TemplateType
+ */
+type TemplateType = string | ((options: {
+    state: State;
+}) => string);
+/**
+ * Generic template values interface for typed access to state.values
+ * Users can extend this interface for type safety in their templates
+ */
+interface TemplateValues {
+    [key: string]: unknown;
+}
+/**
+ * Create a template function from a v1 template
+ * @param template The v1 template (string or function)
+ * @returns A function that processes the template with the given state
+ */
+declare function createTemplateFunction(template: TemplateType): (state: State) => string;
+/**
+ * Process a template with the given state
+ * @param template The template to process (string or function)
+ * @param state The state to use for processing
+ * @returns The processed template string
+ */
+declare function processTemplate(template: TemplateType, state: State): string;
+/**
+ * Type-safe accessor for template values
+ * @param state The state containing the values
+ * @param defaultValues Optional default values to use if values are missing
+ * @returns The values object with type information
+ */
+declare function getTemplateValues<T extends TemplateValues>(state: State, defaultValues?: Partial<T>): T;
+
+type index_Account = Account;
+type index_Action = Action;
+type index_ActionExample = ActionExample;
+type index_ActionResponse = ActionResponse;
+type index_ActionTimelineType = ActionTimelineType;
+declare const index_ActionTimelineType: typeof ActionTimelineType;
+type index_Actor = Actor;
+type index_Adapter = Adapter;
+type index_AgentRuntime = AgentRuntime;
+declare const index_AgentRuntime: typeof AgentRuntime;
+type index_CacheKeyPrefix = CacheKeyPrefix;
+declare const index_CacheKeyPrefix: typeof CacheKeyPrefix;
+type index_CacheOptions = CacheOptions;
+type index_CacheStore = CacheStore;
+declare const index_CacheStore: typeof CacheStore;
+type index_Character = Character;
+type index_ChunkRow = ChunkRow;
+type index_Client = Client;
+type index_ClientInstance = ClientInstance;
+type index_Content = Content;
+type index_ConversationExample = ConversationExample;
+type index_DataIrysFetchedFromGQL = DataIrysFetchedFromGQL;
+type index_DirectoryItem = DirectoryItem;
+type index_EmbeddingModelSettings = EmbeddingModelSettings;
+type index_EvaluationExample = EvaluationExample;
+type index_Evaluator = Evaluator;
+type index_Goal = Goal;
+type index_GoalStatus = GoalStatus;
+declare const index_GoalStatus: typeof GoalStatus;
+type index_GraphQLTag = GraphQLTag;
+type index_Handler = Handler;
+type index_HandlerCallback = HandlerCallback;
+type index_IAgentConfig = IAgentConfig;
+type index_IAgentRuntime = IAgentRuntime;
+type index_IAwsS3Service = IAwsS3Service;
+type index_IBrowserService = IBrowserService;
+type index_ICacheManager = ICacheManager;
+type index_IDatabaseAdapter = IDatabaseAdapter;
+type index_IDatabaseCacheAdapter = IDatabaseCacheAdapter;
+type index_IImageDescriptionService = IImageDescriptionService;
+type index_IIrysService = IIrysService;
+type index_IMemoryManager = IMemoryManager;
+type index_IPdfService = IPdfService;
+type index_IRAGKnowledgeManager = IRAGKnowledgeManager;
+type index_ISlackService = ISlackService;
+type index_ISpeechService = ISpeechService;
+type index_ITeeLogService = ITeeLogService;
+type index_ITextGenerationService = ITextGenerationService;
+type index_ITranscriptionService = ITranscriptionService;
+type index_IVideoService = IVideoService;
+type index_ImageModelSettings = ImageModelSettings;
+type index_IrysDataType = IrysDataType;
+declare const index_IrysDataType: typeof IrysDataType;
+type index_IrysMessageType = IrysMessageType;
+declare const index_IrysMessageType: typeof IrysMessageType;
+type index_IrysTimestamp = IrysTimestamp;
+type index_KnowledgeItem = KnowledgeItem;
+type index_KnowledgeScope = KnowledgeScope;
+declare const index_KnowledgeScope: typeof KnowledgeScope;
+type index_LoggingLevel = LoggingLevel;
+declare const index_LoggingLevel: typeof LoggingLevel;
+type index_Media = Media;
+type index_Memory = Memory;
+type index_MessageExample = MessageExample;
+type index_Model = Model;
+type index_ModelClass = ModelClass;
+declare const index_ModelClass: typeof ModelClass;
+type index_ModelConfiguration = ModelConfiguration;
+type index_ModelProviderName = ModelProviderName;
+declare const index_ModelProviderName: typeof ModelProviderName;
+type index_ModelSettings = ModelSettings;
+type index_Models = Models;
+type index_Objective = Objective;
+type index_Participant = Participant;
+type index_Plugin = Plugin;
+type index_Provider = Provider;
+type index_RAGKnowledgeItem = RAGKnowledgeItem;
+type index_Relationship = Relationship;
+type index_Room = Room;
+type index_Service = Service;
+declare const index_Service: typeof Service;
+type index_ServiceType = ServiceType;
+declare const index_ServiceType: typeof ServiceType;
+type index_State = State;
+type index_TelemetrySettings = TelemetrySettings;
+type index_TemplateType = TemplateType;
+type index_TokenizerType = TokenizerType;
+declare const index_TokenizerType: typeof TokenizerType;
+type index_TranscriptionProvider = TranscriptionProvider;
+declare const index_TranscriptionProvider: typeof TranscriptionProvider;
+type index_TwitterSpaceDecisionOptions = TwitterSpaceDecisionOptions;
+type index_UploadIrysResult = UploadIrysResult;
+type index_Validator = Validator;
+declare const index_asUUID: typeof asUUID;
+declare const index_convertContentToV1: typeof convertContentToV1;
+declare const index_convertContentToV2: typeof convertContentToV2;
+declare const index_createTemplateFunction: typeof createTemplateFunction;
+declare const index_formatActors: typeof formatActors;
+declare const index_formatMessages: typeof formatMessages;
+declare const index_formatPosts: typeof formatPosts;
+declare const index_formatTimestamp: typeof formatTimestamp;
+declare const index_fromV2ActionExample: typeof fromV2ActionExample;
+declare const index_fromV2Provider: typeof fromV2Provider;
+declare const index_fromV2State: typeof fromV2State;
+declare const index_generateUuidFromString: typeof generateUuidFromString;
+declare const index_getActorDetails: typeof getActorDetails;
+declare const index_getTemplateValues: typeof getTemplateValues;
+declare const index_processTemplate: typeof processTemplate;
+declare const index_toV2ActionExample: typeof toV2ActionExample;
+declare const index_toV2Provider: typeof toV2Provider;
+declare const index_toV2State: typeof toV2State;
+declare namespace index {
+  export { type index_Account as Account, type index_Action as Action, type index_ActionExample as ActionExample, type index_ActionResponse as ActionResponse, index_ActionTimelineType as ActionTimelineType, type index_Actor as Actor, type index_Adapter as Adapter, index_AgentRuntime as AgentRuntime, index_CacheKeyPrefix as CacheKeyPrefix, type index_CacheOptions as CacheOptions, index_CacheStore as CacheStore, type index_Character as Character, type index_ChunkRow as ChunkRow, type index_Client as Client, type index_ClientInstance as ClientInstance, type index_Content as Content, type index_ConversationExample as ConversationExample, type index_DataIrysFetchedFromGQL as DataIrysFetchedFromGQL, type index_DirectoryItem as DirectoryItem, type index_EmbeddingModelSettings as EmbeddingModelSettings, type index_EvaluationExample as EvaluationExample, type index_Evaluator as Evaluator, type index_Goal as Goal, index_GoalStatus as GoalStatus, type index_GraphQLTag as GraphQLTag, type index_Handler as Handler, type index_HandlerCallback as HandlerCallback, type index_IAgentConfig as IAgentConfig, type index_IAgentRuntime as IAgentRuntime, type index_IAwsS3Service as IAwsS3Service, type index_IBrowserService as IBrowserService, type index_ICacheManager as ICacheManager, type index_IDatabaseAdapter as IDatabaseAdapter, type index_IDatabaseCacheAdapter as IDatabaseCacheAdapter, type index_IImageDescriptionService as IImageDescriptionService, type index_IIrysService as IIrysService, type index_IMemoryManager as IMemoryManager, type index_IPdfService as IPdfService, type index_IRAGKnowledgeManager as IRAGKnowledgeManager, type index_ISlackService as ISlackService, type index_ISpeechService as ISpeechService, type index_ITeeLogService as ITeeLogService, type index_ITextGenerationService as ITextGenerationService, type index_ITranscriptionService as ITranscriptionService, type index_IVideoService as IVideoService, type index_ImageModelSettings as ImageModelSettings, index_IrysDataType as IrysDataType, index_IrysMessageType as IrysMessageType, type index_IrysTimestamp as IrysTimestamp, type index_KnowledgeItem as KnowledgeItem, index_KnowledgeScope as KnowledgeScope, index_LoggingLevel as LoggingLevel, type index_Media as Media, type index_Memory as Memory, type index_MessageExample as MessageExample, type index_Model as Model, index_ModelClass as ModelClass, type index_ModelConfiguration as ModelConfiguration, index_ModelProviderName as ModelProviderName, type index_ModelSettings as ModelSettings, type index_Models as Models, type index_Objective as Objective, type index_Participant as Participant, type index_Plugin as Plugin, type index_Provider as Provider, type index_RAGKnowledgeItem as RAGKnowledgeItem, type index_Relationship as Relationship, type index_Room as Room, index_Service as Service, index_ServiceType as ServiceType, type index_State as State, type index_TelemetrySettings as TelemetrySettings, type index_TemplateType as TemplateType, index_TokenizerType as TokenizerType, index_TranscriptionProvider as TranscriptionProvider, type index_TwitterSpaceDecisionOptions as TwitterSpaceDecisionOptions, type UUID$1 as UUID, type index_UploadIrysResult as UploadIrysResult, type index_Validator as Validator, index_asUUID as asUUID, index_convertContentToV1 as convertContentToV1, index_convertContentToV2 as convertContentToV2, index_createTemplateFunction as createTemplateFunction, index_formatActors as formatActors, index_formatMessages as formatMessages, index_formatPosts as formatPosts, index_formatTimestamp as formatTimestamp, index_fromV2ActionExample as fromV2ActionExample, index_fromV2Provider as fromV2Provider, index_fromV2State as fromV2State, index_generateUuidFromString as generateUuidFromString, index_getActorDetails as getActorDetails, index_getTemplateValues as getTemplateValues, index_processTemplate as processTemplate, index_toV2ActionExample as toV2ActionExample, index_toV2Provider as toV2Provider, index_toV2State as toV2State };
+}
+
+export { type Adapter as $, type ActionExample as A, ModelProviderName as B, type Content as C, type Memory as D, type EmbeddingModelSettings as E, type MessageExample as F, GoalStatus as G, type Handler as H, type ImageModelSettings as I, type HandlerCallback as J, type Action as K, type EvaluationExample as L, ModelClass as M, type Evaluator as N, type Objective as O, type Provider as P, type Account as Q, type Relationship as R, type State as S, type TemplateType as T, type UUID$1 as U, type Validator as V, type Participant as W, type Room as X, type Media as Y, type ClientInstance as Z, type Client as _, asUUID as a, type Plugin as a0, type IAgentConfig as a1, type TelemetrySettings as a2, type ModelConfiguration as a3, type Character as a4, type TwitterSpaceDecisionOptions as a5, type IDatabaseAdapter as a6, type IDatabaseCacheAdapter as a7, type IMemoryManager as a8, type IRAGKnowledgeManager as a9, type ISlackService as aA, TokenizerType as aB, TranscriptionProvider as aC, ActionTimelineType as aD, KnowledgeScope as aE, CacheKeyPrefix as aF, type DirectoryItem as aG, type ChunkRow as aH, type CacheOptions as aa, CacheStore as ab, type ICacheManager as ac, Service as ad, type IAgentRuntime as ae, type IImageDescriptionService as af, type ITranscriptionService as ag, type IVideoService as ah, type ITextGenerationService as ai, type IBrowserService as aj, type ISpeechService as ak, type IPdfService as al, type IAwsS3Service as am, type UploadIrysResult as an, type DataIrysFetchedFromGQL as ao, type GraphQLTag as ap, IrysMessageType as aq, IrysDataType as ar, type IrysTimestamp as as, type IIrysService as at, type ITeeLogService as au, ServiceType as av, LoggingLevel as aw, type KnowledgeItem as ax, type RAGKnowledgeItem as ay, type ActionResponse as az, fromV2ActionExample as b, toV2ActionExample as c, convertContentToV1 as d, convertContentToV2 as e, fromV2State as f, generateUuidFromString as g, fromV2Provider as h, index as i, toV2Provider as j, createTemplateFunction as k, getTemplateValues as l, getActorDetails as m, formatActors as n, formatMessages as o, processTemplate as p, formatTimestamp as q, formatPosts as r, AgentRuntime as s, toV2State as t, type ConversationExample as u, type Actor as v, type Goal as w, type ModelSettings as x, type Model as y, type Models as z };