@elizaos/ui 2.0.0-alpha.85 → 2.0.0-beta.2

package/utils/number-parsing.d.ts

@@ -0,0 +1,26 @@
+export interface ParsePositiveNumberOptions {
+    fallback?: number;
+    floor?: boolean;
+}
+export interface ParseClampedNumberOptions {
+    min?: number;
+    max?: number;
+    fallback?: number;
+}
+export interface ParseClampedIntegerOptions {
+    min?: number;
+    max?: number;
+    fallback?: number;
+}
+export declare function parsePositiveInteger(value: string | null | undefined, fallback: number): number;
+export declare function parsePositiveInteger(value: string | null | undefined, fallback?: number): number | undefined;
+export declare function parsePositiveFloat(value: string | null | undefined, options?: ParsePositiveNumberOptions): number | undefined;
+export declare function parseClampedFloat(value: string | null | undefined, options: ParseClampedNumberOptions & {
+    fallback: number;
+}): number;
+export declare function parseClampedFloat(value: string | null | undefined, options?: ParseClampedNumberOptions): number | undefined;
+export declare function parseClampedInteger(value: string | null | undefined, options: ParseClampedIntegerOptions & {
+    fallback: number;
+}): number;
+export declare function parseClampedInteger(value: string | null | undefined, options?: ParseClampedIntegerOptions): number | undefined;
+//# sourceMappingURL=number-parsing.d.ts.map

package/utils/number-parsing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-parsing.d.ts","sourceRoot":"","sources":["../../../../../src/utils/number-parsing.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,yBAAyB;IACxC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,0BAA0B;IACzC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAUD,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,QAAQ,EAAE,MAAM,GACf,MAAM,CAAC;AACV,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,GAAG,SAAS,CAAC;AAgBtB,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,OAAO,CAAC,EAAE,0BAA0B,GACnC,MAAM,GAAG,SAAS,CAUpB;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,OAAO,EAAE,yBAAyB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GACxD,MAAM,CAAC;AACV,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,OAAO,CAAC,EAAE,yBAAyB,GAClC,MAAM,GAAG,SAAS,CAAC;AAgBtB,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,OAAO,EAAE,0BAA0B,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GACzD,MAAM,CAAC;AACV,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAChC,OAAO,CAAC,EAAE,0BAA0B,GACnC,MAAM,GAAG,SAAS,CAAC"}

package/utils/number-parsing.js

@@ -0,0 +1,51 @@
+function sanitizeNumericText(value) {
+    return value == null ? "" : value.trim();
+}
+function normalizeFallback(fallback) {
+    return Number.isFinite(fallback) ? fallback : undefined;
+}
+export function parsePositiveInteger(value, fallback) {
+    const raw = sanitizeNumericText(value);
+    if (!raw)
+        return normalizeFallback(fallback);
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return normalizeFallback(fallback);
+    }
+    return Math.max(1, Math.floor(parsed));
+}
+export function parsePositiveFloat(value, options) {
+    const raw = sanitizeNumericText(value);
+    if (!raw)
+        return normalizeFallback(options?.fallback);
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return normalizeFallback(options?.fallback);
+    }
+    return options?.floor ? Math.floor(parsed) : parsed;
+}
+export function parseClampedFloat(value, options = {}) {
+    const raw = sanitizeNumericText(value);
+    if (!raw)
+        return normalizeFallback(options.fallback);
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed))
+        return normalizeFallback(options.fallback);
+    const min = options.min ?? -Infinity;
+    const max = options.max ?? Infinity;
+    return Math.max(min, Math.min(max, parsed));
+}
+export function parseClampedInteger(value, options = {}) {
+    const raw = sanitizeNumericText(value);
+    if (!raw)
+        return normalizeFallback(options.fallback);
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed))
+        return normalizeFallback(options.fallback);
+    const { min, max } = options;
+    if (min !== undefined && parsed < min)
+        return min;
+    if (max !== undefined && parsed > max)
+        return max;
+    return parsed;
+}

