fix: activation memory config crashes get_default() with OpenAI (MemTensor#1051)

## Summary

Two bugs in `default_config.py` that crash `get_default()` when
`enable_activation_memory=True`:

**Bug 1: `act_mem` injected into MOSConfig (extra=forbid)**

`get_default_config()` adds `act_mem` dict to the config passed to
`MOSConfig(**config_dict)`, but `MOSConfig` has no `act_mem` field and
inherits `extra="forbid"` from `BaseConfig`:

```
pydantic_core.ValidationError: 1 validation error for MOSConfig
act_mem
  Extra inputs are not permitted [type=extra_forbidden]
```

**Bug 2: KV cache with `openai` backend**

`get_default_cube_config()` hardcodes `extractor_llm` backend to
`"openai"` for KV cache memory, but `KVCacheMemoryConfig` validator
requires `huggingface`/`huggingface_singleton`/`vllm` (KV cache extracts
internal attention tensors via `build_kv_cache`, which needs local model
access):

```
ConfigurationError: KVCacheMemoryConfig requires extractor_llm backend
to be 'huggingface' or 'huggingface_singleton', got 'openai'
```

## Reproduction

```python
from memos.mem_os.utils.default_config import get_default

# This crashes with ValidationError
config, cube = get_default(
    openai_api_key="sk-...",
    enable_activation_memory=True,
)
```

## Fix

- Remove `act_mem` from `get_default_config()` — the
`enable_activation_memory` bool flag is sufficient for `MOSConfig`;
`act_mem` config belongs in MemCube config only.
- In `get_default_cube_config()`, require explicit
`activation_memory_backend` kwarg (e.g. `"huggingface"`) instead of
hardcoding `"openai"`. Skip `act_mem` gracefully when no compatible
local backend is provided.

## Test plan

- [ ] `get_default(openai_api_key="sk-...",
enable_activation_memory=True)` no longer crashes
- [ ] `get_default(openai_api_key="sk-...",
enable_activation_memory=True, activation_memory_backend="huggingface",
activation_memory_llm_config={...})` creates valid act_mem config
- [ ] `get_default(openai_api_key="sk-...")` continues to work as before

Author: CaralHsi

src/memos/mem_os/utils/default_config.py

@@ -3,12 +3,15 @@
 Provides simplified configuration generation for users.
 """
 
+import logging
 from typing import Literal
 
 from memos.configs.mem_cube import GeneralMemCubeConfig
 from memos.configs.mem_os import MOSConfig
 from memos.mem_cube.general import GeneralMemCube
 
+logger = logging.getLogger(__name__)
+
 
 def get_default_config(
     openai_api_key: str,
@@ -116,20 +119,9 @@ def get_default_config(
             },
         }
 
-    # Add activation memory if enabled
-    if config_dict.get("enable_activation_memory", False):
-        config_dict["act_mem"] = {
-            "backend": "kv_cache",
-            "config": {
-                "memory_filename": kwargs.get(
-                    "activation_memory_filename", "activation_memory.pickle"
-                ),
-                "extractor_llm": {
-                    "backend": "openai",
-                    "config": openai_config,
-                },
-            },
-        }
+    # Note: act_mem configuration belongs in MemCube config (get_default_cube_config),
+    # not in MOSConfig which doesn't have an act_mem field (extra="forbid").
+    # The enable_activation_memory flag above is sufficient for MOSConfig.
 
     return MOSConfig(**config_dict)
 
@@ -237,21 +229,33 @@ def get_default_cube_config(
             },
         }
 
-    # Configure activation memory if enabled
+    # Configure activation memory if enabled.
+    # KV cache activation memory requires a local HuggingFace/vLLM model (it
+    # extracts internal attention KV tensors via build_kv_cache), so it cannot
+    # work with remote API backends like OpenAI.
+    # Only create act_mem when activation_memory_backend is explicitly provided.
     act_mem_config = {}
     if kwargs.get("enable_activation_memory", False):
-        act_mem_config = {
-            "backend": "kv_cache",
-            "config": {
-                "memory_filename": kwargs.get(
-                    "activation_memory_filename", "activation_memory.pickle"
-                ),
-                "extractor_llm": {
-                    "backend": "openai",
-                    "config": openai_config,
+        extractor_backend = kwargs.get("activation_memory_backend")
+        if extractor_backend in ("huggingface", "huggingface_singleton", "vllm"):
+            act_mem_config = {
+                "backend": "kv_cache",
+                "config": {
+                    "memory_filename": kwargs.get(
+                        "activation_memory_filename", "activation_memory.pickle"
+                    ),
+                    "extractor_llm": {
+                        "backend": extractor_backend,
+                        "config": kwargs.get("activation_memory_llm_config", {}),
+                    },
                 },
-            },
-        }
+            }
+        else:
+            logger.info(
+                "Activation memory (kv_cache) requires a local model backend "
+                "(huggingface/vllm) via activation_memory_backend kwarg. "
+                "Skipping act_mem in MemCube config."
+            )
 
     # Create MemCube configuration
     cube_config_dict = {