@elizaos/agent 0.25.8 → 2.0.0-alpha.83

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

@@ -0,0 +1,118 @@
+import fs from "node:fs";
+import path from "node:path";
+import JSON5 from "json5";
+import { collectConfigEnvVars } from "./env-vars";
+import { resolveConfigIncludes } from "./includes";
+import { resolveConfigPath, resolveUserPath } from "./paths";
+export * from "./types";
+export function loadElizaConfig() {
+    const configPath = resolveConfigPath();
+    let raw;
+    try {
+        raw = fs.readFileSync(configPath, "utf-8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return { logging: { level: "error" } };
+        }
+        throw err;
+    }
+    const parsed = JSON5.parse(raw);
+    const resolved = resolveConfigIncludes(parsed, configPath);
+    const skillsJsonPath = resolveUserPath("~/.eliza/skills.json");
+    if (!fs.existsSync(skillsJsonPath)) {
+        try {
+            const skillsDir = path.dirname(skillsJsonPath);
+            if (!fs.existsSync(skillsDir)) {
+                fs.mkdirSync(skillsDir, { recursive: true });
+            }
+            fs.writeFileSync(skillsJsonPath, JSON.stringify({ extraDirs: [] }, null, 2), "utf-8");
+        }
+        catch (err) {
+            console.warn(`[eliza] Failed to auto-create ~/.eliza/skills.json: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (fs.existsSync(skillsJsonPath)) {
+        try {
+            const skillsRaw = fs.readFileSync(skillsJsonPath, "utf-8");
+            const skillsConfig = JSON5.parse(skillsRaw);
+            if (skillsConfig.extraDirs &&
+                Array.isArray(skillsConfig.extraDirs) &&
+                skillsConfig.extraDirs.length > 0) {
+                if (!resolved.skills)
+                    resolved.skills = {};
+                if (!resolved.skills.load)
+                    resolved.skills.load = {};
+                if (!resolved.skills.load.extraDirs) {
+                    resolved.skills.load.extraDirs = [];
+                }
+                const existing = new Set(resolved.skills.load.extraDirs);
+                for (const dir of skillsConfig.extraDirs) {
+                    const loadedDir = resolveUserPath(dir);
+                    if (!existing.has(loadedDir)) {
+                        resolved.skills.load.extraDirs.push(loadedDir);
+                        existing.add(loadedDir);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.warn(`[eliza] Failed to load ~/.eliza/skills.json: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (!resolved.logging) {
+        resolved.logging = { level: "error" };
+    }
+    else if (!resolved.logging.level) {
+        resolved.logging.level = "error";
+    }
+    const envVars = collectConfigEnvVars(resolved);
+    for (const [key, value] of Object.entries(envVars)) {
+        if (process.env[key] === undefined) {
+            process.env[key] = value;
+        }
+    }
+    return resolved;
+}
+function stripIncludeDirectives(value) {
+    if (value === null || value === undefined)
+        return value;
+    if (Array.isArray(value))
+        return value.map(stripIncludeDirectives);
+    if (typeof value !== "object")
+        return value;
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+        if (key === "$include")
+            continue;
+        result[key] = stripIncludeDirectives(val);
+    }
+    return result;
+}
+export function saveElizaConfig(config) {
+    const configPath = resolveConfigPath();
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    const sanitized = stripIncludeDirectives(config);
+    if (!sanitized || typeof sanitized !== "object") {
+        throw new Error(`[eliza-config] stripIncludeDirectives returned invalid result: ${typeof sanitized}`);
+    }
+    const content = `${JSON.stringify(sanitized, null, 2)}\n`;
+    fs.writeFileSync(configPath, content, {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`[eliza-config] Config file missing after write: ${configPath}`);
+    }
+    const stat = fs.statSync(configPath);
+    if (stat.size === 0) {
+        throw new Error(`[eliza-config] Config file is empty after write: ${configPath}`);
+    }
+}
+export function configFileExists() {
+    return fs.existsSync(resolveConfigPath());
+}
+// Backward-compat aliases for downstream forks using the old name

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

@@ -0,0 +1,3 @@
+import type { ElizaConfig } from "./types";
+export declare function collectConfigEnvVars(cfg?: ElizaConfig): Record<string, string>;
+//# sourceMappingURL=env-vars.d.ts.map

package/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,SAAS,CAAC;AAgD3C,wBAAgB,oBAAoB,CAClC,GAAG,CAAC,EAAE,WAAW,GAChB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAkCxB"}

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

@@ -0,0 +1,76 @@
+/**
+ * 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",
+    "GITHUB_TOKEN",
+    "DATABASE_URL",
+    "POSTGRES_URL",
+]);
+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;
+}

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

@@ -0,0 +1,26 @@
+/**
+ * $include directive for modular configs.
+ *
+ * ```json5
+ * { "$include": "./base.json5" }
+ * { "$include": ["./a.json5", "./b.json5"] }
+ * ```
+ */
+export declare const INCLUDE_KEY = "$include";
+export declare const MAX_INCLUDE_DEPTH = 10;
+export type IncludeResolver = {
+    readFile: (path: string) => string;
+    parseJson: (raw: string) => unknown;
+};
+export declare class ConfigIncludeError extends Error {
+    readonly includePath: string;
+    readonly cause?: Error;
+    constructor(message: string, includePath: string, cause?: Error);
+}
+export declare class CircularIncludeError extends ConfigIncludeError {
+    readonly chain: string[];
+    constructor(chain: string[]);
+}
+export declare function deepMerge(target: unknown, source: unknown): unknown;
+export declare function resolveConfigIncludes(obj: unknown, configPath: string, resolver?: IncludeResolver): unknown;
+//# sourceMappingURL=includes.d.ts.map

package/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;AAmID,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,OAAO,EACZ,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,eAAiC,GAC1C,OAAO,CAET"}

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

@@ -0,0 +1,148 @@
+/**
+ * $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 JSON5 from "json5";
+import { isPlainObject } from "./object-utils";
+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;
+        }
+        if (!(INCLUDE_KEY in obj)) {
+            return this.processObject(obj);
+        }
+        return this.processInclude(obj);
+    }
+    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/packages/agent/src/config/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./character-schema";
+export * from "./config";
+export * from "./env-vars";
+export * from "./includes";
+export * from "./object-utils";
+export * from "./paths";
+export * from "./plugin-auto-enable";
+export * from "./types";
+export * from "./types.agent-defaults";
+export * from "./types.agents";
+export * from "./types.eliza";
+export * from "./types.gateway";
+export * from "./types.hooks";
+export * from "./types.messages";
+export * from "./types.tools";
+//# sourceMappingURL=index.d.ts.map

package/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,oBAAoB,CAAC;AACnC,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,SAAS,CAAC;AACxB,cAAc,sBAAsB,CAAC;AACrC,cAAc,SAAS,CAAC;AACxB,cAAc,wBAAwB,CAAC;AACvC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC"}

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

@@ -0,0 +1,15 @@
+export * from "./character-schema";
+export * from "./config";
+export * from "./env-vars";
+export * from "./includes";
+export * from "./object-utils";
+export * from "./paths";
+export * from "./plugin-auto-enable";
+export * from "./types";
+export * from "./types.agent-defaults";
+export * from "./types.agents";
+export * from "./types.eliza";
+export * from "./types.gateway";
+export * from "./types.hooks";
+export * from "./types.messages";
+export * from "./types.tools";

package/packages/agent/src/config/object-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+//# sourceMappingURL=object-utils.d.ts.map

package/packages/agent/src/config/object-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-utils.d.ts","sourceRoot":"","sources":["../../../../../src/config/object-utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,aAAa,CAC3B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAOlC"}

package/packages/agent/src/config/object-utils.js

@@ -0,0 +1,6 @@
+export function isPlainObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.prototype.toString.call(value) === "[object Object]");
+}

package/packages/agent/src/config/paths.d.ts

@@ -0,0 +1,13 @@
+export declare function getElizaNamespace(env?: NodeJS.ProcessEnv): string;
+export declare function resolveUserPath(input: string): string;
+export declare function resolveStateDir(env?: NodeJS.ProcessEnv, homedir?: () => string): string;
+export declare function resolveConfigPath(env?: NodeJS.ProcessEnv, stateDirPath?: string): string;
+export declare function resolveDefaultConfigCandidates(env?: NodeJS.ProcessEnv, homedir?: () => string): string[];
+/**
+ * Directory for per-provider model cache files.
+ * Each provider gets its own file: `~/.eliza/models/<providerId>.json`
+ */
+export declare function resolveModelsCacheDir(env?: NodeJS.ProcessEnv, stateDirPath?: string): string;
+export declare function resolveOAuthDir(env?: NodeJS.ProcessEnv, stateDirPath?: string): string;
+export declare function resolveOAuthPath(env?: NodeJS.ProcessEnv, stateDirPath?: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/packages/agent/src/config/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../../../src/config/paths.ts"],"names":[],"mappings":"AAGA,wBAAgB,iBAAiB,CAC/B,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,MAAM,CAGR;AAUD,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAUrD;AAED,wBAAgB,eAAe,CAC7B,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,OAAO,GAAE,MAAM,MAAmB,GACjC,MAAM,CAMR;AAED,wBAAgB,iBAAiB,CAC/B,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,YAAY,GAAE,MAAyC,GACtD,MAAM,CAOR;AAED,wBAAgB,8BAA8B,CAC5C,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,OAAO,GAAE,MAAM,MAAmB,GACjC,MAAM,EAAE,CAeV;AAID;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,YAAY,GAAE,MAAyC,GACtD,MAAM,CAER;AAED,wBAAgB,eAAe,CAC7B,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,YAAY,GAAE,MAAyC,GACtD,MAAM,CAMR;AAED,wBAAgB,gBAAgB,CAC9B,GAAG,GAAE,MAAM,CAAC,UAAwB,EACpC,YAAY,GAAE,MAAyC,GACtD,MAAM,CAER"}

package/packages/agent/src/config/paths.js

@@ -0,0 +1,67 @@
+import os from "node:os";
+import path from "node:path";
+export function getElizaNamespace(env = process.env) {
+    const override = env.ELIZA_NAMESPACE?.trim();
+    return override && override.length > 0 ? override : "eliza";
+}
+function stateDir(homedir = os.homedir, env = process.env) {
+    const namespace = getElizaNamespace(env);
+    return path.join(homedir(), `.${namespace}`);
+}
+export function resolveUserPath(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        return trimmed;
+    }
+    if (trimmed.startsWith("~")) {
+        const expanded = trimmed.replace(/^~(?=$|[\\/])/, os.homedir());
+        return path.resolve(expanded);
+    }
+    return path.resolve(trimmed);
+}
+export function resolveStateDir(env = process.env, homedir = os.homedir) {
+    const override = env.ELIZA_STATE_DIR?.trim();
+    if (override) {
+        return resolveUserPath(override);
+    }
+    return stateDir(homedir, env);
+}
+export function resolveConfigPath(env = process.env, stateDirPath = resolveStateDir(env, os.homedir)) {
+    const override = env.ELIZA_CONFIG_PATH?.trim();
+    if (override) {
+        return resolveUserPath(override);
+    }
+    const namespace = getElizaNamespace(env);
+    return path.join(stateDirPath, `${namespace}.json`);
+}
+export function resolveDefaultConfigCandidates(env = process.env, homedir = os.homedir) {
+    const explicit = env.ELIZA_CONFIG_PATH?.trim();
+    if (explicit) {
+        return [resolveUserPath(explicit)];
+    }
+    const namespace = getElizaNamespace(env);
+    const elizaStateDir = env.ELIZA_STATE_DIR?.trim();
+    if (elizaStateDir) {
+        const resolved = resolveUserPath(elizaStateDir);
+        return [path.join(resolved, `${namespace}.json`)];
+    }
+    return [path.join(stateDir(homedir, env), `${namespace}.json`)];
+}
+const OAUTH_FILENAME = "oauth.json";
+/**
+ * Directory for per-provider model cache files.
+ * Each provider gets its own file: `~/.eliza/models/<providerId>.json`
+ */
+export function resolveModelsCacheDir(env = process.env, stateDirPath = resolveStateDir(env, os.homedir)) {
+    return path.join(stateDirPath, "models");
+}
+export function resolveOAuthDir(env = process.env, stateDirPath = resolveStateDir(env, os.homedir)) {
+    const override = env.ELIZA_OAUTH_DIR?.trim();
+    if (override) {
+        return resolveUserPath(override);
+    }
+    return path.join(stateDirPath, "credentials");
+}
+export function resolveOAuthPath(env = process.env, stateDirPath = resolveStateDir(env, os.homedir)) {
+    return path.join(resolveOAuthDir(env, stateDirPath), OAUTH_FILENAME);
+}

package/packages/agent/src/config/plugin-auto-enable.d.ts

@@ -0,0 +1,16 @@
+import type { ElizaConfig } from "./types";
+export interface ApplyPluginAutoEnableResult {
+    config: ElizaConfig;
+    changes: string[];
+}
+export interface ApplyPluginAutoEnableParams {
+    config: Partial<ElizaConfig>;
+    env: NodeJS.ProcessEnv;
+}
+export declare const CONNECTOR_PLUGINS: Record<string, string>;
+export declare const STREAMING_PLUGINS: Record<string, string>;
+export declare const AUTH_PROVIDER_PLUGINS: Record<string, string>;
+export declare function isConnectorConfigured(connectorName: string, connectorConfig: unknown): boolean;
+export declare function isStreamingDestinationConfigured(destName: string, destConfig: unknown): boolean;
+export declare function applyPluginAutoEnable(params: ApplyPluginAutoEnableParams): ApplyPluginAutoEnableResult;
+//# sourceMappingURL=plugin-auto-enable.d.ts.map

package/packages/agent/src/config/plugin-auto-enable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-auto-enable.d.ts","sourceRoot":"","sources":["../../../../../src/config/plugin-auto-enable.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,2BAA2B;IAC1C,MAAM,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAC7B,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB;AAED,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAsBpD,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAOpD,CAAC;AAuBF,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA6BxD,CAAC;AA8BF,wBAAgB,qBAAqB,CACnC,aAAa,EAAE,MAAM,EACrB,eAAe,EAAE,OAAO,GACvB,OAAO,CA8ET;AAED,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,OAAO,GAClB,OAAO,CAqBT;AA0BD,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,2BAA2B,GAClC,2BAA2B,CAkQ7B"}