package/utils/openExternalUrl.d.ts

@@ -0,0 +1,22 @@
+export declare function openExternalUrl(url: string): Promise<void>;
+export declare function closeExternalBrowser(): Promise<void>;
+/**
+ * Pre-open a blank window **synchronously** inside a user-gesture handler,
+ * then navigate it after an async API call resolves with the real URL.
+ * This avoids popup-blocker issues that occur when `window.open` is called
+ * after an `await` (losing the user-gesture context).
+ *
+ * Usage:
+ * ```ts
+ * const win = preOpenWindow();
+ * const { authUrl } = await client.startLogin();
+ * navigatePreOpenedWindow(win, authUrl);
+ * ```
+ */
+export declare function preOpenWindow(): Window | null;
+/**
+ * Navigate a pre-opened window to the real URL, or fall back to
+ * `openExternalUrl` if the pre-open was blocked / we're on desktop.
+ */
+export declare function navigatePreOpenedWindow(popup: Window | null, url: string): void;
+//# sourceMappingURL=openExternalUrl.d.ts.map

package/utils/openExternalUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openExternalUrl.d.ts","sourceRoot":"","sources":["../../../../../src/utils/openExternalUrl.ts"],"names":[],"mappings":"AAiCA,wBAAsB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAsChE;AAED,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC,CAS1D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,IAAI,MAAM,GAAG,IAAI,CAY7C;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,GAAG,IAAI,EACpB,GAAG,EAAE,MAAM,GACV,IAAI,CAaN"}

package/utils/openExternalUrl.js

@@ -0,0 +1,108 @@
+import { Capacitor, registerPlugin } from "@capacitor/core";
+import { getElectrobunRendererRpc, invokeDesktopBridgeRequestWithTimeout, } from "../bridge/electrobun-rpc.js";
+let registeredCapacitorBrowser = null;
+function isCapacitorGlobal(value) {
+    return !!value && typeof value === "object";
+}
+function getCapacitorBrowser() {
+    if (!Capacitor.isNativePlatform())
+        return null;
+    const cap = Reflect.get(globalThis, "Capacitor");
+    if (isCapacitorGlobal(cap) && cap.Plugins?.Browser) {
+        return cap.Plugins.Browser;
+    }
+    registeredCapacitorBrowser ??=
+        registerPlugin("Browser");
+    return registeredCapacitorBrowser;
+}
+export async function openExternalUrl(url) {
+    // Capacitor native (iOS WKWebView / Android WebView): use the Browser
+    // plugin. Avoids `window.open` which loses user-gesture context across
+    // awaits and is silently dropped by WKWebView.
+    const capacitorBrowser = getCapacitorBrowser();
+    if (capacitorBrowser) {
+        await capacitorBrowser.open({ url });
+        return;
+    }
+    const bridged = await invokeDesktopBridgeRequestWithTimeout({
+        rpcMethod: "desktopOpenExternal",
+        ipcChannel: "desktop:openExternal",
+        params: { url },
+        timeoutMs: 10_000,
+    });
+    if (bridged !== null && bridged.status === "ok")
+        return;
+    // Inside Electrobun — never fall through to window.open() which spawns an
+    // unmanaged BrowserView to an external URL and crashes the shell.
+    if (getElectrobunRendererRpc() !== undefined) {
+        console.warn("[openExternalUrl] desktopOpenExternal RPC returned null — skipping window.open fallback");
+        return;
+    }
+    // Non-desktop (web browser) fallback.
+    if (typeof window === "undefined" || typeof window.open !== "function") {
+        console.warn("[openExternalUrl] window.open unavailable — URL:", url);
+        return;
+    }
+    const popup = window.open(url, "_blank", "noopener,noreferrer");
+    if (!popup) {
+        console.warn("[openExternalUrl] popup blocked — URL:", url);
+    }
+}
+export async function closeExternalBrowser() {
+    const capacitorBrowser = getCapacitorBrowser();
+    if (!capacitorBrowser?.close)
+        return;
+    try {
+        await capacitorBrowser.close();
+    }
+    catch {
+        // Browser.close rejects when there is no active native browser window.
+    }
+}
+/**
+ * Pre-open a blank window **synchronously** inside a user-gesture handler,
+ * then navigate it after an async API call resolves with the real URL.
+ * This avoids popup-blocker issues that occur when `window.open` is called
+ * after an `await` (losing the user-gesture context).
+ *
+ * Usage:
+ * ```ts
+ * const win = preOpenWindow();
+ * const { authUrl } = await client.startLogin();
+ * navigatePreOpenedWindow(win, authUrl);
+ * ```
+ */
+export function preOpenWindow() {
+    if (getElectrobunRendererRpc() !== undefined)
+        return null; // Desktop uses RPC
+    // Capacitor native: openExternalUrl uses the Browser plugin (no
+    // gesture-context dependency). Avoid window.open here because WKWebView's
+    // delegate would route "about:blank" to UIApplication.shared.open and
+    // briefly flash Safari before the real URL ever resolves.
+    if (Capacitor.isNativePlatform())
+        return null;
+    if (typeof window === "undefined" || typeof window.open !== "function")
+        return null;
+    // Open a blank window synchronously (preserves user-gesture context).
+    // No noopener (nullifies return value) or noreferrer (can make about:blank cross-origin).
+    return window.open("about:blank", "_blank");
+}
+/**
+ * Navigate a pre-opened window to the real URL, or fall back to
+ * `openExternalUrl` if the pre-open was blocked / we're on desktop.
+ */
+export function navigatePreOpenedWindow(popup, url) {
+    if (popup && !popup.closed) {
+        popup.location.href = url;
+        // Security: sever the opener reference now that navigation is done.
+        try {
+            popup.opener = null;
+        }
+        catch {
+            /* cross-origin — fine */
+        }
+        return;
+    }
+    // Fallback — desktop RPC or retry window.open
+    void openExternalUrl(url);
+}

