# ElizaOS Developer Update: June 19-25, 2025

## Core Framework

ElizaOS has undergone significant architectural enhancements this week with the completion of the server package separation from the CLI. This major refactoring allows for more modular and maintainable code while preserving backward compatibility.

### Server Package Split

The server functionality has been extracted into its own dedicated `@elizaos/server` package, enabling independent usage of server components while maintaining compatibility with existing CLI integrations. This change facilitates better separation of concerns and opens new integration possibilities:

```javascript
// Before: Direct import from CLI
import { createServer } from '@elizaos/cli/dist/server';

// After: Clean import from dedicated package
import { createServer } from '@elizaos/server';
```

All CLI imports have been updated to use the new server package, preserving type safety across package boundaries. PR [#5122](https://github.com/elizaos/eliza/pull/5122) adds over 68k lines of code while removing ~2.8k lines, reflecting the comprehensive nature of this structural change.

### Character Validation

A robust Zod-based character validation system has been implemented with safe JSON parsing to improve error handling and prevent runtime issues:

```typescript
// New character schema validation
export const CharacterSchema = z.object({
  name: z.string().min(1),
  plugins: z.array(z.string()).default([]),
  settings: z.record(z.any()).default({}),
  // Additional properties...
});

// Safe character loading with validation
export const loadCharacterFromPath = async (
  path: string
): Promise<Result<Character, Error>> => {
  return tryCatch(
    async () => {
      const content = await fs.readFile(path, 'utf-8');
      const safeJson = await safeJsonParse(content);
      // Schema validation with descriptive errors
      return CharacterSchema.parse(safeJson);
    },
    (error) => new Error(`Failed to load character from ${path}: ${error}`)
  );
};
```

This change eliminates numerous sources of runtime errors and provides developers with clear feedback when character configurations are invalid. PR [#5167](https://github.com/elizaos/eliza/pull/5167)

### Project Loading Refactor

Character loading logic has been consolidated to eliminate duplication between CLI and server implementations, improving maintainability and consistency:

```typescript
// Centralized character loading logic
export const loadCharacterFromSource = async (
  source: CharacterSource,
  options?: CharacterLoadOptions
): Promise<Result<Character, Error>> => {
  switch (source.type) {
    case 'file':
      return loadCharacterFromPath(source.path);
    case 'object':
      return ok(validateCharacter(source.character));
    case 'json':
      return loadCharacterFromJson(source.json);
    // Additional source types...
  }
};
```

This refactoring creates a single source of truth for character loading, reducing the risk of inconsistent behavior between different parts of the system. PR [#5169](https://github.com/elizaos/eliza/pull/5169)

## New Features

### Camera Plugin Support

A new camera plugin has been developed to enable visual input processing for Eliza. This allows agents to process and respond to visual data, significantly expanding their capabilities:

```typescript
// Example camera plugin registration
const character = {
  name: 'Vision Agent',
  plugins: [
    '@elizaos/plugin-bootstrap',
    '@elizaos/plugin-camera',
    '@elizaos/plugin-anthropic'
  ],
  settings: {
    // Camera plugin settings
    cameraSettings: {
      captureInterval: 5000, // milliseconds
      resolution: 'medium',
      processingMode: 'continuous'
    }
  }
};
```

The camera plugin enables various use cases like object recognition, scene interpretation, and visual-based assistant capabilities.

### Command Consolidation

Better agent management has been implemented by merging `elizaos stop` into `elizaos agent stop --all`, creating a more consistent CLI experience:

```bash
# Old approach (deprecated)
elizaos stop

# New consolidated approach
elizaos agent stop --all
```

This change streamlines the CLI interface by organizing commands under a more logical hierarchy. PR [#5175](https://github.com/elizaos/eliza/pull/5175)

### GUI Chat Title

Added GUI chat title functionality to improve the chat interface experience and make conversations more identifiable:

```typescript
// React component for chat title
<ChatHeader
  title={chatTitle || `Chat with ${agentName}`}
  onTitleChange={handleTitleChange}
  editable={userIsOwner}
/>
```

This feature allows users to name and organize their chat sessions for better context management. PR [#5179](https://github.com/elizaos/eliza/pull/5179)

## Bug Fixes

### Message Filtering

Fixed message filtering to properly scope messages to the current chat/channel by channelId. This resolves issues where messages would incorrectly appear across different chats:

```typescript
// Before: Missing channel scoping
const messages = await getMessages();

// After: Proper channel scoping
const messages = await getMessages({
  channelId: currentChannelId
});
```

This fix ensures that conversations remain properly isolated and contextual. PR [#5149](https://github.com/elizaos/eliza/pull/5149)

### UI Responsiveness

Resolved a critical issue where the GUI would get stuck in the "agent is thinking" state, particularly when:
- An agent selected the IGNORE action
- An empty text response was sent
- Action execution failed silently

This fix improves the reliability of the user interface by properly handling edge cases in agent responses:

```typescript
// Added safeguard to prevent UI from getting stuck
useEffect(() => {
  if (isThinking && lastMessageTime && Date.now() - lastMessageTime > THINKING_TIMEOUT) {
    setIsThinking(false);
    console.warn('Agent response timed out, resetting UI state');
  }
}, [isThinking, lastMessageTime]);
```

PR [#5151](https://github.com/elizaos/eliza/pull/5151)

### Knowledge Plugin Issues

Fixed file path loading and UI uploads in the knowledge plugin, addressing user reports of "Unexpected end of form" errors when uploading markdown files. The updated code properly handles file paths and form data:

```typescript
// Fixed file upload handling
router.post('/upload', async (req, res) => {
  try {
    const form = await parseMultipartForm(req);
    const file = form.files.file;
    
    if (!file) {
      return res.status(400).json({ error: 'No file uploaded' });
    }
    
    // Process file content with proper encoding and path handling
    const content = await fs.promises.readFile(file.path, 'utf8');
    // Additional processing...
    
    return res.json({ success: true });
  } catch (error) {
    console.error('Error in knowledge upload:', error);
    return res.status(500).json({ error: error.message });
  }
});
```

## API Changes

### API Route Organization

The API routes have been reorganized into a logical domain-based structure for better maintainability:

```
/api
├── agents
│   ├── [agentId]
│   │   ├── channels
│   │   ├── logs
│   │   ├── memories
│   │   └── ...
│   └── index.ts
├── channels
│   ├── [channelId]
│   │   ├── messages
│   │   └── participants
│   └── index.ts
└── ...
```

This structure makes it easier to locate and manage related endpoints, improving developer experience and code organization.

### Channel Management APIs

Added API endpoints for managing agents across channels, enabling more flexible agent participation in conversations:

```typescript
// New channel management endpoints:
// GET    /api/agents/:agentId/channels
// POST   /api/agents/:agentId/channels/:channelId/join
// DELETE /api/agents/:agentId/channels/:channelId/leave
```

These endpoints provide programmatic control over which agents participate in which conversation channels. PR [#5113](https://github.com/elizaos/eliza/pull/5113)

## Social Media Integrations

### Twitter Account Status

The project's Twitter account is currently suspended, but the team is actively working with Twitter support to restore it. In the meantime, developers should use alternative platforms for announcements and updates.

### Twitter Plugin Maintenance

The Twitter plugin documentation has been updated to reflect ongoing maintenance. Deprecation notices have been added, and Twitter has been removed from the main featured connectors lists in documentation.

## Model Provider Updates

### Expanded Provider Options

Ollama has been added as a fourth AI provider option in the `elizaos create` command, alongside existing Local AI, OpenAI, and Anthropic options:

```bash
# Creating a new project with Ollama provider
elizaos create myproject --ai-provider ollama
```

This addition gives developers more flexibility in choosing their preferred AI backend. PR [#5160](https://github.com/elizaos/eliza/pull/5160)

### Memory Requirements Guidance

Updated documentation and runtime checks to provide better guidance on hardware requirements for different models. For systems with limited resources (16GB VRAM), gemma3:12b is now recommended as a good balance between capability and resource consumption.

## Breaking Changes

### V1 to V2 Migration Considerations

V2 is now live but still undergoing active development. When migrating from V1 to V2, developers should be aware of the following changes:

1. **Character Validation**: V2 enforces stricter character validation, so character files that worked in V1 may require updates.

2. **Plugin System Compatibility**: The current plugin system has compatibility issues between versions. Developers should test their plugins thoroughly when upgrading.

3. **Project Structure**: The `.eliza` directory now centralizes all generated data, replacing scattered locations used in V1.

4. **Command Interface**: Some CLI commands have been reorganized (like the `stop` command migration mentioned above).

5. **API Routes**: API consumers will need to update to the new domain-based route structure.

For assistance with migration challenges, please reach out in the #development channel on Discord.

---

For detailed implementation examples and further documentation, visit our [updated documentation site](https://eliza.how/docs/intro).