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

package/packages/typescript/src/settings.d.ts

@@ -0,0 +1,99 @@
+import type { Character, IAgentRuntime, OnboardingConfig, Setting, World, WorldSettings } from "./types";
+/**
+ * Creates a Setting object from a configSetting object by omitting the 'value' property.
+ *
+ * @param {Omit<Setting, 'value'>} configSetting - The configSetting object to create the Setting from.
+ * @returns {Setting} A new Setting object created from the provided configSetting object.
+ */
+export declare function createSettingFromConfig(configSetting: Omit<Setting, "value">): Setting;
+/**
+ * Gets the salt for the agent.
+ *
+ * @returns {string} The salt for the agent.
+ */
+export declare function getSalt(): string;
+/**
+ * Clears the salt cache - useful for tests or when environment changes
+ */
+export declare function clearSaltCache(): void;
+/**
+ * Common encryption function for string values
+ * @param {string} value - The string value to encrypt
+ * @param {string} salt - The salt to use for encryption
+ * @returns {string} - The encrypted value in 'iv:encrypted' format
+ */
+export declare function encryptStringValue(value: string, salt: string): string;
+/**
+ * Common decryption function for string values
+ * @param value - The encrypted value in 'iv:encrypted' format
+ * @param salt - The salt to use for decryption
+ * @returns The decrypted string value, or original value if not encrypted
+ */
+export declare function decryptStringValue(value: string, salt: string): string;
+/**
+ * Migrates an encrypted string from legacy v1 (AES-CBC) to v2 (AES-GCM).
+ *
+ * - v2 values are returned unchanged
+ * - v1 values are decrypted then re-encrypted as v2
+ * - non-encrypted values are returned unchanged
+ */
+export declare function migrateEncryptedStringValue(value: string, salt: string): string;
+/**
+ * Applies salt to the value of a setting
+ * Only applies to secret settings with string values
+ */
+export declare function saltSettingValue(setting: Setting, salt: string): Setting;
+/**
+ * Removes salt from the value of a setting
+ * Only applies to secret settings with string values
+ */
+export declare function unsaltSettingValue(setting: Setting, salt: string): Setting;
+/**
+ * Applies salt to all settings in a WorldSettings object
+ */
+export declare function saltWorldSettings(worldSettings: WorldSettings, salt: string): WorldSettings;
+/**
+ * Removes salt from all settings in a WorldSettings object
+ */
+export declare function unsaltWorldSettings(worldSettings: WorldSettings, salt: string): WorldSettings;
+/**
+ * Updates settings state in world metadata
+ */
+export declare function updateWorldSettings(runtime: IAgentRuntime, serverId: string, worldSettings: WorldSettings): Promise<boolean>;
+/**
+ * Gets settings state from world metadata
+ */
+export declare function getWorldSettings(runtime: IAgentRuntime, serverId: string): Promise<WorldSettings | null>;
+/**
+ * Initializes settings configuration for a server
+ */
+export declare function initializeOnboarding(runtime: IAgentRuntime, world: World, config: OnboardingConfig): Promise<WorldSettings | null>;
+/**
+ * Encrypts sensitive data in a Character object
+ * @param {Character} character - The character object to encrypt secrets for
+ * @returns {Character} - A copy of the character with encrypted secrets
+ */
+export declare function encryptedCharacter(character: Character): Character;
+/**
+ * Decrypts sensitive data in a Character object
+ * @param {Character} character - The character object with encrypted secrets
+ * @param {IAgentRuntime} runtime - The runtime information needed for salt generation
+ * @returns {Character} - A copy of the character with decrypted secrets
+ */
+export declare function decryptedCharacter(character: Character, _runtime: IAgentRuntime): Character;
+/**
+ * Helper function to encrypt all string values in an object
+ * @param {Record<string, string | number | boolean>} obj - Object with values to encrypt
+ * @param {string} salt - The salt to use for encryption
+ * @returns {Record<string, unknown>} - Object with encrypted values
+ */
+export declare function encryptObjectValues(obj: Record<string, string | number | boolean>, salt: string): Record<string, string | number | boolean>;
+/**
+ * Helper function to decrypt all string values in an object
+ * @param {Record<string, string | number | boolean>} obj - Object with encrypted values
+ * @param {string} salt - The salt to use for decryption
+ * @returns {Record<string, unknown>} - Object with decrypted values
+ */
+export declare function decryptObjectValues(obj: Record<string, string | number | boolean>, salt: string): Record<string, string | number | boolean>;
+export { decryptStringValue as decryptSecret };
+//# sourceMappingURL=settings.d.ts.map

