@elizaos/agent 2.0.0-alpha.97 → 2.0.0-beta.1

package/dist/packages/agent/src/config/env-vars.d.ts

@@ -0,0 +1,9 @@
+import type { ElizaConfig } from "./types.ts";
+/**
+ * Maps connector config fields to the environment variables expected by
+ * elizaOS plugins. Keep this aligned with runtime/eliza.ts.
+ */
+export declare const CONNECTOR_ENV_MAP: Readonly<Record<string, Readonly<Record<string, string>>>>;
+export declare function collectConfigEnvVars(cfg?: ElizaConfig): Record<string, string>;
+export declare function collectConnectorEnvVars(cfg?: ElizaConfig): Record<string, string>;
+//# sourceMappingURL=env-vars.d.ts.map

package/dist/packages/agent/src/config/env-vars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-vars.d.ts","sourceRoot":"","sources":["../../../../../src/config/env-vars.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAmD9C;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CACtC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAuFjD,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,GAAG,CAAC,EAAE,WAAW,GAChB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAkCxB;AAED,wBAAgB,uBAAuB,CACrC,GAAG,CAAC,EAAE,WAAW,GAChB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAsIxB"}

package/dist/packages/agent/src/config/env-vars.js

@@ -0,0 +1,281 @@
+/**
+ * Environment variable keys that must NEVER be synced from config → process.env.
+ *
+ * Mirrors the BLOCKED_ENV_KEYS set in server.ts.  This is a defense-in-depth
+ * gate: even if a blocked key is somehow persisted into eliza.config.json
+ * (e.g. via an API bypass or manual file edit), it will not be loaded into the
+ * process environment on startup.
+ *
+ * Categories:
+ *   - Process-level code injection (NODE_OPTIONS, LD_PRELOAD, …)
+ *   - TLS / proxy hijack (NODE_TLS_REJECT_UNAUTHORIZED, HTTP_PROXY, …)
+ *   - Module resolution (NODE_PATH)
+ *   - Privilege escalation tokens (ELIZA_API_TOKEN, …)
+ *   - Wallet private keys
+ *   - System paths
+ */
+const BLOCKED_STARTUP_ENV_KEYS = new Set([
+    "LD_PRELOAD",
+    "LD_LIBRARY_PATH",
+    "DYLD_INSERT_LIBRARIES",
+    "DYLD_LIBRARY_PATH",
+    "NODE_OPTIONS",
+    "NODE_EXTRA_CA_CERTS",
+    "NODE_TLS_REJECT_UNAUTHORIZED",
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "ALL_PROXY",
+    "NO_PROXY",
+    "NODE_PATH",
+    "SSL_CERT_FILE",
+    "SSL_CERT_DIR",
+    "CURL_CA_BUNDLE",
+    "PATH",
+    "HOME",
+    "SHELL",
+    "ELIZA_API_TOKEN",
+    "ELIZA_WALLET_EXPORT_TOKEN",
+    "ELIZA_TERMINAL_RUN_TOKEN",
+    "HYPERSCAPE_AUTH_TOKEN",
+    "EVM_PRIVATE_KEY",
+    "SOLANA_PRIVATE_KEY",
+    "STEWARD_API_KEY",
+    "STEWARD_AGENT_TOKEN",
+    "ELIZA_CLOUD_CLIENT_ADDRESS_KEY",
+    "GITHUB_TOKEN",
+    "DATABASE_URL",
+    "POSTGRES_URL",
+]);
+/**
+ * Maps connector config fields to the environment variables expected by
+ * elizaOS plugins. Keep this aligned with runtime/eliza.ts.
+ */
+export const CONNECTOR_ENV_MAP = {
+    bluebubbles: {
+        enabled: "BLUEBUBBLES_ENABLED",
+        serverUrl: "BLUEBUBBLES_SERVER_URL",
+        password: "BLUEBUBBLES_PASSWORD",
+        webhookPath: "BLUEBUBBLES_WEBHOOK_PATH",
+        autoStartCommand: "BLUEBUBBLES_AUTOSTART_COMMAND",
+        autoStartArgs: "BLUEBUBBLES_AUTOSTART_ARGS",
+        autoStartCwd: "BLUEBUBBLES_AUTOSTART_CWD",
+        autoStartWaitMs: "BLUEBUBBLES_AUTOSTART_WAIT_MS",
+        dmPolicy: "BLUEBUBBLES_DM_POLICY",
+        groupPolicy: "BLUEBUBBLES_GROUP_POLICY",
+        allowFrom: "BLUEBUBBLES_ALLOW_FROM",
+        groupAllowFrom: "BLUEBUBBLES_GROUP_ALLOW_FROM",
+        sendReadReceipts: "BLUEBUBBLES_SEND_READ_RECEIPTS",
+    },
+    discord: {
+        token: "DISCORD_API_TOKEN",
+        botToken: "DISCORD_API_TOKEN",
+        applicationId: "DISCORD_APPLICATION_ID",
+        syncProfile: "DISCORD_SYNC_PROFILE",
+        profileName: "DISCORD_PROFILE_NAME",
+        profileAvatar: "DISCORD_PROFILE_AVATAR",
+    },
+    discordLocal: {
+        enabled: "DISCORD_LOCAL_ENABLED",
+        clientId: "DISCORD_LOCAL_CLIENT_ID",
+        clientSecret: "DISCORD_LOCAL_CLIENT_SECRET",
+        scopes: "DISCORD_LOCAL_SCOPES",
+        messageChannelIds: "DISCORD_LOCAL_MESSAGE_CHANNEL_IDS",
+        sendDelayMs: "DISCORD_LOCAL_SEND_DELAY_MS",
+    },
+    telegram: {
+        botToken: "TELEGRAM_BOT_TOKEN",
+    },
+    telegramAccount: {
+        phone: "TELEGRAM_ACCOUNT_PHONE",
+        appId: "TELEGRAM_ACCOUNT_APP_ID",
+        appHash: "TELEGRAM_ACCOUNT_APP_HASH",
+        deviceModel: "TELEGRAM_ACCOUNT_DEVICE_MODEL",
+        systemVersion: "TELEGRAM_ACCOUNT_SYSTEM_VERSION",
+    },
+    slack: {
+        botToken: "SLACK_BOT_TOKEN",
+        appToken: "SLACK_APP_TOKEN",
+        userToken: "SLACK_USER_TOKEN",
+    },
+    signal: {
+        authDir: "SIGNAL_AUTH_DIR",
+        account: "SIGNAL_ACCOUNT_NUMBER",
+        httpUrl: "SIGNAL_HTTP_URL",
+        cliPath: "SIGNAL_CLI_PATH",
+    },
+    imessage: {
+        enabled: "IMESSAGE_ENABLED",
+        cliPath: "IMESSAGE_CLI_PATH",
+        dbPath: "IMESSAGE_DB_PATH",
+        dmPolicy: "IMESSAGE_DM_POLICY",
+        groupPolicy: "IMESSAGE_GROUP_POLICY",
+        allowFrom: "IMESSAGE_ALLOW_FROM",
+        pollIntervalMs: "IMESSAGE_POLL_INTERVAL_MS",
+    },
+    whatsapp: {
+        authDir: "WHATSAPP_AUTH_DIR",
+        sessionPath: "WHATSAPP_AUTH_DIR",
+        dmPolicy: "WHATSAPP_DM_POLICY",
+        groupPolicy: "WHATSAPP_GROUP_POLICY",
+    },
+    msteams: {
+        appId: "MSTEAMS_APP_ID",
+        appPassword: "MSTEAMS_APP_PASSWORD",
+    },
+    mattermost: {
+        botToken: "MATTERMOST_BOT_TOKEN",
+        baseUrl: "MATTERMOST_BASE_URL",
+    },
+    googlechat: {
+        serviceAccountKey: "GOOGLE_CHAT_SERVICE_ACCOUNT_KEY",
+    },
+    blooio: {
+        apiKey: "BLOOIO_API_KEY",
+        fromNumber: "BLOOIO_PHONE_NUMBER",
+        webhookSecret: "BLOOIO_WEBHOOK_SECRET",
+        webhookUrl: "BLOOIO_WEBHOOK_URL",
+        webhookPort: "BLOOIO_WEBHOOK_PORT",
+    },
+};
+export function collectConfigEnvVars(cfg) {
+    const envConfig = cfg?.env;
+    if (!envConfig) {
+        return {};
+    }
+    const entries = {};
+    if (envConfig.vars) {
+        for (const [key, value] of Object.entries(envConfig.vars)) {
+            if (!value) {
+                continue;
+            }
+            if (BLOCKED_STARTUP_ENV_KEYS.has(key.toUpperCase())) {
+                continue;
+            }
+            entries[key] = value;
+        }
+    }
+    for (const [key, value] of Object.entries(envConfig)) {
+        if (key === "shellEnv" || key === "vars") {
+            continue;
+        }
+        if (typeof value !== "string" || !value.trim()) {
+            continue;
+        }
+        if (BLOCKED_STARTUP_ENV_KEYS.has(key.toUpperCase())) {
+            continue;
+        }
+        entries[key] = value;
+    }
+    return entries;
+}
+export function collectConnectorEnvVars(cfg) {
+    const rawConnectors = cfg?.connectors ?? cfg?.channels;
+    if (!rawConnectors ||
+        typeof rawConnectors !== "object" ||
+        Array.isArray(rawConnectors)) {
+        return {};
+    }
+    const connectors = rawConnectors;
+    const entries = {};
+    for (const [connectorName, envMap] of Object.entries(CONNECTOR_ENV_MAP)) {
+        const connectorConfig = connectors[connectorName];
+        if (!connectorConfig ||
+            typeof connectorConfig !== "object" ||
+            Array.isArray(connectorConfig)) {
+            continue;
+        }
+        const configObj = connectorConfig;
+        // Mirror Discord token aliases so older plugins and settings surfaces
+        // agree on a single configured state.
+        if (connectorName === "discord") {
+            const tokenValue = (typeof configObj.token === "string" && configObj.token.trim()) ||
+                (typeof configObj.botToken === "string" && configObj.botToken.trim()) ||
+                "";
+            if (tokenValue) {
+                entries.DISCORD_API_TOKEN = tokenValue;
+                entries.DISCORD_BOT_TOKEN = tokenValue;
+            }
+        }
+        for (const [configField, envKey] of Object.entries(envMap)) {
+            // Discord token/botToken are handled above with token-first precedence; the
+            // env map maps both fields to DISCORD_API_TOKEN, so applying them here would
+            // let botToken overwrite token.
+            if (connectorName === "discord" &&
+                (configField === "token" || configField === "botToken")) {
+                continue;
+            }
+            const value = configObj[configField];
+            let normalized = null;
+            if (typeof value === "string") {
+                normalized = value.trim() ? value : null;
+            }
+            else if (typeof value === "number" && Number.isFinite(value)) {
+                normalized = String(value);
+            }
+            else if (typeof value === "boolean") {
+                normalized = value ? "true" : "false";
+            }
+            else if (Array.isArray(value)) {
+                const serialized = value
+                    .map((entry) => {
+                    if (typeof entry === "string")
+                        return entry.trim();
+                    if (typeof entry === "number" && Number.isFinite(entry)) {
+                        return String(entry);
+                    }
+                    return "";
+                })
+                    .filter((entry) => entry.length > 0)
+                    .join(",");
+                normalized = serialized.length > 0 ? serialized : null;
+            }
+            if (!normalized) {
+                continue;
+            }
+            if (BLOCKED_STARTUP_ENV_KEYS.has(envKey.toUpperCase())) {
+                continue;
+            }
+            entries[envKey] = normalized;
+        }
+        if (connectorName === "whatsapp") {
+            const allowFrom = configObj.allowFrom;
+            if (Array.isArray(allowFrom) && allowFrom.length > 0) {
+                const normalized = allowFrom
+                    .map((value) => String(value).trim())
+                    .filter(Boolean);
+                if (normalized.length > 0) {
+                    entries.WHATSAPP_ALLOW_FROM = normalized.join(",");
+                }
+            }
+            const groupAllowFrom = configObj.groupAllowFrom;
+            if (Array.isArray(groupAllowFrom) && groupAllowFrom.length > 0) {
+                const normalized = groupAllowFrom
+                    .map((value) => String(value).trim())
+                    .filter(Boolean);
+                if (normalized.length > 0) {
+                    entries.WHATSAPP_GROUP_ALLOW_FROM = normalized.join(",");
+                }
+            }
+            const accounts = configObj.accounts;
+            if (accounts &&
+                typeof accounts === "object" &&
+                !Array.isArray(accounts)) {
+                const firstEnabledAccount = Object.values(accounts).find((account) => {
+                    if (!account ||
+                        typeof account !== "object" ||
+                        Array.isArray(account)) {
+                        return false;
+                    }
+                    const candidate = account;
+                    return (candidate.enabled !== false && typeof candidate.authDir === "string");
+                });
+                if (firstEnabledAccount &&
+                    typeof firstEnabledAccount.authDir === "string" &&
+                    firstEnabledAccount.authDir.trim()) {
+                    entries.WHATSAPP_AUTH_DIR = firstEnabledAccount.authDir.trim();
+                }
+            }
+        }
+    }
+    return entries;
+}

