@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.334

package/packages/typescript/src/network/fetch-guard.d.ts

@@ -0,0 +1,34 @@
+/**
+ * SSRF-guarded fetch utilities.
+ *
+ * Provides a fetch wrapper that validates URLs and pins DNS to prevent
+ * SSRF attacks and DNS rebinding.
+ */
+import { type LookupFn, type SsrfPolicy } from "./ssrf.js";
+type FetchLike = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export type GuardedFetchOptions = {
+    url: string;
+    fetchImpl?: FetchLike;
+    init?: RequestInit;
+    maxRedirects?: number;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    policy?: SsrfPolicy;
+    lookupFn?: LookupFn;
+};
+export type GuardedFetchResult = {
+    response: Response;
+    finalUrl: string;
+    release: () => Promise<void>;
+};
+/**
+ * Fetch with SSRF protection.
+ *
+ * - Validates URL protocol (http/https only)
+ * - Resolves and pins DNS to prevent rebinding attacks
+ * - Follows redirects manually with validation
+ * - Supports timeout and abort signals
+ */
+export declare function fetchWithSsrfGuard(params: GuardedFetchOptions): Promise<GuardedFetchResult>;
+export {};
+//# sourceMappingURL=fetch-guard.d.ts.map

package/packages/typescript/src/network/fetch-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-guard.d.ts","sourceRoot":"","sources":["../../../../../../typescript/src/network/fetch-guard.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACN,KAAK,QAAQ,EAGb,KAAK,UAAU,EACf,MAAM,WAAW,CAAC;AAEnB,KAAK,SAAS,GAAG,CAChB,KAAK,EAAE,WAAW,GAAG,GAAG,EACxB,IAAI,CAAC,EAAE,WAAW,KACd,OAAO,CAAC,QAAQ,CAAC,CAAC;AAEvB,MAAM,MAAM,mBAAmB,GAAG;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAChC,QAAQ,EAAE,QAAQ,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B,CAAC;AAmDF;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CACvC,MAAM,EAAE,mBAAmB,GACzB,OAAO,CAAC,kBAAkB,CAAC,CAkG7B"}

package/packages/typescript/src/network/fetch-guard.js

