this is maybe the wrong way to do this, committing

agent/src/cache.ts

@@ -9,7 +9,7 @@ import {
     CacheStore,
     type Character,
     DbCacheAdapter,
-    elizaLogger,
+    logger,
     FsCacheAdapter,
     type IDatabaseCacheAdapter
 } from "@elizaos/core"
@@ -37,7 +37,7 @@ export function initializeCache(cacheStore: string, character: Character, baseDi
 	switch (cacheStore) {
 		case CacheStore.REDIS:
 			if (process.env.REDIS_URL) {
-				elizaLogger.info("Connecting to Redis...")
+				logger.info("Connecting to Redis...")
 				const redisClient = new RedisClient(process.env.REDIS_URL)
 				if (!character?.id) {
 					throw new Error("CacheStore.REDIS requires id to be set in character definition")
@@ -51,14 +51,14 @@ export function initializeCache(cacheStore: string, character: Character, baseDi
 
 		case CacheStore.DATABASE:
 			if (db) {
-				elizaLogger.info("Using Database Cache...")
+				logger.info("Using Database Cache...")
 				return initializeDbCache(character, db)
 			} else {
 				throw new Error("Database adapter is not provided for CacheStore.Database.")
 			}
 
 		case CacheStore.FILESYSTEM:
-			elizaLogger.info("Using File System Cache...")
+			logger.info("Using File System Cache...")
 			if (!baseDir) {
 				throw new Error("baseDir must be provided for CacheStore.FILESYSTEM.")
 			}

agent/src/characters.ts

@@ -6,7 +6,7 @@
 import {
     type Character,
     defaultCharacter,
-    elizaLogger,
+    logger,
     validateCharacterConfig
 } from "@elizaos/core"
 import { onchainJson } from "@elizaos/plugin-iq6900"
@@ -38,7 +38,7 @@ export function parseArguments(): {
 			})
 			.parseSync()
 	} catch (error) {
-		elizaLogger.error("Error parsing arguments:", error)
+		logger.error("Error parsing arguments:", error)
 		return {}
 	}
 }
@@ -102,7 +102,7 @@ export async function loadCharacterFromOnchain(): Promise<Character[]> {
 
 		// Handle plugins
 		if (isAllStrings(character.plugins)) {
-			elizaLogger.info("Plugins are: ", character.plugins)
+			logger.info("Plugins are: ", character.plugins)
 			const importedPlugins = await Promise.all(
 				character.plugins.map(async (plugin) => {
 					const importedPlugin = await import(plugin)
@@ -113,10 +113,10 @@ export async function loadCharacterFromOnchain(): Promise<Character[]> {
 		}
 
 		loadedCharacters.push(character)
-		elizaLogger.info(`Successfully loaded character from: ${process.env.IQ_WALLET_ADDRESS}`)
+		logger.info(`Successfully loaded character from: ${process.env.IQ_WALLET_ADDRESS}`)
 		return loadedCharacters
 	} catch (e) {
-		elizaLogger.error(`Error parsing character from ${process.env.IQ_WALLET_ADDRESS}: ${e}`)
+		logger.error(`Error parsing character from ${process.env.IQ_WALLET_ADDRESS}: ${e}`)
 		process.exit(1)
 	}
 }
@@ -135,7 +135,7 @@ async function loadCharactersFromUrl(url: string): Promise<Character[]> {
 		}
 		return characters
 	} catch (e) {
-		elizaLogger.error(`Error loading character(s) from ${url}: ${e}`)
+		logger.error(`Error loading character(s) from ${url}: ${e}`)
 		process.exit(1)
 	}
 }
@@ -162,11 +162,11 @@ export async function jsonToCharacter(filePath: string, character: any): Promise
 	// Handle plugins
 	character.plugins = await handlePluginImporting(character.plugins)
 	if (character.extends) {
-		elizaLogger.info(`Merging  ${character.name} character with parent characters`)
+		logger.info(`Merging  ${character.name} character with parent characters`)
 		for (const extendPath of character.extends) {
 			const baseCharacter = await loadCharacter(path.resolve(path.dirname(filePath), extendPath))
 			character = mergeCharacters(baseCharacter, character)
-			elizaLogger.info(`Merged ${character.name} with ${baseCharacter.name}`)
+			logger.info(`Merged ${character.name} with ${baseCharacter.name}`)
 		}
 	}
 	return character
@@ -196,7 +196,7 @@ export async function loadCharacterTryPath(characterPath: string): Promise<Chara
 		path.resolve(__dirname, "../../characters", path.basename(characterPath)), // relative to project root characters dir
 	]
 
-	elizaLogger.info(
+	logger.info(
 		"Trying paths:",
 		pathsToTry.map((p) => ({
 			path: p,
@@ -213,17 +213,17 @@ export async function loadCharacterTryPath(characterPath: string): Promise<Chara
 	}
 
 	if (content === null) {
-		elizaLogger.error(`Error loading character from ${characterPath}: File not found in any of the expected locations`)
-		elizaLogger.error("Tried the following paths:")
-		pathsToTry.forEach((p) => elizaLogger.error(` - ${p}`))
+		logger.error(`Error loading character from ${characterPath}: File not found in any of the expected locations`)
+		logger.error("Tried the following paths:")
+		pathsToTry.forEach((p) => logger.error(` - ${p}`))
 		throw new Error(`Error loading character from ${characterPath}: File not found in any of the expected locations`)
 	}
 	try {
 		const character: Character = await loadCharacter(resolvedPath)
-		elizaLogger.info(`Successfully loaded character from: ${resolvedPath}`)
+		logger.info(`Successfully loaded character from: ${resolvedPath}`)
 		return character
 	} catch (e) {
-		elizaLogger.error(`Error parsing character from ${resolvedPath}: ${e}`)
+		logger.error(`Error parsing character from ${resolvedPath}: ${e}`)
 		throw new Error(`Error parsing character from ${resolvedPath}: ${e}`)
 	}
 }
@@ -241,7 +241,7 @@ async function readCharactersFromStorage(characterPaths: string[]): Promise<stri
 			characterPaths.push(path.join(uploadDir, fileName))
 		})
 	} catch (err) {
-		elizaLogger.error(`Error reading directory: ${err.message}`)
+		logger.error(`Error reading directory: ${err.message}`)
 	}
 
 	return characterPaths
@@ -268,7 +268,7 @@ export async function loadCharacters(charactersArg: string): Promise<Character[]
 	}
 
 	if (hasValidRemoteUrls()) {
-		elizaLogger.info("Loading characters from remote URLs")
+		logger.info("Loading characters from remote URLs")
 		const characterUrls = commaSeparatedStringToArray(process.env.REMOTE_CHARACTER_URLS)
 		for (const characterUrl of characterUrls) {
 			const characters = await loadCharactersFromUrl(characterUrl)
@@ -277,7 +277,7 @@ export async function loadCharacters(charactersArg: string): Promise<Character[]
 	}
 
 	if (loadedCharacters.length === 0) {
-		elizaLogger.info("No characters found, using default character")
+		logger.info("No characters found, using default character")
 		loadedCharacters.push(defaultCharacter)
 	}
 

agent/src/clients.ts

@@ -14,15 +14,15 @@ import { TwitterClientInterface } from "@elizaos/client-twitter"
 import { FarcasterClientInterface } from "@elizaos/client-farcaster"
 import { JeeterClientInterface } from "@elizaos/client-simsai"
 import { XmtpClientInterface } from "@elizaos/client-xmtp"
-import { Character, Client, Clients, elizaLogger, IAgentRuntime } from "@elizaos/core"
+import { Character, Client, Clients, logger, IAgentRuntime } from "@elizaos/core"
 
 // also adds plugins from character file into the runtime
 export async function initializeClients(character: Character, runtime: IAgentRuntime) {
 	// each client can only register once
 	// and if we want two we can explicitly support it
 	const clients: Record<string, any> = {}
 	const clientTypes: string[] = character.clients?.map((str) => str.toLowerCase()) || []
-	elizaLogger.log("initializeClients", clientTypes, "for", character.name)
+	logger.log("initializeClients", clientTypes, "for", character.name)
 
 
 	// Start Auto Client if "auto" detected as a configured client
@@ -90,7 +90,7 @@ export async function initializeClients(character: Character, runtime: IAgentRun
 		if (simsaiClient) clients.simsai = simsaiClient
 	}
 
-	elizaLogger.log("client keys", Object.keys(clients))
+	logger.log("client keys", Object.keys(clients))
 
 	// TODO: Add Slack client to the list
 	// Initialize clients as an object
@@ -122,7 +122,7 @@ export async function initializeClients(character: Character, runtime: IAgentRun
 				for (const client of plugin.clients) {
 					const startedClient = await client.start(runtime)
 					const clientType = determineClientType(client)
-					elizaLogger.debug(`Initializing client of type: ${clientType}`)
+					logger.debug(`Initializing client of type: ${clientType}`)
 					clients[clientType] = startedClient
 				}
 			}

agent/src/database.ts

@@ -4,7 +4,7 @@
 import { SqliteDatabaseAdapter } from "@elizaos/adapter-sqlite"
 
 import {
-	elizaLogger
+	logger
 } from "@elizaos/runtime"
 
 // import { intifacePlugin } from "@elizaos/plugin-intiface";
@@ -17,16 +17,16 @@ const __dirname = path.dirname(__filename) // get the name of the directory
 
 export function initializeDatabase(dataDir: string) {
 		const filePath = process.env.SQLITE_FILE ?? path.resolve(dataDir, "db.sqlite")
-		elizaLogger.info(`Initializing SQLite database at ${filePath}...`)
+		logger.info(`Initializing SQLite database at ${filePath}...`)
 		const db = new SqliteDatabaseAdapter(new Database(filePath))
 
 		// Test the connection
 		db.init()
 			.then(() => {
-				elizaLogger.success("Successfully connected to SQLite database")
+				logger.success("Successfully connected to SQLite database")
 			})
 			.catch((error) => {
-				elizaLogger.error("Failed to connect to SQLite:", error)
+				logger.error("Failed to connect to SQLite:", error)
 			})
 
 		return db

packages/runtime/src/defaultCharacter.ts → agent/src/defaultCharacter.ts

@@ -1,11 +1,10 @@
-import { Character, ModelProviderName } from "./types.ts";
+import { Character, ModelProviderName } from "../../packages/runtime/src/types.ts";
 
 export const defaultCharacter: Character = {
     name: "Eliza",
     username: "eliza",
     plugins: [],
     clients: [],
-    modelProvider: ModelProviderName.LLAMALOCAL,
     settings: {
         secrets: {},
         voice: {

agent/src/index.ts

@@ -3,7 +3,7 @@ import {
 	AgentRuntime,
 	CacheStore,
 	type Character,
-	elizaLogger,
+	logger,
 	type ICacheManager,
 	type IDatabaseAdapter,
 	type IDatabaseCacheAdapter,
@@ -15,7 +15,7 @@ import {
 	AgentRuntime,
 	CacheStore,
 	type Character,
-	elizaLogger,
+	logger,
 	type ICacheManager,
 	type IDatabaseAdapter,
 	type IDatabaseCacheAdapter,
@@ -33,11 +33,12 @@ import { initializeClients } from "./clients"
 import { initializeDatabase } from "./database"
 import { handlePluginImporting, importPlugins } from "./plugins"
 import { getTokenForProvider, logFetch } from "./utils"
+import { defaultCharacter } from "./defaultCharacter"
 const __filename = fileURLToPath(import.meta.url) // get the resolved path to the file
 const __dirname = path.dirname(__filename) // get the name of the directory
 
 export async function createAgent(character: Character, db: IDatabaseAdapter, cache: ICacheManager): Promise<AgentRuntime> {
-	const { plugins, verifiableInferenceAdapter } = await importPlugins(character, token);
+	const plugins = await importPlugins(character);
 	return new AgentRuntime({
 		databaseAdapter: db,
 		modelProvider: character.modelProvider,
@@ -92,15 +93,15 @@ async function startAgent(character: Character, directClient: DirectClient): Pro
         directClient.registerAgent(runtime);
 
         // report to console
-        elizaLogger.debug(`Started ${character.name} as ${runtime.agentId}`);
+        logger.debug(`Started ${character.name} as ${runtime.agentId}`);
 
         return runtime;
     } catch (error) {
-        elizaLogger.error(
+        logger.error(
             `Error starting agent for character ${character.name}:`,
             error
         );
-        elizaLogger.error(error);
+        logger.error(error);
         // if (db) {
         //     await db.close();
         // }
@@ -132,17 +133,22 @@ const startAgents = async () => {
 	let serverPort = Number.parseInt(settings.SERVER_PORT || "3000")
 	const characters = await loadAllCharacters()
 
+	if (characters.length === 0) {
+		// import default character
+		characters.push(defaultCharacter);
+	}
+
     try {
         for (const character of characters) {
             await startAgent(character, directClient);
         }
     } catch (error) {
-        elizaLogger.error("Error starting agents:", error);
+        logger.error("Error starting agents:", error);
     }
 
     // Find available port
     while (!(await checkPortAvailable(serverPort))) {
-        elizaLogger.warn(
+        logger.warn(
             `Port ${serverPort} is in use, trying ${serverPort + 1}`
         );
         serverPort++;
@@ -163,16 +169,16 @@ const startAgents = async () => {
     directClient.start(serverPort);
 
     if (serverPort !== Number.parseInt(settings.SERVER_PORT || "3000")) {
-        elizaLogger.log(`Server started on alternate port ${serverPort}`);
+        logger.log(`Server started on alternate port ${serverPort}`);
     }
 
-    elizaLogger.log(
+    logger.log(
         "Run `pnpm start:client` to start the client and visit the outputted URL (http://localhost:5173) to chat with your agents. When running multiple agents, use client with different port `SERVER_PORT=3001 pnpm start:client`"
     );
 };
 
 startAgents().catch((error) => {
-    elizaLogger.error("Unhandled error in startAgents:", error);
+    logger.error("Unhandled error in startAgents:", error);
     process.exit(1);
 });