package/packages/typescript/src/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../../../../typescript/src/settings.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACX,SAAS,EACT,aAAa,EACb,gBAAgB,EAChB,OAAO,EACP,KAAK,EACL,aAAa,EACb,MAAM,SAAS,CAAC;AAKjB;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACtC,aAAa,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,GACnC,OAAO,CAcT;AAoCD;;;;GAIG;AACH,wBAAgB,OAAO,IAAI,MAAM,CAwChC;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAGrC;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAsCtE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAiDtE;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAC1C,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,GACV,MAAM,CAeR;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAaxE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAa1E;AA0BD;;GAEG;AACH,wBAAgB,iBAAiB,CAChC,aAAa,EAAE,aAAa,EAC5B,IAAI,EAAE,MAAM,GACV,aAAa,CASf;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAClC,aAAa,EAAE,aAAa,EAC5B,IAAI,EAAE,MAAM,GACV,aAAa,CASf;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACxC,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,aAAa,GAC1B,OAAO,CAAC,OAAO,CAAC,CAyBlB;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CACrC,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,MAAM,GACd,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAe/B;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,aAAa,EACtB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,gBAAgB,GACtB,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAuC/B;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,CAalE;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CACjC,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,aAAa,GACrB,SAAS,CAaX;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAClC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,EAC9C,IAAI,EAAE,MAAM,GACV,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAY3C;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAClC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,EAC9C,IAAI,EAAE,MAAM,GACV,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAY3C;AAED,OAAO,EAAE,kBAAkB,IAAI,aAAa,EAAE,CAAC"}

package/packages/typescript/src/settings.js