@@ -0,0 +1,136 @@
+/**
+ * SSRF-guarded fetch utilities.
+ *
+ * Provides a fetch wrapper that validates URLs and pins DNS to prevent
+ * SSRF attacks and DNS rebinding.
+ */
+import { resolvePinnedHostname, resolvePinnedHostnameWithPolicy, } from "./ssrf.js";
+const DEFAULT_MAX_REDIRECTS = 3;
+function isRedirectStatus(status) {
+    return (status === 301 ||
+        status === 302 ||
+        status === 303 ||
+        status === 307 ||
+        status === 308);
+}
+function buildAbortSignal(params) {
+    const { timeoutMs, signal } = params;
+    if (!timeoutMs && !signal) {
+        return { signal: undefined, cleanup: () => { } };
+    }
+    if (!timeoutMs) {
+        return { signal, cleanup: () => { } };
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    const onAbort = () => controller.abort();
+    if (signal) {
+        if (signal.aborted) {
+            controller.abort();
+        }
+        else {
+            signal.addEventListener("abort", onAbort, { once: true });
+        }
+    }
+    const cleanup = () => {
+        clearTimeout(timeoutId);
+        if (signal) {
+            signal.removeEventListener("abort", onAbort);
+        }
+    };
+    return { signal: controller.signal, cleanup };
+}
+/**
+ * Fetch with SSRF protection.
+ *
+ * - Validates URL protocol (http/https only)
+ * - Resolves and pins DNS to prevent rebinding attacks
+ * - Follows redirects manually with validation
+ * - Supports timeout and abort signals
+ */
+export async function fetchWithSsrfGuard(params) {
+    const fetcher = params.fetchImpl ?? globalThis.fetch;
+    if (!fetcher) {
+        throw new Error("fetch is not available");
+    }
+    const maxRedirects = typeof params.maxRedirects === "number" &&
+        Number.isFinite(params.maxRedirects)
+        ? Math.max(0, Math.floor(params.maxRedirects))
+        : DEFAULT_MAX_REDIRECTS;
+    const { signal, cleanup } = buildAbortSignal({
+        timeoutMs: params.timeoutMs,
+        signal: params.signal,
+    });
+    let released = false;
+    const release = async () => {
+        if (released) {
+            return;
+        }
+        released = true;
+        cleanup();
+    };
+    const visited = new Set();
+    let currentUrl = params.url;
+    let redirectCount = 0;
+    while (true) {
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(currentUrl);
+        }
+        catch {
+            await release();
+            throw new Error("Invalid URL: must be http or https");
+        }
+        if (!["http:", "https:"].includes(parsedUrl.protocol)) {
+            await release();
+            throw new Error("Invalid URL: must be http or https");
+        }
+        try {
+            const usePolicy = Boolean(params.policy?.allowPrivateNetwork ||
+                params.policy?.allowedHostnames?.length);
+            const _pinned = usePolicy
+                ? await resolvePinnedHostnameWithPolicy(parsedUrl.hostname, {
+                    lookupFn: params.lookupFn,
+                    policy: params.policy,
+                })
+                : await resolvePinnedHostname(parsedUrl.hostname, params.lookupFn);
+            // Note: In browser environments, we can't pin DNS, so we rely on policy validation only
+            const init = {
+                ...(params.init ? { ...params.init } : {}),
+                redirect: "manual",
+                ...(signal ? { signal } : {}),
+            };
+            const response = await fetcher(parsedUrl.toString(), init);
+            if (isRedirectStatus(response.status)) {
+                const location = response.headers.get("location");
+                if (!location) {
+                    await release();
+                    throw new Error(`Redirect missing location header (${response.status})`);
+                }
+                redirectCount += 1;
+                if (redirectCount > maxRedirects) {
+                    await release();
+                    throw new Error(`Too many redirects (limit: ${maxRedirects})`);
+                }
+                const nextUrl = new URL(location, parsedUrl).toString();
+                if (visited.has(nextUrl)) {
+                    await release();
+                    throw new Error("Redirect loop detected");
+                }
+                visited.add(nextUrl);
+                void response.body?.cancel();
+                currentUrl = nextUrl;
+                continue;
+            }
+            return {
+                response,
+                finalUrl: currentUrl,
+                release,
+            };
+        }
+        catch (err) {
+            await release();
+            throw err;
+        }
+    }
+}

package/packages/typescript/src/network/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Network utilities for Eliza.
+ *
+ * Provides SSRF protection and secure fetch utilities.
+ *
+ * Note: The dispatcher utilities (undici-based DNS pinning) are Node-specific
+ * and should be imported directly from "./network/dispatcher.js" when needed.
+ */
+export { fetchWithSsrfGuard, type GuardedFetchOptions, type GuardedFetchResult, } from "./fetch-guard.js";
+export { assertPublicHostname, createPinnedLookup, isBlockedHostname, isPrivateIpAddress, type LookupFn, type PinnedHostname, resolvePinnedHostname, resolvePinnedHostnameWithPolicy, SsrfBlockedError, type SsrfPolicy, } from "./ssrf.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/typescript/src/network/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../typescript/src/network/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EACN,kBAAkB,EAClB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,GACvB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACN,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,qBAAqB,EACrB,+BAA+B,EAC/B,gBAAgB,EAChB,KAAK,UAAU,GACf,MAAM,WAAW,CAAC"}

package/packages/typescript/src/network/index.js

@@ -0,0 +1,10 @@
+/**
+ * Network utilities for Eliza.
+ *
+ * Provides SSRF protection and secure fetch utilities.
+ *
+ * Note: The dispatcher utilities (undici-based DNS pinning) are Node-specific
+ * and should be imported directly from "./network/dispatcher.js" when needed.
+ */
+export { fetchWithSsrfGuard, } from "./fetch-guard.js";
+export { assertPublicHostname, createPinnedLookup, isBlockedHostname, isPrivateIpAddress, resolvePinnedHostname, resolvePinnedHostnameWithPolicy, SsrfBlockedError, } from "./ssrf.js";

package/packages/typescript/src/network/ssrf.d.ts

