@elizaos/python 2.0.0-alpha.10

package/elizaos/settings.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import hashlib
+import os
+import secrets
+from collections.abc import Mapping
+
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+from cryptography.hazmat.primitives.padding import PKCS7
+
+
+def get_salt() -> str:
+    salt = os.environ.get("SECRET_SALT", "secretsalt")
+    node_env = os.environ.get("NODE_ENV", "").strip().lower()
+    allow_default = os.environ.get("ELIZA_ALLOW_DEFAULT_SECRET_SALT", "").strip().lower() == "true"
+    if node_env == "production" and salt == "secretsalt" and not allow_default:
+        raise RuntimeError(
+            "SECRET_SALT must be set to a non-default value in production. "
+            "Set ELIZA_ALLOW_DEFAULT_SECRET_SALT=true to override (not recommended)."
+        )
+    return salt
+
+
+def _derive_key(salt: str) -> bytes:
+    return hashlib.sha256(salt.encode("utf-8")).digest()[:32]
+
+
+def _looks_encrypted(value: str) -> bool:
+    parts = value.split(":")
+    # v2: v2:ivHex:ciphertextHex:tagHex
+    if len(parts) == 4 and parts[0] == "v2":
+        try:
+            iv = bytes.fromhex(parts[1])
+            tag = bytes.fromhex(parts[3])
+        except ValueError:
+            return False
+        return len(iv) == 12 and len(tag) == 16
+
+    # v1 legacy: ivHex:ciphertextHex
+    if len(parts) != 2:
+        return False
+    try:
+        iv = bytes.fromhex(parts[0])
+    except ValueError:
+        return False
+    return len(iv) == 16
+
+
+def encrypt_string_value(value: object, salt: str) -> object:
+    if value is None or isinstance(value, (bool, int, float)):
+        return value
+    if not isinstance(value, str):
+        return value
+
+    if _looks_encrypted(value):
+        return value
+
+    # v2: AES-256-GCM with integrity tag
+    key = _derive_key(salt)
+    iv = secrets.token_bytes(12)
+    aad = b"elizaos:settings:v2"
+    aesgcm = AESGCM(key)
+    ciphertext_and_tag = aesgcm.encrypt(iv, value.encode("utf-8"), aad)
+    ciphertext = ciphertext_and_tag[:-16]
+    tag = ciphertext_and_tag[-16:]
+    return f"v2:{iv.hex()}:{ciphertext.hex()}:{tag.hex()}"
+
+
+def decrypt_string_value(value: object, salt: str) -> object:
+    if not isinstance(value, str):
+        return value
+
+    parts = value.split(":")
+    if len(parts) == 4 and parts[0] == "v2":
+        try:
+            iv = bytes.fromhex(parts[1])
+            ciphertext = bytes.fromhex(parts[2])
+            tag = bytes.fromhex(parts[3])
+        except ValueError:
+            return value
+        if len(iv) != 12 or len(tag) != 16:
+            return value
+
+        key = _derive_key(salt)
+        aad = b"elizaos:settings:v2"
+        aesgcm = AESGCM(key)
+        try:
+            plaintext_bytes = aesgcm.decrypt(iv, ciphertext + tag, aad)
+        except Exception:
+            return value
+        try:
+            return plaintext_bytes.decode("utf-8")
+        except UnicodeDecodeError:
+            return value
+
+    if len(parts) != 2:
+        return value
+
+    iv_hex, ciphertext_hex = parts
+    try:
+        iv = bytes.fromhex(iv_hex)
+    except ValueError:
+        return value
+    if len(iv) != 16:
+        return value
+
+    try:
+        ciphertext = bytes.fromhex(ciphertext_hex)
+    except ValueError:
+        return value
+
+    key = _derive_key(salt)
+    cipher = Cipher(algorithms.AES(key), modes.CBC(iv))
+    decryptor = cipher.decryptor()
+
+    try:
+        padded = decryptor.update(ciphertext) + decryptor.finalize()
+    except Exception:
+        return value
+
+    try:
+        unpadder = PKCS7(128).unpadder()
+        plaintext_bytes = unpadder.update(padded) + unpadder.finalize()
+    except ValueError:
+        return value
+
+    try:
+        return plaintext_bytes.decode("utf-8")
+    except UnicodeDecodeError:
+        return value
+
+
+def encrypt_object_values(obj: Mapping[str, object], salt: str) -> dict[str, object]:
+    result: dict[str, object] = {}
+    for key, value in obj.items():
+        if isinstance(value, str) and value:
+            result[key] = encrypt_string_value(value, salt)
+        else:
+            result[key] = value
+    return result
+
+
+def decrypt_object_values(obj: Mapping[str, object], salt: str) -> dict[str, object]:
+    result: dict[str, object] = {}
+    for key, value in obj.items():
+        if isinstance(value, str) and value:
+            result[key] = decrypt_string_value(value, salt)
+        else:
+            result[key] = value
+    return result
+
+
+def migrate_encrypted_string_value(value: object, salt: str) -> object:
+    """
+    Migrate a legacy v1 encrypted string (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
+    """
+    if not isinstance(value, str):
+        return value
+    if value.startswith("v2:"):
+        return value
+    if not _looks_encrypted(value):
+        return value
+
+    decrypted = decrypt_string_value(value, salt)
+    if decrypted == value:
+        return value
+    return encrypt_string_value(decrypted, salt)
+
+
+def migrate_object_values(obj: Mapping[str, object], salt: str) -> dict[str, object]:
+    result: dict[str, object] = {}
+    for key, value in obj.items():
+        result[key] = migrate_encrypted_string_value(value, salt)
+    return result
+
+
+decrypt_secret = decrypt_string_value

