@elizaos/core 1.0.0-alpha.57 → 1.0.0-alpha.59

package/dist/types.d.ts

@@ -1,24 +1,28 @@
 import type { Readable } from "node:stream";
-/**
- * Represents a UUID string in the format "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
- */
 /**
  * Type definition for a Universally Unique Identifier (UUID) using a specific format.
  * @typedef {`${string}-${string}-${string}-${string}-${string}`} UUID
  */
 export type UUID = `${string}-${string}-${string}-${string}-${string}`;
 /**
- * Represents the content of a message or communication
+ * Helper function to safely cast a string to strongly typed UUID
+ * @param id The string UUID to validate and cast
+ * @returns The same UUID with branded type information
+ */
+export declare function asUUID(id: string): UUID;
+/**
+ * Represents the content of a memory, message, or other information
  */
 export interface Content {
+    /** The agent's internal thought process */
     thought?: string;
     /** The agent's plan for the next message */
     plan?: string;
-    /** The main text content */
+    /** The main text content visible to users */
     text?: string;
-    /** Optional action associated with the message */
+    /** Optional actions to be performed */
     actions?: string[];
-    /** Optional providers associated with the message */
+    /** Optional providers to use for context generation */
     providers?: string[];
     /** Optional source/origin of the content */
     source?: string;
@@ -28,7 +32,10 @@ export interface Content {
     inReplyTo?: UUID;
     /** Array of media attachments */
     attachments?: Media[];
-    /** Additional dynamic properties */
+    /**
+     * Additional dynamic properties
+     * Use specific properties above instead of this when possible
+     */
     [key: string]: unknown;
 }
 /**
@@ -40,20 +47,11 @@ export interface ActionExample {
     /** Content of the example */
     content: Content;
 }
-/**
- * Example conversation content with user ID
- */
-export interface ConversationExample {
-    /** UUID of user in conversation */
-    entityId: UUID;
-    /** Content of the conversation */
-    content: Content;
-}
-export type ModelType = (typeof ModelTypes)[keyof typeof ModelTypes] | string;
+export type ModelTypeName = (typeof ModelType)[keyof typeof ModelType] | string;
 /**
  * Model size/type classification
  */