@@ -0,0 +1,58 @@
+/**
+ * SSRF (Server-Side Request Forgery) protection utilities.
+ *
+ * Provides DNS pinning and IP address validation to prevent SSRF attacks
+ * when fetching external resources.
+ */
+export type LookupAddress = {
+    address: string;
+    family: number;
+};
+export type LookupCallback = (err: Error | null, address: string | LookupAddress[], family?: number) => void;
+export type LookupFn = (hostname: string, options: {
+    all: true;
+}) => Promise<LookupAddress[]>;
+export declare class SsrfBlockedError extends Error {
+    constructor(message: string);
+}
+export type SsrfPolicy = {
+    allowPrivateNetwork?: boolean;
+    allowedHostnames?: string[];
+};
+/**
+ * Check if an IP address is private/internal.
+ */
+export declare function isPrivateIpAddress(address: string): boolean;
+/**
+ * Check if a hostname should be blocked (localhost, internal domains).
+ */
+export declare function isBlockedHostname(hostname: string): boolean;
+/**
+ * Create a DNS lookup function that pins to specific resolved addresses.
+ */
+export declare function createPinnedLookup(params: {
+    hostname: string;
+    addresses: string[];
+    fallback?: unknown;
+}): unknown;
+export type PinnedHostname = {
+    hostname: string;
+    addresses: string[];
+    lookup: unknown;
+};
+/**
+ * Resolve a hostname with SSRF policy enforcement.
+ */
+export declare function resolvePinnedHostnameWithPolicy(hostname: string, params?: {
+    lookupFn?: LookupFn;
+    policy?: SsrfPolicy;
+}): Promise<PinnedHostname>;
+/**
+ * Resolve a hostname and pin DNS to prevent TOCTOU attacks.
+ */
+export declare function resolvePinnedHostname(hostname: string, lookupFn?: LookupFn): Promise<PinnedHostname>;
+/**
+ * Assert that a hostname resolves to a public IP address.
+ */
+export declare function assertPublicHostname(hostname: string, lookupFn?: LookupFn): Promise<void>;
+//# sourceMappingURL=ssrf.d.ts.map

package/packages/typescript/src/network/ssrf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssrf.d.ts","sourceRoot":"","sources":["../../../../../../typescript/src/network/ssrf.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,MAAM,aAAa,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhE,MAAM,MAAM,cAAc,GAAG,CAC5B,GAAG,EAAE,KAAK,GAAG,IAAI,EACjB,OAAO,EAAE,MAAM,GAAG,aAAa,EAAE,EACjC,MAAM,CAAC,EAAE,MAAM,KACX,IAAI,CAAC;AAEV,MAAM,MAAM,QAAQ,GAAG,CACtB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE;IAAE,GAAG,EAAE,IAAI,CAAA;CAAE,KAClB,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;AAE9B,qBAAa,gBAAiB,SAAQ,KAAK;gBAC9B,OAAO,EAAE,MAAM;CAI3B;AAED,MAAM,MAAM,UAAU,GAAG;IACxB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAuGF;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CA+B3D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAa3D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB,GAAG,OAAO,CA4DV;AAED,MAAM,MAAM,cAAc,GAAG;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,wBAAsB,+BAA+B,CACpD,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE;IAAE,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAAC,MAAM,CAAC,EAAE,UAAU,CAAA;CAAO,GACvD,OAAO,CAAC,cAAc,CAAC,CAkDzB;AAED;;GAEG;AACH,wBAAsB,qBAAqB,CAC1C,QAAQ,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,QAAQ,GACjB,OAAO,CAAC,cAAc,CAAC,CAEzB;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACzC,QAAQ,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,QAAQ,GACjB,OAAO,CAAC,IAAI,CAAC,CAEf"}

package/packages/typescript/src/network/ssrf.js