@@ -0,0 +1,409 @@
+import { createUniqueUuid } from "./entities";
+import { logger } from "./logger";
+import { BufferUtils } from "./utils/buffer";
+import * as cryptoUtils from "./utils/crypto-compat";
+import { getEnv, getEnvironment } from "./utils/environment";
+/**
+ * Creates a Setting object from a configSetting object by omitting the 'value' property.
+ *
+ * @param {Omit<Setting, 'value'>} configSetting - The configSetting object to create the Setting from.
+ * @returns {Setting} A new Setting object created from the provided configSetting object.
+ */
+export function createSettingFromConfig(configSetting) {
+    return {
+        name: configSetting.name,
+        description: configSetting.description,
+        usageDescription: configSetting.usageDescription || "",
+        value: null,
+        required: configSetting.required,
+        validation: configSetting.validation || undefined,
+        public: configSetting.public || false,
+        secret: configSetting.secret || false,
+        dependsOn: configSetting.dependsOn || [],
+        onSetAction: configSetting.onSetAction || undefined,
+        visibleIf: configSetting.visibleIf || undefined,
+    };
+}
+let saltCache = null;
+let saltErrorLogged = false;
+const SALT_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes TTL
+function isEncryptedV1(value) {
+    const parts = value.split(":");
+    if (parts.length !== 2)
+        return false;
+    try {
+        const iv = BufferUtils.fromHex(parts[0]);
+        return iv.length === 16;
+    }
+    catch {
+        return false;
+    }
+}
+function isEncryptedV2(value) {
+    const parts = value.split(":");
+    if (parts.length !== 4)
+        return false;
+    if (parts[0] !== "v2")
+        return false;
+    try {
+        const iv = BufferUtils.fromHex(parts[1]);
+        const tag = BufferUtils.fromHex(parts[3]);
+        return iv.length === 12 && tag.length === 16;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Gets the salt for the agent.
+ *
+ * @returns {string} The salt for the agent.
+ */
+export function getSalt() {
+    getEnvironment().clearCache();
+    const currentEnvSalt = getEnv("SECRET_SALT", "secretsalt") || "secretsalt";
+    const nodeEnv = (getEnv("NODE_ENV", "") || "").toLowerCase();
+    const isProduction = nodeEnv === "production";
+    const allowDefaultSaltRaw = getEnv("ELIZA_ALLOW_DEFAULT_SECRET_SALT", "") || "";
+    const allowDefaultSalt = allowDefaultSaltRaw.toLowerCase() === "true";
+    const now = Date.now();
+    // Return cached value only if still valid AND matches current env
+    if (saltCache !== null) {
+        const cacheFresh = now - saltCache.timestamp < SALT_CACHE_TTL_MS;
+        if (cacheFresh && saltCache.value === currentEnvSalt) {
+            return saltCache.value;
+        }
+    }
+    if (isProduction && currentEnvSalt === "secretsalt" && !allowDefaultSalt) {
+        throw new Error("SECRET_SALT must be set to a non-default value in production. " +
+            "Set ELIZA_ALLOW_DEFAULT_SECRET_SALT=true to override (not recommended).");
+    }
+    if (currentEnvSalt === "secretsalt" && !saltErrorLogged) {
+        logger.warn({ src: "core:settings", event: "core.settings.default_secret_salt" }, "SECRET_SALT is not set or using default value");
+        saltErrorLogged = true;
+    }
+    // Update cache with latest env-derived salt
+    saltCache = {
+        value: currentEnvSalt,
+        timestamp: now,
+    };
+    return currentEnvSalt;
+}
+/**
+ * Clears the salt cache - useful for tests or when environment changes
+ */
+export function clearSaltCache() {
+    saltCache = null;
+    saltErrorLogged = false;
+}
+/**
+ * Common encryption function for string values
+ * @param {string} value - The string value to encrypt
+ * @param {string} salt - The salt to use for encryption
+ * @returns {string} - The encrypted value in 'iv:encrypted' format
+ */
+export function encryptStringValue(value, salt) {
+    // Check if value is undefined or null
+    if (value === undefined || value === null) {
+        return value; // Return the value as is (undefined or null)
+    }
+    if (typeof value === "boolean" || typeof value === "number") {
+        return value;
+    }
+    if (typeof value !== "string") {
+        return value;
+    }
+    // If already encrypted (legacy v1 iv:ciphertext or v2:iv:ciphertext:tag), return as-is.
+    if (isEncryptedV1(value) || isEncryptedV2(value)) {
+        return value;
+    }
+    // v2 encryption: AES-256-GCM with integrity tag
+    const key = cryptoUtils
+        .createHash("sha256")
+        .update(salt)
+        .digest()
+        .slice(0, 32);
+    const iv = BufferUtils.randomBytes(12);
+    const aad = new TextEncoder().encode("elizaos:settings:v2");
+    const plaintextBytes = BufferUtils.fromString(value, "utf8");
+    const { ciphertext, tag } = cryptoUtils.encryptAes256Gcm(key, iv, plaintextBytes, aad);
+    // Store version + IV + ciphertext + tag so we can decrypt and authenticate later
+    return `v2:${BufferUtils.toHex(iv)}:${BufferUtils.toHex(ciphertext)}:${BufferUtils.toHex(tag)}`;
+}
+/**
+ * Common decryption function for string values
+ * @param value - The encrypted value in 'iv:encrypted' format
+ * @param salt - The salt to use for decryption
+ * @returns The decrypted string value, or original value if not encrypted
+ */
+export function decryptStringValue(value, salt) {
+    try {
+        const parts = value.split(":");
+        // v2: AES-256-GCM with tag
+        if (isEncryptedV2(value)) {
+            // v2:<ivHex>:<ciphertextHex>:<tagHex>
+            const iv = BufferUtils.fromHex(parts[1]);
+            const ciphertext = BufferUtils.fromHex(parts[2]);
+            const tag = BufferUtils.fromHex(parts[3]);
+            const key = cryptoUtils
+                .createHash("sha256")
+                .update(salt)
+                .digest()
+                .slice(0, 32);
+            const aad = new TextEncoder().encode("elizaos:settings:v2");
+            const plaintextBytes = cryptoUtils.decryptAes256Gcm(key, iv, ciphertext, tag, aad);
+            return BufferUtils.bufferToString(plaintextBytes, "utf8");
+        }
+        // v1 legacy: ivHex:ciphertextHex (AES-256-CBC)
+        if (!isEncryptedV1(value)) {
+            return value;
+        }
+        const iv = BufferUtils.fromHex(parts[0]);
+        const encrypted = parts[1];
+        const key = cryptoUtils
+            .createHash("sha256")
+            .update(salt)
+            .digest()
+            .slice(0, 32);
+        const decipher = cryptoUtils.createDecipheriv("aes-256-cbc", key, iv);
+        let decrypted = decipher.update(encrypted, "hex", "utf8");
+        decrypted += decipher.final("utf8");
+        return decrypted;
+    }
+    catch (error) {
+        logger.error({ src: "core:settings", error }, "Decryption failed");
+        // Return the original value on error
+        return value;
+    }
+}
+/**
+ * Migrates an encrypted string from legacy v1 (AES-CBC) to v2 (AES-GCM).
+ *
+ * - v2 values are returned unchanged
+ * - v1 values are decrypted then re-encrypted as v2
+ * - non-encrypted values are returned unchanged
+ */
+export function migrateEncryptedStringValue(value, salt) {
+    if (typeof value !== "string") {
+        return value;
+    }
+    if (isEncryptedV2(value)) {
+        return value;
+    }
+    if (!isEncryptedV1(value)) {
+        return value;
+    }
+    const decrypted = decryptStringValue(value, salt);
+    if (decrypted === value) {
+        return value;
+    }
+    return encryptStringValue(decrypted, salt);
+}
+/**
+ * Applies salt to the value of a setting
+ * Only applies to secret settings with string values
+ */
+export function saltSettingValue(setting, salt) {
+    const settingCopy = { ...setting };
+    // Only encrypt string values in secret settings
+    if (setting.secret === true &&
+        typeof setting.value === "string" &&
+        setting.value) {
+        settingCopy.value = encryptStringValue(setting.value, salt);
+    }
+    return settingCopy;
+}
+/**
+ * Removes salt from the value of a setting
+ * Only applies to secret settings with string values
+ */
+export function unsaltSettingValue(setting, salt) {
+    const settingCopy = { ...setting };
+    // Only decrypt string values in secret settings
+    if (setting.secret === true &&
+        typeof setting.value === "string" &&
+        setting.value) {
+        settingCopy.value = decryptStringValue(setting.value, salt);
+    }
+    return settingCopy;
+}
+function extractSettingsRecord(worldSettings) {
+    if (worldSettings.settings && typeof worldSettings.settings === "object") {
+        return worldSettings.settings;
+    }
+    const { settings: _settings, ...rest } = worldSettings;
+    return rest;
+}
+function wrapSettingsRecord(worldSettings, settings) {
+    if (worldSettings.settings !== undefined) {
+        return {
+            ...worldSettings,
+            settings,
+        };
+    }
+    return settings;
+}
+/**
+ * Applies salt to all settings in a WorldSettings object
+ */
+export function saltWorldSettings(worldSettings, salt) {
+    const settingsRecord = extractSettingsRecord(worldSettings);
+    const saltedSettings = {};
+    for (const [key, setting] of Object.entries(settingsRecord)) {
+        saltedSettings[key] = saltSettingValue(setting, salt);
+    }
+    return wrapSettingsRecord(worldSettings, saltedSettings);
+}
+/**
+ * Removes salt from all settings in a WorldSettings object
+ */
+export function unsaltWorldSettings(worldSettings, salt) {
+    const settingsRecord = extractSettingsRecord(worldSettings);
+    const unsaltedSettings = {};
+    for (const [key, setting] of Object.entries(settingsRecord)) {
+        unsaltedSettings[key] = unsaltSettingValue(setting, salt);
+    }
+    return wrapSettingsRecord(worldSettings, unsaltedSettings);
+}
+/**
+ * Updates settings state in world metadata
+ */
+export async function updateWorldSettings(runtime, serverId, worldSettings) {
+    const worldId = createUniqueUuid(runtime, serverId);
+    const world = await runtime.getWorld(worldId);
+    if (!world) {
+        logger.error({ src: "core:settings", serverId }, "World not found");
+        return false;
+    }
+    // Initialize metadata if it doesn't exist
+    if (!world.metadata) {
+        world.metadata = {};
+    }
+    // Apply salt to settings before saving
+    const salt = getSalt();
+    const saltedSettings = saltWorldSettings(worldSettings, salt);
+    // Update settings state
+    world.metadata.settings = saltedSettings;
+    // Save updated world
+    await runtime.updateWorld(world);
+    return true;
+}
+/**
+ * Gets settings state from world metadata
+ */
+export async function getWorldSettings(runtime, serverId) {
+    const worldId = createUniqueUuid(runtime, serverId);
+    const world = await runtime.getWorld(worldId);
+    const settings = world?.metadata?.settings;
+    if (!settings) {
+        return null;
+    }
+    // Get settings from metadata
+    const saltedSettings = settings;
+    // Remove salt from settings before returning
+    const salt = getSalt();
+    return unsaltWorldSettings(saltedSettings, salt);
+}
+/**
+ * Initializes settings configuration for a server
+ */
+export async function initializeOnboarding(runtime, world, config) {
+    // Check if settings state already exists
+    const existingSettings = world.metadata?.settings;
+    if (existingSettings) {
+        logger.debug({ src: "core:settings", serverId: world.messageServerId }, "Onboarding state already exists");
+        // Get settings from metadata and remove salt
+        const saltedSettings = existingSettings;
+        const salt = getSalt();
+        return unsaltWorldSettings(saltedSettings, salt);
+    }
+    // Create new settings state
+    const worldSettings = {};
+    // Initialize settings from config
+    if (config.settings) {
+        for (const [key, configSetting] of Object.entries(config.settings)) {
+            worldSettings[key] = createSettingFromConfig(configSetting);
+        }
+    }
+    // Save settings state to world metadata
+    if (!world.metadata) {
+        world.metadata = {};
+    }
+    // No need to salt here as the settings are just initialized with null values
+    world.metadata.settings = worldSettings;
+    await runtime.updateWorld(world);
+    logger.info({ src: "core:settings", serverId: world.messageServerId }, "Settings config initialized");
+    return worldSettings;
+}
+/**
+ * Encrypts sensitive data in a Character object
+ * @param {Character} character - The character object to encrypt secrets for
+ * @returns {Character} - A copy of the character with encrypted secrets
+ */
+export function encryptedCharacter(character) {
+    const encryptedChar = {
+        ...character,
+        secrets: character.secrets ? { ...character.secrets } : undefined,
+    };
+    const salt = getSalt();
+    // Encrypt character.secrets if it exists
+    if (encryptedChar.secrets) {
+        encryptedChar.secrets = encryptObjectValues(encryptedChar.secrets, salt);
+    }
+    return encryptedChar;
+}
+/**
+ * Decrypts sensitive data in a Character object
+ * @param {Character} character - The character object with encrypted secrets
+ * @param {IAgentRuntime} runtime - The runtime information needed for salt generation
+ * @returns {Character} - A copy of the character with decrypted secrets
+ */
+export function decryptedCharacter(character, _runtime) {
+    const decryptedChar = {
+        ...character,
+        secrets: character.secrets ? { ...character.secrets } : undefined,
+    };
+    const salt = getSalt();
+    // Decrypt character.secrets if it exists
+    if (decryptedChar.secrets) {
+        decryptedChar.secrets = decryptObjectValues(decryptedChar.secrets, salt);
+    }
+    return decryptedChar;
+}
+/**
+ * Helper function to encrypt all string values in an object
+ * @param {Record<string, string | number | boolean>} obj - Object with values to encrypt
+ * @param {string} salt - The salt to use for encryption
+ * @returns {Record<string, unknown>} - Object with encrypted values
+ */
+export function encryptObjectValues(obj, salt) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (typeof value === "string" && value) {
+            result[key] = encryptStringValue(value, salt);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Helper function to decrypt all string values in an object
+ * @param {Record<string, string | number | boolean>} obj - Object with encrypted values
+ * @param {string} salt - The salt to use for decryption
+ * @returns {Record<string, unknown>} - Object with decrypted values
+ */
+export function decryptObjectValues(obj, salt) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (typeof value === "string" && value) {
+            result[key] = decryptStringValue(value, salt);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+export { decryptStringValue as decryptSecret };

package/packages/typescript/src/should-respond.d.ts

@@ -0,0 +1,2 @@
+export declare function isExplicitSelfModificationRequest(text: string): boolean;
+//# sourceMappingURL=should-respond.d.ts.map

package/packages/typescript/src/should-respond.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"should-respond.d.ts","sourceRoot":"","sources":["../../../../../typescript/src/should-respond.ts"],"names":[],"mappings":"AAOA,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAavE"}

package/packages/typescript/src/should-respond.js

@@ -0,0 +1,16 @@
+const EXPLICIT_SELF_MODIFICATION_PATTERNS = [
+    /\b(?:update|change|modify|adjust|tweak|revise|refresh|set)\s+(?:(?:your|ur|its)\s+)?(?:personality|character|tone|voice|style|behavior|behaviour|response(?:s| style)?|how\s+you\s+respond|way\s+you\s+respond)\b/i,
+    /\b(?:update|change|modify|adjust|tweak|revise|refresh|set)\s+(?:the\s+|this\s+)?(?:agent|assistant|bot)(?:'s)?\s+(?:personality|character|tone|voice|style|behavior|behaviour|response(?:\s+style)?)\b/i,
+    /\b(?:change|update|modify|adjust|set)\s+(?:your\s+)?response\s+style\b/i,
+    /\b(?:change|update|modify|adjust|set)\s+how\s+you\s+(?:respond|reply|sound|talk)\b/i,
+];
+export function isExplicitSelfModificationRequest(text) {
+    if (typeof text !== "string") {
+        return false;
+    }
+    const normalized = text.trim();
+    if (normalized.length === 0) {
+        return false;
+    }
+    return EXPLICIT_SELF_MODIFICATION_PATTERNS.some((pattern) => pattern.test(normalized));
+}

package/packages/typescript/src/streaming-context.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Streaming context management for automatic streaming in useModel calls.
+ *
+ * Follows the OpenTelemetry ContextManager pattern:
+ * - Interface for context management
+ * - Platform-specific implementations (Node.js AsyncLocalStorage, Browser Stack)
+ * - Auto-detected at runtime - no separate entry points needed
+ *
+ * @see https://opentelemetry.io/docs/languages/js/context/
+ */
+import type { StreamChunkCallback } from "./types/components";
+/**
+ * Streaming context containing callbacks for streaming lifecycle.
+ */
+export interface StreamingContext {
+    /** Called for each chunk of streamed content */
+    onStreamChunk: StreamChunkCallback;
+    /** Called when a useModel streaming call completes (allows reset between calls) */
+    onStreamEnd?: () => void;
+    messageId?: string;
+    /** Optional abort signal to cancel streaming */
+    abortSignal?: AbortSignal;
+}
+/**
+ * Interface for streaming context managers.
+ * Different implementations exist for Node.js (AsyncLocalStorage) and Browser (Stack).
+ */
+export interface IStreamingContextManager {
+    /**
+     * Run a function with a streaming context.
+     * The context will be available to all nested async calls via `active()`.
+     */
+    run<T>(context: StreamingContext | undefined, fn: () => T): T;
+    /**
+     * Get the currently active streaming context.
+     * Returns undefined if no context is active.
+     */
+    active(): StreamingContext | undefined;
+}
+/**
+ * Set the global streaming context manager.
+ * Can be used to override the auto-detected manager.
+ *
+ * @param manager - The context manager to use globally
+ */
+export declare function setStreamingContextManager(manager: IStreamingContextManager): void;
+/**
+ * Get the global streaming context manager.
+ * Auto-detects and creates the appropriate manager on first access.
+ */
+export declare function getStreamingContextManager(): IStreamingContextManager;
+/**
+ * Run a function with a streaming context.
+ * All useModel calls within this function will automatically use streaming.
+ *
+ * @example
+ * ```typescript
+ * await runWithStreamingContext(
+ *   { onStreamChunk: async (chunk) => sendSSE(chunk), messageId },
+ *   async () => {
+ *     // All useModel calls here will stream automatically
+ *     await runtime.processMessage(message);
+ *   }
+ * );
+ * ```
+ *
+ * @param context - The streaming context with onStreamChunk callback
+ * @param fn - The function to run with streaming context
+ * @returns The result of the function
+ */
+export declare function runWithStreamingContext<T>(context: StreamingContext | undefined, fn: () => T): T;
+/**
+ * Get the currently active streaming context.
+ * Called by useModel to check if automatic streaming should be enabled.
+ *
+ * @returns The current streaming context or undefined
+ */
+export declare function getStreamingContext(): StreamingContext | undefined;
+/**
+ * While `> 0`, the runtime is inside `useModel`'s delivery of one `textStream` chunk to
+ * `paramsChunk` / `ctxChunk` (after `model_stream_chunk` with `source: "use_model"`).
+ * `DefaultMessageService` skips its own `model_stream_chunk` (`source: "message_service"`) in
+ * this window so the same raw token is not processed twice. Non-Node environments return `0`.
+ */
+export declare function getModelStreamChunkDeliveryDepth(): number;
+/** Wrap `paramsChunk` / `ctxChunk` invocations from `useModel`'s stream loop. */
+export declare function runInsideModelStreamChunkDelivery<T>(fn: () => T | Promise<T>): T | Promise<T>;
+//# sourceMappingURL=streaming-context.d.ts.map

package/packages/typescript/src/streaming-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-context.d.ts","sourceRoot":"","sources":["../../../../../typescript/src/streaming-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAChC,gDAAgD;IAChD,aAAa,EAAE,mBAAmB,CAAC;IACnC,mFAAmF;IACnF,WAAW,CAAC,EAAE,MAAM,IAAI,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,WAAW,CAAC,EAAE,WAAW,CAAC;CAC1B;AAED;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACxC;;;OAGG;IACH,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,gBAAgB,GAAG,SAAS,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;IAE9D;;;OAGG;IACH,MAAM,IAAI,gBAAgB,GAAG,SAAS,CAAC;CACvC;AAoED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACzC,OAAO,EAAE,wBAAwB,GAC/B,IAAI,CAEN;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,wBAAwB,CAErE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EACxC,OAAO,EAAE,gBAAgB,GAAG,SAAS,EACrC,EAAE,EAAE,MAAM,CAAC,GACT,CAAC,CAEH;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,IAAI,gBAAgB,GAAG,SAAS,CAElE;AAmCD;;;;;GAKG;AACH,wBAAgB,gCAAgC,IAAI,MAAM,CAGzD;AAED,iFAAiF;AACjF,wBAAgB,iCAAiC,CAAC,CAAC,EAClD,EAAE,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GACtB,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAOhB"}