package/utils/owner-name.d.ts

@@ -0,0 +1,3 @@
+export declare const OWNER_NAME_MAX_LENGTH = 60;
+export declare function normalizeOwnerName(value: string | null | undefined): string;
+//# sourceMappingURL=owner-name.d.ts.map

package/utils/owner-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"owner-name.d.ts","sourceRoot":"","sources":["../../../../../src/utils/owner-name.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAExC,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAM3E"}

package/utils/owner-name.js

@@ -0,0 +1,7 @@
+export const OWNER_NAME_MAX_LENGTH = 60;
+export function normalizeOwnerName(value) {
+    if (typeof value !== "string") {
+        return "";
+    }
+    return value.trim().slice(0, OWNER_NAME_MAX_LENGTH);
+}

package/utils/rate-limiter.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Generic in-memory rate limiter with automatic sweep.
+ *
+ * Consolidates the per-IP rate limiting pattern from
+ * `@elizaos/plugin-wallet/lib/wallet-export-guard` and the pairing attempt
+ * limiter in `server.ts`.
+ */
+export interface RateLimiterOptions {
+    /** Time window in milliseconds. An action is blocked if the last allowed
+     *  action for the same key happened less than `windowMs` ago. */
+    windowMs: number;
+    /** How often (ms) to sweep stale entries. Defaults to `windowMs * 1.5`. */
+    sweepIntervalMs?: number;
+}
+export interface RateLimitCheck {
+    /** `true` if the action is allowed. */
+    allowed: boolean;
+    /** Seconds until the action would be allowed again (0 when allowed). */
+    retryAfterSeconds: number;
+}
+export interface RateLimiter {
+    /** Check *and* record an action for `key`. */
+    check(key: string): RateLimitCheck;
+    /** Peek without recording — returns the same shape but doesn't consume. */
+    peek(key: string): RateLimitCheck;
+    /** Remove all tracked keys. */
+    clear(): void;
+    /** Stop the background sweep timer (for clean shutdown / tests). */
+    dispose(): void;
+}
+export declare function createRateLimiter(opts: RateLimiterOptions): RateLimiter;
+//# sourceMappingURL=rate-limiter.d.ts.map