@@ -0,0 +1,252 @@
+/**
+ * SSRF (Server-Side Request Forgery) protection utilities.
+ *
+ * Provides DNS pinning and IP address validation to prevent SSRF attacks
+ * when fetching external resources.
+ */
+export class SsrfBlockedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SsrfBlockedError";
+    }
+}
+const PRIVATE_IPV6_PREFIXES = ["fe80:", "fec0:", "fc", "fd"];
+const BLOCKED_HOSTNAMES = new Set(["localhost", "metadata.google.internal"]);
+function normalizeHostname(hostname) {
+    const normalized = hostname.trim().toLowerCase().replace(/\.$/, "");
+    if (normalized.startsWith("[") && normalized.endsWith("]")) {
+        return normalized.slice(1, -1);
+    }
+    return normalized;
+}
+function normalizeHostnameSet(values) {
+    if (!values || values.length === 0) {
+        return new Set();
+    }
+    return new Set(values.map((value) => normalizeHostname(value)).filter(Boolean));
+}
+function parseIpv4(address) {
+    const parts = address.split(".");
+    if (parts.length !== 4) {
+        return null;
+    }
+    const numbers = parts.map((part) => Number.parseInt(part, 10));
+    if (numbers.some((value) => Number.isNaN(value) || value < 0 || value > 255)) {
+        return null;
+    }
+    return numbers;
+}
+function parseIpv4FromMappedIpv6(mapped) {
+    if (mapped.includes(".")) {
+        return parseIpv4(mapped);
+    }
+    const parts = mapped.split(":").filter(Boolean);
+    if (parts.length === 1) {
+        const value = Number.parseInt(parts[0], 16);
+        if (Number.isNaN(value) || value < 0 || value > 0xffff_ffff) {
+            return null;
+        }
+        return [
+            (value >>> 24) & 0xff,
+            (value >>> 16) & 0xff,
+            (value >>> 8) & 0xff,
+            value & 0xff,
+        ];
+    }
+    if (parts.length !== 2) {
+        return null;
+    }
+    const high = Number.parseInt(parts[0], 16);
+    const low = Number.parseInt(parts[1], 16);
+    if (Number.isNaN(high) ||
+        Number.isNaN(low) ||
+        high < 0 ||
+        low < 0 ||
+        high > 0xffff ||
+        low > 0xffff) {
+        return null;
+    }
+    const value = (high << 16) + low;
+    return [
+        (value >>> 24) & 0xff,
+        (value >>> 16) & 0xff,
+        (value >>> 8) & 0xff,
+        value & 0xff,
+    ];
+}
+function isPrivateIpv4(parts) {
+    const [octet1, octet2] = parts;
+    if (octet1 === 0) {
+        return true;
+    }
+    if (octet1 === 10) {
+        return true;
+    }
+    if (octet1 === 127) {
+        return true;
+    }
+    if (octet1 === 169 && octet2 === 254) {
+        return true;
+    }
+    if (octet1 === 172 && octet2 >= 16 && octet2 <= 31) {
+        return true;
+    }
+    if (octet1 === 192 && octet2 === 168) {
+        return true;
+    }
+    if (octet1 === 100 && octet2 >= 64 && octet2 <= 127) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Check if an IP address is private/internal.
+ */
+export function isPrivateIpAddress(address) {
+    let normalized = address.trim().toLowerCase();
+    if (normalized.startsWith("[") && normalized.endsWith("]")) {
+        normalized = normalized.slice(1, -1);
+    }
+    if (!normalized) {
+        return false;
+    }
+    if (normalized.startsWith("::ffff:")) {
+        const mapped = normalized.slice("::ffff:".length);
+        const ipv4 = parseIpv4FromMappedIpv6(mapped);
+        if (ipv4) {
+            return isPrivateIpv4(ipv4);
+        }
+    }
+    if (normalized.includes(":")) {
+        if (normalized === "::" || normalized === "::1") {
+            return true;
+        }
+        return PRIVATE_IPV6_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+    }
+    const ipv4 = parseIpv4(normalized);
+    if (!ipv4) {
+        return false;
+    }
+    return isPrivateIpv4(ipv4);
+}
+/**
+ * Check if a hostname should be blocked (localhost, internal domains).
+ */
+export function isBlockedHostname(hostname) {
+    const normalized = normalizeHostname(hostname);
+    if (!normalized) {
+        return false;
+    }
+    if (BLOCKED_HOSTNAMES.has(normalized)) {
+        return true;
+    }
+    return (normalized.endsWith(".localhost") ||
+        normalized.endsWith(".local") ||
+        normalized.endsWith(".internal"));
+}
+/**
+ * Create a DNS lookup function that pins to specific resolved addresses.
+ */
+export function createPinnedLookup(params) {
+    const normalizedHost = normalizeHostname(params.hostname);
+    const fallback = params.fallback;
+    const fallbackLookup = fallback;
+    const fallbackWithOptions = fallback;
+    const records = params.addresses.map((address) => ({
+        address,
+        family: address.includes(":") ? 6 : 4,
+    }));
+    let index = 0;
+    return ((host, options, callback) => {
+        const cb = typeof options === "function"
+            ? options
+            : callback;
+        if (!cb) {
+            return;
+        }
+        const normalized = normalizeHostname(host);
+        if (!normalized || normalized !== normalizedHost) {
+            if (fallback) {
+                if (typeof options === "function" || options === undefined) {
+                    return fallbackLookup(host, cb);
+                }
+                return fallbackWithOptions(host, options, cb);
+            }
+            throw new Error("DNS Context restricted: fallback missing.");
+        }
+        const opts = typeof options === "object" && options !== null
+            ? options
+            : {};
+        const requestedFamily = typeof options === "number"
+            ? options
+            : typeof opts.family === "number"
+                ? opts.family
+                : 0;
+        const candidates = requestedFamily === 4 || requestedFamily === 6
+            ? records.filter((entry) => entry.family === requestedFamily)
+            : records;
+        const usable = candidates.length > 0 ? candidates : records;
+        if (opts.all) {
+            cb(null, usable);
+            return;
+        }
+        const chosen = usable[index % usable.length];
+        index += 1;
+        cb(null, chosen.address, chosen.family);
+    });
+}
+/**
+ * Resolve a hostname with SSRF policy enforcement.
+ */
+export async function resolvePinnedHostnameWithPolicy(hostname, params = {}) {
+    const normalized = normalizeHostname(hostname);
+    if (!normalized) {
+        throw new Error("Invalid hostname");
+    }
+    const allowPrivateNetwork = Boolean(params.policy?.allowPrivateNetwork);
+    const allowedHostnames = normalizeHostnameSet(params.policy?.allowedHostnames);
+    const isExplicitAllowed = allowedHostnames.has(normalized);
+    if (!allowPrivateNetwork && !isExplicitAllowed) {
+        if (isBlockedHostname(normalized)) {
+            throw new SsrfBlockedError(`Blocked hostname: ${hostname}`);
+        }
+        if (isPrivateIpAddress(normalized)) {
+            throw new SsrfBlockedError("Blocked: private/internal IP address");
+        }
+    }
+    const lookupFn = params.lookupFn;
+    if (!lookupFn)
+        throw new Error("lookupFn is required in environment agnostic core");
+    const results = await lookupFn(normalized, { all: true });
+    if (results.length === 0) {
+        throw new Error(`Unable to resolve hostname: ${hostname}`);
+    }
+    if (!allowPrivateNetwork && !isExplicitAllowed) {
+        for (const entry of results) {
+            if (isPrivateIpAddress(entry.address)) {
+                throw new SsrfBlockedError("Blocked: resolves to private/internal IP address");
+            }
+        }
+    }
+    const addresses = Array.from(new Set(results.map((entry) => entry.address)));
+    if (addresses.length === 0) {
+        throw new Error(`Unable to resolve hostname: ${hostname}`);
+    }
+    return {
+        hostname: normalized,
+        addresses,
+        lookup: createPinnedLookup({ hostname: normalized, addresses }),
+    };
+}
+/**
+ * Resolve a hostname and pin DNS to prevent TOCTOU attacks.
+ */
+export async function resolvePinnedHostname(hostname, lookupFn) {
+    return await resolvePinnedHostnameWithPolicy(hostname, { lookupFn });
+}
+/**
+ * Assert that a hostname resolves to a public IP address.
+ */
+export async function assertPublicHostname(hostname, lookupFn) {
+    await resolvePinnedHostname(hostname, lookupFn);
+}

package/packages/typescript/src/optimization/ab-analysis.d.ts

@@ -0,0 +1,3 @@
+/** Fast stable-ish fingerprint for template / trace keys (not cryptographic). */
+export declare function simpleHash(s: string): string;
+//# sourceMappingURL=ab-analysis.d.ts.map

package/packages/typescript/src/optimization/ab-analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ab-analysis.d.ts","sourceRoot":"","sources":["../../../../../../typescript/src/optimization/ab-analysis.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAM5C"}

package/packages/typescript/src/optimization/ab-analysis.js

@@ -0,0 +1,8 @@
+/** Fast stable-ish fingerprint for template / trace keys (not cryptographic). */
+export function simpleHash(s) {
+    return s
+        .split("")
+        .reduce((h, c) => ((h * 31) ^ c.charCodeAt(0)) >>> 0, 5381)
+        .toString(16)
+        .slice(0, 8);
+}

package/packages/typescript/src/optimization-root-dir.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Resolved optimization root directory for disk traces / artifacts.
+ *
+ * Core exposes this helper so `AgentRuntime.getOptimizationDir()` and plugins
+ * agree on a single default when `OPTIMIZATION_DIR` is unset.
+ */
+export declare function getOptimizationRootDir(settingValue?: string | null): string;
+//# sourceMappingURL=optimization-root-dir.d.ts.map

package/packages/typescript/src/optimization-root-dir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimization-root-dir.d.ts","sourceRoot":"","sources":["../../../../../typescript/src/optimization-root-dir.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAK3E"}

package/packages/typescript/src/optimization-root-dir.js

@@ -0,0 +1,14 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * Resolved optimization root directory for disk traces / artifacts.
+ *
+ * Core exposes this helper so `AgentRuntime.getOptimizationDir()` and plugins
+ * agree on a single default when `OPTIMIZATION_DIR` is unset.
+ */
+export function getOptimizationRootDir(settingValue) {
+    if (settingValue && typeof settingValue === "string") {
+        return settingValue;
+    }
+    return join(homedir(), ".eliza", "optimization");
+}

package/packages/typescript/src/plugin-lifecycle.d.ts

@@ -0,0 +1,16 @@
+import type { Plugin, PluginOwnership } from "./types/plugin";
+import type { IAgentRuntime } from "./types/runtime";
+type RuntimeWithPluginLifecycle = IAgentRuntime & {
+    __elizaPluginLifecycleInstalled?: boolean;
+    __elizaPluginOwnership?: Map<string, PluginOwnership>;
+    registerDatabaseAdapter: (adapter: IAgentRuntime["adapter"]) => void;
+    unloadPlugin?: (pluginName: string) => Promise<PluginOwnership | null>;
+    reloadPlugin?: (plugin: Plugin) => Promise<void>;
+    applyPluginConfig?: (pluginName: string, config: Record<string, string>) => Promise<boolean>;
+    getPluginOwnership?: (pluginName: string) => PluginOwnership | null;
+    getAllPluginOwnership?: () => PluginOwnership[];
+};
+export declare function installRuntimePluginLifecycle(runtime: IAgentRuntime): void;
+export declare function supportsRuntimePluginLifecycle(runtime: IAgentRuntime | null): runtime is RuntimeWithPluginLifecycle;
+export {};
+//# sourceMappingURL=plugin-lifecycle.d.ts.map

package/packages/typescript/src/plugin-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-lifecycle.d.ts","sourceRoot":"","sources":["../../../../../typescript/src/plugin-lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,MAAM,EAGN,eAAe,EAEf,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAsErD,KAAK,0BAA0B,GAAG,aAAa,GAAG;IACjD,+BAA+B,CAAC,EAAE,OAAO,CAAC;IAC1C,sBAAsB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACtD,uBAAuB,EAAE,CAAC,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,KAAK,IAAI,CAAC;IACrE,YAAY,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;IACvE,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,iBAAiB,CAAC,EAAE,CACnB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAC1B,OAAO,CAAC,OAAO,CAAC,CAAC;IACtB,kBAAkB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,eAAe,GAAG,IAAI,CAAC;IACpE,qBAAqB,CAAC,EAAE,MAAM,eAAe,EAAE,CAAC;CAChD,CAAC;AA2hBF,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CA0R1E;AAED,wBAAgB,8BAA8B,CAC7C,OAAO,EAAE,aAAa,GAAG,IAAI,GAC3B,OAAO,IAAI,0BAA0B,CAUvC"}