package/dist/packages/agent/src/config/feature-flags.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Centralised readers for Eliza feature flags that gate unreleased or
+ * in-progress integrations. Keep this module dependency-free so it can be
+ * imported from any layer (api, runtime, cloud) without cycles.
+ *
+ * Flags live in `process.env` (set via `config.env` on disk). They are read
+ * each call so a runtime restart picks up changes without a module reload.
+ */
+/**
+ * Eliza Cloud remote-signing wallet bridge.
+ *
+ * When on: `POST /api/cloud/login/status` provisions cloud wallets, writes
+ * `WALLET_SOURCE_*`, and the UI exposes a dual-wallet (local | cloud) picker.
+ * When off: zero cloud-wallet code paths run; wallet UI/API behave as before.
+ */
+export declare function isCloudWalletEnabled(): boolean;
+//# sourceMappingURL=feature-flags.d.ts.map

package/dist/packages/agent/src/config/feature-flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flags.d.ts","sourceRoot":"","sources":["../../../../../src/config/feature-flags.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAyBH;;;;;;GAMG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAE9C"}

package/dist/packages/agent/src/config/feature-flags.js

@@ -0,0 +1,37 @@
+/**
+ * Centralised readers for Eliza feature flags that gate unreleased or
+ * in-progress integrations. Keep this module dependency-free so it can be
+ * imported from any layer (api, runtime, cloud) without cycles.
+ *
+ * Flags live in `process.env` (set via `config.env` on disk). They are read
+ * each call so a runtime restart picks up changes without a module reload.
+ */
+function readBoolFlag(name, fallback = false) {
+    const raw = process.env[name];
+    if (raw === undefined || raw === null || raw === "")
+        return fallback;
+    const trimmed = String(raw).trim().toLowerCase();
+    if (trimmed === "1" ||
+        trimmed === "true" ||
+        trimmed === "yes" ||
+        trimmed === "on") {
+        return true;
+    }
+    if (trimmed === "0" ||
+        trimmed === "false" ||
+        trimmed === "no" ||
+        trimmed === "off") {
+        return false;
+    }
+    return fallback;
+}
+/**
+ * Eliza Cloud remote-signing wallet bridge.
+ *
+ * When on: `POST /api/cloud/login/status` provisions cloud wallets, writes
+ * `WALLET_SOURCE_*`, and the UI exposes a dual-wallet (local | cloud) picker.
+ * When off: zero cloud-wallet code paths run; wallet UI/API behave as before.
+ */
+export function isCloudWalletEnabled() {
+    return readBoolFlag("ENABLE_CLOUD_WALLET");
+}