package/utils/rate-limiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limiter.d.ts","sourceRoot":"","sources":["../../../../../src/utils/rate-limiter.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,kBAAkB;IACjC;qEACiE;IACjE,QAAQ,EAAE,MAAM,CAAC;IACjB,2EAA2E;IAC3E,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc;IAC7B,uCAAuC;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,wEAAwE;IACxE,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,WAAW;IAC1B,8CAA8C;IAC9C,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAAC;IACnC,2EAA2E;IAC3E,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAAC;IAClC,+BAA+B;IAC/B,KAAK,IAAI,IAAI,CAAC;IACd,oEAAoE;IACpE,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,kBAAkB,GAAG,WAAW,CA6CvE"}

package/utils/rate-limiter.js

@@ -0,0 +1,52 @@
+/**
+ * Generic in-memory rate limiter with automatic sweep.
+ *
+ * Consolidates the per-IP rate limiting pattern from
+ * `@elizaos/plugin-wallet/lib/wallet-export-guard` and the pairing attempt
+ * limiter in `server.ts`.
+ */
+export function createRateLimiter(opts) {
+    const { windowMs } = opts;
+    const sweepIntervalMs = opts.sweepIntervalMs ?? Math.ceil(windowMs * 1.5);
+    const map = new Map(); // key → lastActionAt
+    const sweepTimer = setInterval(() => {
+        const cutoff = Date.now() - windowMs * 2;
+        for (const [key, ts] of map) {
+            if (ts < cutoff)
+                map.delete(key);
+        }
+    }, sweepIntervalMs);
+    // Allow the process to exit without this timer holding it
+    if (typeof sweepTimer === "object" && "unref" in sweepTimer) {
+        sweepTimer.unref();
+    }
+    function peekImpl(key) {
+        const last = map.get(key);
+        if (last === undefined)
+            return { allowed: true, retryAfterSeconds: 0 };
+        const elapsed = Date.now() - last;
+        if (elapsed >= windowMs)
+            return { allowed: true, retryAfterSeconds: 0 };
+        return {
+            allowed: false,
+            retryAfterSeconds: Math.ceil((windowMs - elapsed) / 1000),
+        };
+    }
+    return {
+        check(key) {
+            const result = peekImpl(key);
+            if (result.allowed) {
+                map.set(key, Date.now());
+            }
+            return result;
+        },
+        peek: peekImpl,
+        clear() {
+            map.clear();
+        },
+        dispose() {
+            clearInterval(sweepTimer);
+            map.clear();
+        },
+    };
+}

package/utils/serialise.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Creates a serialised (sequential) promise queue.
+ *
+ * Each call to the returned function chains the provided async `fn` after
+ * the previous one completes, ensuring only one operation runs at a time.
+ *
+ * Usage:
+ *   const run = createSerialise();
+ *   await run(async () => { ... });
+ */
+export declare function createSerialise(): <T>(fn: () => Promise<T>) => Promise<T>;
+//# sourceMappingURL=serialise.d.ts.map

package/utils/serialise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialise.d.ts","sourceRoot":"","sources":["../../../../../src/utils/serialise.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,eAAe,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAUzE"}

package/utils/serialise.js

@@ -0,0 +1,21 @@
+/**
+ * Creates a serialised (sequential) promise queue.
+ *
+ * Each call to the returned function chains the provided async `fn` after
+ * the previous one completes, ensuring only one operation runs at a time.
+ *
+ * Usage:
+ *   const run = createSerialise();
+ *   await run(async () => { ... });
+ */
+export function createSerialise() {
+    let lock = Promise.resolve();
+    return (fn) => {
+        const prev = lock;
+        let resolve;
+        lock = new Promise((r) => {
+            resolve = r;
+        });
+        return prev.then(fn).finally(() => resolve?.());
+    };
+}

