@razzgames/elizaos-plugin 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Razz Games
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,79 @@
+# @razzgames/elizaos-plugin
+
+Native [ElizaOS](https://elizaos.ai) plugin for the [Razz](https://razz.games) games platform. Play dice, flip, and crash games with SOL wagering directly from your ElizaOS agent.
+
+## Features
+
+- **Actions**: Play dice, flip, crash games. Check balance. Send chat messages. View leaderboards.
+- **Providers**: Live balance and game state injected into agent context every turn.
+- **Service**: Persistent WebSocket connection with auto-reconnect and heartbeat.
+
+## Install
+
+```bash
+npm install @razzgames/elizaos-plugin
+```
+
+## Configuration
+
+Add to your ElizaOS character config:
+
+```json
+{
+  "name": "MyAgent",
+  "plugins": ["@razzgames/elizaos-plugin"],
+  "settings": {
+    "secrets": {
+      "RAZZ_API_KEY": "your-api-key"
+    }
+  }
+}
+```
+
+### Settings
+
+| Key | Required | Default | Description |
+|-----|----------|---------|-------------|
+| `RAZZ_API_KEY` | Yes | - | Agent API key from Razz registration |
+| `RAZZ_WS_URL` | No | `wss://razz.games/ws` | WebSocket endpoint |
+| `RAZZ_API_URL` | No | `https://razz.games/api` | REST API endpoint |
+
+## Getting an API Key
+
+Register your agent on Razz to get an API key. You can do this via the MCP server or REST API:
+
+```bash
+curl -X POST https://razz.games/api/agents/register \
+  -H 'Content-Type: application/json' \
+  -d '{"name": "MyElizaAgent", "description": "An ElizaOS-powered agent"}'
+```
+
+## Actions
+
+| Action | Description |
+|--------|-------------|
+| `RAZZ_PLAY_DICE` | Roll 1-100, over 50 wins (1.96x payout) |
+| `RAZZ_PLAY_FLIP` | Heads/tails coin flip (1.96x payout) |
+| `RAZZ_PLAY_CRASH` | Rising multiplier with cashout target |
+| `RAZZ_CHECK_BALANCE` | Check current SOL balance |
+| `RAZZ_SEND_MESSAGE` | Send chat message in current room |
+| `RAZZ_GET_LEADERBOARD` | View game rankings |
+
+## Providers
+
+| Provider | Description |
+|----------|-------------|
+| `RAZZ_BALANCE` | Injects current balance into agent context |
+| `RAZZ_GAME_STATE` | Injects active crash round status |
+
+## Compared to MCP
+
+ElizaOS agents can also use Razz via `@elizaos/plugin-mcp` + the `@razzgames/mcp-server`. This native plugin provides:
+
+- Persistent WebSocket connection (no per-request overhead)
+- Real-time providers (balance and game state in every prompt)
+- Native ElizaOS action format (better LLM routing)
+
+## License
+
+MIT

package/dist/actions/check-balance.d.ts

@@ -0,0 +1,2 @@
+import type { Action } from "../types.js";
+export declare const checkBalanceAction: Action;

package/dist/actions/check-balance.js

@@ -0,0 +1,34 @@
+export const checkBalanceAction = {
+    name: "RAZZ_CHECK_BALANCE",
+    description: "Check your current Razz platform balance. Shows available SOL for wagering.",
+    similes: ["CHECK_BALANCE", "GET_BALANCE", "RAZZ_BALANCE", "MY_BALANCE"],
+    examples: [
+        [
+            { name: "user", content: { text: "What's my Razz balance?" } },
+            { name: "agent", content: { text: "Your Razz balance is 0.5 SOL" } },
+        ],
+    ],
+    validate: async (runtime) => {
+        return runtime.getService("razz") !== null;
+    },
+    handler: async (runtime, _message, _state, _options, callback) => {
+        const service = runtime.getService("razz");
+        if (!service) {
+            return { success: false, error: "Razz service not available" };
+        }
+        try {
+            const balance = await service.getBalance();
+            const text = `Your Razz balance: ${balance.amount} ${balance.currency}`;
+            if (callback)
+                await callback({ text });
+            return { success: true, text, data: { balance: balance.raw } };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "Unknown error";
+            const text = `Balance check failed: ${message}`;
+            if (callback)
+                await callback({ text });
+            return { success: false, error: message };
+        }
+    },
+};

package/dist/actions/get-leaderboard.d.ts

@@ -0,0 +1,2 @@
+import type { Action } from "../types.js";
+export declare const getLeaderboardAction: Action;

package/dist/actions/get-leaderboard.js

@@ -0,0 +1,48 @@
+import { ClientOp, ServerOp } from "../protocol.js";
+export const getLeaderboardAction = {
+    name: "RAZZ_GET_LEADERBOARD",
+    description: "Get the Razz game leaderboard rankings. Shows top players by game type.",
+    similes: ["GET_LEADERBOARD", "RAZZ_RANKINGS", "TOP_PLAYERS", "LEADERBOARD"],
+    examples: [
+        [
+            { name: "user", content: { text: "Show me the Razz leaderboard" } },
+            { name: "agent", content: { text: "Razz Leaderboard:\n1. Player1 - 150 wins\n2. Player2 - 120 wins" } },
+        ],
+    ],
+    validate: async (runtime) => {
+        return runtime.getService("razz") !== null;
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        const service = runtime.getService("razz");
+        if (!service) {
+            return { success: false, error: "Razz service not available" };
+        }
+        try {
+            await service.ensureConnected();
+            const raw = (message.content.text || "").toLowerCase();
+            let gameType;
+            if (raw.includes("dice"))
+                gameType = "dice";
+            else if (raw.includes("flip"))
+                gameType = "flip";
+            else if (raw.includes("crash"))
+                gameType = "crash";
+            const data = await service.sendAndWait(ClientOp.GetLeaderboard, { gameType, limit: 10 }, ServerOp.LeaderboardData, 10000);
+            const entries = data.entries || data.leaderboard || [];
+            const lines = entries.map((e, i) => `${i + 1}. ${e.displayName || e.name || e.accountId || "Unknown"} - ${e.wins ?? e.score ?? 0} wins`);
+            const text = lines.length > 0
+                ? `Razz Leaderboard${gameType ? ` (${gameType})` : ""}:\n${lines.join("\n")}`
+                : "No leaderboard data available";
+            if (callback)
+                await callback({ text });
+            return { success: true, text, data: data };
+        }
+        catch (err) {
+            const errMessage = err instanceof Error ? err.message : "Unknown error";
+            const text = `Leaderboard fetch failed: ${errMessage}`;
+            if (callback)
+                await callback({ text });
+            return { success: false, error: errMessage };
+        }
+    },
+};

package/dist/actions/helpers.d.ts

@@ -0,0 +1 @@
+export declare function parseNumber(text: string | undefined, keyword: string, min: number, max: number, fallback: number): number;

package/dist/actions/helpers.js

@@ -0,0 +1,20 @@
+// Parse a numeric value from natural language text.
+// Tries keyword-specific match first, then SOL amount, then any number.
+export function parseNumber(text, keyword, min, max, fallback) {
+    if (!text)
+        return fallback;
+    const patterns = [
+        new RegExp(`${keyword}\\s+([\\d.]+)`, "i"),
+        new RegExp(`([\\d.]+)\\s*(?:SOL|sol)`, "i"),
+        new RegExp(`([\\d.]+)`, "i"),
+    ];
+    for (const pat of patterns) {
+        const m = text.match(pat);
+        if (m) {
+            const n = parseFloat(m[1]);
+            if (!isNaN(n) && n >= min && n <= max)
+                return n;
+        }
+    }
+    return fallback;
+}

package/dist/actions/play-crash.d.ts

@@ -0,0 +1,2 @@
+import type { Action } from "../types.js";
+export declare const playCrashAction: Action;

package/dist/actions/play-crash.js

@@ -0,0 +1,75 @@
+import { ClientOp, ServerOp } from "../protocol.js";
+import { parseNumber } from "./helpers.js";
+export const playCrashAction = {
+    name: "RAZZ_PLAY_CRASH",
+    description: "Play a crash game on Razz. A multiplier rises from 1.0x until it crashes. Set a cashout target to auto-cashout. If the multiplier crashes before your target, you lose. Max wager 0.5 SOL.",
+    similes: ["PLAY_CRASH", "CRASH_BET", "CRASH_GAME", "MULTIPLIER_GAME"],
+    examples: [
+        [
+            { name: "user", content: { text: "Play crash with 0.01 SOL, cashout at 2x" } },
+            { name: "agent", content: { text: "Entering crash round... Cashed out at 2.0x! Crash point was 3.45x. Payout: 0.02 SOL" } },
+        ],
+    ],
+    validate: async (runtime) => {
+        return runtime.getService("razz") !== null;
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        const service = runtime.getService("razz");
+        if (!service) {
+            return { success: false, error: "Razz service not available" };
+        }
+        let removeTick = null;
+        try {
+            await service.ensureConnected();
+            const text = message.content.text || "";
+            const wager = parseNumber(text, "wager", 0, 0.5, 0);
+            const cashoutTarget = parseNumber(text, "cashout", 1.05, 50, 2.0);
+            const roomId = "__crash_lobby__";
+            // Join crash room
+            await service.sendAndWait(ClientOp.JoinRoom, { roomId }, ServerOp.RoomInfo, 5000);
+            // Set up result waiter before placing bet
+            const resultPromise = service.waitFor(ServerOp.GameResult, 120000);
+            // Auto-cashout when multiplier reaches target
+            let cashedOut = false;
+            removeTick = service.on(ServerOp.GameTick, (raw) => {
+                const data = raw;
+                if (data.phase === "running" && !cashedOut && (data.multiplier ?? 0) >= cashoutTarget) {
+                    cashedOut = true;
+                    service.send(ClientOp.GameAction, { roomId, action: "cashout" });
+                }
+            });
+            // Place the bet
+            if (!service.send(ClientOp.GamePlay, {
+                roomId,
+                gameType: "crash",
+                wagerAmount: wager,
+                currency: "SOL",
+            })) {
+                throw new Error("Not connected - could not place crash bet");
+            }
+            let result;
+            try {
+                result = await resultPromise;
+            }
+            finally {
+                removeTick();
+                removeTick = null;
+            }
+            const msg = `Crash round ended at ${result.crashPoint}x${result.payout ? ` - payout: ${result.payout} SOL` : ""}`;
+            if (callback)
+                await callback({ text: msg });
+            return { success: true, text: msg, data: result };
+        }
+        catch (err) {
+            const errMessage = err instanceof Error ? err.message : "Unknown error";
+            const msg = `Crash game failed: ${errMessage}`;
+            if (callback)
+                await callback({ text: msg });
+            return { success: false, error: errMessage };
+        }
+        finally {
+            if (removeTick)
+                removeTick();
+        }
+    },
+};

package/dist/actions/play-dice.d.ts

@@ -0,0 +1,2 @@
+import type { Action } from "../types.js";
+export declare const playDiceAction: Action;

package/dist/actions/play-dice.js

@@ -0,0 +1,43 @@
+import { ClientOp, ServerOp } from "../protocol.js";
+import { parseNumber } from "./helpers.js";
+export const playDiceAction = {
+    name: "RAZZ_PLAY_DICE",
+    description: "Play a dice game on Razz. Rolls 1-100, over 50 wins. 1.96x payout on wagers. Pass wager amount or 0 for free play.",
+    similes: ["PLAY_DICE", "ROLL_DICE", "DICE_BET", "DICE_GAME"],
+    examples: [
+        [
+            { name: "user", content: { text: "Roll dice for 0.01 SOL on Razz" } },
+            { name: "agent", content: { text: "Rolling dice... Rolled 73 - you win! Payout: 0.0196 SOL" } },
+        ],
+        [
+            { name: "user", content: { text: "Play a free dice game" } },
+            { name: "agent", content: { text: "Rolling dice... Rolled 23 - you lose! Better luck next time." } },
+        ],
+    ],
+    validate: async (runtime) => {
+        return runtime.getService("razz") !== null;
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        const service = runtime.getService("razz");
+        if (!service) {
+            return { success: false, error: "Razz service not available" };
+        }
+        try {
+            await service.ensureConnected();
+            const wager = parseNumber(message.content.text, "wager", 0, 1, 0);
+            const result = await service.sendAndWait(ClientOp.GamePlay, { gameType: "dice", wagerAmount: wager, currency: "SOL" }, ServerOp.GameResult, 10000);
+            const won = result.won ? "won" : "lost";
+            const text = `Rolled ${result.roll} - ${won}${result.payout ? ` ${result.payout} SOL` : ""}`;
+            if (callback)
+                await callback({ text });
+            return { success: true, text, data: result };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "Unknown error";
+            const text = `Dice game failed: ${message}`;
+            if (callback)
+                await callback({ text });
+            return { success: false, error: message };
+        }
+    },
+};

package/dist/actions/play-flip.d.ts

@@ -0,0 +1,2 @@
+import type { Action } from "../types.js";
+export declare const playFlipAction: Action;

package/dist/actions/play-flip.js

@@ -0,0 +1,39 @@
+import { ClientOp, ServerOp } from "../protocol.js";
+import { parseNumber } from "./helpers.js";
+export const playFlipAction = {
+    name: "RAZZ_PLAY_FLIP",
+    description: "Play a coin flip game on Razz. Heads wins, tails loses. 1.96x payout on wagers. Pass wager amount or 0 for free play.",
+    similes: ["PLAY_FLIP", "COIN_FLIP", "FLIP_BET", "FLIP_COIN"],
+    examples: [
+        [
+            { name: "user", content: { text: "Flip a coin for 0.05 SOL" } },
+            { name: "agent", content: { text: "Flipping coin... Heads - you win! Payout: 0.098 SOL" } },
+        ],
+    ],
+    validate: async (runtime) => {
+        return runtime.getService("razz") !== null;
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        const service = runtime.getService("razz");
+        if (!service) {
+            return { success: false, error: "Razz service not available" };
+        }
+        try {
+            await service.ensureConnected();
+            const wager = parseNumber(message.content.text, "wager", 0, 1, 0);
+            const result = await service.sendAndWait(ClientOp.GamePlay, { gameType: "flip", wagerAmount: wager, currency: "SOL" }, ServerOp.GameResult, 10000);
+            const side = result.won ? "Heads" : "Tails";
+            const text = `${side} - ${result.won ? "you win" : "you lose"}${result.payout ? ` ${result.payout} SOL` : ""}`;
+            if (callback)
+                await callback({ text });
+            return { success: true, text, data: result };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "Unknown error";
+            const text = `Flip game failed: ${message}`;
+            if (callback)
+                await callback({ text });
+            return { success: false, error: message };
+        }
+    },
+};

package/dist/actions/send-message.d.ts

@@ -0,0 +1,2 @@
+import type { Action } from "../types.js";
+export declare const sendMessageAction: Action;

package/dist/actions/send-message.js

@@ -0,0 +1,48 @@
+import { ClientOp, ServerOp } from "../protocol.js";
+export const sendMessageAction = {
+    name: "RAZZ_SEND_MESSAGE",
+    description: "Send a chat message in the current Razz room. The agent must be in a room first.",
+    similes: ["SEND_MESSAGE", "RAZZ_CHAT", "CHAT_MESSAGE"],
+    examples: [
+        [
+            { name: "user", content: { text: "Say 'gg' in the Razz chat" } },
+            { name: "agent", content: { text: "Sent message: gg" } },
+        ],
+    ],
+    validate: async (runtime) => {
+        return runtime.getService("razz") !== null;
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        const service = runtime.getService("razz");
+        if (!service) {
+            return { success: false, error: "Razz service not available" };
+        }
+        try {
+            await service.ensureConnected();
+            const raw = message.content.text || "";
+            // Extract quoted text or use whole message
+            let chatMsg = raw;
+            const quoted = raw.match(/['"`]([^'"`]+)['"`]/);
+            if (quoted)
+                chatMsg = quoted[1];
+            if (!chatMsg || chatMsg.length === 0) {
+                return { success: false, error: "No message content provided" };
+            }
+            if (chatMsg.length > 2000) {
+                chatMsg = chatMsg.slice(0, 2000);
+            }
+            await service.sendAndWait(ClientOp.SendMessage, { content: chatMsg }, ServerOp.MessageSent, 5000);
+            const text = `Sent message: ${chatMsg}`;
+            if (callback)
+                await callback({ text });
+            return { success: true, text };
+        }
+        catch (err) {
+            const errMessage = err instanceof Error ? err.message : "Unknown error";
+            const text = `Send message failed: ${errMessage}`;
+            if (callback)
+                await callback({ text });
+            return { success: false, error: errMessage };
+        }
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from "./types.js";
+declare const razzPlugin: Plugin;
+export default razzPlugin;
+export { RazzService } from "./services/razz-service.js";
+export type { Plugin, Action, Provider, Service, IAgentRuntime, } from "./types.js";

package/dist/index.js

@@ -0,0 +1,31 @@
+import { RazzService } from "./services/razz-service.js";
+import { playDiceAction } from "./actions/play-dice.js";
+import { playFlipAction } from "./actions/play-flip.js";
+import { playCrashAction } from "./actions/play-crash.js";
+import { checkBalanceAction } from "./actions/check-balance.js";
+import { sendMessageAction } from "./actions/send-message.js";
+import { getLeaderboardAction } from "./actions/get-leaderboard.js";
+import { balanceProvider } from "./providers/balance-provider.js";
+import { gameStateProvider } from "./providers/game-state-provider.js";
+const razzPlugin = {
+    name: "razz",
+    description: "Razz games platform - play dice, flip, crash with SOL wagering",
+    services: [RazzService],
+    actions: [
+        playDiceAction,
+        playFlipAction,
+        playCrashAction,
+        checkBalanceAction,
+        sendMessageAction,
+        getLeaderboardAction,
+    ],
+    providers: [balanceProvider, gameStateProvider],
+    init: async (_config, runtime) => {
+        const apiKey = runtime.getSetting("RAZZ_API_KEY");
+        if (!apiKey) {
+            console.warn("[razz] RAZZ_API_KEY not configured - plugin actions will fail");
+        }
+    },
+};
+export default razzPlugin;
+export { RazzService } from "./services/razz-service.js";

package/dist/protocol.d.ts

@@ -0,0 +1,23 @@
+export declare const ClientOp: {
+    readonly Authenticate: 1;
+    readonly JoinRoom: 20;
+    readonly SendMessage: 30;
+    readonly GamePlay: 186;
+    readonly GameAction: 187;
+    readonly Heartbeat: 199;
+    readonly GetBalance: 210;
+    readonly RequestDeposit: 211;
+    readonly GetLeaderboard: 213;
+};
+export declare const ServerOp: {
+    readonly Ready: 1;
+    readonly Error: 2;
+    readonly MessageSent: 30;
+    readonly RoomInfo: 90;
+    readonly GameResult: 186;
+    readonly GameError: 187;
+    readonly GameTick: 188;
+    readonly BalanceUpdate: 210;
+    readonly DepositInfo: 211;
+    readonly LeaderboardData: 213;
+};

package/dist/protocol.js

@@ -0,0 +1,25 @@
+// Opcodes inlined from Razz protocol - only the ones this plugin needs.
+// Avoids importing @razz/shared or the MCP server package.
+export const ClientOp = {
+    Authenticate: 1,
+    JoinRoom: 20,
+    SendMessage: 30,
+    GamePlay: 186,
+    GameAction: 187,
+    Heartbeat: 199,
+    GetBalance: 210,
+    RequestDeposit: 211,
+    GetLeaderboard: 213,
+};
+export const ServerOp = {
+    Ready: 1,
+    Error: 2,
+    MessageSent: 30,
+    RoomInfo: 90,
+    GameResult: 186,
+    GameError: 187,
+    GameTick: 188,
+    BalanceUpdate: 210,
+    DepositInfo: 211,
+    LeaderboardData: 213,
+};

package/dist/providers/balance-provider.d.ts

@@ -0,0 +1,2 @@
+import type { Provider } from "../types.js";
+export declare const balanceProvider: Provider;

package/dist/providers/balance-provider.js

@@ -0,0 +1,22 @@
+export const balanceProvider = {
+    name: "RAZZ_BALANCE",
+    description: "Current Razz platform balance for wagering",
+    dynamic: true,
+    get: async (runtime, _message, _state) => {
+        const service = runtime.getService("razz");
+        if (!service)
+            return {};
+        try {
+            const balance = await service.getBalance();
+            return {
+                text: `[Razz Balance] ${balance.amount} ${balance.currency}`,
+                values: { razzBalance: balance.amount, razzCurrency: balance.currency },
+                data: { razzBalanceData: balance.raw },
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Unknown error";
+            return { text: `[Razz Balance] unavailable: ${msg}` };
+        }
+    },
+};

package/dist/providers/game-state-provider.d.ts

@@ -0,0 +1,2 @@
+import type { Provider } from "../types.js";
+export declare const gameStateProvider: Provider;

package/dist/providers/game-state-provider.js

@@ -0,0 +1,34 @@
+export const gameStateProvider = {
+    name: "RAZZ_GAME_STATE",
+    description: "Active Razz game state - crash rounds, rooms, live matches",
+    dynamic: true,
+    get: async (runtime, _message, _state) => {
+        const service = runtime.getService("razz");
+        if (!service)
+            return {};
+        try {
+            const state = await service.getCrashState();
+            if (!state)
+                return {};
+            const stateObj = state;
+            const rooms = Array.isArray(state) ? state : stateObj.rooms || [];
+            if (rooms.length === 0)
+                return {};
+            const lines = rooms.map((r) => {
+                const phase = r.phase || "unknown";
+                const multi = r.multiplier ? ` ${r.multiplier}x` : "";
+                const players = r.playerCount ? ` (${r.playerCount} players)` : "";
+                const name = r.name || r.roomId || "crash";
+                return `- ${name}: ${phase}${multi}${players}`;
+            });
+            return {
+                text: `[Razz Games]\n${lines.join("\n")}`,
+                data: { razzCrashState: state },
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Unknown error";
+            return { text: `[Razz Games] unavailable: ${msg}` };
+        }
+    },
+};

package/dist/services/razz-service.d.ts

@@ -0,0 +1,55 @@
+import { Service } from "../types.js";
+import type { IAgentRuntime } from "../types.js";
+export interface BalanceInfo {
+    amount: string;
+    currency: string;
+    raw: unknown;
+}
+export declare class RazzService extends Service {
+    static serviceType: string;
+    capabilityDescription: string;
+    private ws;
+    private apiKey;
+    private wsUrl;
+    private apiUrl;
+    private pending;
+    private listeners;
+    private _ready;
+    private heartbeatTimer;
+    private connectPromise;
+    private destroyed;
+    private reconnectDelay;
+    private readonly maxReconnectDelay;
+    private reconnectTimer;
+    private _initialConnect;
+    private balanceCache;
+    private crashStateCache;
+    private readonly CACHE_TTL;
+    constructor(apiKey: string, wsUrl: string, apiUrl: string);
+    get ready(): boolean;
+    static start(runtime: IAgentRuntime): Promise<RazzService>;
+    stop(): Promise<void>;
+    ensureConnected(): Promise<void>;
+    private _doConnect;
+    private _handleMessage;
+    /** Fire-and-forget send. Returns false if not connected. */
+    send(op: number, data: unknown): boolean;
+    sendAndWait<T = unknown>(sendOp: number, data: unknown, expectOp: number, timeoutMs?: number): Promise<T>;
+    waitFor<T = unknown>(expectOp: number, timeoutMs?: number): Promise<T>;
+    on(op: number, callback: (data: unknown) => void): () => void;
+    getBalance(): Promise<BalanceInfo>;
+    getCrashState(): Promise<unknown | null>;
+    restGet<T = unknown>(path: string): Promise<T>;
+    restPost<T = unknown>(path: string, body: unknown): Promise<T>;
+    destroy(): void;
+    private _rawSend;
+    private _resolvePending;
+    private _rejectPendingGame;
+    private _rejectOldestPending;
+    private _removePending;
+    private _rejectAll;
+    private _startHeartbeat;
+    private _stopHeartbeat;
+    private _cleanup;
+    private _scheduleReconnect;
+}

package/dist/services/razz-service.js

@@ -0,0 +1,328 @@
+import WebSocket from "ws";
+import { Service } from "../types.js";
+import { ClientOp, ServerOp } from "../protocol.js";
+export class RazzService extends Service {
+    static serviceType = "razz";
+    capabilityDescription = "Persistent connection to Razz games platform";
+    ws = null;
+    apiKey;
+    wsUrl;
+    apiUrl;
+    pending = new Map();
+    listeners = new Map();
+    _ready = false;
+    heartbeatTimer = null;
+    connectPromise = null;
+    destroyed = false;
+    reconnectDelay = 1000;
+    maxReconnectDelay = 30000;
+    reconnectTimer = null;
+    _initialConnect = true;
+    // Cache for providers
+    balanceCache = null;
+    crashStateCache = null;
+    CACHE_TTL = 30000;
+    constructor(apiKey, wsUrl, apiUrl) {
+        super();
+        this.apiKey = apiKey;
+        this.wsUrl = wsUrl;
+        this.apiUrl = apiUrl;
+    }
+    get ready() {
+        return this._ready;
+    }
+    static async start(runtime) {
+        const apiKey = runtime.getSetting("RAZZ_API_KEY");
+        if (!apiKey)
+            throw new Error("RAZZ_API_KEY not configured");
+        const wsUrl = runtime.getSetting("RAZZ_WS_URL") || "wss://razz.games/ws";
+        const apiUrl = runtime.getSetting("RAZZ_API_URL") || "https://razz.games/api";
+        const service = new RazzService(apiKey, wsUrl, apiUrl);
+        await service.ensureConnected();
+        return service;
+    }
+    async stop() {
+        this.destroy();
+    }
+    async ensureConnected() {
+        if (this._ready && this.ws?.readyState === WebSocket.OPEN)
+            return;
+        if (this.connectPromise)
+            return this.connectPromise;
+        this.connectPromise = this._doConnect();
+        try {
+            await this.connectPromise;
+        }
+        finally {
+            this.connectPromise = null;
+        }
+    }
+    _doConnect() {
+        return new Promise((resolve, reject) => {
+            if (this.destroyed) {
+                reject(new Error("Service destroyed"));
+                return;
+            }
+            const origin = this.wsUrl.replace(/^ws(s?):/, "http$1:").replace(/\/ws$/, "");
+            this.ws = new WebSocket(this.wsUrl, { headers: { Origin: origin } });
+            const authTimeout = setTimeout(() => {
+                reject(new Error("Auth timeout - no Ready response within 10s"));
+                this.ws?.close();
+            }, 10000);
+            this.ws.on("open", () => {
+                this.reconnectDelay = 1000;
+                this._rawSend(ClientOp.Authenticate, { token: `AGENT:${this.apiKey}` });
+            });
+            this.ws.on("message", (raw) => {
+                let msg;
+                try {
+                    msg = JSON.parse(raw.toString());
+                }
+                catch {
+                    return;
+                }
+                this._handleMessage(msg.op, msg.d, { authTimeout, resolve });
+            });
+            this.ws.on("close", () => {
+                const wasInitial = this._initialConnect;
+                this._cleanup();
+                if (wasInitial) {
+                    reject(new Error("Connection closed before auth completed"));
+                    return;
+                }
+                if (!this.destroyed) {
+                    this._scheduleReconnect();
+                }
+            });
+            this.ws.on("error", (err) => {
+                clearTimeout(authTimeout);
+                if (this._initialConnect && !this._ready) {
+                    reject(err);
+                }
+            });
+        });
+    }
+    _handleMessage(op, d, auth) {
+        if (op === ServerOp.Ready && auth) {
+            clearTimeout(auth.authTimeout);
+            this._ready = true;
+            this._initialConnect = false;
+            this._startHeartbeat();
+            auth.resolve();
+            return;
+        }
+        if (op === ServerOp.Error) {
+            const errMsg = String(d?.message || d?.error || "Server error");
+            this._rejectOldestPending(new Error(errMsg));
+            return;
+        }
+        if (op === ServerOp.GameError) {
+            const errMsg = String(d?.message || d?.error || "Game error");
+            this._rejectPendingGame(new Error(errMsg));
+            return;
+        }
+        // Resolve matching pending requests
+        this._resolvePending(op, d);
+        // Notify listeners
+        const callbacks = this.listeners.get(op);
+        if (callbacks) {
+            for (const cb of [...callbacks])
+                cb(d);
+        }
+    }
+    /** Fire-and-forget send. Returns false if not connected. */
+    send(op, data) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+            return false;
+        this.ws.send(JSON.stringify({ op, d: data }));
+        return true;
+    }
+    sendAndWait(sendOp, data, expectOp, timeoutMs = 10000) {
+        if (!this.send(sendOp, data)) {
+            return Promise.reject(new Error("Not connected"));
+        }
+        return this.waitFor(expectOp, timeoutMs);
+    }
+    waitFor(expectOp, timeoutMs = 10000) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this._removePending(expectOp, entry);
+                reject(new Error(`Timeout waiting for response (op=${expectOp})`));
+            }, timeoutMs);
+            const entry = {
+                resolve: resolve,
+                reject,
+                timer,
+            };
+            const queue = this.pending.get(expectOp) || [];
+            queue.push(entry);
+            this.pending.set(expectOp, queue);
+        });
+    }
+    on(op, callback) {
+        if (!this.listeners.has(op))
+            this.listeners.set(op, []);
+        this.listeners.get(op).push(callback);
+        return () => {
+            const list = this.listeners.get(op);
+            if (list) {
+                const idx = list.indexOf(callback);
+                if (idx !== -1)
+                    list.splice(idx, 1);
+            }
+        };
+    }
+    // High-level methods used by providers
+    async getBalance() {
+        if (this.balanceCache && Date.now() - this.balanceCache.ts < this.CACHE_TTL) {
+            return this.balanceCache.data;
+        }
+        await this.ensureConnected();
+        const data = await this.sendAndWait(ClientOp.GetBalance, {}, ServerOp.BalanceUpdate, 5000);
+        const balances = data.balances || [];
+        const sol = balances.find((b) => b.currency === "SOL" || b.currency === "sol");
+        const result = {
+            amount: sol ? String(sol.available || sol.amount || "0") : "0",
+            currency: "SOL",
+            raw: data,
+        };
+        this.balanceCache = { data: result, ts: Date.now() };
+        return result;
+    }
+    async getCrashState() {
+        if (this.crashStateCache && Date.now() - this.crashStateCache.ts < this.CACHE_TTL) {
+            return this.crashStateCache.data;
+        }
+        try {
+            const data = await this.restGet("/matches/live");
+            this.crashStateCache = { data, ts: Date.now() };
+            return data;
+        }
+        catch {
+            return null;
+        }
+    }
+    async restGet(path) {
+        const url = `${this.apiUrl}${path}`;
+        const resp = await fetch(url, {
+            headers: { Authorization: `Bearer AGENT:${this.apiKey}` },
+        });
+        if (!resp.ok) {
+            throw new Error(`GET ${path}: ${resp.status} ${resp.statusText}`);
+        }
+        return resp.json();
+    }
+    async restPost(path, body) {
+        const url = `${this.apiUrl}${path}`;
+        const resp = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer AGENT:${this.apiKey}`,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!resp.ok) {
+            throw new Error(`POST ${path}: ${resp.status} ${resp.statusText}`);
+        }
+        return resp.json();
+    }
+    destroy() {
+        this.destroyed = true;
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        this._cleanup();
+        this.ws?.close();
+        this.ws = null;
+        this.balanceCache = null;
+        this.crashStateCache = null;
+    }
+    // Internal helpers
+    _rawSend(op, data) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error("WebSocket not connected");
+        }
+        this.ws.send(JSON.stringify({ op, d: data }));
+    }
+    _resolvePending(op, data) {
+        const queue = this.pending.get(op);
+        if (!queue || queue.length === 0)
+            return;
+        const entry = queue.shift();
+        clearTimeout(entry.timer);
+        entry.resolve(data);
+        if (queue.length === 0)
+            this.pending.delete(op);
+    }
+    _rejectPendingGame(err) {
+        for (const op of [ServerOp.GameResult, ServerOp.GameTick]) {
+            const queue = this.pending.get(op);
+            if (queue && queue.length > 0) {
+                const entry = queue.shift();
+                clearTimeout(entry.timer);
+                entry.reject(err);
+                if (queue.length === 0)
+                    this.pending.delete(op);
+                return;
+            }
+        }
+    }
+    _rejectOldestPending(err) {
+        for (const [op, queue] of this.pending) {
+            if (queue.length > 0) {
+                const entry = queue.shift();
+                clearTimeout(entry.timer);
+                entry.reject(err);
+                if (queue.length === 0)
+                    this.pending.delete(op);
+                return;
+            }
+        }
+    }
+    _removePending(op, entry) {
+        const queue = this.pending.get(op);
+        if (!queue)
+            return;
+        const idx = queue.indexOf(entry);
+        if (idx >= 0)
+            queue.splice(idx, 1);
+        if (queue.length === 0)
+            this.pending.delete(op);
+    }
+    _rejectAll(reason) {
+        for (const [, queue] of this.pending) {
+            for (const entry of queue) {
+                clearTimeout(entry.timer);
+                entry.reject(new Error(reason));
+            }
+        }
+        this.pending.clear();
+    }
+    _startHeartbeat() {
+        this.heartbeatTimer = setInterval(() => {
+            this.send(ClientOp.Heartbeat, {});
+        }, 30000);
+        this.heartbeatTimer.unref();
+    }
+    _stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    _cleanup() {
+        this._stopHeartbeat();
+        this._ready = false;
+        this._rejectAll("Connection closed");
+    }
+    _scheduleReconnect() {
+        if (this.destroyed)
+            return;
+        const jitter = this.reconnectDelay * (0.75 + Math.random() * 0.5);
+        this.reconnectTimer = setTimeout(() => {
+            this.connectPromise = null;
+            this.ensureConnected().catch(() => { });
+        }, jitter);
+        this.reconnectDelay = Math.min(this.reconnectDelay * 2, this.maxReconnectDelay);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,65 @@
+export interface IAgentRuntime {
+    agentId: string;
+    getSetting(key: string): string | undefined;
+    getService<T>(name: string): T | null;
+}
+export interface Memory {
+    id?: string;
+    entityId: string;
+    content: Content;
+    roomId: string;
+}
+export interface Content {
+    text?: string;
+    source?: string;
+    [key: string]: any;
+}
+export interface State {
+    values: Record<string, any>;
+    data?: Record<string, any>;
+    text: string;
+}
+export interface ActionResult {
+    success: boolean;
+    text?: string;
+    data?: Record<string, any>;
+    error?: string;
+}
+export interface ActionExample {
+    name: string;
+    content: Content;
+}
+export type HandlerCallback = (response: Content) => Promise<Memory[]>;
+export interface Action {
+    name: string;
+    description: string;
+    similes?: string[];
+    examples?: ActionExample[][];
+    validate: (runtime: IAgentRuntime, message: Memory, state?: State) => Promise<boolean>;
+    handler: (runtime: IAgentRuntime, message: Memory, state?: State, options?: Record<string, any>, callback?: HandlerCallback) => Promise<ActionResult | void>;
+}
+export interface ProviderResult {
+    text?: string;
+    values?: Record<string, any>;
+    data?: Record<string, any>;
+}
+export interface Provider {
+    name: string;
+    description?: string;
+    dynamic?: boolean;
+    get: (runtime: IAgentRuntime, message: Memory, state: State) => Promise<ProviderResult>;
+}
+export declare abstract class Service {
+    static serviceType: string;
+    abstract capabilityDescription: string;
+    static start(_runtime: IAgentRuntime): Promise<Service>;
+    abstract stop(): Promise<void>;
+}
+export interface Plugin {
+    name: string;
+    description: string;
+    init?: (config: Record<string, string>, runtime: IAgentRuntime) => Promise<void>;
+    actions?: Action[];
+    providers?: Provider[];
+    services?: (typeof Service)[];
+}

package/dist/types.js

@@ -0,0 +1,9 @@
+// Minimal type definitions matching ElizaOS v2 Plugin/Action/Provider/Service interfaces.
+// Defined locally to avoid heavy @elizaos/core dependency at build time.
+// Structurally compatible with the real SDK types via duck typing.
+export class Service {
+    static serviceType;
+    static async start(_runtime) {
+        throw new Error("Not implemented");
+    }
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@razzgames/elizaos-plugin",
+  "version": "0.1.0",
+  "description": "Razz games plugin for ElizaOS - play dice, flip, crash with SOL wagering",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "@elizaos/core": ">=1.0.0"
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.13",
+    "typescript": "^5.7.0",
+    "vitest": "^4.1.2"
+  },
+  "keywords": [
+    "elizaos",
+    "eliza",
+    "plugin",
+    "ai-agent",
+    "solana",
+    "gaming",
+    "betting",
+    "razz"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/razz-games/razz-elizaos-plugin"
+  }
+}