-export declare const ModelTypes: {
+export declare const ModelType: {
     readonly SMALL: "TEXT_SMALL";
     readonly MEDIUM: "TEXT_LARGE";
     readonly LARGE: "TEXT_LARGE";
@@ -74,8 +72,8 @@ export declare const ModelTypes: {
     readonly OBJECT_SMALL: "OBJECT_SMALL";
     readonly OBJECT_LARGE: "OBJECT_LARGE";
 };
-export type ServiceType = (typeof ServiceTypes)[keyof typeof ServiceTypes];
-export declare const ServiceTypes: {
+export type ServiceTypeName = (typeof ServiceType)[keyof typeof ServiceType];
+export declare const ServiceType: {
     readonly TRANSCRIPTION: "transcription";
     readonly VIDEO: "video";
     readonly BROWSER: "browser";
@@ -100,6 +98,9 @@ export interface State {
     };
     text: string;
 }
+/**
+ * Memory type enumeration for built-in memory types
+ */
 export type MemoryTypeAlias = string;
 export declare enum MemoryType {
     DOCUMENT = "document",
@@ -108,11 +109,15 @@ export declare enum MemoryType {
     DESCRIPTION = "description",
     CUSTOM = "custom"
 }
+export type MemoryScope = "shared" | "private" | "room";
+/**
+ * Base interface for all memory metadata types
+ */
 export interface BaseMetadata {
     type: MemoryTypeAlias;
     source?: string;
     sourceId?: UUID;
-    scope?: string;
+    scope?: MemoryScope;
     timestamp?: number;
     tags?: string[];
 }
@@ -131,10 +136,9 @@ export interface DescriptionMetadata extends BaseMetadata {
     type: MemoryType.DESCRIPTION;
 }
 export interface CustomMetadata extends BaseMetadata {
-    type: MemoryTypeAlias;
     [key: string]: unknown;
 }
-export type MemoryMetadata = DocumentMetadata | FragmentMetadata | MessageMetadata | DescriptionMetadata | CustomMetadata | any;
+export type MemoryMetadata = DocumentMetadata | FragmentMetadata | MessageMetadata | DescriptionMetadata | CustomMetadata;
 /**
  * Represents a stored memory/message
  */
@@ -145,21 +149,40 @@ export interface Memory {
     entityId: UUID;
     /** Associated agent ID */
     agentId?: UUID;
-    /** Optional creation timestamp */
+    /** Optional creation timestamp in milliseconds since epoch */
     createdAt?: number;
     /** Memory content */
     content: Content;
-    /** Optional embedding vector */
+    /** Optional embedding vector for semantic search */
     embedding?: number[];
     /** Associated room ID */
     roomId: UUID;
-    /** Whether memory is unique */
+    /** Whether memory is unique (used to prevent duplicates) */
     unique?: boolean;
-    /** Embedding similarity score */
+    /** Embedding similarity score (set when retrieved via search) */
     similarity?: number;
-    /** Metadata for the knowledge */
+    /** Metadata for the memory */
     metadata?: MemoryMetadata;
 }
+/**
+ * Represents a log entry
+ */
+export interface Log {
+    /** Optional unique identifier */
+    id?: UUID;
+    /** Associated entity ID */
+    entityId: UUID;
+    /** Associated room ID */
+    roomId?: UUID;
+    /** Log body */
+    body: {
+        [key: string]: unknown;
+    };
+    /** Log type */
+    type: string;
+    /** Log creation timestamp */
+    createdAt: Date;
+}
 /**
  * Example message for demonstration
  */
@@ -413,7 +436,6 @@ export interface Plugin {
     config?: {
         [key: string]: any;
     };
-    memoryManagers?: IMemoryManager[];
     services?: (typeof Service)[];
     componentTypes?: {
         name: string;
@@ -444,13 +466,6 @@ export interface ProjectAgent {
 export interface Project {
     agents: ProjectAgent[];
 }
-export interface ModelConfiguration {
-    temperature?: number;
-    maxOutputTokens?: number;
-    frequency_penalty?: number;
-    presence_penalty?: number;
-    maxInputTokens?: number;
-}
 export type TemplateType = string | ((options: {
     state: State | {
         [key: string]: string;
@@ -504,7 +519,13 @@ export interface Character {
         post?: string[];
     };
 }
+export declare enum AgentStatus {
+    ACTIVE = "active",
+    INACTIVE = "inactive"
+}
 export interface Agent extends Character {
+    enabled?: boolean;
+    status?: AgentStatus;
     createdAt: number;
     updatedAt: number;
 }
@@ -579,6 +600,14 @@ export interface IDatabaseAdapter {
         roomId: UUID;
         type: string;
     }): Promise<void>;
+    getLogs(params: {
+        entityId: UUID;
+        roomId?: UUID;
+        type?: string;
+        count?: number;
+        offset?: number;
+    }): Promise<Log[]>;
+    deleteLog(logId: UUID): Promise<void>;
     searchMemories(params: {
         embedding: number[];
         match_threshold?: number;
@@ -588,8 +617,8 @@ export interface IDatabaseAdapter {
         tableName: string;
     }): Promise<Memory[]>;
     createMemory(memory: Memory, tableName: string, unique?: boolean): Promise<UUID>;
-    removeMemory(memoryId: UUID, tableName: string): Promise<void>;
-    removeAllMemories(roomId: UUID, tableName: string): Promise<void>;
+    deleteMemory(memoryId: UUID): Promise<void>;
+    deleteAllMemories(roomId: UUID, tableName: string): Promise<void>;
     countMemories(roomId: UUID, unique?: boolean, tableName?: string): Promise<number>;
     createWorld(world: World): Promise<UUID>;
     getWorld(id: UUID): Promise<World | null>;
@@ -659,51 +688,74 @@ export interface IDatabaseAdapter {
     updateTask(id: UUID, task: Partial<Task>): Promise<void>;
     deleteTask(id: UUID): Promise<void>;
 }
-export interface IMemoryManager {
-    runtime: IAgentRuntime;
-    tableName: string;
-    addEmbeddingToMemory(memory: Memory): Promise<Memory>;
-    getMemories(opts: {
-        roomId: UUID;
-        count?: number;
-        unique?: boolean;
-        start?: number;
-        end?: number;
-    }): Promise<Memory[]>;
-    searchMemories(params: {
-        embedding: number[];
-        match_threshold?: number;
-        count?: number;
-        roomId?: UUID;
-        unique?: boolean;
-        metadata?: MemoryMetadata;
-    }): Promise<Memory[]>;
-    getCachedEmbeddings(content: string): Promise<{
-        embedding: number[];
-        levenshtein_score: number;
-    }[]>;
-    getMemoryById(id: UUID): Promise<Memory | null>;
-    getMemoriesByRoomIds(params: {
-        roomIds: UUID[];
-        limit?: number;
-    }): Promise<Memory[]>;
-    createMemory(memory: Memory, unique?: boolean): Promise<UUID>;
-    removeMemory(memoryId: UUID): Promise<void>;
-    removeAllMemories(roomId: UUID): Promise<void>;
-    countMemories(roomId: UUID, unique?: boolean): Promise<number>;
+/**
+ * Result interface for embedding similarity searches
+ */
+export interface EmbeddingSearchResult {
+    embedding: number[];
+    levenshtein_score: number;
+}
+/**
+ * Options for memory retrieval operations
+ */
+export interface MemoryRetrievalOptions {
+    roomId: UUID;
+    count?: number;
+    unique?: boolean;
+    start?: number;
+    end?: number;
+    agentId?: UUID;
+}
+/**
+ * Options for memory search operations
+ */
+export interface MemorySearchOptions {
+    embedding: number[];
+    match_threshold?: number;
+    count?: number;
+    roomId: UUID;
+    agentId?: UUID;
+    unique?: boolean;
+    metadata?: Partial<MemoryMetadata>;
+}
+/**
+ * Options for multi-room memory retrieval
+ */
+export interface MultiRoomMemoryOptions {
+    roomIds: UUID[];
+    limit?: number;
+    agentId?: UUID;
+}
+/**
+ * Unified options pattern for memory operations
+ * Provides a simpler, more consistent interface
+ */
+export interface UnifiedMemoryOptions {
+    roomId: UUID;
+    limit?: number;
+    agentId?: UUID;
+    unique?: boolean;
+    start?: number;
+    end?: number;
+}
+/**
+ * Specialized memory search options
+ */
+export interface UnifiedSearchOptions extends UnifiedMemoryOptions {
+    embedding: number[];
+    similarity?: number;
 }
 export type CacheOptions = {
     expires?: number;
 };
 export interface IAgentRuntime extends IDatabaseAdapter {
     agentId: UUID;
-    databaseAdapter: IDatabaseAdapter;
     character: Character;
     providers: Provider[];
     actions: Action[];
     evaluators: Evaluator[];
     plugins: Plugin[];
-    services: Map<ServiceType, Service>;
+    services: Map<ServiceTypeName, Service>;
     events: Map<string, ((params: any) => Promise<void>)[]>;
     fetch?: typeof fetch | null;
     routes: Route[];
@@ -715,9 +767,8 @@ export interface IAgentRuntime extends IDatabaseAdapter {
         overlap: number;
         modelContextSize: number;
     }): Promise<void>;
-    getMemoryManager(tableName: string): IMemoryManager | null;
-    getService<T extends Service>(service: ServiceType | string): T | null;
-    getAllServices(): Map<ServiceType, Service>;
+    getService<T extends Service>(service: ServiceTypeName | string): T | null;
+    getAllServices(): Map<ServiceTypeName, Service>;
     registerService(service: typeof Service): void;
     registerDatabaseAdapter(adapter: IDatabaseAdapter): void;
     setSetting(key: string, value: string | boolean | null | any, secret: boolean): void;
@@ -751,15 +802,16 @@ export interface IAgentRuntime extends IDatabaseAdapter {
      * @param {ModelParamsMap[T] | any} params - The parameters for the model, typed based on model type
      * @returns {Promise<R>} - The model result, typed based on the provided generic type parameter
      */
-    useModel<T extends ModelType, R = ModelResultMap[T]>(modelType: T, params: Omit<ModelParamsMap[T], "runtime"> | any): Promise<R>;
-    registerModel(modelType: ModelType | string, handler: (params: any) => Promise<any>): void;
-    getModel(modelType: ModelType | string): ((runtime: IAgentRuntime, params: any) => Promise<any>) | undefined;
+    useModel<T extends ModelTypeName, R = ModelResultMap[T]>(modelType: T, params: Omit<ModelParamsMap[T], "runtime"> | any): Promise<R>;
+    registerModel(modelType: ModelTypeName | string, handler: (params: any) => Promise<any>): void;
+    getModel(modelType: ModelTypeName | string): ((runtime: IAgentRuntime, params: any) => Promise<any>) | undefined;
     registerEvent(event: string, handler: (params: any) => Promise<void>): void;
     getEvent(event: string): ((params: any) => Promise<void>)[] | undefined;
     emitEvent(event: string | string[], params: any): Promise<void>;
     registerTaskWorker(taskHandler: TaskWorker): void;
     getTaskWorker(name: string): TaskWorker | undefined;
     stop(): Promise<void>;
+    addEmbeddingToMemory(memory: Memory): Promise<Memory>;
 }
 export type KnowledgeItem = {
     id: UUID;
@@ -782,7 +834,7 @@ export interface ChunkRow {
 export type GenerateTextParams = {
     runtime: IAgentRuntime;
     prompt: string;
-    modelType: ModelType;
+    modelType: ModelTypeName;
     maxTokens?: number;
     temperature?: number;
     frequencyPenalty?: number;
@@ -791,11 +843,11 @@ export type GenerateTextParams = {
 };
 export interface TokenizeTextParams {
     prompt: string;
-    modelType: ModelType;
+    modelType: ModelTypeName;
 }
 export interface DetokenizeTextParams {
     tokens: number[];
-    modelType: ModelType;
+    modelType: ModelTypeName;
 }
 export interface IVideoService extends Service {
     isVideoUrl(url: string): boolean;
@@ -1007,7 +1059,7 @@ export interface TokenizeTextParams extends BaseModelParams {
     /** The text to tokenize */
     prompt: string;
     /** The model type to use for tokenization */
-    modelType: ModelType;
+    modelType: ModelTypeName;
 }
 /**
  * Parameters for text detokenization models
@@ -1016,7 +1068,7 @@ export interface DetokenizeTextParams extends BaseModelParams {
     /** The tokens to convert back to text */
     tokens: number[];
     /** The model type to use for detokenization */
-    modelType: ModelType;
+    modelType: ModelTypeName;
 }
 /**
  * Parameters for image generation models
@@ -1100,7 +1152,7 @@ export interface ObjectGenerationParams<T = any> extends BaseModelParams {
     /** For enum type, the allowed values */
     enumValues?: string[];
     /** Model type to use */
-    modelType?: ModelType;
+    modelType?: ModelTypeName;
     /** Model temperature (0.0 to 1.0) */
     temperature?: number;
     /** Sequences that should stop generation */
@@ -1110,47 +1162,47 @@ export interface ObjectGenerationParams<T = any> extends BaseModelParams {
  * Map of model types to their parameter types
  */
 export interface ModelParamsMap {
-    [ModelTypes.TEXT_SMALL]: TextGenerationParams;
-    [ModelTypes.TEXT_LARGE]: TextGenerationParams;
-    [ModelTypes.TEXT_EMBEDDING]: TextEmbeddingParams | string | null;
-    [ModelTypes.TEXT_TOKENIZER_ENCODE]: TokenizeTextParams;
-    [ModelTypes.TEXT_TOKENIZER_DECODE]: DetokenizeTextParams;
-    [ModelTypes.TEXT_REASONING_SMALL]: TextGenerationParams;
-    [ModelTypes.TEXT_REASONING_LARGE]: TextGenerationParams;
-    [ModelTypes.IMAGE]: ImageGenerationParams;
-    [ModelTypes.IMAGE_DESCRIPTION]: ImageDescriptionParams | string;
-    [ModelTypes.TRANSCRIPTION]: TranscriptionParams | Buffer | string;
-    [ModelTypes.TEXT_TO_SPEECH]: TextToSpeechParams | string;
-    [ModelTypes.AUDIO]: AudioProcessingParams;
-    [ModelTypes.VIDEO]: VideoProcessingParams;
-    [ModelTypes.OBJECT_SMALL]: ObjectGenerationParams<any>;
-    [ModelTypes.OBJECT_LARGE]: ObjectGenerationParams<any>;
+    [ModelType.TEXT_SMALL]: TextGenerationParams;
+    [ModelType.TEXT_LARGE]: TextGenerationParams;
+    [ModelType.TEXT_EMBEDDING]: TextEmbeddingParams | string | null;
+    [ModelType.TEXT_TOKENIZER_ENCODE]: TokenizeTextParams;
+    [ModelType.TEXT_TOKENIZER_DECODE]: DetokenizeTextParams;
+    [ModelType.TEXT_REASONING_SMALL]: TextGenerationParams;
+    [ModelType.TEXT_REASONING_LARGE]: TextGenerationParams;
+    [ModelType.IMAGE]: ImageGenerationParams;
+    [ModelType.IMAGE_DESCRIPTION]: ImageDescriptionParams | string;
+    [ModelType.TRANSCRIPTION]: TranscriptionParams | Buffer | string;
+    [ModelType.TEXT_TO_SPEECH]: TextToSpeechParams | string;
+    [ModelType.AUDIO]: AudioProcessingParams;
+    [ModelType.VIDEO]: VideoProcessingParams;
+    [ModelType.OBJECT_SMALL]: ObjectGenerationParams<any>;
+    [ModelType.OBJECT_LARGE]: ObjectGenerationParams<any>;
     [key: string]: BaseModelParams | any;
 }
 /**
  * Map of model types to their return value types
  */
 export interface ModelResultMap {
-    [ModelTypes.TEXT_SMALL]: string;
-    [ModelTypes.TEXT_LARGE]: string;
-    [ModelTypes.TEXT_EMBEDDING]: number[];
-    [ModelTypes.TEXT_TOKENIZER_ENCODE]: number[];
-    [ModelTypes.TEXT_TOKENIZER_DECODE]: string;
-    [ModelTypes.TEXT_REASONING_SMALL]: string;
-    [ModelTypes.TEXT_REASONING_LARGE]: string;
-    [ModelTypes.IMAGE]: {
+    [ModelType.TEXT_SMALL]: string;
+    [ModelType.TEXT_LARGE]: string;
+    [ModelType.TEXT_EMBEDDING]: number[];
+    [ModelType.TEXT_TOKENIZER_ENCODE]: number[];
+    [ModelType.TEXT_TOKENIZER_DECODE]: string;
+    [ModelType.TEXT_REASONING_SMALL]: string;
+    [ModelType.TEXT_REASONING_LARGE]: string;
+    [ModelType.IMAGE]: {
         url: string;
     }[];
-    [ModelTypes.IMAGE_DESCRIPTION]: {
+    [ModelType.IMAGE_DESCRIPTION]: {
         title: string;
         description: string;
     };
-    [ModelTypes.TRANSCRIPTION]: string;
-    [ModelTypes.TEXT_TO_SPEECH]: Readable | Buffer;
-    [ModelTypes.AUDIO]: any;
-    [ModelTypes.VIDEO]: any;
-    [ModelTypes.OBJECT_SMALL]: any;
-    [ModelTypes.OBJECT_LARGE]: any;
+    [ModelType.TRANSCRIPTION]: string;
+    [ModelType.TEXT_TO_SPEECH]: Readable | Buffer;
+    [ModelType.AUDIO]: any;
+    [ModelType.VIDEO]: any;
+    [ModelType.OBJECT_SMALL]: any;
+    [ModelType.OBJECT_LARGE]: any;
     [key: string]: any;
 }
 /**
@@ -1224,6 +1276,15 @@ export interface MessagePayload extends EventPayload {
     message: Memory;
     callback?: HandlerCallback;
 }
+/**
+ * Payload for events that are invoked without a message
+ */
+export interface InvokePayload extends EventPayload {
+    worldId: UUID;
+    userId: string;
+    roomId: UUID;
+    callback?: HandlerCallback;
+}
 /**
  * Run event payload type
  */
@@ -1258,6 +1319,18 @@ export interface EvaluatorEventPayload extends EventPayload {
     completed?: boolean;
     error?: Error;
 }
+/**
+ * Represents the parameters for a message received handler.
+ * @typedef {Object} MessageReceivedHandlerParams
+ * @property {IAgentRuntime} runtime - The agent runtime associated with the message.
+ * @property {Memory} message - The message received.
+ * @property {HandlerCallback} callback - The callback function to be executed after handling the message.
+ */
+export type MessageReceivedHandlerParams = {
+    runtime: IAgentRuntime;
+    message: Memory;
+    callback: HandlerCallback;
+};
 /**
  * Maps event types to their corresponding payload types
  */
@@ -1271,7 +1344,7 @@ export interface EventPayloadMap {
     [EventTypes.MESSAGE_RECEIVED]: MessagePayload;
     [EventTypes.MESSAGE_SENT]: MessagePayload;
     [EventTypes.REACTION_RECEIVED]: MessagePayload;
-    [EventTypes.POST_GENERATED]: MessagePayload;
+    [EventTypes.POST_GENERATED]: InvokePayload;
     [EventTypes.INTERACTION_RECEIVED]: MessagePayload;
     [EventTypes.RUN_STARTED]: RunEventPayload;
     [EventTypes.RUN_ENDED]: RunEventPayload;
@@ -1292,3 +1365,151 @@ export declare enum SOCKET_MESSAGE_TYPE {
     ROOM_JOINING = 1,
     SEND_MESSAGE = 2
 }
+/**
+ * Specialized memory type for messages with enhanced type checking
+ */
+export interface MessageMemory extends Memory {
+    metadata: MessageMetadata;
+    content: Content & {
+        text: string;
+    };
+}
+/**
+ * Factory function to create a new message memory with proper defaults
+ */
+export declare function createMessageMemory(params: {
+    id?: UUID;
+    entityId: UUID;
+    agentId?: UUID;
+    roomId: UUID;
+    content: Content & {
+        text: string;
+    };
+    embedding?: number[];
+}): MessageMemory;
+/**
+ * Generic service interface that provides better type checking for services
+ * @template ConfigType The configuration type for this service
+ * @template ResultType The result type returned by the service operations
+ */
+export interface TypedService<ConfigType = unknown, ResultType = unknown> extends Service {
+    /**
+     * The configuration for this service instance
+     */
+    config: ConfigType;
+    /**
+     * Process an input with this service
+     * @param input The input to process
+     * @returns A promise resolving to the result
+     */
+    process(input: unknown): Promise<ResultType>;
+}
+/**
+ * Generic factory function to create a typed service instance
+ * @param runtime The agent runtime
+ * @param serviceType The type of service to get
+ * @returns The service instance or null if not available
+ */
+export declare function getTypedService<T extends TypedService<any, any>>(runtime: IAgentRuntime, serviceType: ServiceTypeName): T | null;
+/**
+ * Type guard to check if a memory metadata is a DocumentMetadata
+ * @param metadata The metadata to check
+ * @returns True if the metadata is a DocumentMetadata
+ */
+export declare function isDocumentMetadata(metadata: MemoryMetadata): metadata is DocumentMetadata;
+/**
+ * Type guard to check if a memory metadata is a FragmentMetadata
+ * @param metadata The metadata to check
+ * @returns True if the metadata is a FragmentMetadata
+ */
+export declare function isFragmentMetadata(metadata: MemoryMetadata): metadata is FragmentMetadata;
+/**
+ * Type guard to check if a memory metadata is a MessageMetadata
+ * @param metadata The metadata to check
+ * @returns True if the metadata is a MessageMetadata
+ */
+export declare function isMessageMetadata(metadata: MemoryMetadata): metadata is MessageMetadata;
+/**
+ * Type guard to check if a memory metadata is a DescriptionMetadata
+ * @param metadata The metadata to check
+ * @returns True if the metadata is a DescriptionMetadata
+ */
+export declare function isDescriptionMetadata(metadata: MemoryMetadata): metadata is DescriptionMetadata;
+/**
+ * Type guard to check if a memory metadata is a CustomMetadata
+ * @param metadata The metadata to check
+ * @returns True if the metadata is a CustomMetadata
+ */
+export declare function isCustomMetadata(metadata: MemoryMetadata): metadata is CustomMetadata;
+/**
+ * Standardized service error type for consistent error handling
+ */
+export interface ServiceError {
+    code: string;
+    message: string;
+    details?: unknown;
+    cause?: Error;
+}
+/**
+ * Type-safe helper for accessing the video service
+ */
+export declare function getVideoService(runtime: IAgentRuntime): IVideoService | null;
+/**
+ * Type-safe helper for accessing the browser service
+ */
+export declare function getBrowserService(runtime: IAgentRuntime): IBrowserService | null;
+/**
+ * Type-safe helper for accessing the PDF service
+ */
+export declare function getPdfService(runtime: IAgentRuntime): IPdfService | null;
+/**
+ * Type-safe helper for accessing the file service
+ */
+export declare function getFileService(runtime: IAgentRuntime): IFileService | null;
+/**
+ * Memory type guard for document memories
+ */
+export declare function isDocumentMemory(memory: Memory): memory is Memory & {
+    metadata: DocumentMetadata;
+};
+/**
+ * Memory type guard for fragment memories
+ */
+export declare function isFragmentMemory(memory: Memory): memory is Memory & {
+    metadata: FragmentMetadata;
+};
+/**
+ * Safely access the text content of a memory
+ * @param memory The memory to extract text from
+ * @param defaultValue Optional default value if no text is found
+ * @returns The text content or default value
+ */
+export declare function getMemoryText(memory: Memory, defaultValue?: string): string;
+/**
+ * Safely create a ServiceError from any caught error
+ */
+export declare function createServiceError(error: unknown, code?: string): ServiceError;
+/**
+ * Replace 'any' types with more specific types
+ */
+export type StateValue = string | number | boolean | null | StateObject | StateArray;
+export interface StateObject {
+    [key: string]: StateValue;
+}
+export type StateArray = StateValue[];
+/**
+ * Enhanced State interface with more specific types
+ */
+export interface EnhancedState {
+    values: StateObject;
+    data: StateObject;
+    text: string;
+    [key: string]: StateValue;
+}
+export type ComponentData = Record<string, unknown>;
+export type EventDataObject = Record<string, unknown>;
+export type TypedEventHandler = (data: EventDataObject) => Promise<void> | void;
+export type DbConnection = unknown;
+export type MetadataObject = Record<string, unknown>;
+export type ModelHandler = (runtime: IAgentRuntime, params: Record<string, unknown>) => Promise<unknown>;
+export type ServiceConfig = Record<string, unknown>;