package/elizaos/streaming_context.py

@@ -0,0 +1,159 @@
+"""Streaming context management for automatic streaming in use_model calls.
+
+Follows the OpenTelemetry ContextManager pattern (matching TypeScript implementation):
+- Interface for context management
+- Uses contextvars for async-safe context propagation
+- Automatic streaming in nested async calls
+
+This provides parity with TypeScript's streaming-context.ts.
+"""
+
+from collections.abc import Callable
+from contextvars import ContextVar
+from dataclasses import dataclass
+from typing import Any, TypeVar
+
+# Type for generic return values
+T = TypeVar("T")
+
+
+@dataclass
+class StreamingContext:
+    """Streaming context containing callbacks for streaming lifecycle.
+
+    Attributes:
+        on_stream_chunk: Called for each chunk of streamed content.
+        on_stream_end: Called when a use_model streaming call completes.
+        message_id: Optional message ID for tracking.
+        abort_signal: Optional callable returning True if cancelled.
+    """
+
+    on_stream_chunk: Callable[[str, str | None], Any]
+    """Called for each chunk of streamed content (chunk, message_id) -> None"""
+
+    on_stream_end: Callable[[], None] | None = None
+    """Called when a use_model streaming call completes (allows reset between calls)"""
+
+    message_id: str | None = None
+    """Optional message ID for tracking"""
+
+    abort_signal: Callable[[], bool] | None = None
+    """Optional abort signal - callable returning True if cancelled"""
+
+
+# Context variable for async-safe streaming context propagation
+_streaming_context: ContextVar[StreamingContext | None] = ContextVar(
+    "streaming_context", default=None
+)
+
+
+def run_with_streaming_context(
+    context: StreamingContext | None,
+    fn: Callable[[], T],
+) -> T:
+    """Run a function with a streaming context.
+
+    All use_model calls within this function will automatically use streaming
+    if a context with on_stream_chunk is provided.
+
+    Example:
+        async def handle_request(message: Memory) -> None:
+            async def on_chunk(chunk: str, msg_id: str | None) -> None:
+                await send_sse(chunk)
+
+            ctx = StreamingContext(on_stream_chunk=on_chunk)
+            await run_with_streaming_context(
+                ctx,
+                lambda: runtime.process_message(message)
+            )
+
+    Args:
+        context: The streaming context with on_stream_chunk callback.
+        fn: The function to run with streaming context.
+
+    Returns:
+        The result of the function.
+    """
+    token = _streaming_context.set(context)
+    try:
+        return fn()
+    finally:
+        _streaming_context.reset(token)
+
+
+async def run_with_streaming_context_async(
+    context: StreamingContext | None,
+    fn: Callable[[], Any],
+) -> Any:
+    """Run an async function with a streaming context.
+
+    Same as run_with_streaming_context but for async functions.
+
+    Example:
+        async def handle_request(message: Memory) -> None:
+            async def on_chunk(chunk: str, msg_id: str | None) -> None:
+                await send_sse(chunk)
+
+            ctx = StreamingContext(on_stream_chunk=on_chunk)
+            await run_with_streaming_context_async(
+                ctx,
+                lambda: runtime.process_message(message)
+            )
+
+    Args:
+        context: The streaming context with on_stream_chunk callback.
+        fn: The async function to run with streaming context.
+
+    Returns:
+        The result of the async function.
+    """
+    token = _streaming_context.set(context)
+    try:
+        result = fn()
+        # Handle both sync and async functions
+        if hasattr(result, "__await__"):
+            return await result
+        return result
+    finally:
+        _streaming_context.reset(token)
+
+
+def get_streaming_context() -> StreamingContext | None:
+    """Get the currently active streaming context.
+
+    Called by use_model to check if automatic streaming should be enabled.
+
+    Returns:
+        The current streaming context or None.
+    """
+    return _streaming_context.get()
+
+
+def set_streaming_context(context: StreamingContext | None) -> None:
+    """Set the streaming context directly.
+
+    This is useful for frameworks that manage their own context lifecycle.
+    Prefer using run_with_streaming_context when possible.
+
+    Args:
+        context: The streaming context to set, or None to clear.
+    """
+    _streaming_context.set(context)
+
+
+def clear_streaming_context() -> None:
+    """Clear the streaming context.
+
+    This is useful for cleanup after streaming operations.
+    """
+    _streaming_context.set(None)
+
+
+__all__ = [
+    "StreamingContext",
+    "run_with_streaming_context",
+    "run_with_streaming_context_async",
+    "get_streaming_context",
+    "set_streaming_context",
+    "clear_streaming_context",
+]

package/elizaos/trajectory_context.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from contextvars import ContextVar
+
+# Async-safe context for associating runtime/model calls with a trajectory step.
+CURRENT_TRAJECTORY_STEP_ID: ContextVar[str | None] = ContextVar(
+    "CURRENT_TRAJECTORY_STEP_ID", default=None
+)
+
+
+@contextmanager
+def bind_trajectory_step(step_id: str | None):
+    token = CURRENT_TRAJECTORY_STEP_ID.set(step_id)
+    try:
+        yield
+    finally:
+        CURRENT_TRAJECTORY_STEP_ID.reset(token)