TypeScript

import { AgentRuntime, corePlugin } from "@elizaos/core";
import type { Character } from "@elizaos/core";

// Define your agent's character
const character: Character = {
  name: "Eliza",
  username: "eliza",
  bio: "A helpful AI assistant built with elizaOS",
  system: "You are a helpful and concise AI assistant.",
  messageExamples: [
    {
      name: "Eliza",
      examples: [
        {
          name: "user",
          content: { text: "Hello!" }
        },
        {
          name: "Eliza",
          content: { text: "Hi! How can I help you today?" }
        }
      ]
    }
  ]
};

// Create runtime with plugins
const runtime = new AgentRuntime({
  character,
  plugins: [
    corePlugin,
    // Add other plugins here
  ],
});

// Initialize and use
await runtime.initialize();

import { v4 as uuidv4 } from "uuid";
import type { Memory, Content } from "@elizaos/core";

const userId = uuidv4();
const roomId = uuidv4();

// Create a message
const message: Memory = {
  id: uuidv4(),
  entity_id: userId,
  room_id: roomId,
  content: {
    text: "What's the weather like?",
    source: "cli",
    channel_type: "DM"
  },
  created_at: Date.now()
};

// Process the message
const result = await runtime.messageService.handleMessage(
  runtime,
  message
);

console.log(result.response_content.text);

import type { Action, ActionContext } from "@elizaos/core";

const weatherAction: Action = {
  name: "GET_WEATHER",
  description: "Get current weather for a location",
  
  validate: async ({ content }: ActionContext) => {
    // Check if the message mentions weather
    return /weather|temperature|forecast/i.test(
      content.text || ""
    );
  },
  
  handler: async ({ runtime, content }: ActionContext) => {
    // Extract location from message
    const location = extractLocation(content.text);
    
    // Call weather API
    const weather = await fetchWeather(location);
    
    return {
      success: true,
      content: {
        text: `The weather in ${location} is ${weather.temp}°F and ${weather.condition}`
      }
    };
  }
};

import type { Provider, State } from "@elizaos/core";

const timeProvider: Provider = {
  name: "CURRENT_TIME",
  
  get: async (runtime: IAgentRuntime, message: Memory) => {
    const now = new Date();
    return {
      currentTime: now.toISOString(),
      timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
      timestamp: now.getTime()
    };
  }
};

import type { Evaluator, Memory } from "@elizaos/core";

const sentimentEvaluator: Evaluator = {
  name: "SENTIMENT_ANALYZER",
  description: "Analyzes sentiment of user messages",
  
  handler: async ({
    runtime,
    message
  }: {
    runtime: IAgentRuntime;
    message: Memory;
  }) => {
    const sentiment = analyzeSentiment(message.content.text);
    
    // Store sentiment in memory
    await runtime.databaseAdapter.createMemory({
      ...message,
      metadata: {
        sentiment: sentiment.score,
        label: sentiment.label
      }
    });
    
    return {
      success: true,
      sentiment
    };
  }
};

import type { Plugin } from "@elizaos/core";

const myPlugin: Plugin = {
  name: "my-custom-plugin",
  description: "A custom plugin for elizaOS",
  
  actions: [weatherAction],
  providers: [timeProvider],
  evaluators: [sentimentEvaluator],
  
  // Optional: Add services
  services: [],
  
  // Optional: Add custom routes
  routes: [
    {
      type: "GET",
      path: "/health",
      handler: async (req, res, runtime) => {
        res.status(200).json({ status: "ok" });
      }
    }
  ]
};

export default myPlugin;

// Automatically uses browser build in web environments
import { AgentRuntime } from "@elizaos/core";

// Browser-safe operations
const runtime = new AgentRuntime({
  character,
  plugins: [corePlugin]
});

npm install buffer crypto-browserify stream-browserify events

# Logging
LOG_LEVEL=debug
LOG_DIAGNOSTIC=true
LOG_JSON_FORMAT=false

# Runtime settings
SECRET_SALT=your-secret-salt
ALLOW_NO_DATABASE=false

# Multi-step reasoning
USE_MULTI_STEP=true
MAX_MULTISTEP_ITERATIONS=6

# Error tracking
SENTRY_DSN=your-sentry-dsn
SENTRY_ENVIRONMENT=production

const runtime = new AgentRuntime({
  character,
  plugins: [corePlugin],
  
  // Database adapter
  databaseAdapter: new PostgresAdapter({
    connectionString: process.env.DATABASE_URL
  }),
  
  // Conversation settings
  conversationLength: 32,
  
  // Custom settings
  settings: {
    ENABLE_AUTONOMY: true,
    ADVANCED_CAPABILITIES: true
  }
});

import type {
  // Core types
  UUID,
  Content,
  Memory,
  Character,
  Agent,
  
  // Component types
  Action,
  Provider,
  Evaluator,
  Plugin,
  Service,
  
  // Runtime types
  IAgentRuntime,
  State,
  ActionContext,
  ActionResult,
  
  // Database types
  IDatabaseAdapter,
  
  // Model types
  ModelHandler,
  GenerateTextOptions,
  GenerateTextResult
} from "@elizaos/core";

const stream = await runtime.generateTextStream({
  prompt: "Tell me a story",
  model: "gpt-4"
});

for await (const chunk of stream) {
  process.stdout.write(chunk);
}

const runtime = new AgentRuntime({
  character,
  plugins: [corePlugin],
  settings: {
    USE_MULTI_STEP: true,
    MAX_MULTISTEP_ITERATIONS: 10
  }
});

// Search memories by embedding
const memories = await runtime.databaseAdapter.searchMemories({
  tableName: "messages",
  roomId: roomId,
  embedding: await runtime.getEmbedding("search query"),
  match_threshold: 0.8,
  match_count: 10
});

// Get recent memories
const recent = await runtime.databaseAdapter.getMemories({
  tableName: "messages",
  roomId: roomId,
  count: 20
});

import { describe, it, expect } from "vitest";
import { AgentRuntime, corePlugin } from "@elizaos/core";

describe("MyPlugin", () => {
  it("should handle weather requests", async () => {
    const runtime = new AgentRuntime({
      character: testCharacter,
      plugins: [corePlugin, myPlugin]
    });
    
    await runtime.initialize();
    
    const result = await runtime.processMessage({
      content: { text: "What's the weather?" },
      // ... other fields
    });
    
    expect(result.content.text).toContain("weather");
  });
});

import { beforeAll, afterAll } from "vitest";
import { InMemoryDatabaseAdapter } from "@elizaos/core";

let runtime: AgentRuntime;

beforeAll(async () => {
  runtime = new AgentRuntime({
    character: testCharacter,
    plugins: [corePlugin],
    databaseAdapter: new InMemoryDatabaseAdapter()
  });
  
  await runtime.initialize();
});

afterAll(async () => {
  await runtime.stop();
});