# ElizaOS Developer Update - Week of August 11-15, 2025

## 1. Core Framework

### Agent Runtime Restructuring
We're making Eliza more modular with a "code first" approach that lets developers import specific actions and services directly. This week's discussions focused on:

- Moving message bus code into core to simplify the architecture
- Evaluating whether the core event system is sufficient for handling individual message events
- Improving action chaining mechanisms for complex tasks in benchmarks

```typescript
// Example of improved action chaining mechanism
const ActionEvaluator = {
  evaluateActionResult: async (result, context) => {
    // Determine if task is complete or needs additional actions
    const needsMoreActions = await evaluateCompleteness(result, context);
    if (needsMoreActions) {
      return await executeNextAction(context);
    }
    return result;
  }
};
```

### Performance Optimization
We've identified that embedding processing in messages is primarily used for knowledge management and slows down the system. The team is working on removing `addEmbeddingToMemory` from messages to improve performance significantly.

## 2. New Features

### Sessions API
A new Sessions API has been introduced that provides a simplified interface for messaging between users and agents:

```typescript
// Creating a new session
const session = await client.sessions.create({
  agentId: "your-agent-id",
  userId: "user-123"
});

// Sending a message in the session
const response = await client.sessions.sendMessage({
  sessionId: session.id,
  content: "Hello, agent!"
});
```

### Character Type System
We've implemented a comprehensive character type system using Zod validation, including a new JesseXBT character focused on Base ecosystem support:

```typescript
// Character type definition with Zod
const CharacterSchema = z.object({
  id: z.string().uuid(),
  name: z.string().min(1),
  bio: z.string(),
  type: z.enum(['assistant', 'expert', 'personality']),
  capabilities: z.array(z.string()).optional(),
  // Additional fields...
});
```

### EVM Plugin
A new EVM (Ethereum Virtual Machine) plugin has been added, integrating wallet and blockchain tooling:

```typescript
// Example of using the EVM plugin to get wallet balance
const balance = await agent.actions.getWalletBalance({
  address: "0x1234567890abcdef",
  chain: "ethereum"
});
console.log(`Balance: ${balance.amount} ${balance.symbol}`);
```

## 3. Bug Fixes

### CLI Publishing Command
Fixed critical issues with the `elizaos publish` command:

- Resolved a bug where `elizaos publish --npm` would falsely report success even when package publishing failed
- Fixed `elizaos publish --test` failing out of the box by improving error handling
- Added better validation and logging

```bash
# Fixed command now properly reports actual status
elizaos publish --npm --test
```

### Action Chaining
Fixed a critical issue where the current implementation was failing when actions needed to be chained together for complex tasks:

- Updated action planner to process outputs after each action
- Implemented `ActionEvaluator` in bootstrap to manage action chains
- Now properly handles reflection and sequential actions

### Logger Type Errors
Resolved issues with logger functions after recent updates:

```typescript
// Previous implementation caused type errors
logger.info("Message with %s", variable);

// New structured logging format
logger.info({ msg: "Message with value", value: variable });
```

## 4. API Changes

### OpenAI-Compatible API
We've added a Hono server with an OpenAI-compatible API:

- Interact with ElizaOS agents using the same API calls you'd use for OpenAI
- Full compatibility with existing OpenAI client libraries
- New tool calls visibility feature that exposes intermediate tool calls in chat completions API while maintaining OpenAI API compliance

```typescript
// Example of using the OpenAI-compatible API
const response = await fetch("http://localhost:3000/v1/chat/completions", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "eliza-agent-id",
    messages: [{ role: "user", content: "Hello, ElizaOS!" }],
    tool_choice: "auto"
  })
});
```

### Workspace Dependencies Standardization
All workspace packages now use `workspace:*` dependency versioning for better synchronization:

```json
// Before
"dependencies": {
  "@elizaos/core": "^1.3.2"
}

// After
"dependencies": {
  "@elizaos/core": "workspace:*"
}
```

## 5. Social Media Integrations

### Twitter Integration
Twitter (X) account issues were resolved this week after a temporary suspension. Users reported some rate limiting issues after reconfiguring agents. If you're experiencing rate limits, try setting:

```
DRY_RUN=true
```

### Discord Integration
The team is investigating a newline bug in agent responses. As a temporary fix, try modifying your system prompt to properly format responses:

```
Please ensure your responses don't contain unnecessary newlines.
Always format your text in clean paragraphs.
```

## 6. Model Provider Updates

### OpenRouter Updates
OpenRouter announced new features:

- Self-serve refunds now available
- Improved activity tracking for token usage
- Fixed an issue causing 500 errors when connecting Eliza and Gaianet

### Multi-Call Protocol (MCP) Issues
Users reported problems with MCP (Multi-Call Protocol):

- Issues with streamable-HTTP connections
- Inability to use multiple tools in a single call
- Investigation ongoing for template modifications or logic changes needed

## 7. Breaking Changes

### V1 to V2 Migration: Logger Changes
A significant change to the logger system requires updates to many plugins:

```typescript
// V1 (deprecated)
logger.info("Processing message %s", messageId);

// V2 (required format)
logger.info({ msg: "Processing message", messageId });
```

### Action Validation Changes
The team is debating whether the validate function for actions should be optional:

```typescript
// Current approach (required)
export const myAction = {
  name: "myAction",
  description: "Does something useful",
  parameters: z.object({
    param1: z.string()
  }),
  validate: async (params) => {
    // Validation logic here
    return true;
  },
  handler: async (params, context) => {
    // Action implementation
  }
};
```

Remember to update all your plugins to accommodate these changes before upgrading to the latest version.