# ElizaOS Developer Update - October 30, 2025

## Core Framework

ElizaOS architecture has seen significant improvements with the introduction of PostgreSQL Row-Level Security (RLS) for true multi-tenant data isolation. This allows multiple ElizaOS servers to securely share a single database with proper tenant isolation.

The unified messaging API has been completed with the addition of `elizaOS.sendMessage()`, providing a standardized way to send messages across all ElizaOS clients. This reduces code duplication and improves maintainability across the platform.

The agent runtime now includes health check endpoints to ensure better stability in production deployments:

```typescript
// Server health check routes are now publicly accessible
app.get('/api/health', (req, res) => {
  res.status(200).json({ status: 'ok' });
});

app.get('/api/messaging/jobs/health', (req, res) => {
  res.status(200).json({ 
    status: 'ok',
    jobsActive: _getActiveJobCount()
  });
});
```

A critical configuration bug has been fixed where `.env` variables were ignored when character-specific secrets were present. The fix now properly merges environment variables with character settings.

## New Features

### Jobs API for Stateless Agent Communication

A new Jobs API has been implemented for one-off messaging functionality, allowing external systems to send single messages to agents and poll for responses without maintaining persistent sessions:

```typescript
// Create a job
const response = await fetch('http://localhost:3000/api/messaging/jobs', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    userId: "user-uuid",
    content: "What is Bitcoin price?"
  })
});

// Poll for result
const jobId = (await response.json()).jobId;
const result = await fetch(`http://localhost:3000/api/messaging/jobs/${jobId}`);
```

The Jobs API includes automatic agent selection, configurable timeouts, and intelligent message handling that filters intermediate action messages and waits for final results.

### x402 Payment Integration

ElizaOS now supports x402 cryptocurrency payments for agent access. This is configurable via environment variables:

```bash
# Enable x402 payments
X402_ENABLED=true
X402_WALLET_ADDRESS=0x123...
X402_PRICE=0.01
X402_NETWORK=base-mainnet
```

The payment system can be used alongside or instead of API keys, with flexible authentication modes:
- Both API key + x402 payment
- API key only
- x402 payment only
- Public access (no auth)

### Headless React Hooks Package

Development has started on a new `@elizaos/react` package containing headless, reusable React hooks for building custom UIs for ElizaOS agents. This includes 30 hooks across categories like Agents, Runs, Messaging, Messages, Memories, and Internal/Agent-Perspective interactions.

## Bug Fixes

Several critical bugs were fixed this week:

1. **Character Configuration Bug**: Fixed an issue where `.env` variables were completely ignored when `character.settings.secrets` exists, preventing proper configuration merging. Now environment variables are properly merged with character-specific overrides.

   ```typescript
   // Previous behavior - character secrets would override ALL env vars
   // New behavior - proper merging with character-specific overrides taking precedence
   const mergedSecrets = mergeSecrets(envSecrets, characterSecrets);
   ```

2. **Discord DM Bug**: Resolved a 403 Forbidden error when creating DM channels in the GUI client by using the actual server ID for DM channel creation:

   ```typescript
   // Before: Used hardcoded or incorrect server ID
   // After: Use actual server ID from available servers
   const createDmChannel = useCreateDmChannel({
     serverId: servers?.[0]?.id ?? null
   });
   ```

3. **Action Options Type Fix**: Custom options can now be added to `Action` via an index signature:

   ```typescript
   interface Action {
     name: string;
     description: string;
     execute: ActionExecuteFunction;
     [key: string]: unknown; // Allow arbitrary custom options
   }
   ```

4. **x402 Client Integration**: Work has begun on finding a suitable Solana x402 client for integration with the payment system.

## API Changes

### Core Runtime API Additions

1. A new `generateText()` API has been implemented for simple text generation without the need for session management:

```typescript
const response = await runtime.generateText({
  systemPrompt: "You are a helpful assistant.",
  userPrompt: "Explain quantum computing in simple terms."
});
```

2. The `IAgentRuntime` interface now exposes the state cache:

```typescript
interface IAgentRuntime {
  // Existing properties...
  stateCache: Map<string, State>;
}
```

3. The Route type now supports PATCH method:

```typescript
type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
```

## Social Media Integrations

The Solana integration is now in the testing phase, but a suitable x402 client is still needed for full implementation. Several discussions have focused on finding the right solution for this integration.

There are concerns about overlapping agent communication protocols causing confusion for new developers. Work has started to clarify differences between various protocols to provide better documentation.

The Lit plugin has been updated with encryption features, and code has been reorganized to create a service instead of keeping libraries in actions.

## Model Provider Updates

A key improvement to the embedding service now makes it optional when no TEXT_EMBEDDING model is registered. The embedding service becomes a no-op in this case, simplifying configuration for deployments that don't require embeddings:

```typescript
// Before: Would throw an error if no embedding model was configured
// Now: Gracefully handles missing embedding model
async enqueueItem(item: EmbeddingQueueItem): Promise<void> {
  if (!this.hasEmbeddingModel) {
    this.logger.debug(
      'No TEXT_EMBEDDING model registered, skipping embedding for:', 
      item.text.substring(0, 50)
    );
    return;
  }
  // Process embedding...
}
```

The evaluator execution has been improved to run asynchronously in the background with robust error handling and logging, preventing evaluator errors from blocking the main message flow.

## Breaking Changes

The upcoming token migration from AI16Z to ElizaOS is progressing, with the team having notified all exchanges. After migration begins, the ElizaOS token will be added as a payment option to x402, joining the currently supported options of DEGENAI, AI16Z, or USDC on Base network.

A new tokenomics model is being considered where each agent would only accept its native token or implement buyback mechanisms.

Solana integration is in testing phase but requires a suitable x402 client before full implementation.

Plans for an "eco explorer" for elizaOS agents were mentioned, with references to the "8004" protocol and a GitHub repository for "praxis-explorer" was shared for review.