package/utils/sql-compat.d.ts

@@ -0,0 +1,10 @@
+import type { AgentRuntime } from "@elizaos/core";
+export declare function quoteIdent(name: string): string;
+export declare function sanitizeIdentifier(value: string | null | undefined): string | null;
+export declare function sqlLiteral(value: string): string;
+export declare function executeRawSql(runtime: AgentRuntime, sqlText: string): Promise<{
+    rows: Record<string, unknown>[];
+    columns: string[];
+}>;
+export declare function ensureRuntimeSqlCompatibility(runtime: AgentRuntime | null | undefined): Promise<void>;
+//# sourceMappingURL=sql-compat.d.ts.map

package/utils/sql-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-compat.d.ts","sourceRoot":"","sources":["../../../../../src/utils/sql-compat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAKlD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,MAAM,GAAG,IAAI,CAOf;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED,wBAAsB,aAAa,CACjC,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC;IACT,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IAChC,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC,CAsBD;AAyED,wBAAsB,6BAA6B,CACjD,OAAO,EAAE,YAAY,GAAG,IAAI,GAAG,SAAS,GACvC,OAAO,CAAC,IAAI,CAAC,CA2Cf"}

package/utils/sql-compat.js

@@ -0,0 +1,111 @@
+const repairedRuntimes = new WeakSet();
+const repairPromises = new WeakMap();
+export function quoteIdent(name) {
+    return `"${name.replace(/"/g, '""')}"`;
+}
+export function sanitizeIdentifier(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    const sanitized = trimmed.replace(/[^a-zA-Z0-9_]/g, "");
+    if (sanitized.length === 0 || sanitized.length > 128)
+        return null;
+    return sanitized;
+}
+export function sqlLiteral(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+export async function executeRawSql(runtime, sqlText) {
+    const db = runtime.adapter?.db;
+    if (!db?.execute) {
+        throw new Error("Database adapter not available");
+    }
+    const { sql } = await import("drizzle-orm");
+    const result = await db.execute(sql.raw(sqlText));
+    const rows = Array.isArray(result.rows) ? result.rows : [];
+    const columns = Array.isArray(result.fields)
+        ? result.fields.map((field) => field.name)
+        : Object.keys(rows[0] ?? {});
+    return { rows, columns };
+}
+async function getTableColumnNames(runtime, tableName, schemaName = "public") {
+    const columns = new Set();
+    try {
+        const { rows } = await executeRawSql(runtime, `SELECT column_name
+         FROM information_schema.columns
+        WHERE table_schema = ${sqlLiteral(schemaName)}
+          AND table_name = ${sqlLiteral(tableName)}
+        ORDER BY ordinal_position`);
+        for (const row of rows) {
+            const value = row.column_name;
+            if (typeof value === "string" && value.length > 0) {
+                columns.add(value);
+            }
+        }
+    }
+    catch {
+        // Fall through to PRAGMA for PGlite/SQLite compatibility.
+    }
+    if (columns.size > 0) {
+        return columns;
+    }
+    try {
+        const safeTableName = sanitizeIdentifier(tableName);
+        if (!safeTableName) {
+            return columns;
+        }
+        const { rows } = await executeRawSql(runtime, `PRAGMA table_info(${safeTableName})`);
+        for (const row of rows) {
+            const value = row.name;
+            if (typeof value === "string" && value.length > 0) {
+                columns.add(value);
+            }
+        }
+    }
+    catch {
+        // Ignore missing-table/missing-pragma support.
+    }
+    return columns;
+}
+async function addColumnIfMissing(runtime, tableName, columnName, definition) {
+    const columns = await getTableColumnNames(runtime, tableName);
+    if (columns.has(columnName)) {
+        return;
+    }
+    throw new Error(`[sql-compat] Missing required column ${quoteIdent(tableName)}.${quoteIdent(columnName)} (${definition}). Run the appropriate database migrations before starting the app.`);
+}
+export async function ensureRuntimeSqlCompatibility(runtime) {
+    if (!runtime?.adapter?.db) {
+        return;
+    }
+    if (repairedRuntimes.has(runtime)) {
+        return;
+    }
+    const existingRepair = repairPromises.get(runtime);
+    if (existingRepair) {
+        await existingRepair;
+        return;
+    }
+    const repairPromise = (async () => {
+        await addColumnIfMissing(runtime, "participants", "agent_id", 'uuid REFERENCES "agents"("id") ON DELETE CASCADE');
+        await addColumnIfMissing(runtime, "participants", "room_state", "text");
+        for (const [columnName, definition] of [
+            ["step_count", "integer NOT NULL DEFAULT 0"],
+            ["llm_call_count", "integer NOT NULL DEFAULT 0"],
+            ["total_prompt_tokens", "integer NOT NULL DEFAULT 0"],
+            ["total_completion_tokens", "integer NOT NULL DEFAULT 0"],
+            ["total_reward", "real NOT NULL DEFAULT 0"],
+            ["scenario_id", "text"],
+            ["batch_id", "text"],
+        ]) {
+            await addColumnIfMissing(runtime, "trajectories", columnName, definition);
+        }
+        repairedRuntimes.add(runtime);
+    })().finally(() => {
+        repairPromises.delete(runtime);
+    });
+    repairPromises.set(runtime, repairPromise);
+    await repairPromise;
+}

package/utils/streaming-text.d.ts

@@ -0,0 +1,9 @@
+export declare function mergeStreamingText(existing: string, incoming: string): string;
+export declare function computeStreamingDelta(existing: string, incoming: string): string;
+export type StreamingUpdateResult = {
+    kind: "append" | "replace" | "noop";
+    nextText: string;
+    emittedText: string;
+};
+export declare function resolveStreamingUpdate(existing: string, incoming: string): StreamingUpdateResult;
+//# sourceMappingURL=streaming-text.d.ts.map

package/utils/streaming-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-text.d.ts","sourceRoot":"","sources":["../../../../../src/utils/streaming-text.ts"],"names":[],"mappings":"AA6DA,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CA6D7E;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,MAAM,CAOR;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,qBAAqB,CAgBvB"}

package/utils/streaming-text.js

@@ -0,0 +1,112 @@
+/**
+ * Merge streaming text updates that may arrive as pure deltas, cumulative
+ * snapshots, or overlapping suffix/prefix fragments.
+ */
+function commonPrefixLength(left, right) {
+    const maxLength = Math.min(left.length, right.length);
+    let index = 0;
+    while (index < maxLength &&
+        left.charCodeAt(index) === right.charCodeAt(index)) {
+        index += 1;
+    }
+    return index;
+}
+function commonSuffixLength(left, right, sharedPrefixLength) {
+    const maxLength = Math.min(left.length - sharedPrefixLength, right.length - sharedPrefixLength);
+    let length = 0;
+    while (length < maxLength &&
+        left.charCodeAt(left.length - 1 - length) ===
+            right.charCodeAt(right.length - 1 - length)) {
+        length += 1;
+    }
+    return length;
+}
+function isLikelySnapshotReplacement(existing, incoming) {
+    const sharedPrefixLength = commonPrefixLength(existing, incoming);
+    const sharedSuffixLength = commonSuffixLength(existing, incoming, sharedPrefixLength);
+    const sharedLength = sharedPrefixLength + sharedSuffixLength;
+    const minLength = Math.min(existing.length, incoming.length);
+    // For short strings, a modest shared prefix is strong evidence of a
+    // snapshot replacement (e.g. case correction, punctuation addition).
+    if (minLength < 30 && sharedPrefixLength >= 2) {
+        return true;
+    }
+    return (sharedPrefixLength >= 8 ||
+        sharedLength >= Math.max(4, Math.ceil(minLength * 0.7)));
+}
+export function mergeStreamingText(existing, incoming) {
+    if (!incoming)
+        return existing;
+    if (!existing)
+        return incoming;
+    // Normalize unicode for comparison, but return original incoming when selected.
+    const existingNorm = existing.normalize("NFC");
+    const incomingNorm = incoming.normalize("NFC");
+    if (incomingNorm === existingNorm)
+        return incoming;
+    // Common case: the stream sends the full text-so-far.
+    if (incomingNorm.startsWith(existingNorm)) {
+        return incoming;
+    }
+    // Some providers resend the full text with a revised prefix or wrapper.
+    if (incomingNorm.includes(existingNorm)) {
+        return incoming;
+    }
+    // Ignore clearly regressive snapshots.
+    if (existingNorm.startsWith(incomingNorm)) {
+        return existing;
+    }
+    // Use trimmed existing for overlap detection so trailing whitespace
+    // does not prevent finding a valid overlap.
+    const existingTrimmed = existingNorm.trimEnd();
+    const maxOverlap = Math.min(existingTrimmed.length, incomingNorm.length);
+    const existingTrimmedLength = existingTrimmed.length;
+    for (let overlap = maxOverlap; overlap > 0; overlap -= 1) {
+        const existingStart = existingTrimmedLength - overlap;
+        let match = true;
+        for (let index = 0; index < overlap; index += 1) {
+            if (existingTrimmed.charCodeAt(existingStart + index) !==
+                incomingNorm.charCodeAt(index)) {
+                match = false;
+                break;
+            }
+        }
+        if (!match)
+            continue;
+        if (overlap === incomingNorm.length) {
+            // Preserve repeated single-character deltas like "l" + "l", but avoid
+            // replaying larger suffix fragments already present in the buffer.
+            return incoming.length === 1 ? `${existing}${incoming}` : existing;
+        }
+        return `${existing.slice(0, existing.length - (existingNorm.length - existingTrimmedLength))}${incoming.slice(overlap)}`;
+    }
+    // Some providers revise earlier words in-place while still sending the full
+    // text-so-far. Treat those as snapshot replacements instead of appends.
+    if (isLikelySnapshotReplacement(existingNorm, incomingNorm)) {
+        return incoming;
+    }
+    return `${existing}${incoming}`;
+}
+export function computeStreamingDelta(existing, incoming) {
+    const merged = mergeStreamingText(existing, incoming);
+    if (merged === existing)
+        return "";
+    if (merged.startsWith(existing)) {
+        return merged.slice(existing.length);
+    }
+    return incoming;
+}
+export function resolveStreamingUpdate(existing, incoming) {
+    const merged = mergeStreamingText(existing, incoming);
+    if (merged === existing) {
+        return { kind: "noop", nextText: existing, emittedText: "" };
+    }
+    if (merged.startsWith(existing)) {
+        return {
+            kind: "append",
+            nextText: merged,
+            emittedText: merged.slice(existing.length),
+        };
+    }
+    return { kind: "replace", nextText: merged, emittedText: merged };
+}

package/utils/subscription-auth.d.ts

@@ -0,0 +1,9 @@
+export declare function formatSubscriptionRequestError(err: unknown): string;
+export declare function normalizeOpenAICallbackInput(input: string): {
+    ok: true;
+    code: string;
+} | {
+    ok: false;
+    error: string;
+};
+//# sourceMappingURL=subscription-auth.d.ts.map

package/utils/subscription-auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscription-auth.d.ts","sourceRoot":"","sources":["../../../../../src/utils/subscription-auth.ts"],"names":[],"mappings":"AAAA,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAKnE;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,MAAM,GACtD;IACE,EAAE,EAAE,IAAI,CAAC;IACT,IAAI,EAAE,MAAM,CAAC;CACd,GACD;IACE,EAAE,EAAE,KAAK,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;CACf,CAgDJ"}