@elizaos/core 1.4.2 → 1.4.4

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import pino from 'pino';
 import * as browser from '@sentry/browser';
 export { browser as Sentry };
 
@@ -375,8 +374,8 @@ interface Entity {
     id?: UUID;
     /** Names of the entity */
     names: string[];
-    /** Optional additional metadata */
-    metadata?: Metadata;
+    /** Additional metadata */
+    metadata: Metadata;
     /** Agent ID this account is related to, for agents should be themselves */
     agentId: UUID;
     /** Optional array of components */
@@ -1285,7 +1284,10 @@ declare enum EventType {
     ACTION_COMPLETED = "ACTION_COMPLETED",
     EVALUATOR_STARTED = "EVALUATOR_STARTED",
     EVALUATOR_COMPLETED = "EVALUATOR_COMPLETED",
-    MODEL_USED = "MODEL_USED"
+    MODEL_USED = "MODEL_USED",
+    EMBEDDING_GENERATION_REQUESTED = "EMBEDDING_GENERATION_REQUESTED",
+    EMBEDDING_GENERATION_COMPLETED = "EMBEDDING_GENERATION_COMPLETED",
+    EMBEDDING_GENERATION_FAILED = "EMBEDDING_GENERATION_FAILED"
 }
 /**
  * Platform-specific event type prefix
@@ -1398,6 +1400,17 @@ interface ModelEventPayload extends EventPayload {
         total: number;
     };
 }
+/**
+ * Payload for embedding generation events
+ */
+interface EmbeddingGenerationPayload extends EventPayload {
+    memory: Memory;
+    priority?: 'high' | 'normal' | 'low';
+    retryCount?: number;
+    maxRetries?: number;
+    embedding?: number[];
+    error?: any;
+}
 type MessageReceivedHandlerParams = {
     runtime: IAgentRuntime;
     message: Memory;
@@ -1429,6 +1442,9 @@ interface EventPayloadMap {
     [EventType.EVALUATOR_STARTED]: EvaluatorEventPayload;
     [EventType.EVALUATOR_COMPLETED]: EvaluatorEventPayload;
     [EventType.MODEL_USED]: ModelEventPayload;
+    [EventType.EMBEDDING_GENERATION_REQUESTED]: EmbeddingGenerationPayload;
+    [EventType.EMBEDDING_GENERATION_COMPLETED]: EmbeddingGenerationPayload;
+    [EventType.EMBEDDING_GENERATION_FAILED]: EmbeddingGenerationPayload;
 }
 /**
  * Event handler function type
@@ -1696,6 +1712,7 @@ interface IAgentRuntime extends IDatabaseAdapter {
     getServicesByType<T extends Service>(service: ServiceTypeName | string): T[];
     getAllServices(): Map<ServiceTypeName, Service[]>;
     registerService(service: typeof Service): Promise<void>;
+    getServiceLoadPromise(serviceType: ServiceTypeName): Promise<Service>;
     getRegisteredServiceTypes(): ServiceTypeName[];
     hasService(serviceType: ServiceTypeName | string): boolean;
     registerDatabaseAdapter(adapter: IDatabaseAdapter): void;
@@ -1736,8 +1753,20 @@ interface IAgentRuntime extends IDatabaseAdapter {
     getTaskWorker(name: string): TaskWorker | undefined;
     stop(): Promise<void>;
     addEmbeddingToMemory(memory: Memory): Promise<Memory>;
+    /**
+     * Queue a memory for async embedding generation.
+     * This method is non-blocking and returns immediately.
+     * The embedding will be generated asynchronously via event handlers.
+     * @param memory The memory to generate embeddings for
+     * @param priority Priority level for the embedding generation
+     */
+    queueEmbeddingGeneration(memory: Memory, priority?: 'high' | 'normal' | 'low'): Promise<void>;
     getAllMemories(): Promise<Memory[]>;
     clearAllAgentMemories(): Promise<void>;
+    updateMemory(memory: Partial<Memory> & {
+        id: UUID;
+        metadata?: MemoryMetadata;
+    }): Promise<boolean>;
     createRunId(): UUID;
     startRun(): UUID;
     endRun(): void;
@@ -3539,7 +3568,6 @@ declare const characterSchema: z.ZodObject<{
             channelType: z.ZodOptional<z.ZodString>;
         }, z.ZodTypeAny, "passthrough">>;
     }, "strip", z.ZodTypeAny, {
-        name?: string;
         content?: {
             thought?: string;
             text?: string;
@@ -3554,8 +3582,8 @@ declare const characterSchema: z.ZodObject<{
         } & {
             [k: string]: unknown;
         };
-    }, {
         name?: string;
+    }, {
         content?: {
             thought?: string;
             text?: string;
@@ -3570,6 +3598,7 @@ declare const characterSchema: z.ZodObject<{
         } & {
             [k: string]: unknown;
         };
+        name?: string;
     }>, "many">, "many">>;
     postExamples: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     topics: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -3618,13 +3647,12 @@ declare const characterSchema: z.ZodObject<{
         path?: string;
     })[];
     username?: string;
-    name?: string;
     id?: string;
+    name?: string;
     system?: string;
     templates?: Record<string, string | ((...args: unknown[]) => unknown)>;
     bio?: string | string[];
     messageExamples?: {
-        name?: string;
         content?: {
             thought?: string;
             text?: string;
@@ -3639,6 +3667,7 @@ declare const characterSchema: z.ZodObject<{
         } & {
             [k: string]: unknown;
         };
+        name?: string;
     }[][];
     postExamples?: string[];
     topics?: string[];
@@ -3660,13 +3689,12 @@ declare const characterSchema: z.ZodObject<{
         path?: string;
     })[];
     username?: string;
-    name?: string;
     id?: string;
+    name?: string;
     system?: string;
     templates?: Record<string, string | ((...args: unknown[]) => unknown)>;
     bio?: string | string[];
     messageExamples?: {
-        name?: string;
         content?: {
             thought?: string;
             text?: string;
@@ -3681,6 +3709,7 @@ declare const characterSchema: z.ZodObject<{
         } & {
             [k: string]: unknown;
         };
+        name?: string;
     }[][];
     postExamples?: string[];
     topics?: string[];
@@ -4271,10 +4300,91 @@ declare function formatEntities({ entities }: {
     entities: Entity[];
 }): string;
 
-declare const createLogger: (bindings?: any | boolean) => pino.Logger<never, boolean>;
-declare let logger: pino.Logger<string, boolean>;
+/**
+ * Detects the current runtime environment (browser vs Node.js)
+ * Results are cached for performance
+ */
+declare function getEnvironment(): {
+    isBrowser: boolean;
+    isNode: boolean;
+};
+/**
+ * Clears the cached environment detection result
+ * Useful for testing or when environment changes
+ */
+declare function clearEnvironmentCache(): void;
+/**
+ * Checks if running in Node.js environment
+ */
+declare function isNodeEnv(): boolean;
+/**
+ * Checks if running in browser environment
+ */
+declare function isBrowserEnv(): boolean;
+/**
+ * Checks if process object is available
+ */
+declare function hasProcess(): boolean;
+/**
+ * Gets an environment variable value if process.env is available
+ */
+declare function getProcessEnv(key: string): string | undefined;
+declare const envDetector: {
+    getEnvironment: typeof getEnvironment;
+    clearCache: typeof clearEnvironmentCache;
+    isNode: typeof isNodeEnv;
+    isBrowser: typeof isBrowserEnv;
+    hasProcess: typeof hasProcess;
+    getProcessEnv: typeof getProcessEnv;
+};
+type LogFn = (obj: Record<string, unknown> | string | Error, msg?: string, ...args: unknown[]) => void;
+interface LoggerBindings extends Record<string, unknown> {
+    __forceType?: 'browser' | 'node';
+    level?: string;
+    maxMemoryLogs?: number;
+}
+interface Logger {
+    trace: LogFn;
+    debug: LogFn;
+    info: LogFn;
+    warn: LogFn;
+    error: LogFn;
+    fatal: LogFn;
+    success: LogFn;
+    progress: LogFn;
+    log: LogFn;
+    clear: () => void;
+    child: (bindings: Record<string, unknown>) => Logger;
+    level?: string;
+}
+/**
+ * Interface representing a log entry.
+ * @property time - The timestamp of the log entry
+ * @property level - The log level as a number or string
+ * @property msg - The log message content
+ * @property diagnostic - Flag indicating if this is a diagnostic log
+ * @property agentName - Name of the agent that created the log
+ * @property agentId - ID of the agent that created the log
+ * @property [key: string] - Additional properties that can be added to the log entry
+ */
+interface LogEntry {
+    time?: number;
+    level?: number | string;
+    msg?: string;
+    diagnostic?: boolean;
+    agentName?: string;
+    agentId?: string;
+    [key: string]: unknown;
+}
+declare function createLogger(bindings?: LoggerBindings | boolean): Logger;
+interface ElizaLogger extends Logger {
+    success: LogFn;
+    progress: LogFn;
+    log: LogFn;
+}
+declare const typedLogger: ElizaLogger;
 
-declare const elizaLogger: pino.Logger<string, boolean>;
+declare const elizaLogger: ElizaLogger;
 
 declare const shouldRespondTemplate = "<task>Decide on behalf of {{agentName}} whether they should respond to the message, ignore it or stop the conversation.</task>\n\n<providers>\n{{providers}}\n</providers>\n\n<instructions>Decide if {{agentName}} should respond to or interact with the conversation.\nIf the message is directed at or relevant to {{agentName}}, respond with RESPOND action.\nIf a user asks {{agentName}} to be quiet, respond with STOP action.\nIf {{agentName}} should ignore the message, respond with IGNORE action.</instructions>\n\n<output>\nDo NOT include any thinking, reasoning, or <think> sections in your response. \nGo directly to the XML response format without any preamble or explanation.\n\nRespond using XML format like this:\n<response>\n  <name>{{agentName}}</name>\n  <reasoning>Your reasoning here</reasoning>\n  <action>RESPOND | IGNORE | STOP</action>\n</response>\n\nIMPORTANT: Your response must ONLY contain the <response></response> XML block above. Do not include any text, thinking, or reasoning before or after this XML block. Start your response immediately with <response> and end with </response>.\n</output>";
 declare const messageHandlerTemplate = "<task>Generate dialog and actions for the character {{agentName}}.</task>\n\n<providers>\n{{providers}}\n</providers>\n\nThese are the available valid actions:\n<actionNames>\n{{actionNames}}\n</actionNames>\n\n<instructions>\nWrite a thought and plan for {{agentName}} and decide what actions to take. Also include the providers that {{agentName}} will use to have the right context for responding and acting, if any.\n\nIMPORTANT ACTION ORDERING RULES:\n- Actions are executed in the ORDER you list them - the order MATTERS!\n- REPLY should come FIRST to acknowledge the user's request before executing other actions\n- Common patterns:\n  - For requests requiring tool use: REPLY,CALL_MCP_TOOL (acknowledge first, then gather info)\n  - For task execution: REPLY,SEND_MESSAGE or REPLY,EVM_SWAP_TOKENS (acknowledge first, then do the task)\n  - For multi-step operations: REPLY,ACTION1,ACTION2 (acknowledge first, then complete all steps)\n- REPLY is used to acknowledge and inform the user about what you're going to do\n- Follow-up actions execute the actual tasks after acknowledgment\n- Use IGNORE only when you should not respond at all\n- If you use IGNORE, do not include any other actions. IGNORE should be used alone when you should not respond or take any actions.\n\nIMPORTANT PROVIDER SELECTION RULES:\n- Only include providers if they are needed to respond accurately.\n- If the message mentions images, photos, pictures, attachments, or visual content, OR if you see \"(Attachments:\" in the conversation, you MUST include \"ATTACHMENTS\" in your providers list\n- If the message asks about or references specific people, include \"ENTITIES\" in your providers list  \n- If the message asks about relationships or connections between people, include \"RELATIONSHIPS\" in your providers list\n- If the message asks about facts or specific information, include \"FACTS\" in your providers list\n- If the message asks about the environment or world context, include \"WORLD\" in your providers list\n- If no additional context is needed, you may leave the providers list empty.\n\nIMPORTANT CODE BLOCK FORMATTING RULES:\n- If {{agentName}} includes code examples, snippets, or multi-line code in the response, ALWAYS wrap the code with ``` fenced code blocks (specify the language if known, e.g., ```python).\n- ONLY use fenced code blocks for actual code. Do NOT wrap non-code text, instructions, or single words in fenced code blocks.\n- If including inline code (short single words or function names), use single backticks (`) as appropriate.\n- This ensures the user sees clearly formatted and copyable code when relevant.\n\nFirst, think about what you want to do next and plan your actions. Then, write the next message and include the actions you plan to take.\n</instructions>\n\n<keys>\n\"thought\" should be a short description of what the agent is thinking about and planning.\n\"actions\" should be a comma-separated list of the actions {{agentName}} plans to take based on the thought, IN THE ORDER THEY SHOULD BE EXECUTED (if none, use IGNORE, if simply responding with text, use REPLY)\n\"providers\" should be a comma-separated list of the providers that {{agentName}} will use to have the right context for responding and acting (NEVER use \"IGNORE\" as a provider - use specific provider names like ATTACHMENTS, ENTITIES, FACTS, KNOWLEDGE, etc.)\n\"text\" should be the text of the next message for {{agentName}} which they will send to the conversation.\n</keys>\n\n<output>\nDo NOT include any thinking, reasoning, or <think> sections in your response. \nGo directly to the XML response format without any preamble or explanation.\n\nRespond using XML format like this:\n<response>\n    <thought>Your thought here</thought>\n    <actions>ACTION1,ACTION2</actions>\n    <providers>PROVIDER1,PROVIDER2</providers>\n    <text>Your response text here</text>\n</response>\n\nIMPORTANT: Your response must ONLY contain the <response></response> XML block above. Do not include any text, thinking, or reasoning before or after this XML block. Start your response immediately with <response> and end with </response>.\n</output>";
@@ -4351,6 +4461,8 @@ declare class AgentRuntime implements IAgentRuntime {
     logger: any;
     private settings;
     private servicesInitQueue;
+    private servicePromiseHandles;
+    private servicePromises;
     private currentRunId?;
     private currentActionContext?;
     private maxWorkingMemoryEntries;
@@ -4454,6 +4566,8 @@ declare class AgentRuntime implements IAgentRuntime {
      */
     hasService(serviceType: ServiceTypeName | string): boolean;
     registerService(serviceDef: typeof Service): Promise<void>;
+    private _createServiceResolver;
+    getServiceLoadPromise(serviceType: ServiceTypeName): Promise<Service>;
     registerModel(modelType: ModelTypeName, handler: (params: any) => Promise<any>, provider: string, priority?: number): void;
     getModel(modelType: ModelTypeName, provider?: string): ((runtime: IAgentRuntime, params: any) => Promise<any>) | undefined;
     /**
@@ -4497,6 +4611,7 @@ declare class AgentRuntime implements IAgentRuntime {
     updateComponent(component: Component): Promise<void>;
     deleteComponent(componentId: UUID): Promise<void>;
     addEmbeddingToMemory(memory: Memory): Promise<Memory>;
+    queueEmbeddingGeneration(memory: Memory, priority?: 'high' | 'normal' | 'low'): Promise<void>;
     getMemories(params: {
         entityId?: UUID;
         agentId?: UUID;
@@ -4768,4 +4883,4 @@ interface ServiceDefinition<T extends Service = Service> {
  */
 declare function defineService<T extends Service = Service>(definition: ServiceDefinition<T>): new (runtime?: IAgentRuntime) => T;
 
-export { type Action, type ActionContext, type ActionEventPayload, type ActionExample, type ActionResult, type Agent, AgentRuntime, AgentStatus, type AudioProcessingParams, type BaseMetadata, type BaseModelParams, type BrowserNavigationOptions, CacheKeyPrefix, type ChannelClearedPayload, ChannelType, type Character, type CharacterValidationResult, type ChunkRow, type ClickOptions, type Component, type Content, ContentType, type ControlMessage, type CustomMetadata, DatabaseAdapter, type DbConnection, type DeriveKeyAttestationData, type DescriptionMetadata, type DetokenizeTextParams, type DirectoryItem, type DocumentMetadata, type ElementSelector, type EmailAccount, type EmailAddress, type EmailAttachment, type EmailFolder, type EmailMessage, type EmailSearchOptions, type EmailSendOptions, type EmbeddingSearchResult, type EnhancedState, type Entity, type EntityPayload, type EvaluationExample, type Evaluator, type EvaluatorEventPayload, type EventHandler, type EventPayload, type EventPayloadMap, EventType, type ExtractedContent, type FragmentMetadata, type GenerateTextParams, type Handler, type HandlerCallback, type IAgentRuntime, IBrowserService, type IDatabaseAdapter, IEmailService, ILpService, IMessageService, IPdfService, IPostService, ITokenDataService, ITranscriptionService, IVideoService, IWalletService, IWebSearchService, type ImageDescriptionParams, type ImageGenerationParams, type ImageSearchOptions, type InvokePayload, type IsValidServiceType, type JSONSchema, type KnowledgeItem, KnowledgeScope, type Log, type LpPositionDetails, MODEL_SETTINGS, type Media, type Memory, type MemoryMetadata, type MemoryRetrievalOptions, type MemoryScope, type MemorySearchOptions, MemoryType, type MemoryTypeAlias, type MessageAttachment, type MessageChannel, type MessageContent, type MessageExample, type MessageInfo, type MessageMemory, type MessageMetadata, type MessageParticipant, type MessagePayload, type MessageReaction, type MessageReceivedHandlerParams, type MessageReference, type MessageSearchOptions, type MessageSendOptions, type Metadata, type ModelEventPayload, type ModelHandler, type ModelParamsMap, type ModelResultMap, ModelType, type ModelTypeName, type MultiRoomMemoryOptions, type NewsSearchOptions, type ObjectGenerationParams, type OnboardingConfig, type Participant, type PdfConversionOptions, type PdfExtractionResult, type PdfGenerationOptions, PlatformPrefix, type Plugin, type PluginEvents, type PoolInfo, type PostAnalytics, type PostAuthor, type PostContent, type PostCreateOptions, type PostEngagement, type PostInfo, type PostLocation, type PostMedia, type PostSearchOptions, type Project, type ProjectAgent, type Provider, type ProviderResult, type Relationship, type RemoteAttestationMessage, type RemoteAttestationQuote, Role, type Room, type RoomMetadata, type Route, type RunEventPayload, type RuntimeSettings, SOCKET_MESSAGE_TYPE, type ScreenshotOptions, type SearchOptions, type SearchResponse, type SearchResult, Semaphore, type SendHandlerFunction, type ServerOwnershipState, Service, ServiceBuilder, type ServiceClassMap, type ServiceDefinition, type ServiceError, type ServiceInstance, type ServiceRegistry, ServiceType, type ServiceTypeName, type ServiceTypeRegistry, type ServiceTypeValue, type Setting, type SpeechToTextOptions, type State, type StateArray, type StateObject, type StateValue, TEEMode, type TargetInfo, type Task, type TaskMetadata, type TaskWorker, type TeeAgent, type TeePluginConfig, TeeType, type TemplateType, type TestCase, type TestSuite, type TextEmbeddingParams, type TextGenerationParams, type TextToSpeechOptions, type TextToSpeechParams, type TokenBalance, type TokenData, type TokenizeTextParams, type TransactionResult, type TranscriptionOptions, type TranscriptionParams, type TranscriptionResult, type TranscriptionSegment, type TranscriptionWord, type TypeOptions, type TypedEventHandler, type TypedService, type TypedServiceClass, type UUID, type UnifiedMemoryOptions, type UnifiedSearchOptions, VECTOR_DIMS, type Validator, type VideoDownloadOptions, type VideoFormat, type VideoInfo, type VideoProcessingOptions, type VideoProcessingParams, type VideoSearchOptions, type WalletAsset, type WalletPortfolio, type World, type WorldPayload, type WorldSettings, addHeader, asUUID, booleanFooter, characterSchema, composeActionExamples, composePrompt, composePromptFromState, createActionResult, createLogger, createMessageMemory, createService, createServiceError, createSettingFromConfig, createUniqueUuid, decryptObjectValues, decryptStringValue as decryptSecret, decryptStringValue, decryptedCharacter, defineService, elizaLogger, encryptObjectValues, encryptStringValue, encryptedCharacter, findEntityByName, findWorldsForOwner, formatActionNames, formatActions, formatEntities, formatMessages, formatPosts, formatTimestamp, getContentTypeFromMimeType, getEntityDetails, getLocalServerUrl, getMemoryText, getModelSpecificSettingKey, getSalt, getTypedService, getUserServerRole, getWorldSettings, imageDescriptionTemplate, initializeOnboarding, isCustomMetadata, isDescriptionMetadata, isDocumentMemory, isDocumentMetadata, isFragmentMemory, isFragmentMetadata, isMessageMetadata, isValidCharacter, logger, messageHandlerTemplate, normalizeJsonString, parseAndValidateCharacter, parseBooleanFromText, parseJSONObjectFromText, parseKeyValueXml, postCreationTemplate, safeReplacer, saltSettingValue, saltWorldSettings, shouldRespondTemplate, splitChunks, stringToUuid, trimTokens, truncateToCompleteSentence, unsaltSettingValue, unsaltWorldSettings, updateWorldSettings, validateCharacter, validateUuid };
+export { type Action, type ActionContext, type ActionEventPayload, type ActionExample, type ActionResult, type Agent, AgentRuntime, AgentStatus, type AudioProcessingParams, type BaseMetadata, type BaseModelParams, type BrowserNavigationOptions, CacheKeyPrefix, type ChannelClearedPayload, ChannelType, type Character, type CharacterValidationResult, type ChunkRow, type ClickOptions, type Component, type Content, ContentType, type ControlMessage, type CustomMetadata, DatabaseAdapter, type DbConnection, type DeriveKeyAttestationData, type DescriptionMetadata, type DetokenizeTextParams, type DirectoryItem, type DocumentMetadata, type ElementSelector, type ElizaLogger, type EmailAccount, type EmailAddress, type EmailAttachment, type EmailFolder, type EmailMessage, type EmailSearchOptions, type EmailSendOptions, type EmbeddingGenerationPayload, type EmbeddingSearchResult, type EnhancedState, type Entity, type EntityPayload, type EvaluationExample, type Evaluator, type EvaluatorEventPayload, type EventHandler, type EventPayload, type EventPayloadMap, EventType, type ExtractedContent, type FragmentMetadata, type GenerateTextParams, type Handler, type HandlerCallback, type IAgentRuntime, IBrowserService, type IDatabaseAdapter, IEmailService, ILpService, IMessageService, IPdfService, IPostService, ITokenDataService, ITranscriptionService, IVideoService, IWalletService, IWebSearchService, type ImageDescriptionParams, type ImageGenerationParams, type ImageSearchOptions, type InvokePayload, type IsValidServiceType, type JSONSchema, type KnowledgeItem, KnowledgeScope, type Log, type LogEntry, type Logger, type LoggerBindings, type LpPositionDetails, MODEL_SETTINGS, type Media, type Memory, type MemoryMetadata, type MemoryRetrievalOptions, type MemoryScope, type MemorySearchOptions, MemoryType, type MemoryTypeAlias, type MessageAttachment, type MessageChannel, type MessageContent, type MessageExample, type MessageInfo, type MessageMemory, type MessageMetadata, type MessageParticipant, type MessagePayload, type MessageReaction, type MessageReceivedHandlerParams, type MessageReference, type MessageSearchOptions, type MessageSendOptions, type Metadata, type ModelEventPayload, type ModelHandler, type ModelParamsMap, type ModelResultMap, ModelType, type ModelTypeName, type MultiRoomMemoryOptions, type NewsSearchOptions, type ObjectGenerationParams, type OnboardingConfig, type Participant, type PdfConversionOptions, type PdfExtractionResult, type PdfGenerationOptions, PlatformPrefix, type Plugin, type PluginEvents, type PoolInfo, type PostAnalytics, type PostAuthor, type PostContent, type PostCreateOptions, type PostEngagement, type PostInfo, type PostLocation, type PostMedia, type PostSearchOptions, type Project, type ProjectAgent, type Provider, type ProviderResult, type Relationship, type RemoteAttestationMessage, type RemoteAttestationQuote, Role, type Room, type RoomMetadata, type Route, type RunEventPayload, type RuntimeSettings, SOCKET_MESSAGE_TYPE, type ScreenshotOptions, type SearchOptions, type SearchResponse, type SearchResult, Semaphore, type SendHandlerFunction, type ServerOwnershipState, Service, ServiceBuilder, type ServiceClassMap, type ServiceDefinition, type ServiceError, type ServiceInstance, type ServiceRegistry, ServiceType, type ServiceTypeName, type ServiceTypeRegistry, type ServiceTypeValue, type Setting, type SpeechToTextOptions, type State, type StateArray, type StateObject, type StateValue, TEEMode, type TargetInfo, type Task, type TaskMetadata, type TaskWorker, type TeeAgent, type TeePluginConfig, TeeType, type TemplateType, type TestCase, type TestSuite, type TextEmbeddingParams, type TextGenerationParams, type TextToSpeechOptions, type TextToSpeechParams, type TokenBalance, type TokenData, type TokenizeTextParams, type TransactionResult, type TranscriptionOptions, type TranscriptionParams, type TranscriptionResult, type TranscriptionSegment, type TranscriptionWord, type TypeOptions, type TypedEventHandler, type TypedService, type TypedServiceClass, type UUID, type UnifiedMemoryOptions, type UnifiedSearchOptions, VECTOR_DIMS, type Validator, type VideoDownloadOptions, type VideoFormat, type VideoInfo, type VideoProcessingOptions, type VideoProcessingParams, type VideoSearchOptions, type WalletAsset, type WalletPortfolio, type World, type WorldPayload, type WorldSettings, addHeader, asUUID, booleanFooter, characterSchema, composeActionExamples, composePrompt, composePromptFromState, createActionResult, createLogger, createMessageMemory, createService, createServiceError, createSettingFromConfig, createUniqueUuid, decryptObjectValues, decryptStringValue as decryptSecret, decryptStringValue, decryptedCharacter, defineService, elizaLogger, encryptObjectValues, encryptStringValue, encryptedCharacter, envDetector, findEntityByName, findWorldsForOwner, formatActionNames, formatActions, formatEntities, formatMessages, formatPosts, formatTimestamp, getContentTypeFromMimeType, getEntityDetails, getLocalServerUrl, getMemoryText, getModelSpecificSettingKey, getSalt, getTypedService, getUserServerRole, getWorldSettings, imageDescriptionTemplate, initializeOnboarding, isCustomMetadata, isDescriptionMetadata, isDocumentMemory, isDocumentMetadata, isFragmentMemory, isFragmentMetadata, isMessageMetadata, isValidCharacter, typedLogger as logger, messageHandlerTemplate, normalizeJsonString, parseAndValidateCharacter, parseBooleanFromText, parseJSONObjectFromText, parseKeyValueXml, postCreationTemplate, safeReplacer, saltSettingValue, saltWorldSettings, shouldRespondTemplate, splitChunks, stringToUuid, trimTokens, truncateToCompleteSentence, unsaltSettingValue, unsaltWorldSettings, updateWorldSettings, validateCharacter, validateUuid };

package/dist/index.js

@@ -266,6 +266,9 @@ var EventType = /* @__PURE__ */ ((EventType2) => {
   EventType2["EVALUATOR_STARTED"] = "EVALUATOR_STARTED";
   EventType2["EVALUATOR_COMPLETED"] = "EVALUATOR_COMPLETED";
   EventType2["MODEL_USED"] = "MODEL_USED";
+  EventType2["EMBEDDING_GENERATION_REQUESTED"] = "EMBEDDING_GENERATION_REQUESTED";
+  EventType2["EMBEDDING_GENERATION_COMPLETED"] = "EMBEDDING_GENERATION_COMPLETED";
+  EventType2["EMBEDDING_GENERATION_FAILED"] = "EMBEDDING_GENERATION_FAILED";
   return EventType2;
 })(EventType || {});
 var PlatformPrefix = /* @__PURE__ */ ((PlatformPrefix2) => {
@@ -430,9 +433,6 @@ import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
 import { names, uniqueNamesGenerator } from "unique-names-generator";
 import { z } from "zod";
 
-// src/logger.ts
-import pino from "pino";
-
 // src/sentry/instrument.ts
 import * as Sentry from "@sentry/browser";
 var dsn = process.env.SENTRY_DSN || "https://c20e2d51b66c14a783b0689d536f7e5c@o4509349865259008.ingest.us.sentry.io/4509352524120064";
@@ -448,28 +448,115 @@ if (process.env.SENTRY_LOGGING !== "false") {
 }
 
 // src/logger.ts
+var cachedEnvironment = null;
+function getEnvironment() {
+  if (cachedEnvironment !== null) {
+    return cachedEnvironment;
+  }
+  const isBrowser = typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined" && typeof globalThis.document !== "undefined";
+  const isNode = typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node !== "undefined";
+  cachedEnvironment = { isBrowser, isNode };
+  return cachedEnvironment;
+}
+function clearEnvironmentCache() {
+  cachedEnvironment = null;
+}
+function isNodeEnv() {
+  return getEnvironment().isNode;
+}
+function isBrowserEnv() {
+  return getEnvironment().isBrowser;
+}
+function hasProcess() {
+  return typeof process !== "undefined";
+}
+function getProcessEnv(key) {
+  if (hasProcess() && process.env) {
+    return process.env[key];
+  }
+  return void 0;
+}
+var envDetector = {
+  getEnvironment,
+  clearCache: clearEnvironmentCache,
+  isNode: isNodeEnv,
+  isBrowser: isBrowserEnv,
+  hasProcess,
+  getProcessEnv
+};
 function parseBooleanFromText(value) {
   if (!value) return false;
   const normalized = value.toLowerCase().trim();
   return normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on";
 }
-var InMemoryDestination = class {
-  /**
-   * Constructor for creating a new instance of the class.
-   * @param {DestinationStream|null} stream - The stream to assign to the instance. Can be null.
-   */
-  constructor(stream) {
-    this.logs = [];
-    this.maxLogs = 1e3;
-    this.stream = stream;
+function getConsole() {
+  if (typeof globalThis !== "undefined" && globalThis.console) {
+    return globalThis.console;
   }
-  /**
-   * Writes a log entry to the memory buffer and forwards it to the pretty print stream if available.
-   *
-   * @param {string | LogEntry} data - The data to be written, which can be either a string or a LogEntry object.
-   * @returns {void}
-   */
-  write(data) {
+  if (typeof console !== "undefined") {
+    return console;
+  }
+  return null;
+}
+function safeStringify(obj) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.stringify(obj, (_key, value) => {
+      if (typeof value === "object" && value !== null) {
+        if (seen.has(value)) {
+          return "[Circular]";
+        }
+        seen.add(value);
+      }
+      return value;
+    });
+  } catch (error) {
+    return String(obj);
+  }
+}
+var moduleCache = {};
+function loadPinoSync() {
+  if (moduleCache.pino) {
+    return moduleCache.pino;
+  }
+  try {
+    const module = __require("pino");
+    moduleCache.pino = module;
+    return module;
+  } catch (error) {
+    throw new Error(`Failed to load Pino: ${error.message}`);
+  }
+}
+function loadPinoPrettySync() {
+  if (moduleCache.pinoPretty) {
+    return moduleCache.pinoPretty;
+  }
+  try {
+    const module = __require("pino-pretty");
+    moduleCache.pinoPretty = module;
+    return module;
+  } catch (error) {
+    return null;
+  }
+}
+var PINO_DESTINATION_SYMBOL = Symbol.for("pino-destination");
+var DEFAULT_MAX_MEMORY_LOGS = 1e3;
+var getMaxMemoryLogs = () => {
+  if (envDetector.hasProcess()) {
+    const envValue = envDetector.getProcessEnv("LOG_MAX_MEMORY_SIZE");
+    if (envValue) {
+      const parsed = parseInt(envValue, 10);
+      if (!isNaN(parsed) && parsed > 0) {
+        return parsed;
+      }
+    }
+  }
+  return DEFAULT_MAX_MEMORY_LOGS;
+};
+function createInMemoryDestination(stream, maxLogs) {
+  let logs = [];
+  const maxLogsLimit = maxLogs ?? getMaxMemoryLogs();
+  const write = (data) => {
     let logEntry;
     let stringData;
     if (typeof data === "string") {
@@ -477,20 +564,20 @@ var InMemoryDestination = class {
       try {
         logEntry = JSON.parse(data);
       } catch (e) {
-        if (this.stream) {
-          this.stream.write(data);
+        if (stream) {
+          stream.write(data);
         }
         return;
       }
     } else {
       logEntry = data;
-      stringData = JSON.stringify(data);
+      stringData = safeStringify(data);
     }
     if (!logEntry.time) {
       logEntry.time = Date.now();
     }
-    const isDebugMode2 = (process?.env?.LOG_LEVEL || "").toLowerCase() === "debug";
-    const isLoggingDiagnostic = Boolean(process?.env?.LOG_DIAGNOSTIC);
+    const isDebugMode2 = envDetector.hasProcess() && (envDetector.getProcessEnv("LOG_LEVEL") || "").toLowerCase() === "debug";
+    const isLoggingDiagnostic = envDetector.hasProcess() && Boolean(envDetector.getProcessEnv("LOG_DIAGNOSTIC"));
     if (isLoggingDiagnostic) {
       logEntry.diagnostic = true;
     }
@@ -499,37 +586,162 @@ var InMemoryDestination = class {
         const msg = logEntry.msg || "";
         if (typeof msg === "string" && (msg.includes("registered successfully") || msg.includes("Registering") || msg.includes("Success:") || msg.includes("linked to") || msg.includes("Started"))) {
           if (isLoggingDiagnostic) {
-            console.error("Filtered log:", stringData);
+            const consoleObj = getConsole();
+            if (consoleObj && consoleObj.error) {
+              consoleObj.error("Filtered log:", stringData);
+            }
           }
           return;
         }
       }
     }
-    this.logs.push(logEntry);
-    if (this.logs.length > this.maxLogs) {
-      this.logs.shift();
+    logs.push(logEntry);
+    if (logs.length > maxLogsLimit) {
+      logs.shift();
     }
-    if (this.stream) {
-      this.stream.write(stringData);
+    if (stream) {
+      stream.write(stringData);
     }
-  }
-  /**
-   * Retrieves the recent logs from the system.
-   *
-   * @returns {LogEntry[]} An array of LogEntry objects representing the recent logs.
-   */
-  recentLogs() {
-    return this.logs;
-  }
-  /**
-   * Clears all logs from memory.
-   *
-   * @returns {void}
-   */
-  clear() {
-    this.logs = [];
-  }
+  };
+  const recentLogs = () => logs;
+  const clear = () => {
+    logs = [];
+  };
+  return {
+    write,
+    recentLogs,
+    clear
+  };
+}
+var levelValues = {
+  fatal: 60,
+  error: 50,
+  warn: 40,
+  info: 30,
+  log: 29,
+  progress: 28,
+  success: 27,
+  debug: 20,
+  trace: 10
 };
+function createBrowserLogger(options2 = {}) {
+  const inMemoryDestination = createInMemoryDestination(null, options2.maxMemoryLogs);
+  const level = options2.level || "info";
+  const currentLevel = levelValues[level] || 30;
+  const bindings = options2.base || {};
+  const shouldLog = (logLevel) => {
+    const levelValue = levelValues[logLevel] || 30;
+    return levelValue >= currentLevel;
+  };
+  const getConsoleMethod = (logLevel) => {
+    const consoleObj = getConsole();
+    if (!consoleObj) {
+      return () => {
+      };
+    }
+    const fallback = consoleObj.log ? consoleObj.log.bind(consoleObj) : () => {
+    };
+    switch (logLevel) {
+      case "trace":
+      case "debug":
+        return consoleObj.debug ? consoleObj.debug.bind(consoleObj) : fallback;
+      case "info":
+      case "log":
+      case "progress":
+      case "success":
+        return consoleObj.info ? consoleObj.info.bind(consoleObj) : fallback;
+      case "warn":
+        return consoleObj.warn ? consoleObj.warn.bind(consoleObj) : fallback;
+      case "error":
+      case "fatal":
+        return consoleObj.error ? consoleObj.error.bind(consoleObj) : fallback;
+      default:
+        return fallback;
+    }
+  };
+  const formatMessage = (logLevel, obj, msg, ...args) => {
+    if (!shouldLog(logLevel)) return;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const levelLabel = logLevel.toUpperCase();
+    const logEntry = {
+      time: Date.now(),
+      level: levelValues[logLevel],
+      msg: "",
+      ...bindings
+    };
+    let messageStr = "";
+    let contextObj = {};
+    if (typeof obj === "string") {
+      messageStr = obj;
+      if (msg) {
+        messageStr += " " + msg;
+      }
+      if (args.length > 0) {
+        messageStr += " " + args.map((a) => typeof a === "object" ? safeStringify(a) : String(a)).join(" ");
+      }
+    } else if (obj instanceof Error) {
+      contextObj = { error: { message: obj.message, stack: obj.stack } };
+      messageStr = msg || obj.message;
+    } else if (typeof obj === "object" && obj !== null) {
+      contextObj = obj;
+      messageStr = msg || "";
+      if (args.length > 0) {
+        messageStr += " " + args.map((a) => typeof a === "object" ? safeStringify(a) : String(a)).join(" ");
+      }
+    }
+    Object.assign(logEntry, contextObj);
+    logEntry.msg = messageStr;
+    inMemoryDestination.write(logEntry);
+    const prefix = `[${timestamp}] ${levelLabel}:`;
+    const hasContext = Object.keys(contextObj).length > 0;
+    const consoleMethod = getConsoleMethod(logLevel);
+    if (hasContext) {
+      if (messageStr) {
+        consoleMethod(prefix, messageStr, contextObj);
+      } else {
+        consoleMethod(prefix, contextObj);
+      }
+    } else if (messageStr) {
+      consoleMethod(prefix, messageStr);
+    }
+    if (envDetector.hasProcess() && envDetector.getProcessEnv("SENTRY_LOGGING") !== "false") {
+      if (obj instanceof Error || logLevel === "error" || logLevel === "fatal") {
+        const error = obj instanceof Error ? obj : new Error(messageStr);
+        Sentry.captureException(error);
+      }
+    }
+  };
+  const createLogMethod = (level2) => (obj, msg, ...args) => {
+    formatMessage(level2, obj, msg, ...args);
+  };
+  const clear = () => {
+    inMemoryDestination.clear();
+    const consoleObj = getConsole();
+    if (consoleObj && consoleObj.clear) {
+      consoleObj.clear();
+    }
+  };
+  const child = (childBindings) => {
+    return createBrowserLogger({
+      level,
+      base: { ...bindings, ...childBindings }
+    });
+  };
+  return {
+    level,
+    trace: createLogMethod("trace"),
+    debug: createLogMethod("debug"),
+    info: createLogMethod("info"),
+    warn: createLogMethod("warn"),
+    error: createLogMethod("error"),
+    fatal: createLogMethod("fatal"),
+    success: createLogMethod("success"),
+    progress: createLogMethod("progress"),
+    log: createLogMethod("log"),
+    clear,
+    child
+  };
+}
 var customLevels = {
   fatal: 60,
   error: 50,
@@ -541,10 +753,28 @@ var customLevels = {
   debug: 20,
   trace: 10
 };
-var raw = parseBooleanFromText(process?.env?.LOG_JSON_FORMAT) || false;
-var isDebugMode = (process?.env?.LOG_LEVEL || "").toLowerCase() === "debug";
-var effectiveLogLevel = isDebugMode ? "debug" : process?.env?.DEFAULT_LOG_LEVEL || "info";
-var showTimestamps = process?.env?.LOG_TIMESTAMPS !== void 0 ? parseBooleanFromText(process?.env?.LOG_TIMESTAMPS) : true;
+var raw = envDetector.hasProcess() ? parseBooleanFromText(envDetector.getProcessEnv("LOG_JSON_FORMAT")) || false : false;
+var isDebugMode = envDetector.hasProcess() ? (envDetector.getProcessEnv("LOG_LEVEL") || "").toLowerCase() === "debug" : false;
+var effectiveLogLevel = isDebugMode ? "debug" : (envDetector.hasProcess() ? envDetector.getProcessEnv("DEFAULT_LOG_LEVEL") : null) || "info";
+var showTimestamps = envDetector.hasProcess() && envDetector.getProcessEnv("LOG_TIMESTAMPS") !== void 0 ? parseBooleanFromText(envDetector.getProcessEnv("LOG_TIMESTAMPS")) : true;
+function extractBindingsConfig(bindings) {
+  let level = effectiveLogLevel;
+  let base = {};
+  let forceType;
+  let maxMemoryLogs;
+  if (typeof bindings === "object" && bindings !== null) {
+    forceType = bindings.__forceType;
+    if ("level" in bindings) {
+      level = bindings.level;
+    }
+    if ("maxMemoryLogs" in bindings && typeof bindings.maxMemoryLogs === "number") {
+      maxMemoryLogs = bindings.maxMemoryLogs;
+    }
+    const { level: _, __forceType: __, maxMemoryLogs: ___, ...rest } = bindings;
+    base = rest;
+  }
+  return { level, base, forceType, maxMemoryLogs };
+}
 var createPrettyConfig = () => ({
   colorize: true,
   translateTime: showTimestamps ? "yyyy-mm-dd HH:MM:ss" : false,
@@ -575,7 +805,8 @@ var createPrettyConfig = () => ({
     level: (inputData) => {
       let level;
       if (typeof inputData === "object" && inputData !== null) {
-        level = inputData.level || inputData.value;
+        const data = inputData;
+        level = data.level || data.value;
       } else {
         level = inputData;
       }
@@ -605,21 +836,14 @@ var createPrettyConfig = () => ({
   },
   messageFormat: "{msg}"
 });
-var createStream = async () => {
-  if (raw) {
-    return void 0;
-  }
-  const pretty = await import("pino-pretty");
-  return pretty.default(createPrettyConfig());
-};
 var options = {
   level: effectiveLogLevel,
   // Use more restrictive level unless in debug mode
   customLevels,
   hooks: {
-    logMethod(inputArgs, method) {
+    logMethod: function(inputArgs, method) {
       const [arg1, ...rest] = inputArgs;
-      if (process.env.SENTRY_LOGGING !== "false") {
+      if (envDetector.hasProcess() && envDetector.getProcessEnv("SENTRY_LOGGING") !== "false") {
         if (arg1 instanceof Error) {
           Sentry.captureException(arg1);
         } else {
@@ -636,17 +860,15 @@ var options = {
       });
       if (typeof arg1 === "object") {
         if (arg1 instanceof Error) {
-          method.apply(this, [
-            {
-              error: formatError(arg1)
-            }
-          ]);
+          method.call(this, {
+            error: formatError(arg1)
+          });
         } else {
           const messageParts = rest.map(
-            (arg) => typeof arg === "string" ? arg : JSON.stringify(arg)
+            (arg) => typeof arg === "string" ? arg : safeStringify(arg)
           );
           const message = messageParts.join(" ");
-          method.apply(this, [arg1, message]);
+          method.call(this, arg1, message);
         }
       } else {
         const context = {};
@@ -659,63 +881,69 @@ var options = {
         const message = messageParts.filter((part) => typeof part === "string").join(" ");
         const jsonParts = messageParts.filter((part) => typeof part === "object");
         Object.assign(context, ...jsonParts);
-        method.apply(this, [context, message]);
+        method.call(this, context, message);
       }
     }
   }
 };
-var createLogger = (bindings = false) => {
-  const opts = { ...options };
-  if (bindings) {
-    opts.base = bindings;
-    opts.transport = {
-      target: "pino-pretty",
-      // this is just a string, not a dynamic import
-      options: {
-        colorize: true,
-        translateTime: showTimestamps ? "SYS:standard" : false,
-        ignore: showTimestamps ? "pid,hostname" : "pid,hostname,time"
-      }
-    };
-  }
-  const logger2 = pino(opts);
-  return logger2;
-};
-var logger = pino(options);
-if (typeof process !== "undefined") {
-  let stream = null;
-  if (!raw) {
+function createLogger(bindings = false) {
+  const { level, base, forceType, maxMemoryLogs } = extractBindingsConfig(bindings);
+  if (forceType === "browser") {
+    const opts2 = { level, base };
+    return createBrowserLogger(opts2);
+  }
+  const { isBrowser, isNode } = getEnvironment();
+  if (isBrowser) {
+    const opts2 = { level, base };
+    return createBrowserLogger(opts2);
+  }
+  if (isNode) {
     try {
-      const pretty = __require("pino-pretty");
-      stream = pretty.default ? pretty.default(createPrettyConfig()) : null;
-    } catch (e) {
-      createStream().then((prettyStream) => {
-        const destination = new InMemoryDestination(prettyStream);
-        logger = pino(options, destination);
-        logger[Symbol.for("pino-destination")] = destination;
-        logger.clear = () => {
-          const destination2 = logger[Symbol.for("pino-destination")];
-          if (destination2 instanceof InMemoryDestination) {
-            destination2.clear();
-          }
-        };
-      });
-    }
-  }
-  if (stream !== null || raw) {
-    const destination = new InMemoryDestination(stream);
-    logger = pino(options, destination);
-    logger[Symbol.for("pino-destination")] = destination;
-    logger.clear = () => {
-      const destination2 = logger[Symbol.for("pino-destination")];
-      if (destination2 instanceof InMemoryDestination) {
-        destination2.clear();
+      const Pino = loadPinoSync();
+      const opts2 = { ...options };
+      opts2.base = base;
+      let stream = null;
+      if (!raw) {
+        const pretty = loadPinoPrettySync();
+        if (pretty) {
+          stream = pretty(createPrettyConfig());
+        }
       }
-    };
+      const destination = createInMemoryDestination(stream, maxMemoryLogs);
+      const pinoLogger = Pino(opts2, destination);
+      pinoLogger[PINO_DESTINATION_SYMBOL] = destination;
+      pinoLogger.clear = () => {
+        const dest = pinoLogger[PINO_DESTINATION_SYMBOL];
+        if (dest && typeof dest.clear === "function") {
+          dest.clear();
+        }
+      };
+      if (!pinoLogger.success) {
+        pinoLogger.success = pinoLogger.info.bind(pinoLogger);
+      }
+      if (!pinoLogger.progress) {
+        pinoLogger.progress = pinoLogger.info.bind(pinoLogger);
+      }
+      if (!pinoLogger.log) {
+        pinoLogger.log = pinoLogger.info.bind(pinoLogger);
+      }
+      return pinoLogger;
+    } catch (error) {
+      const consoleObj = getConsole();
+      if (consoleObj && consoleObj.warn) {
+        consoleObj.warn("Pino not available, falling back to BrowserLogger:", error);
+      }
+      const opts2 = { level, base };
+      return createBrowserLogger(opts2);
+    }
   }
+  const opts = { level, base };
+  return createBrowserLogger(opts);
 }
-var elizaLogger = logger;
-var logger_default = logger;
+var logger = createLogger(false);
+var typedLogger = logger;
+var elizaLogger = typedLogger;
+var logger_default = typedLogger;
 
 // src/utils.ts
 function upgradeDoubleToTriple(tpl) {
@@ -1414,7 +1642,7 @@ async function getRecentInteractions(runtime, sourceEntityId, candidateEntities,
 async function findEntityByName(runtime, message, state) {
   const room = state.data.room ?? await runtime.getRoom(message.roomId);
   if (!room) {
-    logger.warn("Room not found for entity search");
+    typedLogger.warn("Room not found for entity search");
     return null;
   }
   const world = room.worldId ? await runtime.getWorld(room.worldId) : null;
@@ -1471,7 +1699,7 @@ async function findEntityByName(runtime, message, state) {
   });
   const resolution = parseKeyValueXml(result);
   if (!resolution) {
-    logger.warn("Failed to parse entity resolution result");
+    typedLogger.warn("Failed to parse entity resolution result");
     return null;
   }
   if (resolution.type === "EXACT_MATCH" && resolution.entityId) {
@@ -1749,12 +1977,12 @@ async function getUserServerRole(runtime, entityId, serverId) {
 }
 async function findWorldsForOwner(runtime, entityId) {
   if (!entityId) {
-    logger.error("User ID is required to find server");
+    typedLogger.error("User ID is required to find server");
     return null;
   }
   const worlds = await runtime.getAllWorlds();
   if (!worlds || worlds.length === 0) {
-    logger.info("No worlds found for this agent");
+    typedLogger.info("No worlds found for this agent");
     return null;
   }
   const ownerWorlds = [];
@@ -2821,6 +3049,9 @@ var AgentRuntime = class {
     // The initial list of plugins specified by the character configuration.
     this.characterPlugins = [];
     this.servicesInitQueue = /* @__PURE__ */ new Set();
+    this.servicePromiseHandles = /* @__PURE__ */ new Map();
+    // write
+    this.servicePromises = /* @__PURE__ */ new Map();
     this.maxWorkingMemoryEntries = 50;
     this.agentId = opts.character?.id ?? opts?.agentId ?? stringToUuid(opts.character?.name ?? uuidv4() + opts.character?.username);
     this.character = opts.character;
@@ -2958,6 +3189,9 @@ var AgentRuntime = class {
     }
     if (plugin.services) {
       for (const service of plugin.services) {
+        if (!this.servicePromises.has(service.serviceType)) {
+          this._createServiceResolver(service.serviceType);
+        }
         if (this.isInitialized) {
           await this.registerService(service);
         } else {
@@ -3136,18 +3370,19 @@ var AgentRuntime = class {
     this.logger.debug(`Success: Provider ${provider.name} registered successfully.`);
   }
   registerAction(action) {
-    this.logger.debug(
-      `${this.character.name}(${this.agentId}) - Registering action: ${action.name}`
-    );
     if (this.actions.find((a) => a.name === action.name)) {
       this.logger.warn(
         `${this.character.name}(${this.agentId}) - Action ${action.name} already exists. Skipping registration.`
       );
     } else {
-      this.actions.push(action);
-      this.logger.debug(
-        `${this.character.name}(${this.agentId}) - Action ${action.name} registered successfully.`
-      );
+      try {
+        this.actions.push(action);
+        this.logger.success(
+          `${this.character.name}(${this.agentId}) - Action ${action.name} registered successfully.`
+        );
+      } catch (e) {
+        console.error("Error registering action", e);
+      }
     }
   }
   registerEvaluator(evaluator) {
@@ -3630,7 +3865,10 @@ var AgentRuntime = class {
         "connections in",
         firstRoom.id
       );
-      await this.addParticipantsRoom(missingIdsInRoom, firstRoom.id);
+      const batches = chunkArray(missingIdsInRoom, 5e3);
+      for (const batch of batches) {
+        await this.addParticipantsRoom(batch, firstRoom.id);
+      }
     }
     this.logger.success(`Success: Successfully connected world`);
   }
@@ -3965,6 +4203,14 @@ var AgentRuntime = class {
       }
       this.services.get(serviceType).push(serviceInstance);
       this.serviceTypes.get(serviceType).push(serviceDef);
+      const resolve = this.servicePromiseHandles.get(serviceType);
+      if (resolve) {
+        resolve(serviceInstance);
+      } else {
+        this.logger.debug(
+          `${this.character.name} - Service ${serviceType} has no servicePromiseHandle`
+        );
+      }
       if (typeof serviceDef.registerSendHandlers === "function") {
         serviceDef.registerSendHandlers(this, serviceInstance);
       }
@@ -3979,6 +4225,29 @@ var AgentRuntime = class {
       throw error;
     }
   }
+  /// ensures servicePromises & servicePromiseHandles for a serviceType
+  _createServiceResolver(serviceType) {
+    let resolver;
+    this.servicePromises.set(
+      serviceType,
+      new Promise((resolve) => {
+        resolver = resolve;
+      })
+    );
+    if (!resolver) {
+      throw new Error(`Failed to create resolver for service ${serviceType}`);
+    }
+    this.servicePromiseHandles.set(serviceType, resolver);
+    return this.servicePromises.get(serviceType);
+  }
+  /// returns a promise that's resolved once this service is loaded
+  getServiceLoadPromise(serviceType) {
+    let p = this.servicePromises.get(serviceType);
+    if (!p) {
+      p = this._createServiceResolver(serviceType);
+    }
+    return p;
+  }
   registerModel(modelType, handler, provider, priority) {
     const modelKey = typeof modelType === "string" ? modelType : ModelType[modelType];
     if (!this.models.has(modelKey)) {
@@ -4338,6 +4607,26 @@ var AgentRuntime = class {
     }
     return memory;
   }
+  async queueEmbeddingGeneration(memory, priority = "normal") {
+    if (!memory) {
+      return;
+    }
+    if (memory.embedding) {
+      return;
+    }
+    if (!memory.content?.text) {
+      this.logger.debug("Skipping embedding generation for memory without text content");
+      return;
+    }
+    await this.emitEvent("EMBEDDING_GENERATION_REQUESTED" /* EMBEDDING_GENERATION_REQUESTED */, {
+      runtime: this,
+      memory,
+      priority,
+      source: "runtime",
+      retryCount: 0,
+      maxRetries: 3
+    });
+  }
   async getMemories(params) {
     return await this.adapter.getMemories(params);
   }
@@ -4640,23 +4929,22 @@ function createSettingFromConfig(configSetting) {
 function getSalt() {
   const secretSalt = (typeof process !== "undefined" ? process.env.SECRET_SALT : import.meta.env.SECRET_SALT) || "secretsalt";
   if (!secretSalt) {
-    logger.error("SECRET_SALT is not set");
+    typedLogger.error("SECRET_SALT is not set");
   }
   const salt = secretSalt;
-  logger.debug(`Generated salt with length: ${salt.length} (truncated for security)`);
   return salt;
 }
 function encryptStringValue(value, salt) {
   if (value === void 0 || value === null) {
-    logger.debug("Attempted to encrypt undefined or null value");
+    typedLogger.debug("Attempted to encrypt undefined or null value");
     return value;
   }
   if (typeof value === "boolean" || typeof value === "number") {
-    logger.debug("Value is a boolean or number, returning as is");
+    typedLogger.debug("Value is a boolean or number, returning as is");
     return value;
   }
   if (typeof value !== "string") {
-    logger.debug(`Value is not a string (type: ${typeof value}), returning as is`);
+    typedLogger.debug(`Value is not a string (type: ${typeof value}), returning as is`);
     return value;
   }
   const parts = value.split(":");
@@ -4664,7 +4952,7 @@ function encryptStringValue(value, salt) {
     try {
       const possibleIv = Buffer.from(parts[0], "hex");
       if (possibleIv.length === 16) {
-        logger.debug("Value appears to be already encrypted, skipping re-encryption");
+        typedLogger.debug("Value appears to be already encrypted, skipping re-encryption");
         return value;
       }
     } catch (e) {
@@ -4686,7 +4974,7 @@ function decryptStringValue(value, salt) {
       return value;
     }
     if (typeof value !== "string") {
-      logger.debug(`Value is not a string (type: ${typeof value}), returning as is`);
+      typedLogger.debug(`Value is not a string (type: ${typeof value}), returning as is`);
       return value;
     }
     const parts = value.split(":");
@@ -4697,7 +4985,7 @@ function decryptStringValue(value, salt) {
     const encrypted = parts[1];
     if (iv.length !== 16) {
       if (iv.length) {
-        logger.debug(`Invalid IV length (${iv.length}) - expected 16 bytes`);
+        typedLogger.debug(`Invalid IV length (${iv.length}) - expected 16 bytes`);
       }
       return value;
     }
@@ -4707,7 +4995,7 @@ function decryptStringValue(value, salt) {
     decrypted += decipher.final("utf8");
     return decrypted;
   } catch (error) {
-    logger.error(`Error decrypting value: ${error}`);
+    typedLogger.error(`Error decrypting value: ${error}`);
     return value;
   }
 }
@@ -4743,7 +5031,7 @@ async function updateWorldSettings(runtime, serverId, worldSettings) {
   const worldId = createUniqueUuid(runtime, serverId);
   const world = await runtime.getWorld(worldId);
   if (!world) {
-    logger.error(`No world found for server ${serverId}`);
+    typedLogger.error(`No world found for server ${serverId}`);
     return false;
   }
   if (!world.metadata) {
@@ -4767,7 +5055,7 @@ async function getWorldSettings(runtime, serverId) {
 }
 async function initializeOnboarding(runtime, world, config) {
   if (world.metadata?.settings) {
-    logger.info(`Onboarding state already exists for server ${world.serverId}`);
+    typedLogger.info(`Onboarding state already exists for server ${world.serverId}`);
     const saltedSettings = world.metadata.settings;
     const salt = getSalt();
     return unsaltWorldSettings(saltedSettings, salt);
@@ -4783,7 +5071,7 @@ async function initializeOnboarding(runtime, world, config) {
   }
   world.metadata.settings = worldSettings;
   await runtime.updateWorld(world);
-  logger.info(`Initialized settings config for server ${world.serverId}`);
+  typedLogger.info(`Initialized settings config for server ${world.serverId}`);
   return worldSettings;
 }
 function encryptedCharacter(character) {
@@ -4951,6 +5239,7 @@ export {
   encryptObjectValues,
   encryptStringValue,
   encryptedCharacter,
+  envDetector,
   findEntityByName,
   findWorldsForOwner,
   formatActionNames,
@@ -4978,7 +5267,7 @@ export {
   isFragmentMetadata,
   isMessageMetadata,
   isValidCharacter,
-  logger,
+  typedLogger as logger,
   messageHandlerTemplate,
   normalizeJsonString,
   parseAndValidateCharacter,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elizaos/core",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -63,5 +63,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "f60dd270910361decc4d4e879e8b2f33c5ddfee2"
+  "gitHead": "670462dd40d05b9b364e9db6eadfff8403f18fdc"
 }