package/dist/packages/agent/src/config/includes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"includes.d.ts","sourceRoot":"","sources":["../../../../../src/config/includes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH,eAAO,MAAM,WAAW,aAAa,CAAC;AACtC,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAGpC,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACnC,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;CACrC,CAAC;AAEF,qBAAa,kBAAmB,SAAQ,KAAK;aAGzB,WAAW,EAAE,MAAM;aACnB,KAAK,CAAC,EAAE,KAAK;gBAF7B,OAAO,EAAE,MAAM,EACC,WAAW,EAAE,MAAM,EACnB,KAAK,CAAC,EAAE,KAAK;CAKhC;AAED,qBAAa,oBAAqB,SAAQ,kBAAkB;aAC9B,KAAK,EAAE,MAAM,EAAE;gBAAf,KAAK,EAAE,MAAM,EAAE;CAO5C;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAcnE;AAoID,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,OAAO,EACZ,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,eAAiC,GAC1C,OAAO,CAET"}

package/dist/packages/agent/src/config/includes.js

@@ -0,0 +1,149 @@
+/**
+ * $include directive for modular configs.
+ *
+ * ```json5
+ * { "$include": "./base.json5" }
+ * { "$include": ["./a.json5", "./b.json5"] }
+ * ```
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { isPlainObject } from "@elizaos/shared";
+import JSON5 from "json5";
+export const INCLUDE_KEY = "$include";
+export const MAX_INCLUDE_DEPTH = 10;
+const BLOCKED_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+export class ConfigIncludeError extends Error {
+    includePath;
+    cause;
+    constructor(message, includePath, cause) {
+        super(message);
+        this.includePath = includePath;
+        this.cause = cause;
+        this.name = "ConfigIncludeError";
+    }
+}
+export class CircularIncludeError extends ConfigIncludeError {
+    chain;
+    constructor(chain) {
+        super(`Circular include detected: ${chain.join(" -> ")}`, chain[chain.length - 1] ?? "");
+        this.chain = chain;
+        this.name = "CircularIncludeError";
+    }
+}
+export function deepMerge(target, source) {
+    if (Array.isArray(target) && Array.isArray(source)) {
+        return [...target, ...source];
+    }
+    if (isPlainObject(target) && isPlainObject(source)) {
+        const result = { ...target };
+        for (const key of Object.keys(source)) {
+            if (BLOCKED_KEYS.has(key))
+                continue;
+            result[key] =
+                key in result ? deepMerge(result[key], source[key]) : source[key];
+        }
+        return result;
+    }
+    return source;
+}
+class IncludeProcessor {
+    basePath;
+    resolver;
+    visited = new Set();
+    depth = 0;
+    constructor(basePath, resolver) {
+        this.basePath = basePath;
+        this.resolver = resolver;
+        this.visited.add(path.normalize(basePath));
+    }
+    process(obj) {
+        if (Array.isArray(obj)) {
+            return obj.map((item) => this.process(item));
+        }
+        if (!isPlainObject(obj)) {
+            return obj;
+        }
+        const record = obj;
+        if (!(INCLUDE_KEY in record)) {
+            return this.processObject(record);
+        }
+        return this.processInclude(record);
+    }
+    processObject(obj) {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (BLOCKED_KEYS.has(key))
+                continue;
+            result[key] = this.process(value);
+        }
+        return result;
+    }
+    processInclude(obj) {
+        const includeValue = obj[INCLUDE_KEY];
+        const otherKeys = Object.keys(obj).filter((k) => k !== INCLUDE_KEY);
+        const included = this.resolveInclude(includeValue);
+        if (otherKeys.length === 0) {
+            return included;
+        }
+        if (!isPlainObject(included)) {
+            throw new ConfigIncludeError("Sibling keys require included content to be an object", typeof includeValue === "string" ? includeValue : INCLUDE_KEY);
+        }
+        const rest = {};
+        for (const key of otherKeys) {
+            rest[key] = this.process(obj[key]);
+        }
+        return deepMerge(included, rest);
+    }
+    resolveInclude(value) {
+        if (typeof value === "string") {
+            return this.loadFile(value);
+        }
+        if (Array.isArray(value)) {
+            return value.reduce((merged, item) => {
+                if (typeof item !== "string") {
+                    throw new ConfigIncludeError(`Invalid $include array item: expected string, got ${typeof item}`, String(item));
+                }
+                return deepMerge(merged, this.loadFile(item));
+            }, {});
+        }
+        throw new ConfigIncludeError(`Invalid $include value: expected string or array of strings, got ${typeof value}`, String(value));
+    }
+    loadFile(includePath) {
+        const resolvedPath = path.isAbsolute(includePath)
+            ? includePath
+            : path.resolve(path.dirname(this.basePath), includePath);
+        const normalized = path.normalize(resolvedPath);
+        if (this.visited.has(normalized)) {
+            throw new CircularIncludeError([...this.visited, normalized]);
+        }
+        if (this.depth >= MAX_INCLUDE_DEPTH) {
+            throw new ConfigIncludeError(`Maximum include depth (${MAX_INCLUDE_DEPTH}) exceeded at: ${includePath}`, includePath);
+        }
+        let raw;
+        try {
+            raw = this.resolver.readFile(normalized);
+        }
+        catch (err) {
+            throw new ConfigIncludeError(`Failed to read include file: ${includePath} (resolved: ${normalized})`, includePath, err instanceof Error ? err : undefined);
+        }
+        let parsed;
+        try {
+            parsed = this.resolver.parseJson(raw);
+        }
+        catch (err) {
+            throw new ConfigIncludeError(`Failed to parse include file: ${includePath} (resolved: ${normalized})`, includePath, err instanceof Error ? err : undefined);
+        }
+        const nested = new IncludeProcessor(normalized, this.resolver);
+        nested.visited = new Set([...this.visited, normalized]);
+        nested.depth = this.depth + 1;
+        return nested.process(parsed);
+    }
+}
+const defaultResolver = {
+    readFile: (p) => fs.readFileSync(p, "utf-8"),
+    parseJson: (raw) => JSON5.parse(raw),
+};
+export function resolveConfigIncludes(obj, configPath, resolver = defaultResolver) {
+    return new IncludeProcessor(configPath, resolver).process(obj);
+}

package/dist/packages/agent/src/config/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./character-schema.ts";
+export * from "./config.ts";
+export * from "./env-vars.ts";
+export * from "./includes.ts";
+export * from "./model-metadata.ts";
+export * from "./owner-contacts.ts";
+export * from "./paths.ts";
+export * from "./schema.ts";
+export * from "./telegram-custom-commands.ts";
+export type { CustomActionDef, CustomActionHandler, DatabaseProviderType, } from "./types.eliza.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/agent/src/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/config/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,+BAA+B,CAAC;AAC9C,YAAY,EACV,eAAe,EACf,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,kBAAkB,CAAC"}

package/dist/packages/agent/src/config/index.js

@@ -0,0 +1,9 @@
+export * from "./character-schema.js";
+export * from "./config.js";
+export * from "./env-vars.js";
+export * from "./includes.js";
+export * from "./model-metadata.js";
+export * from "./owner-contacts.js";
+export * from "./paths.js";
+export * from "./schema.js";
+export * from "./telegram-custom-commands.js";

package/dist/packages/agent/src/config/model-metadata.d.ts

@@ -0,0 +1,20 @@
+import type { ElizaConfig, ModelDefinitionConfig } from "./types.ts";
+export declare const DEFAULT_MODEL_CONTEXT_WINDOW = 128000;
+export declare const DEFAULT_MODEL_MAX_TOKENS = 8192;
+export type ModelTokenMetadataSource = "model-config" | "agent-defaults" | "runtime-default";
+export interface ModelTokenMetadata {
+    modelId: string;
+    providerId?: string;
+    contextWindow: number;
+    maxTokens: number;
+    source: ModelTokenMetadataSource;
+}
+export declare function normalizeModelDefinitionConfig(model: Partial<ModelDefinitionConfig> & {
+    id: string;
+}, defaults?: {
+    contextWindow?: number;
+    maxTokens?: number;
+}): ModelDefinitionConfig;
+export declare function normalizeModelMetadataInConfig(config: ElizaConfig): void;
+export declare function resolveModelTokenMetadata(config?: ElizaConfig, modelId?: string): ModelTokenMetadata;
+//# sourceMappingURL=model-metadata.d.ts.map

package/dist/packages/agent/src/config/model-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-metadata.d.ts","sourceRoot":"","sources":["../../../../../src/config/model-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,qBAAqB,EAEtB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,4BAA4B,SAAU,CAAC;AACpD,eAAO,MAAM,wBAAwB,OAAQ,CAAC;AAU9C,MAAM,MAAM,wBAAwB,GAChC,cAAc,GACd,gBAAgB,GAChB,iBAAiB,CAAC;AAEtB,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,wBAAwB,CAAC;CAClC;AAyCD,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,OAAO,CAAC,qBAAqB,CAAC,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,EACtD,QAAQ,CAAC,EAAE;IACT,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GACA,qBAAqB,CAuBvB;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAmBxE;AAkDD,wBAAgB,yBAAyB,CACvC,MAAM,CAAC,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,MAAM,GACf,kBAAkB,CA+BpB"}