The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.
Rust agent-orchestrationai-agentsai-assistantdesktopllmlocal-firstmcppersonal-aiprivacyrustsecond-braintauri
chore(tinymemes): remove the tinymemes module and its config
Steven Enamakelf6ef43a7bc21
diff --git a/crates/openhuman-core/src/config/schema/memes.rs b/crates/openhuman-core/src/config/schema/memes.rsdeleted file mode 100644index 6cdfcadb84..0000000000--- a/crates/openhuman-core/src/config/schema/memes.rs+++ /dev/null@@ -1,41 +0,0 @@-//! `[memes]` — tuning for TinyMemes reply remixing.-//!-//! Whether remixing runs at all is `[components] memes`; which threads are in-//! the treatment arm is the `OPENHUMAN_TINYMEMES` flag (`off`, `on`, `ab`,-//! `ab:NN`, with `OPENHUMAN_TINYMEMES_DEFAULT` as the build-time default). The-//! environment variables below stay as operator overrides and win over this-//! section when set:-//!-//! | setting | override |-//! | --- | --- |-//! | `timeout_ms` | `OPENHUMAN_TINYMEMES_TIMEOUT_MS` |-//! | `meme_cooldown` | `OPENHUMAN_TINYMEMES_MEME_COOLDOWN` |--use schemars::JsonSchema;-use serde::{Deserialize, Serialize};--pub const DEFAULT_TIMEOUT_MS: u64 = 20_000;-pub const DEFAULT_MEME_COOLDOWN: u32 = 3;--#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]-#[serde(default)]-pub struct MemesConfig {- /// Time budget for one remix, in milliseconds. The original reply is- /// delivered when it runs out.- pub timeout_ms: u64,- /// Replies between memes.- pub meme_cooldown: u32,-}--impl Default for MemesConfig {- fn default() -> Self {- Self {- timeout_ms: DEFAULT_TIMEOUT_MS,- meme_cooldown: DEFAULT_MEME_COOLDOWN,- }- }-}--#[cfg(test)]-#[path = "memes_tests.rs"]-mod tests;diff --git a/crates/openhuman-core/src/config/schema/memes_tests.rs b/crates/openhuman-core/src/config/schema/memes_tests.rsdeleted file mode 100644index 5ae09e2420..0000000000--- a/crates/openhuman-core/src/config/schema/memes_tests.rs+++ /dev/null@@ -1,15 +0,0 @@-use super::*;--#[test]-fn defaults_match_the_documented_values() {- let c = MemesConfig::default();- assert_eq!(c.timeout_ms, 20_000);- assert_eq!(c.meme_cooldown, 3);-}--#[test]-fn a_partial_section_keeps_the_other_defaults() {- let c: MemesConfig = toml::from_str("timeout_ms = 5000").unwrap();- assert_eq!(c.timeout_ms, 5000);- assert_eq!(c.meme_cooldown, DEFAULT_MEME_COOLDOWN);-}diff --git a/crates/openhuman-core/src/modules/registry/records_memes.rs b/crates/openhuman-core/src/modules/registry/records_memes.rsdeleted file mode 100644index d3aa1abe7c..0000000000--- a/crates/openhuman-core/src/modules/registry/records_memes.rs+++ /dev/null@@ -1,80 +0,0 @@-//! Registry record for the `tinymemes` module.--use crate::modules::types::{LoadPolicy, ModuleRecord, PlatformAsset, SourceSpec};--/// The `tinymemes` module: final-reply slang and meme remixing, loaded on-/// first use. The host serves the callbacks it asks for (inference, Jev,-/// search, index storage, delivery).-pub(crate) const TINYMEMES: ModuleRecord = ModuleRecord {- id: "tinymemes",- description: "Final-reply slang and meme remixing through TinyMemes",- bus_name: tinymemes_bus::STATE_INTERFACE,- object_path: tinymemes_bus::STATE_PATH,- version: "0.4.1",- release_url: "https://github.com/tinyhumansai/tinymemes/releases/tag/v0.4.1",- assets: &[- PlatformAsset {- host_key: "macos-15-arm64",- archive: "tinymemes-module-0.4.1-macos-15-arm64.tar.gz",- sha256: "9ef332dfb479260567b4fbf12734d21d635cd6182b338474a5895cafa2093c19",- },- PlatformAsset {- host_key: "macos-15-x86_64",- archive: "tinymemes-module-0.4.1-macos-15-x86_64.tar.gz",- sha256: "dac379e4fa92152644b1e22191614e5424b58ad04cce9f3baadbb9c9e8463a56",- },- PlatformAsset {- host_key: "macos-26-arm64",- archive: "tinymemes-module-0.4.1-macos-26-arm64.tar.gz",- sha256: "7023133d6f88bceea185850da3a9c52a9a0a1ce0f3a065e1095087ac3303b564",- },- PlatformAsset {- host_key: "macos-26-x86_64",- archive: "tinymemes-module-0.4.1-macos-26-x86_64.tar.gz",- sha256: "372eb95b30bc7ce3accc893b3a7cdbe6812bfd2a7bbe65c62c19f07ef7d8f10c",- },- PlatformAsset {- host_key: "ubuntu-22.04-arm64",- archive: "tinymemes-module-0.4.1-ubuntu-22.04-arm64.tar.gz",- sha256: "92dc4a49608aaca0a83f6c50da4a6da5e726b60665a9424441e40cb1d616f652",- },- PlatformAsset {- host_key: "ubuntu-22.04-x86_64",- archive: "tinymemes-module-0.4.1-ubuntu-22.04-x86_64.tar.gz",- sha256: "55060d251d04b62683f0443994f9376b12295f3ac0848258a6faa202fffef781",- },- PlatformAsset {- host_key: "ubuntu-24.04-arm64",- archive: "tinymemes-module-0.4.1-ubuntu-24.04-arm64.tar.gz",- sha256: "c978dcd8e5ed355449785d94817cdaf009208cf4a1a4e7d8c8bc687bffcc0e40",- },- PlatformAsset {- host_key: "ubuntu-24.04-x86_64",- archive: "tinymemes-module-0.4.1-ubuntu-24.04-x86_64.tar.gz",- sha256: "8612106d61a42c59a7e74e0476705285cf0ad917aa5b6ea26e86c05f4d666c76",- },- PlatformAsset {- host_key: "windows-11-arm64",- archive: "tinymemes-module-0.4.1-windows-11-arm64.zip",- sha256: "bac64bbe575a7053232293051a6a45de6e4503d77a83da15de8b957123cf361b",- },- PlatformAsset {- host_key: "windows-2022-x86_64",- archive: "tinymemes-module-0.4.1-windows-2022-x86_64.zip",- sha256: "a00ddc84ca3232e04613a658bd2766b0bbe2fda77d7b07285706cf65d1a85a03",- },- PlatformAsset {- host_key: "windows-2025-x86_64",- archive: "tinymemes-module-0.4.1-windows-2025-x86_64.zip",- sha256: "8279337613b7984340ba3e0b1dfdfe17bd046e013b467152d21fa151933a1639",- },- ],- load: LoadPolicy::Lazy,- source: SourceSpec {- submodule: "tinymemes",- manifest: "crates/tinymemes-module/Cargo.toml",- package: "tinymemes-module",- lib_name: "tinymemes_module",- features: &[],- },-};diff --git a/crates/openhuman-core/src/tinymemes/arm.rs b/crates/openhuman-core/src/tinymemes/arm.rsdeleted file mode 100644index 1413031418..0000000000--- a/crates/openhuman-core/src/tinymemes/arm.rs+++ /dev/null@@ -1,126 +0,0 @@-//! Which turns get remixed: the `OPENHUMAN_TINYMEMES` flag and its A/B split.-//!-//! | value | behaviour |-//! | --- | --- |-//! | unset, `off`, `0`, `false` | disabled; no tinymemes work at all |-//! | `on`, `1`, `true` | every thread is in the treatment arm |-//! | `ab` | 50% of threads are treatment, the rest control |-//! | `ab:NN` | NN% of threads are treatment |-//!-//! Assignment is by a stable hash of the thread id, so a thread keeps its arm-//! for its whole life and across restarts. The flag is read on every turn, so-//! it can change without a restart.-//!-//! A build can ship with a different default: set `OPENHUMAN_TINYMEMES_DEFAULT`-//! (same values) in the environment of the `cargo build` that produces the-//! release, and it is baked in. The runtime `OPENHUMAN_TINYMEMES` still wins-//! whenever it is set, so a deployment can always be switched back off.--pub(crate) const FLAG_ENV: &str = "OPENHUMAN_TINYMEMES";--/// Default baked in at build time (`OPENHUMAN_TINYMEMES_DEFAULT` during-/// `cargo build`); `None` means off.-const BUILD_DEFAULT: Option<&str> = option_env!("OPENHUMAN_TINYMEMES_DEFAULT");--/// Parsed flag value.-#[derive(Clone, Copy, Debug, PartialEq, Eq)]-pub(crate) enum Mode {- Off,- On,- Ab { percent: u8 },-}--/// The arm a thread is in.-#[derive(Clone, Copy, Debug, PartialEq, Eq)]-pub(crate) enum Arm {- /// Feature off: nothing runs and nothing is logged per turn.- Disabled,- /// In an experiment, not remixed. Logged for the throughput comparison.- Control,- /// Remixed.- Treatment,-}--impl Arm {- pub(crate) fn as_str(self) -> &'static str {- match self {- Arm::Disabled => "disabled",- Arm::Control => "control",- Arm::Treatment => "treatment",- }- }-}--pub(crate) fn mode_from(value: Option<&str>) -> Mode {- let Some(raw) = value.map(|v| v.trim().to_ascii_lowercase()) else {- return Mode::Off;- };- match raw.as_str() {- "" | "off" | "0" | "false" | "no" => Mode::Off,- "on" | "1" | "true" | "yes" => Mode::On,- "ab" => Mode::Ab { percent: 50 },- // Any all-digit percentage above 100 means 100, including one too- // large for `u64`.- other => match other.strip_prefix("ab:").map(str::trim) {- Some(digits) if !digits.is_empty() && digits.bytes().all(|b| b.is_ascii_digit()) => {- Mode::Ab {- percent: digits.parse::<u64>().map_or(100, |n| n.min(100)) as u8,- }- }- _ => {- log::warn!("[tinymemes] unrecognised {FLAG_ENV} value; treating as off");- Mode::Off- }- },- }-}--pub(crate) fn mode() -> Mode {- resolve_mode(std::env::var(FLAG_ENV).ok().as_deref(), BUILD_DEFAULT)-}--/// The runtime value when set, else the build-time default, else off.-pub(crate) fn resolve_mode(runtime: Option<&str>, build_default: Option<&str>) -> Mode {- match runtime {- Some(value) => mode_from(Some(value)),- None => mode_from(build_default),- }-}--/// Stable 0..100 bucket for a thread (FNV-1a, so it does not change between-/// builds or platforms the way `DefaultHasher` may).-pub(crate) fn bucket(thread_id: &str) -> u8 {- let mut hash: u64 = 0xcbf2_9ce4_8422_2325;- for byte in thread_id.as_bytes() {- hash ^= u64::from(*byte);- hash = hash.wrapping_mul(0x0100_0000_01b3);- }- (hash % 100) as u8-}--/// The arm for a thread under `config`: the `[components] memes` switch is the-/// master, and the flag's arm is honoured only while the component is on.-pub(crate) fn arm_for(config: &crate::config::Config, mode: Mode, thread_id: &str) -> Arm {- if !config.components.memes {- return Arm::Disabled;- }- assign(mode, thread_id)-}--pub(crate) fn assign(mode: Mode, thread_id: &str) -> Arm {- match mode {- Mode::Off => Arm::Disabled,- Mode::On => Arm::Treatment,- Mode::Ab { percent } => {- if bucket(thread_id) < percent {- Arm::Treatment- } else {- Arm::Control- }- }- }-}--#[cfg(test)]-#[path = "arm_tests.rs"]-mod tests;diff --git a/crates/openhuman-core/src/tinymemes/arm_tests.rs b/crates/openhuman-core/src/tinymemes/arm_tests.rsdeleted file mode 100644index a8612684ea..0000000000--- a/crates/openhuman-core/src/tinymemes/arm_tests.rs+++ /dev/null@@ -1,70 +0,0 @@-use super::*;--#[test]-fn flag_values_parse() {- assert_eq!(mode_from(None), Mode::Off);- assert_eq!(mode_from(Some("off")), Mode::Off);- assert_eq!(mode_from(Some(" ON ")), Mode::On);- assert_eq!(mode_from(Some("1")), Mode::On);- assert_eq!(mode_from(Some("ab")), Mode::Ab { percent: 50 });- assert_eq!(mode_from(Some("ab:20")), Mode::Ab { percent: 20 });- assert_eq!(mode_from(Some("ab:300")), Mode::Ab { percent: 100 });- assert_eq!(mode_from(Some("ab:99999")), Mode::Ab { percent: 100 });- assert_eq!(- mode_from(Some("ab:18446744073709551616")),- Mode::Ab { percent: 100 }- );- assert_eq!(mode_from(Some("ab:")), Mode::Off);- assert_eq!(mode_from(Some("ab:-5")), Mode::Off);- assert_eq!(mode_from(Some("ab:250")), Mode::Ab { percent: 100 });- assert_eq!(mode_from(Some("ab:100")), Mode::Ab { percent: 100 });- assert_eq!(mode_from(Some("sometimes")), Mode::Off);-}--#[test]-fn assignment_is_stable_and_respects_the_split() {- assert_eq!(assign(Mode::Off, "t"), Arm::Disabled);- assert_eq!(assign(Mode::On, "t"), Arm::Treatment);- assert_eq!(assign(Mode::Ab { percent: 0 }, "t"), Arm::Control);- assert_eq!(assign(Mode::Ab { percent: 100 }, "t"), Arm::Treatment);-- let a = assign(Mode::Ab { percent: 50 }, "thread-abc");- for _ in 0..10 {- assert_eq!(assign(Mode::Ab { percent: 50 }, "thread-abc"), a);- }-- let treated = (0..2000)- .filter(|i| assign(Mode::Ab { percent: 30 }, &format!("thread-{i}")) == Arm::Treatment)- .count();- assert!((450..750).contains(&treated), "treated={treated}");-}--#[test]-fn bucket_is_fixed_across_builds() {- // FNV-1a is specified, so this value must never change; a change would- // silently move live threads between arms.- assert_eq!(bucket("thread-abc"), 56);- assert_eq!(bucket(""), (0xcbf2_9ce4_8422_2325_u64 % 100) as u8);-}--#[test]-fn runtime_flag_overrides_the_build_default() {- assert_eq!(resolve_mode(None, None), Mode::Off);- assert_eq!(resolve_mode(None, Some("on")), Mode::On);- assert_eq!(resolve_mode(None, Some("ab:30")), Mode::Ab { percent: 30 });- // A deployment can always switch a shipped default back off.- assert_eq!(resolve_mode(Some("off"), Some("on")), Mode::Off);- assert_eq!(- resolve_mode(Some("ab"), Some("on")),- Mode::Ab { percent: 50 }- );-}--#[test]-fn arms_have_log_names() {- assert_eq!(Arm::Disabled.as_str(), "disabled");- assert_eq!(Arm::Control.as_str(), "control");- assert_eq!(Arm::Treatment.as_str(), "treatment");- // The live flag resolves without panicking whatever the environment holds.- let _ = mode();-}diff --git a/crates/openhuman-core/src/tinymemes/callbacks.rs b/crates/openhuman-core/src/tinymemes/callbacks.rsdeleted file mode 100644index cf2a2b9c64..0000000000--- a/crates/openhuman-core/src/tinymemes/callbacks.rs+++ /dev/null@@ -1,305 +0,0 @@-//! What the module asks of the host while it works on a remix: one-//! completion, one Jev evaluation, one web search, and the learned-state-//! documents ([`super::docs`]).-//!-//! Every callback carries the correlation id of the remix it belongs to (the-//! module echoes the one the host put in the request). A [`Registry`] entry-//! per id holds that remix's workspace, so remixes for different workspaces-//! run side by side and a callback with no live id is refused. An entry lives-//! until the module reports the request finished with `End` (background-//! research can outlast the call), or is swept after [`MAX_AGE`].--use std::collections::HashMap;-use std::future::Future;-use std::sync::{Arc, LazyLock, Mutex};-use std::time::{Duration, Instant};--use serde::de::DeserializeOwned;-use serde_json::Value;-use tinyinference_decisions::{Client, EvaluationRequest};-use tinymemes_bus::{- host_methods, CompleteRequest, EvaluateEnvelope, HostFailure, HostResult, IndexKind,- LoadIndexRequest, SaveIndexRequest, SearchRequest,-};--use super::{docs, inference, jev, search};-use crate::config::Config;-use crate::core::runtime::{CoreContext, DispatchCtx};--/// How long an entry may live without its `End`.-const MAX_AGE: Duration = Duration::from_secs(15 * 60);--/// The workspace one remix runs for, and who it runs for.-///-/// Callbacks arrive on the module bus, outside the task that asked for the-/// remix, so the caller's context is captured when the remix is registered and-/// re-entered for each callback ([`Session::enter`]). A remix acts for the-/// host, never for an agent, so there is no memory identity to carry.-/// Only the caller's own scope counts, so in SaaS an unscoped caller's-/// callbacks fail closed instead of acting as the operator.-pub(super) struct Session {- config: Config,- jev: tokio::sync::OnceCell<Option<Arc<Client>>>,- context: Option<Arc<CoreContext>>,-}--impl Session {- /// The dispatch context the registering caller runs under; the host's own- /// when it had none (a single-user process), which fails closed in SaaS.- pub(super) fn dispatch_ctx(&self) -> DispatchCtx {- match self.context.clone() {- Some(context) => DispatchCtx::new(context),- None => DispatchCtx::host_default(),- }- }-- pub(super) fn new(ctx: &DispatchCtx, config: &Config) -> Self {- Self {- config: config.clone(),- jev: tokio::sync::OnceCell::new(),- // Only the caller's own context is carried. Without one, a- // single-user process falls back to its default context on the- // callback side as anywhere else, and SaaS fails closed.- context: ctx.core().cloned(),- }- }-- /// Run `fut` as the registering caller.- pub(super) async fn enter<F: Future>(&self, fut: F) -> F::Output {- let fut = Box::pin(fut);- match self.context.clone() {- Some(context) => CoreContext::scope(context, fut).await,- None => fut.await,- }- }-}--struct Entry {- session: Arc<Session>,- registered: Instant,-}--static REGISTRY: LazyLock<Mutex<HashMap<String, Entry>>> = LazyLock::new(Mutex::default);--fn registry() -> std::sync::MutexGuard<'static, HashMap<String, Entry>> {- REGISTRY.lock().unwrap_or_else(|e| e.into_inner())-}--/// A registered remix. Dropping it forgets the remix unless it was-/// [`kept`](Self::keep_for_background) for research that runs on after the-/// call returns.-pub(super) struct Registration {- correlation: String,- keep: bool,-}--impl Registration {- /// The id to put in the request.- pub(super) fn correlation(&self) -> &str {- &self.correlation- }-- /// The call succeeded: leave the entry for the module's `End`.- pub(super) fn keep_for_background(mut self) {- self.keep = true;- }-}--impl Drop for Registration {- fn drop(&mut self) {- if !self.keep {- registry().remove(&self.correlation);- }- }-}--/// Register a remix for `config`'s workspace under a fresh correlation id.-pub(super) fn register(ctx: &DispatchCtx, config: &Config) -> Registration {- let correlation = uuid::Uuid::new_v4().to_string();- let mut sessions = registry();- sessions.retain(|_, entry| entry.registered.elapsed() < MAX_AGE);- sessions.insert(- correlation.clone(),- Entry {- session: Arc::new(Session::new(ctx, config)),- registered: Instant::now(),- },- );- Registration {- correlation,- keep: false,- }-}--/// The session a callback answers for, if its remix is still registered.-pub(super) fn session(correlation: &str) -> Option<Arc<Session>> {- registry()- .get(correlation)- .map(|entry| entry.session.clone())-}--/// The module finished this remix: forget it.-pub(super) fn end(correlation: &str) {- if registry().remove(correlation).is_some() {- log::debug!("[tinymemes] remix ended correlation={correlation}");- }-}--/// How many registered remixes belong to `workspace`; tests use a unique-/// workspace so parallel tests cannot disturb the count.-#[cfg(test)]-pub(super) fn live_for(workspace: &std::path::Path) -> usize {- registry()- .values()- .filter(|entry| entry.session.config.workspace_dir == workspace)- .count()-}--/// The correlation id a callback payload carries (`[ { "correlation": .. } ]`).-pub(super) fn correlation_of(payload: &Value) -> Option<&str> {- payload- .as_array()?- .first()?- .get("correlation")?- .as_str()- .filter(|c| !c.is_empty())-}--fn args<T: DeserializeOwned>(value: Value) -> Result<T, tinybus::Error> {- let (request,): (T,) = serde_json::from_value(value)- .map_err(|_| tinybus::Error::failed("invalid tinymemes host request"))?;- Ok(request)-}--fn reply<T: serde::Serialize>(result: HostResult<T>) -> Result<Value, tinybus::Error> {- serde_json::to_value(result)- .map_err(|_| tinybus::Error::failed("invalid tinymemes host response"))-}--/// Answer one host callback for `session`.-pub(super) async fn dispatch(- session: &Session,- member: &str,- payload: Value,-) -> Result<Value, tinybus::Error> {- log::debug!("[tinymemes] host callback member={member}");- session.enter(answer(session, member, payload)).await-}--async fn answer(session: &Session, member: &str, payload: Value) -> Result<Value, tinybus::Error> {- match member {- host_methods::COMPLETE => reply(complete(session, args(payload)?).await),- host_methods::EVALUATE => reply(evaluate(session, args(payload)?).await),- host_methods::SEARCH => reply(search(session, args(payload)?).await),- host_methods::LOAD_INDEX => reply(load_index(session, args(payload)?).await),- host_methods::SAVE_INDEX => reply(save_index(session, args(payload)?).await),- // The remixed text is returned to the caller, which delivers it- // itself; nothing is handed over through the module.- host_methods::DELIVER => reply(HostResult::Ok(())),- host_methods::END => {- if let Some(correlation) = correlation_of(&payload) {- end(correlation);- }- reply(HostResult::Ok(()))- }- _ => Err(tinybus::Error::failed("unknown tinymemes host operation")),- }-}--async fn complete(session: &Session, request: CompleteRequest) -> HostResult<String> {- inference::complete(- &session.dispatch_ctx(),- &session.config,- &request.system,- &request.user,- )- .await- .map_err(|error| {- log::warn!("[tinymemes] complete callback failed: {error}");- HostFailure::Backend- })-}--async fn evaluate(session: &Session, envelope: EvaluateEnvelope) -> HostResult<EvaluateEnvelope> {- let Some(client) = session- .jev- .get_or_init(|| async { jev::managed(&session.config) })- .await- else {- log::debug!("[tinymemes] evaluate callback: managed jev unavailable");- return Err(HostFailure::Unsupported);- };- let request: EvaluationRequest =- serde_json::from_value(envelope.body).map_err(|_| HostFailure::Unsupported)?;- let result = client.evaluate(&request).await.map_err(|error| {- log::warn!("[tinymemes] evaluate callback failed: {error}");- HostFailure::Backend- })?;- let body = serde_json::to_value(result.response).map_err(|_| HostFailure::Backend)?;- Ok(EvaluateEnvelope {- correlation: String::new(),- body,- })-}--async fn search(- session: &Session,- request: SearchRequest,-) -> HostResult<Vec<tinymemes_bus::SearchResult>> {- let Some(backend) =- search::OpenHumanSearch::available(&session.dispatch_ctx(), &session.config)- else {- return Err(HostFailure::Unsupported);- };- backend- .search(&request.query, request.max_results as usize)- .await- .map_err(|error| {- // The query is derived from the chat, so only the error is logged.- log::warn!("[tinymemes] search callback failed: {error}");- HostFailure::Backend- })-}--async fn load_index(session: &Session, request: LoadIndexRequest) -> HostResult<Option<String>> {- let config = session.config.clone();- let kind: IndexKind = request.kind;- match session- .dispatch_ctx()- .spawn_blocking(move || docs::load(&config, kind))- .await- {- Ok(Ok(document)) => Ok(document),- Ok(Err(error)) => {- log::warn!("[tinymemes] cannot read index: {error}");- Err(HostFailure::Backend)- }- Err(error) => {- log::warn!("[tinymemes] index read task failed: {error}");- Err(HostFailure::Backend)- }- }-}--async fn save_index(session: &Session, request: SaveIndexRequest) -> HostResult<()> {- let config = session.config.clone();- match session- .dispatch_ctx()- .spawn_blocking(move || docs::save(&config, request.kind, request.json))- .await- {- Ok(Ok(())) => Ok(()),- Ok(Err(error)) => {- log::warn!("[tinymemes] cannot save index: {error}");- Err(HostFailure::Backend)- }- Err(error) => {- log::warn!("[tinymemes] index write task failed: {error}");- Err(HostFailure::Backend)- }- }-}--#[cfg(test)]-#[path = "callbacks_tests.rs"]-mod tests;diff --git a/crates/openhuman-core/src/tinymemes/callbacks_tests.rs b/crates/openhuman-core/src/tinymemes/callbacks_tests.rsdeleted file mode 100644index c89614746e..0000000000--- a/crates/openhuman-core/src/tinymemes/callbacks_tests.rs+++ /dev/null@@ -1,187 +0,0 @@-use super::*;-use serde_json::json;--fn config_in(dir: &std::path::Path) -> Config {- let mut config = Config::default();- config.config_path = dir.join("config.toml");- config.workspace_dir = dir.join("workspace");- config.secrets.encrypt = false;- config-}--fn decode<T: DeserializeOwned>(value: Value) -> HostResult<T> {- serde_json::from_value(value).unwrap()-}--#[tokio::test]-async fn an_index_saved_through_the_host_loads_back_per_kind() {- let dir = tempfile::tempdir().unwrap();- let session = Session::new(- &crate::core::runtime::DispatchCtx::host_default(),- &config_in(dir.path()),- );-- let missing = dispatch(- &session,- host_methods::LOAD_INDEX,- json!([{ "kind": "slang" }]),- )- .await- .unwrap();- assert_eq!(decode::<Option<String>>(missing), Ok(None));-- for (kind, body) in [- ("slang", "{\"terms\":1}"),- ("memes", "{\"memes\":2}"),- ("remixed", "[\"m1\"]"),- ] {- let saved = dispatch(- &session,- host_methods::SAVE_INDEX,- json!([{ "kind": kind, "json": body }]),- )- .await- .unwrap();- assert_eq!(decode::<()>(saved), Ok(()));- }- for (kind, body) in [- ("slang", "{\"terms\":1}"),- ("memes", "{\"memes\":2}"),- ("remixed", "[\"m1\"]"),- ] {- let loaded = dispatch(- &session,- host_methods::LOAD_INDEX,- json!([{ "kind": kind }]),- )- .await- .unwrap();- assert_eq!(decode::<Option<String>>(loaded), Ok(Some(body.into())));- }-}--#[tokio::test]-async fn without_managed_jev_evaluate_is_unsupported() {- let dir = tempfile::tempdir().unwrap();- let session = Session::new(- &crate::core::runtime::DispatchCtx::host_default(),- &config_in(dir.path()),- );- let request = json!([{ "body": { "questions": {}, "messages": [] } }]);- let result = dispatch(&session, host_methods::EVALUATE, request)- .await- .unwrap();- assert_eq!(- decode::<EvaluateEnvelope>(result),- Err(HostFailure::Unsupported)- );-}--#[tokio::test]-async fn search_switched_off_is_unsupported() {- let dir = tempfile::tempdir().unwrap();- let mut config = config_in(dir.path());- config.search.enabled = Some(false);- let session = Session::new(&crate::core::runtime::DispatchCtx::host_default(), &config);- let result = dispatch(- &session,- host_methods::SEARCH,- json!([{ "query": "q", "max_results": 3 }]),- )- .await- .unwrap();- assert_eq!(- decode::<Vec<tinymemes_bus::SearchResult>>(result),- Err(HostFailure::Unsupported)- );-}--#[tokio::test]-async fn deliver_is_acknowledged_and_unknown_members_are_refused() {- let dir = tempfile::tempdir().unwrap();- let session = Session::new(- &crate::core::runtime::DispatchCtx::host_default(),- &config_in(dir.path()),- );- let delivered = dispatch(- &session,- host_methods::DELIVER,- json!([{ "reply": "hi", "remixed": true }]),- )- .await- .unwrap();- assert_eq!(decode::<()>(delivered), Ok(()));- assert!(dispatch(&session, "Nope", json!([])).await.is_err());- assert!(dispatch(&session, host_methods::COMPLETE, json!("bad"))- .await- .is_err());-}--#[test]-fn registrations_are_independent_and_forgotten_on_drop() {- let dir = tempfile::tempdir().unwrap();- let config = config_in(dir.path());- let a = register(&crate::core::runtime::DispatchCtx::host_default(), &config);- let b = register(&crate::core::runtime::DispatchCtx::host_default(), &config);- assert_ne!(a.correlation(), b.correlation());- assert!(session(a.correlation()).is_some() && session(b.correlation()).is_some());- let a_id = a.correlation().to_owned();- drop(a);- assert!(- session(&a_id).is_none(),- "a failed call leaves nothing behind"- );- assert!(session(b.correlation()).is_some());- assert!(session("").is_none() && session("unknown").is_none());-}--#[test]-fn a_kept_registration_lives_until_the_module_reports_the_end() {- let dir = tempfile::tempdir().unwrap();- let registration = register(- &crate::core::runtime::DispatchCtx::host_default(),- &config_in(dir.path()),- );- let id = registration.correlation().to_owned();- registration.keep_for_background();- assert!(- session(&id).is_some(),- "background research may still call back"- );- end(&id);- assert!(session(&id).is_none());- end(&id);-}--#[test]-fn the_correlation_id_is_read_from_the_first_argument_only() {- assert_eq!(- correlation_of(&json!([{ "correlation": "c1", "kind": "slang" }])),- Some("c1")- );- for bad in [- json!([{ "correlation": "" }]),- json!([{ "correlation": 7 }]),- json!([{}]),- json!([]),- json!({ "correlation": "c1" }),- json!("c1"),- ] {- assert_eq!(correlation_of(&bad), None, "{bad}");- }-}--#[tokio::test]-async fn a_remix_session_answers_under_the_context_that_registered_it() {- use crate::core::runtime::{CoreContext, DispatchCtx, DomainSet};- let dir = tempfile::tempdir().unwrap();- let caller = CoreContext::for_test(DomainSet::full(), None);- let other = CoreContext::for_test(DomainSet::full(), None);- let session = Session::new(- &DispatchCtx::new(Arc::clone(&caller)),- &config_in(dir.path()),- );- // A callback arrives on the module bus while some other context is active.- let seen = CoreContext::scope(Arc::clone(&other), async { session.dispatch_ctx() }).await;- assert!(Arc::ptr_eq(seen.core().expect("bound"), &caller));-}diff --git a/crates/openhuman-core/src/tinymemes/docs.rs b/crates/openhuman-core/src/tinymemes/docs.rsdeleted file mode 100644index 35a95dac42..0000000000--- a/crates/openhuman-core/src/tinymemes/docs.rs+++ /dev/null@@ -1,117 +0,0 @@-//! The learned-state documents the module asks the host to keep: the slang-//! index, the meme index and the ring of remixed message ids.-//!-//! They live on the storage document port ([`crate::storage`]) under the-//! acting scope, in `memes.state`, one document per [`IndexKind`]. The host-//! never interprets them: the formats, the ring and its cap belong to the-//! module, and the text-to-body mapping to `tinymemes_bus::storage`-//! (`state_body` / `state_text`), which also declares the step that brought-//! the v1 `tinymemes_documents` rows (`{"json": "<text>"}`) here.-//!-//! Older installs kept them as `<workspace>/tinymemes/{slang-index,-//! meme-index,remixed}.json`. The first load of a kind with no stored document-//! adopts that file's content once and renames the file to `<name>.migrated`,-//! so nothing is lost and the file is never read again.--use std::path::{Path, PathBuf};--use anyhow::{anyhow, Result};-use tinymemes_bus::storage::{state_body, state_id, state_text, STATE_COLLECTION as COLLECTION};-use tinymemes_bus::IndexKind;-use tinystoragedrivers::{CollectionSpec, Precondition};--use crate::config::Config;-use crate::storage::documents::Repo;--const DOMAIN: &str = "tinymemes::docs";-/// Directory of the pre-storage files, under the workspace.-const LEGACY_DIR: &str = "tinymemes";--fn collections() -> Vec<CollectionSpec> {- vec![CollectionSpec::new(COLLECTION)]-}--fn doc_id(kind: IndexKind) -> &'static str {- state_id(kind)-}--fn legacy_file(kind: IndexKind) -> &'static str {- match kind {- IndexKind::Slang => "slang-index.json",- IndexKind::Memes => "meme-index.json",- IndexKind::Remixed => "remixed.json",- }-}--fn legacy_path(workspace_dir: &Path, kind: IndexKind) -> PathBuf {- workspace_dir.join(LEGACY_DIR).join(legacy_file(kind))-}--fn repo(config: &Config) -> Result<Repo> {- Repo::current_for(&config.workspace_dir, DOMAIN, collections)-}--/// The stored document for `kind`, adopting the legacy file once.-pub(super) fn load(config: &Config, kind: IndexKind) -> Result<Option<String>> {- let repo = repo(config)?;- let id = doc_id(kind);- let stored = repo.run(move |docs| async move { docs.get(COLLECTION, id).await })?;- if let Some(stored) = stored {- return Ok(Some(state_text(kind, &stored.doc)));- }- let path = legacy_path(&config.workspace_dir, kind);- // Only an absent file means "nothing to adopt". Any other failure- // (permissions, bad UTF-8) is an error: answering `None` would let the- // module start empty and save over state the old file still holds.- let legacy = match std::fs::read_to_string(&path) {- Ok(legacy) => legacy,- Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None),- Err(e) => return Err(anyhow!("read {}: {e}", path.display())),- };- // `Absent`: a concurrent save wins over the old file's content.- let adopted = state_body(kind, &legacy);- let written = repo.run(move |docs| async move {- docs.put(COLLECTION, id, adopted, Precondition::Absent)- .await- .map(|_| ())- });- match written {- Ok(()) => {- let migrated = path.with_extension("json.migrated");- match std::fs::rename(&path, &migrated) {- Ok(()) => log::info!(- "[tinymemes] adopted {} into storage (kept as {})",- legacy_file(kind),- migrated.display()- ),- Err(e) => log::warn!("[tinymemes] cannot retire {}: {e}", path.display()),- }- Ok(Some(legacy))- }- // Somebody stored a document in between; theirs is the truth. When no- // document exists the put failed for a real reason, which is reported.- Err(error) => {- let stored = repo.run(move |docs| async move { docs.get(COLLECTION, id).await })?;- match stored {- Some(stored) => Ok(Some(state_text(kind, &stored.doc))),- None => Err(error),- }- }- }-}--/// Replace the stored document for `kind`.-pub(super) fn save(config: &Config, kind: IndexKind, json: String) -> Result<()> {- let repo = repo(config)?;- let id = doc_id(kind);- repo.run(move |docs| async move {- docs.put(COLLECTION, id, state_body(kind, &json), Precondition::None)- .await- .map(|_| ())- })- .map_err(|e| anyhow!("save {id}: {e}"))-}--#[cfg(test)]-#[path = "docs_tests.rs"]-mod tests;diff --git a/crates/openhuman-core/src/tinymemes/docs_tests.rs b/crates/openhuman-core/src/tinymemes/docs_tests.rsdeleted file mode 100644index d8187b737f..0000000000--- a/crates/openhuman-core/src/tinymemes/docs_tests.rs+++ /dev/null@@ -1,119 +0,0 @@-use super::*;--fn config_in(dir: &Path) -> Config {- let mut config = Config::default();- config.config_path = dir.join("config.toml");- config.workspace_dir = dir.join("workspace");- config.secrets.encrypt = false;- config-}--fn write_legacy(config: &Config, kind: IndexKind, content: &str) {- let path = legacy_path(&config.workspace_dir, kind);- std::fs::create_dir_all(path.parent().unwrap()).unwrap();- std::fs::write(path, content).unwrap();-}--#[test]-fn a_saved_document_loads_back_and_kinds_are_separate() {- let dir = tempfile::tempdir().unwrap();- let config = config_in(dir.path());- assert_eq!(load(&config, IndexKind::Slang).unwrap(), None);- save(&config, IndexKind::Slang, "{\"terms\":1}".into()).unwrap();- assert_eq!(- load(&config, IndexKind::Slang).unwrap().as_deref(),- Some("{\"terms\":1}")- );- assert_eq!(load(&config, IndexKind::Memes).unwrap(), None);- assert_eq!(load(&config, IndexKind::Remixed).unwrap(), None);- save(&config, IndexKind::Slang, "{\"terms\":2}".into()).unwrap();- assert_eq!(- load(&config, IndexKind::Slang).unwrap().as_deref(),- Some("{\"terms\":2}")- );-}--#[test]-fn the_legacy_remixed_json_is_adopted_once_and_retired() {- let dir = tempfile::tempdir().unwrap();- let config = config_in(dir.path());- write_legacy(&config, IndexKind::Remixed, "[\"m1\",\"m2\"]");-- assert_eq!(- load(&config, IndexKind::Remixed).unwrap().as_deref(),- Some("[\"m1\",\"m2\"]")- );- let legacy = legacy_path(&config.workspace_dir, IndexKind::Remixed);- assert!(!legacy.exists(), "the old file is retired");- assert!(legacy.with_extension("json.migrated").is_file());-- // The module's later saves are the truth; a stray file is not re-adopted.- save(&config, IndexKind::Remixed, "[\"m1\",\"m2\",\"m3\"]".into()).unwrap();- write_legacy(&config, IndexKind::Remixed, "[\"stale\"]");- assert_eq!(- load(&config, IndexKind::Remixed).unwrap().as_deref(),- Some("[\"m1\",\"m2\",\"m3\"]")- );-}--#[test]-fn every_legacy_index_file_is_adopted() {- let dir = tempfile::tempdir().unwrap();- let config = config_in(dir.path());- write_legacy(&config, IndexKind::Slang, "{\"slang\":true}");- write_legacy(&config, IndexKind::Memes, "{\"memes\":true}");- assert_eq!(- load(&config, IndexKind::Slang).unwrap().as_deref(),- Some("{\"slang\":true}")- );- assert_eq!(- load(&config, IndexKind::Memes).unwrap().as_deref(),- Some("{\"memes\":true}")- );-}--#[test]-fn a_stored_document_wins_over_a_legacy_file() {- let dir = tempfile::tempdir().unwrap();- let config = config_in(dir.path());- save(&config, IndexKind::Memes, "{\"new\":1}".into()).unwrap();- write_legacy(&config, IndexKind::Memes, "{\"old\":1}");- assert_eq!(- load(&config, IndexKind::Memes).unwrap().as_deref(),- Some("{\"new\":1}")- );- assert!(legacy_path(&config.workspace_dir, IndexKind::Memes).exists());-}--#[cfg(unix)]-#[test]-fn an_unreadable_legacy_file_is_an_error_not_an_empty_start() {- use std::os::unix::fs::PermissionsExt;- let dir = tempfile::tempdir().unwrap();- let config = config_in(dir.path());- write_legacy(&config, IndexKind::Remixed, "[\"keep\"]");- let path = legacy_path(&config.workspace_dir, IndexKind::Remixed);- std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o000)).unwrap();- if std::fs::read_to_string(&path).is_ok() {- // Running as a user who can read anything (root): nothing to assert.- return;- }- assert!(load(&config, IndexKind::Remixed).is_err());- std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).unwrap();- assert_eq!(- load(&config, IndexKind::Remixed).unwrap().as_deref(),- Some("[\"keep\"]"),- "the state is still there once the file can be read"- );-}--#[test]-fn an_invalid_utf8_legacy_file_is_an_error() {- let dir = tempfile::tempdir().unwrap();- let config = config_in(dir.path());- let path = legacy_path(&config.workspace_dir, IndexKind::Slang);- std::fs::create_dir_all(path.parent().unwrap()).unwrap();- std::fs::write(&path, [0xff, 0xfe, 0x00]).unwrap();- assert!(load(&config, IndexKind::Slang).is_err());- assert!(path.exists(), "an unreadable file is left where it is");-}diff --git a/crates/openhuman-core/src/tinymemes/e2e_tests.rs b/crates/openhuman-core/src/tinymemes/e2e_tests.rsdeleted file mode 100644index e99743ee44..0000000000--- a/crates/openhuman-core/src/tinymemes/e2e_tests.rs+++ /dev/null@@ -1,150 +0,0 @@-//! The host and the real compiled `tinymemes` module over the bus.-//!-//! Runs where a module library exists (`node scripts/modules/build.mjs-//! tinymemes` with `OPENHUMAN_MODULE_SOURCE_DIR`, or the released modules the CI-//! installer stages under `OPENHUMAN_MODULE_PATH`); skipped, with a message,-//! otherwise. The library is loaded through a path override, the same way a-//! developer points a host at a local build.--use super::*;-use service::MODULE_ID;-use tinymemes_bus::IndexKind;--fn config_in(dir: &std::path::Path, artifact: &std::path::Path) -> Config {- let mut config = Config::default();- config.config_path = dir.join("config.toml");- config.workspace_dir = dir.join("workspace");- config.secrets.encrypt = false;- config.components.memes = true;- config.modules.allow_download = false;- config- .modules- .overrides- .push(crate::config::schema::ModuleOverride::with_path(- MODULE_ID,- artifact.to_str().unwrap(),- ));- config-}--fn artifact() -> Option<std::path::PathBuf> {- let artifact = crate::modules::local_artifact(MODULE_ID);- if artifact.is_none() {- eprintln!(- "SKIPPED (not run, not asserted): no tinymemes library. Run \- `node scripts/modules/build.mjs tinymemes` and set OPENHUMAN_MODULE_SOURCE_DIR, \- or point OPENHUMAN_MODULE_PATH at the released modules"- );- }- artifact-}--fn request(reply: &str) -> RemixRequest {- serde_json::from_value(serde_json::json!({- "conversation": [{ "role": "user", "text": "ok the report is done", "id": "u-1" }],- "reply": reply,- "region": "global",- "timeout_ms": 20_000,- "reply_id": "run-1:reply",- }))- .unwrap()-}--fn write_legacy(config: &Config, kind_file: &str, content: &str) {- let dir = config.workspace_dir.join("tinymemes");- std::fs::create_dir_all(&dir).unwrap();- std::fs::write(dir.join(kind_file), content).unwrap();-}--/// With no Jev, no inference provider and no search on this host, the module-/// still answers: it asks, is told it is unsupported, and fails open to the-/// original reply. Its document reads reach the host's callbacks with its-/// correlation id, which is visible as the legacy file being adopted.-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn the_real_module_fails_open_and_reads_its_documents_through_the_host() {- let Some(artifact) = artifact() else { return };- let dir = tempfile::tempdir().unwrap();- let config = config_in(dir.path(), &artifact);- write_legacy(&config, "remixed.json", "[\"old-1\"]");-- let response = service::remix(- &crate::core::runtime::DispatchCtx::host_default(),- &config,- request("That's done."),- )- .await- .expect("the module answered");- assert!(!response.remixed, "{response:?}");- assert_eq!(response.reply, "That's done.");- // The module reported the request finished, so nothing is kept for it.- assert_eq!(callbacks::live_for(&config.workspace_dir), 0);-- let legacy = config.workspace_dir.join("tinymemes/remixed.json");- assert!(- !legacy.exists(),- "the module's LoadIndex adopted the old file"- );- assert_eq!(- docs::load(&config, IndexKind::Remixed).unwrap().as_deref(),- Some("[\"old-1\"]")- );-}--#[tokio::test(flavor = "multi_thread", worker_threads = 2)]-async fn a_disabled_request_passes_through_without_a_callback() {- let Some(artifact) = artifact() else { return };- let dir = tempfile::tempdir().unwrap();- let config = config_in(dir.path(), &artifact);- write_legacy(&config, "remixed.json", "[\"untouched\"]");- let mut disabled = request("hello");- disabled.enabled = false;- let response = service::remix(- &crate::core::runtime::DispatchCtx::host_default(),- &config,- disabled,- )- .await- .unwrap();- assert_eq!(response.reply, "hello");- assert_eq!(response.skipped, Some(SkipReason::Disabled));- assert_eq!(- callbacks::live_for(&config.workspace_dir),- 0,- "a disabled request keeps no registration"- );- assert!(- config.workspace_dir.join("tinymemes/remixed.json").exists(),- "a disabled request reads nothing"- );-}--/// Two workspaces remix at once. Each callback is answered for the workspace-/// of its own correlation id, and neither waits behind a process-wide gate.-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]-async fn concurrent_remixes_for_two_workspaces_stay_in_their_own_documents() {- let Some(artifact) = artifact() else { return };- let (dir_a, dir_b) = (tempfile::tempdir().unwrap(), tempfile::tempdir().unwrap());- let (a, b) = (- config_in(dir_a.path(), &artifact),- config_in(dir_b.path(), &artifact),- );- write_legacy(&a, "remixed.json", "[\"from-a\"]");- write_legacy(&b, "remixed.json", "[\"from-b\"]");-- let host = crate::core::runtime::DispatchCtx::host_default();- let (ra, rb) = tokio::join!(- service::remix(&host, &a, request("reply a")),- service::remix(&host, &b, request("reply b"))- );- assert_eq!(ra.unwrap().reply, "reply a");- assert_eq!(rb.unwrap().reply, "reply b");-- assert_eq!(- docs::load(&a, IndexKind::Remixed).unwrap().as_deref(),- Some("[\"from-a\"]")- );- assert_eq!(- docs::load(&b, IndexKind::Remixed).unwrap().as_deref(),- Some("[\"from-b\"]")- );-}diff --git a/crates/openhuman-core/src/tinymemes/history.rs b/crates/openhuman-core/src/tinymemes/history.rsdeleted file mode 100644index b448088271..0000000000--- a/crates/openhuman-core/src/tinymemes/history.rs+++ /dev/null@@ -1,57 +0,0 @@-//! The thread as the user saw it, in the contract's vocabulary.--use tinymemes_bus::{WireRole, WireTurn};--use crate::threads::store::ConversationMessage;--/// Whether a finished reply is worth remixing at all.-pub(super) fn should_remix(reply: &str, placeholder: &str) -> bool {- reply != placeholder && !reply.trim().is_empty()-}--/// The thread as the user saw it, oldest first: delivered replies (remixed or-/// not) and the user's messages. `current_user_message` is appended unless it-/// is already the last stored turn (the store may have persisted it first).-pub(super) fn history_turns(- messages: &[ConversationMessage],- current_user_message: &str,-) -> Vec<WireTurn> {- let mut turns: Vec<WireTurn> = messages- .iter()- .filter(|m| !m.content.trim().is_empty())- .filter_map(|m| match m.sender.as_str() {- "user" => Some(WireTurn {- role: WireRole::User,- text: m.content.clone(),- remixed: false,- id: Some(m.id.clone()),- }),- "agent" | "assistant" => Some(WireTurn {- role: WireRole::Assistant,- text: m.content.clone(),- // Whether it went out remixed is the module's to say: it keeps- // the ring of remixed ids and matches them by this id.- remixed: false,- id: Some(m.id.clone()),- }),- _ => None,- })- .collect();- let current = current_user_message.trim();- let already_there = turns- .last()- .is_some_and(|t| t.role == WireRole::User && t.text.trim() == current);- if !current.is_empty() && !already_there {- turns.push(WireTurn {- role: WireRole::User,- text: current.to_owned(),- remixed: false,- id: None,- });- }- turns-}--#[cfg(test)]-#[path = "history_tests.rs"]-mod tests;diff --git a/crates/openhuman-core/src/tinymemes/history_tests.rs b/crates/openhuman-core/src/tinymemes/history_tests.rsdeleted file mode 100644index 3634380ac8..0000000000--- a/crates/openhuman-core/src/tinymemes/history_tests.rs+++ /dev/null@@ -1,56 +0,0 @@-use super::*;--fn msg(id: &str, sender: &str, content: &str) -> ConversationMessage {- ConversationMessage {- id: id.to_owned(),- content: content.to_owned(),- message_type: "text".to_owned(),- extra_metadata: serde_json::Value::Null,- sender: sender.to_owned(),- created_at: "2026-10-09T00:00:00Z".to_owned(),- }-}--#[test]-fn only_real_answers_are_remixed() {- assert!(should_remix("a real answer", "budget exhausted"));- assert!(!should_remix("budget exhausted", "budget exhausted"));- assert!(!should_remix(" \n", "budget exhausted"));-}--#[test]-fn history_carries_message_ids_and_appends_the_pending_message() {- let messages = vec![- msg("u1", "user", "bhai build fail"),- msg("r1", "agent", "Arre yaar, moye moye"),- msg("r2", "agent", "Plain reply"),- msg("s1", "system", "ignored"),- msg("u2", "user", " "),- ];- let turns = history_turns(&messages, "phir se fail");- assert_eq!(turns.len(), 4);- assert_eq!(turns[0].role, WireRole::User);- assert_eq!(turns[1].role, WireRole::Assistant);- // The module owns the ring of remixed ids; the host only names the turns.- assert_eq!(turns[1].id.as_deref(), Some("r1"));- assert_eq!(turns[2].id.as_deref(), Some("r2"));- assert!(turns.iter().all(|t| !t.remixed));- assert_eq!(turns[3].text, "phir se fail");- assert_eq!(turns[3].id, None);-}--#[test]-fn pending_message_is_not_duplicated_when_already_stored() {- let messages = vec![msg("u1", "user", "hello there")];- let turns = history_turns(&messages, "hello there ");- assert_eq!(turns.len(), 1);-}--#[test]-fn a_new_message_repeating_an_earlier_one_is_still_appended() {- // user("hello"), agent("reply"), then a new "hello": a distinct message.- let messages = vec![msg("u1", "user", "hello"), msg("r1", "agent", "reply")];- let turns = history_turns(&messages, "hello");- assert_eq!(turns.len(), 3);- assert_eq!(turns[2].text, "hello");-}diff --git a/crates/openhuman-core/src/tinymemes/inference.rs b/crates/openhuman-core/src/tinymemes/inference.rsdeleted file mode 100644index 48f9f85c03..0000000000--- a/crates/openhuman-core/src/tinymemes/inference.rs+++ /dev/null@@ -1,82 +0,0 @@-//! OpenHuman's own inference, served to the module's `Complete` callback.-//!-//! Every call goes through the provider OpenHuman is configured with for the-//! `summarization` role (managed backend, BYOK cloud, or local), the same-//! path thread titles and follow-up suggestions use. Reasoning is switched off-//! for these calls only; a rewrite needs none, and reasoning models otherwise-//! spend ~10 s per call. The rest of OpenHuman keeps its configured reasoning.--use tinyinference_llm::message::Message;-use tinyinference_llm::model::ModelRequest;--use crate::config::Config;-use crate::core::runtime::DispatchCtx;-use crate::inference::provider;--/// Workload role whose provider tinymemes borrows.-pub(crate) const ROLE: &str = "summarization";-const TEMPERATURE: f64 = 0.7;--/// One system + user completion on the `summarization` provider.-pub(crate) async fn complete(- ctx: &DispatchCtx,- config: &Config,- system: &str,- user: &str,-) -> Result<String, String> {- // Built per call so a provider change in Settings applies without a- // restart; construction is cheap and synchronous.- let (model, resolved) =- provider::create_chat_model_with_model_id_in(ctx, ROLE, config, TEMPERATURE)- .map_err(|e| format!("openhuman inference unavailable: {e}"))?;- // Reasoning off for tinymemes' calls only (the rest of OpenHuman keeps- // its configured reasoning). The managed backend honours the- // `without_reasoning` flag; a BYOK route to OpenRouter needs- // OpenRouter's own switch. Other endpoints are left untouched, since an- // unknown field can be rejected.- let mut request = crate::inference::registry::provider_request_without_reasoning(- crate::inference::provider::factory::PROVIDER_OPENHUMAN,- ModelRequest::new(vec![Message::system(system), Message::user(user)])- .with_temperature(TEMPERATURE),- );- if routes_to_openrouter(config) {- request.provider_options = serde_json::json!({ "reasoning": { "enabled": false } });- }- let response = model- .invoke(&(), request)- .await- .map_err(|e| format!("openhuman inference failed model={resolved}: {e}"))?;- let text = response.text();- if text.trim().is_empty() {- return Err(format!(- "openhuman inference returned no text model={resolved}"- ));- }- Ok(text)-}--/// Whether tinymemes' role resolves to an OpenRouter endpoint: a BYOK-/// `openrouter:` route, or a custom inference URL on openrouter.ai.-pub(crate) fn routes_to_openrouter(config: &Config) -> bool {- let route_is_openrouter = config- .memory_provider- .as_deref()- .map(|p| p.trim().to_ascii_lowercase())- .is_some_and(|p| p.starts_with("openrouter:") || p == "openrouter");- let url_is_openrouter = config- .inference_url- .as_deref()- .is_some_and(|u| u.to_ascii_lowercase().contains("openrouter.ai"));- route_is_openrouter || url_is_openrouter-}--/// The model id OpenHuman would use for tinymemes, for the startup log line.-pub(crate) fn resolved_model(ctx: &DispatchCtx, config: &Config) -> String {- provider::create_chat_model_with_model_id_in(ctx, ROLE, config, TEMPERATURE)- .map(|(_, id)| id)- .unwrap_or_else(|e| format!("unavailable ({e})"))-}--#[cfg(test)]-#[path = "inference_tests.rs"]-mod tests;diff --git a/crates/openhuman-core/src/tinymemes/inference_tests.rs b/crates/openhuman-core/src/tinymemes/inference_tests.rsdeleted file mode 100644index 96eaa121d2..0000000000--- a/crates/openhuman-core/src/tinymemes/inference_tests.rs+++ /dev/null@@ -1,32 +0,0 @@-use super::*;--#[test]-fn openrouter_routes_are_detected() {- let mut config = Config::default();- assert!(!routes_to_openrouter(&config));- config.inference_url = Some("https://openrouter.ai/api/v1".into());- assert!(routes_to_openrouter(&config));- config.inference_url = Some("https://OpenRouter.AI/api/v1".into());- assert!(routes_to_openrouter(&config));- config.inference_url = Some("https://api.openai.com/v1".into());- assert!(!routes_to_openrouter(&config));- config.memory_provider = Some("openrouter:deepseek/deepseek-v4-flash".into());- assert!(routes_to_openrouter(&config));- config.memory_provider = Some("ollama:llama3.1:8b".into());- assert!(!routes_to_openrouter(&config));-}--#[test]-fn the_model_label_never_fails() {- let dir = tempfile::tempdir().unwrap();- let mut config = Config::default();- config.config_path = dir.path().join("config.toml");- config.workspace_dir = dir.path().join("workspace");- config.secrets.encrypt = false;- // Either the resolved model id or an `unavailable (...)` label.- assert!(- !resolved_model(&crate::core::runtime::DispatchCtx::host_default(), &config)- .trim()- .is_empty()- );-}diff --git a/crates/openhuman-core/src/tinymemes/jev.rs b/crates/openhuman-core/src/tinymemes/jev.rsdeleted file mode 100644index 27e20db9a5..0000000000--- a/crates/openhuman-core/src/tinymemes/jev.rs+++ /dev/null@@ -1,44 +0,0 @@-//! Jev as OpenHuman manages it.-//!-//! The module uses the OpenHuman-managed Jev: a signed-in TinyHumans session-//! reaches Jev through the backend's System One proxy, billed to the account.-//! There is no other OpenHuman-side route.-//!-//! `None` means managed Jev is unavailable (signed out, or the offline local-//! session, which has no backend account); the `Evaluate` callback then-//! reports `Unsupported` and the module returns the original reply.--use std::sync::Arc;--use tinyinference_decisions::{Client, ClientConfig};--use crate::config::Config;-use crate::security::credentials::session_support::{- is_local_session_token, resolve_backend_credential, BackendCredential,-};--pub(crate) fn managed(config: &Config) -> Option<Arc<Client>> {- // Only a session token can be the offline local session; an API key is- // never classified by its shape.- let secret = match resolve_backend_credential(config).ok()? {- BackendCredential::Session(token) if is_local_session_token(&token) => return None,- BackendCredential::Session(token) | BackendCredential::ApiKey(token) => token,- };- let base = config.resolved_endpoints.control_plane_url.clone()?;- let mut client = ClientConfig::tinyhumans_openrouter(secret);- client.base_url = base;- if let Some(identity) = config.resolved_endpoints.product_identity.clone() {- client = client.with_sdk_name(&identity);- }- match Client::new(client) {- Ok(c) => Some(Arc::new(c)),- Err(e) => {- log::warn!("[tinymemes] managed jev client build failed: {e}");- None- }- }-}--#[cfg(test)]-#[path = "jev_tests.rs"]-mod tests;diff --git a/crates/openhuman-core/src/tinymemes/jev_tests.rs b/crates/openhuman-core/src/tinymemes/jev_tests.rsdeleted file mode 100644index 797cf90659..0000000000--- a/crates/openhuman-core/src/tinymemes/jev_tests.rs+++ /dev/null@@ -1,24 +0,0 @@-use super::*;--fn config_in(dir: &std::path::Path) -> Config {- let mut config = Config::default();- config.config_path = dir.join("config.toml");- config.workspace_dir = dir.join("workspace");- config.secrets.encrypt = false;- config-}--#[test]-fn without_a_backend_credential_managed_jev_is_unavailable() {- let dir = tempfile::tempdir().unwrap();- assert!(managed(&config_in(dir.path())).is_none());-}--#[test]-fn an_api_key_reaches_managed_jev() {- let dir = tempfile::tempdir().unwrap();- let mut config = config_in(dir.path());- config.resolved_endpoints.control_plane_url = Some("https://api.example.test".into());- crate::security::credentials::api_key::store_api_key(&config, "th_live_test").unwrap();- assert!(managed(&config).is_some());-}diff --git a/crates/openhuman-core/src/tinymemes/mod.rs b/crates/openhuman-core/src/tinymemes/mod.rsdeleted file mode 100644index bbcef290bb..0000000000--- a/crates/openhuman-core/src/tinymemes/mod.rs+++ /dev/null@@ -1,351 +0,0 @@-//! TinyMemes host adapter: remixes the orchestrator's final reply with-//! region slang and memes when the chat can take it.-//!-//! The engine (Jev reading, rating, rewrite, slang and meme indexes) runs in-//! the `tinymemes` module, reached over its `tinymemes-bus` contract. This-//! domain keeps what is the host's:-//!-//! - the `OPENHUMAN_TINYMEMES` flag and the A/B split ([`arm`]);-//! - the thread as the user saw it, each message named by its id-//! ([`history`]); the module keeps the ring of remixed ids itself and tags-//! earlier remixed replies from it;-//! - the callbacks the module asks for while it works: OpenHuman inference,-//! managed Jev, web search and the learned-state documents ([`callbacks`],-//! [`docs`], served over the bus by [`service`]). Each carries the remix's-//! correlation id, so remixes for different workspaces run side by side.-//!-//! The module also owns the `TINYMEMES_*` environment overrides (OpenRouter key-//! and model, Jev route), the LLM fallback when this host has no Jev, and the-//! slang and meme research it runs in the background after delivery.-//!-//! Behaviour:-//!-//! - Runs after the turn, on `full_response` only. Sub-agent output never-//! reaches it.-//! - The agent's own transcript keeps the original wording, so the-//! orchestrator never sees its replies in slang.-//! - Fails open: any error, refusal or timeout delivers the original reply.-//!-//! Every turn in an experiment logs one grep-friendly `[tinymemes] turn` line-//! (arm, turn time, remix time, rating, outcome) for the A/B comparison. No-//! user content is logged.--mod arm;-mod callbacks;-mod docs;-mod history;-mod inference;-mod jev;-mod search;-pub(crate) mod service;--use crate::config::Config;-use crate::core::runtime::DispatchCtx;-use async_trait::async_trait;-use std::time::{Duration, Instant};-use tinymemes_bus::{RemixOptions, RemixRequest, RemixResponse, SkipReason};--pub(crate) use arm::Arm;-pub(crate) use arm::FLAG_ENV;--/// Whether an `OPENHUMAN_TINYMEMES` value turns remixing on in any form.-pub(crate) fn flag_enabled(value: &str) -> bool {- arm::mode_from(Some(value)) != arm::Mode::Off-}--const TIMEOUT_ENV: &str = "OPENHUMAN_TINYMEMES_TIMEOUT_MS";-const COOLDOWN_ENV: &str = "OPENHUMAN_TINYMEMES_MEME_COOLDOWN";--/// Whether this thread's answer text must be held back from streaming because-/// its final reply will be remixed (treatment arm). The UI then shows only the-/// remixed reply instead of the original streaming in and being replaced.-pub(crate) fn holds_text_stream(config: &Config, thread_id: &str) -> bool {- arm::arm_for(config, arm::mode(), thread_id) == Arm::Treatment-}--/// Something that can remix one reply: the module in production, a script in-/// tests.-#[async_trait]-pub(crate) trait Remixer: Send + Sync {- async fn remix(&self, request: RemixRequest) -> Result<RemixResponse, String>;-}--/// The loadable `tinymemes` module, with this workspace's callbacks served.-struct ModuleRemixer<'a> {- ctx: &'a DispatchCtx,- config: &'a Config,-}--#[async_trait]-impl Remixer for ModuleRemixer<'_> {- async fn remix(&self, request: RemixRequest) -> Result<RemixResponse, String> {- service::remix(self.ctx, self.config, request).await- }-}--/// Remix a finished task's reply in place, when it is a real answer (not-/// empty, not the `placeholder` sent when the inference budget ran out) and-/// the thread is in the treatment arm. Fails open: the reply is left-/// untouched on any error.-pub(crate) async fn remix_task_reply(- ctx: &DispatchCtx,- config: &Config,- thread_id: &str,- request_id: &str,- user_message: &str,- full_response: &mut String,- placeholder: &str,- turn_elapsed: Duration,-) {- if !history::should_remix(full_response, placeholder) {- return;- }- if let Some(remixed) = remix_final_reply(- arm::arm_for(config, arm::mode(), thread_id),- ctx,- config,- thread_id,- request_id,- user_message,- full_response,- turn_elapsed,- )- .await- {- *full_response = remixed;- }-}--/// Remix a finished turn's reply. Returns the text to deliver instead, or-/// `None` to deliver the original. `turn_elapsed` is the agent turn's own-/// duration, logged for both arms so throughput can be compared.-async fn remix_final_reply(- arm: Arm,- ctx: &DispatchCtx,- config: &Config,- thread_id: &str,- request_id: &str,- user_message: &str,- reply: &str,- turn_elapsed: Duration,-) -> Option<String> {- let turn = TurnInfo {- request_id,- bucket: arm::bucket(thread_id),- turn_ms: turn_elapsed.as_millis(),- };- if !gate(arm, &turn) {- return None;- }- let started = Instant::now();- // Fail open: without the thread, the reading would judge the reply out of- // context, so the original goes out instead.- let Some(messages) = load(ctx, config, thread_id).await else {- log_outcome(&turn, started, "history_unavailable", None);- return None;- };- let remixer = ModuleRemixer { ctx, config };- remix_with(- &remixer,- options(ctx, config),- &messages,- &turn,- started,- user_message,- reply,- budget(config),- )- .await-}--/// Per-turn identifiers for the A/B log line.-#[derive(Clone, Copy)]-struct TurnInfo<'a> {- request_id: &'a str,- bucket: u8,- turn_ms: u128,-}--/// Whether the arm runs the remix. The control arm logs its turn for the-/// throughput comparison; a disabled flag does nothing at all.-fn gate(arm: Arm, turn: &TurnInfo<'_>) -> bool {- match arm {- Arm::Disabled => false,- Arm::Control => {- log::info!(- "[tinymemes] turn arm={} bucket={} request_id={} turn_ms={} remix_ms=0 \- outcome=not_remixed",- arm.as_str(),- turn.bucket,- turn.request_id,- turn.turn_ms- );- false- }- Arm::Treatment => true,- }-}--/// The thread as stored. Blocking file work, so it runs off the async-/// runtime. `None` when the thread cannot be read.-async fn load(- ctx: &DispatchCtx,- config: &Config,- thread_id: &str,-) -> Option<Vec<crate::threads::store::ConversationMessage>> {- let config = config.clone();- let thread_id = thread_id.to_owned();- let ctx = ctx.clone();- ctx.clone()- .spawn_blocking(move || {- crate::threads::store::get_messages(&ctx, config.workspace_dir.clone(), &thread_id)- .map_err(|e| log::warn!("[tinymemes] thread history unavailable: {e}"))- .ok()- })- .await- .ok()- .flatten()-}--/// What the host decides for the module: the meme cooldown-/// (`OPENHUMAN_TINYMEMES_MEME_COOLDOWN` over `[memes] meme_cooldown`) and-/// whether web search can serve research at all.-fn options(ctx: &DispatchCtx, config: &Config) -> RemixOptions {- options_with(- std::env::var(COOLDOWN_ENV).ok().as_deref(),- config.memes.meme_cooldown,- search::OpenHumanSearch::available(ctx, config).is_some(),- )-}--fn options_with(env: Option<&str>, configured: u32, research: bool) -> RemixOptions {- RemixOptions {- meme_cooldown_turns: Some(- env.and_then(|v| v.trim().parse::<u32>().ok())- .unwrap_or(configured),- ),- research,- }-}--/// The remix time budget: `OPENHUMAN_TINYMEMES_TIMEOUT_MS` when set, else-/// `[memes] timeout_ms`.-fn budget(config: &Config) -> Duration {- budget_with(- std::env::var(TIMEOUT_ENV).ok().as_deref(),- config.memes.timeout_ms,- )-}--fn budget_with(env: Option<&str>, configured_ms: u64) -> Duration {- Duration::from_millis(- env.and_then(|v| v.trim().parse::<u64>().ok())- .unwrap_or(configured_ms),- )-}--/// Read, rate, and remix `reply` against the thread, within `budget`.-#[allow(clippy::too_many_arguments)]-async fn remix_with(- remixer: &dyn Remixer,- options: RemixOptions,- messages: &[crate::threads::store::ConversationMessage],- turn: &TurnInfo<'_>,- started: Instant,- user_message: &str,- reply: &str,- budget: Duration,-) -> Option<String> {- let request = RemixRequest {- conversation: history::history_turns(messages, user_message),- reply: reply.to_owned(),- region: None,- enabled: true,- timeout_ms: u64::try_from(budget.as_millis()).unwrap_or(u64::MAX),- deliver: false,- // Set by the service, which owns the registry of live remixes.- correlation: String::new(),- // The module remembers this id when the reply goes out remixed.- reply_id: Some(crate::threads::store::run_reply_message_id(turn.request_id)),- options,- };- // The module enforces `timeout_ms` itself; this outer bound also covers- // module load, callback serving and the bus hop.- let response = match tokio::time::timeout(budget, remixer.remix(request)).await {- Ok(Ok(response)) => response,- Ok(Err(error)) => {- log::warn!(- "[tinymemes] remix unavailable request_id={}: {error}",- turn.request_id- );- log_outcome(turn, started, "error", None);- return None;- }- Err(_) => {- log_outcome(turn, started, "timeout", None);- return None;- }- };-- // Whether the delivered reply actually changed.- let changed = response.remixed && response.reply.trim() != reply.trim();- let result = if changed {- "remixed"- } else {- match response.skipped {- Some(SkipReason::Timeout) => "timeout",- Some(SkipReason::Failed) => "error",- _ => "unchanged",- }- };- log_outcome(turn, started, result, Some(&response));- changed.then_some(response.reply)-}--fn log_outcome(- turn: &TurnInfo<'_>,- started: Instant,- result: &str,- response: Option<&RemixResponse>,-) {- log::info!(- "{}",- turn_line(turn, started.elapsed().as_millis(), result, response)- );-}--/// The treatment arm's per-turn log line. No user content goes in it.-fn turn_line(- turn: &TurnInfo<'_>,- remix_ms: u128,- result: &str,- response: Option<&RemixResponse>,-) -> String {- let TurnInfo {- request_id,- bucket,- turn_ms,- } = *turn;- format!(- "[tinymemes] turn arm=treatment bucket={bucket} request_id={request_id} turn_ms={turn_ms} \- remix_ms={remix_ms} outcome={result} score={} skipped={} wants_more_memes={}",- response.and_then(|r| r.score).map_or(-1, i32::from),- response- .and_then(|r| r.skipped)- .map_or("none", |s| match s {- SkipReason::Disabled => "disabled",- SkipReason::BelowThreshold => "below_threshold",- SkipReason::Timeout => "timeout",- SkipReason::Failed => "failed",- }),- response.is_some_and(|r| r.wants_more_memes),- )-}--#[cfg(test)]-#[path = "mod_tests.rs"]-mod tests;--#[cfg(test)]-#[path = "e2e_tests.rs"]-mod e2e_tests;diff --git a/crates/openhuman-core/src/tinymemes/mod_tests.rs b/crates/openhuman-core/src/tinymemes/mod_tests.rsdeleted file mode 100644index 831f14a573..0000000000--- a/crates/openhuman-core/src/tinymemes/mod_tests.rs+++ /dev/null@@ -1,321 +0,0 @@-use super::*;--use std::sync::atomic::{AtomicUsize, Ordering};--use crate::threads::store::ConversationMessage;--/// Answers every remix with a fixed response, after an optional delay.-struct ScriptedRemixer {- response: Result<RemixResponse, String>,- delay: Duration,- calls: AtomicUsize,- last: std::sync::Mutex<Option<RemixRequest>>,-}--impl ScriptedRemixer {- fn new(response: Result<RemixResponse, String>) -> Self {- Self {- response,- delay: Duration::ZERO,- calls: AtomicUsize::new(0),- last: std::sync::Mutex::new(None),- }- }-}--#[async_trait]-impl Remixer for ScriptedRemixer {- async fn remix(&self, request: RemixRequest) -> Result<RemixResponse, String> {- self.calls.fetch_add(1, Ordering::SeqCst);- *self.last.lock().unwrap() = Some(request);- tokio::time::sleep(self.delay).await;- self.response.clone()- }-}--fn remixed_response(reply: &str) -> RemixResponse {- RemixResponse {- reply: reply.to_owned(),- remixed: true,- skipped: None,- score: Some(7),- wants_more_memes: false,- }-}--fn skipped_response(reply: &str, reason: SkipReason) -> RemixResponse {- RemixResponse {- reply: reply.to_owned(),- remixed: false,- skipped: Some(reason),- score: None,- wants_more_memes: false,- }-}--fn turn(request_id: &str) -> TurnInfo<'_> {- TurnInfo {- request_id,- bucket: 7,- turn_ms: 1234,- }-}--fn msg(id: &str, sender: &str, content: &str) -> ConversationMessage {- ConversationMessage {- id: id.to_owned(),- content: content.to_owned(),- message_type: "text".to_owned(),- extra_metadata: serde_json::Value::Null,- sender: sender.to_owned(),- created_at: "2026-10-09T00:00:00Z".to_owned(),- }-}--fn thread() -> Vec<ConversationMessage> {- vec![- msg("u1", "user", "bhai build fail ho gaya"),- msg("r1", "agent", "Arre yaar, moye moye"),- ]-}--async fn run(remixer: &ScriptedRemixer, request_id: &str, budget: Duration) -> Option<String> {- remix_with(- remixer,- options_with(None, 3, true),- &thread(),- &turn(request_id),- Instant::now(),- "phir se fail",- "Build failed again.",- budget,- )- .await-}--#[test]-fn the_budget_defaults_to_the_configured_twenty_seconds() {- let config = Config::default();- assert_eq!(- budget_with(None, config.memes.timeout_ms),- Duration::from_secs(20)- );-}--#[test]-fn the_budget_env_override_beats_config_and_bad_values_fall_back() {- assert_eq!(- budget_with(Some("1500"), 20_000),- Duration::from_millis(1500)- );- assert_eq!(- budget_with(Some("soon"), 7_000),- Duration::from_millis(7_000)- );-}--#[test]-fn component_off_disables_every_arm() {- let mut config = Config::default();- config.components.memes = false;- for mode in [arm::Mode::On, arm::Mode::Ab { percent: 100 }] {- assert_eq!(arm::arm_for(&config, mode, "t1"), Arm::Disabled);- }- assert!(!holds_text_stream(&config, "t1"));-}--#[test]-fn arm_is_honoured_only_when_the_component_is_on() {- let config = Config::default();- assert!(config.components.memes);- assert_eq!(arm::arm_for(&config, arm::Mode::Off, "t1"), Arm::Disabled);- assert_eq!(arm::arm_for(&config, arm::Mode::On, "t1"), Arm::Treatment);- assert_eq!(- arm::arm_for(&config, arm::Mode::Ab { percent: 0 }, "t1"),- Arm::Control- );-}--#[test]-fn precedence_matrix_env_beats_build_default_and_component_gates_both() {- // env set wins over the build default; unset falls to it; neither is off.- assert_eq!(arm::resolve_mode(Some("off"), Some("on")), arm::Mode::Off);- assert_eq!(arm::resolve_mode(Some("on"), None), arm::Mode::On);- assert_eq!(arm::resolve_mode(None, Some("on")), arm::Mode::On);- assert_eq!(arm::resolve_mode(None, None), arm::Mode::Off);- let mut config = Config::default();- config.components.memes = false;- assert_eq!(- arm::arm_for(&config, arm::resolve_mode(Some("on"), Some("on")), "t"),- Arm::Disabled- );-}--#[test]-fn only_the_treatment_arm_passes_the_gate() {- let t = turn("req");- assert!(!gate(Arm::Disabled, &t));- assert!(!gate(Arm::Control, &t));- assert!(gate(Arm::Treatment, &t));-}--#[tokio::test]-async fn a_remixed_reply_is_delivered_and_named_for_the_module_to_remember() {- let remixer = ScriptedRemixer::new(Ok(remixed_response("Arre yaar, build phir fail!")));- let out = run(&remixer, "req-ok", Duration::from_secs(5)).await;- assert_eq!(out.as_deref(), Some("Arre yaar, build phir fail!"));-- // The module remembers remixed ids itself: it is told which id this reply- // will have, and the thread's turns carry theirs.- let request = remixer.last.lock().unwrap().clone().unwrap();- assert!(request.enabled && !request.deliver);- assert_eq!(request.reply, "Build failed again.");- assert_eq!(request.timeout_ms, 5000);- assert_eq!(request.conversation.last().unwrap().text, "phir se fail");- assert_eq!(- request.reply_id,- Some(crate::threads::store::run_reply_message_id("req-ok"))- );- assert_eq!(request.conversation[1].id.as_deref(), Some("r1"));- assert_eq!(request.options.meme_cooldown_turns, Some(3));- assert!(request.options.research);-}--#[tokio::test]-async fn an_unchanged_reply_sends_the_original() {- for reason in [- SkipReason::BelowThreshold,- SkipReason::Failed,- SkipReason::Timeout,- ] {- let remixer = ScriptedRemixer::new(Ok(skipped_response("Build failed again.", reason)));- assert_eq!(- run(&remixer, "req-skip", Duration::from_secs(5)).await,- None- );- }-}--#[tokio::test]-async fn a_remix_that_returns_the_same_text_is_not_a_change() {- let remixer = ScriptedRemixer::new(Ok(remixed_response("Build failed again. ")));- assert_eq!(- run(&remixer, "req-same", Duration::from_secs(5)).await,- None- );-}--#[tokio::test]-async fn a_module_error_sends_the_original() {- let remixer = ScriptedRemixer::new(Err("module unavailable".into()));- assert_eq!(run(&remixer, "req-err", Duration::from_secs(5)).await, None);-}--#[tokio::test]-async fn a_slow_remix_times_out_to_the_original() {- let mut remixer = ScriptedRemixer::new(Ok(remixed_response("too late")));- remixer.delay = Duration::from_secs(30);- let out = run(&remixer, "req-slow", Duration::from_millis(50)).await;- assert_eq!(out, None);-}--#[tokio::test]-async fn a_disabled_flag_leaves_the_task_reply_alone() {- let dir = tempfile::tempdir().unwrap();- let mut config = Config::default();- config.config_path = dir.path().join("config.toml");- config.workspace_dir = dir.path().join("workspace");- let mut reply = String::from("Build failed again.");- // Disabled arm: no module is touched and nothing changes.- let out = remix_final_reply(- Arm::Disabled,- &DispatchCtx::ambient(),- &config,- "thread",- "req",- "msg",- &reply,- Duration::from_millis(5),- )- .await;- assert_eq!(out, None);- remix_task_reply(- &DispatchCtx::ambient(),- &config,- "thread",- "req",- "msg",- &mut reply,- "placeholder",- Duration::ZERO,- )- .await;- assert_eq!(reply, "Build failed again.");-}--#[test]-fn the_turn_line_reports_the_outcome_without_user_content() {- let t = turn("req-1");- let none = turn_line(&t, 5, "error", None);- assert!(none.contains("outcome=error") && none.contains("score=-1"));- let some = turn_line(&t, 9, "remixed", Some(&remixed_response("secret text")));- assert!(some.contains("score=7") && some.contains("request_id=req-1"));- assert!(!some.contains("secret text"));- let skipped = turn_line(- &t,- 9,- "unchanged",- Some(&skipped_response("x", SkipReason::BelowThreshold)),- );- assert!(skipped.contains("skipped=below_threshold"));-}--#[test]-fn flag_values_enable_remixing() {- assert!(flag_enabled("on"));- assert!(flag_enabled("ab:30"));- assert!(!flag_enabled("off"));-}--#[tokio::test]-async fn component_off_refuses_the_remix_before_any_module_load() {- let mut config = Config::default();- config.components.memes = false;- let request = RemixRequest {- conversation: Vec::new(),- reply: "hi".to_owned(),- region: None,- enabled: true,- timeout_ms: 100,- deliver: false,- correlation: String::new(),- reply_id: None,- options: RemixOptions::default(),- };- let err = service::remix(- &crate::core::runtime::DispatchCtx::host_default(),- &config,- request,- )- .await- .unwrap_err();- assert!(err.contains("component is off"), "{err}");-}--#[test]-fn the_cooldown_env_beats_config_and_bad_values_fall_back() {- assert_eq!(- options_with(Some("5"), 3, true).meme_cooldown_turns,- Some(5)- );- assert_eq!(- options_with(Some("0"), 3, true).meme_cooldown_turns,- Some(0)- );- assert_eq!(- options_with(Some("often"), 3, true).meme_cooldown_turns,- Some(3)- );- assert_eq!(options_with(None, 4, false).meme_cooldown_turns, Some(4));- assert!(!options_with(None, 4, false).research);-}diff --git a/crates/openhuman-core/src/tinymemes/search.rs b/crates/openhuman-core/src/tinymemes/search.rsdeleted file mode 100644index f7f120313c..0000000000--- a/crates/openhuman-core/src/tinymemes/search.rs+++ /dev/null@@ -1,68 +0,0 @@-//! OpenHuman's web search as the module's `Search` callback.-//!-//! Runs the same checks the `web_search` tool does before calling the search-//! module: search enabled in settings, the LocalOnly egress block, and at-//! least one provider able to serve the search role.--use serde_json::json;--use crate::config::Config;-use crate::core::runtime::DispatchCtx;--const TOOL: &str = tinysearch_bus::tools::WEB_SEARCH;--pub(crate) struct OpenHumanSearch {- ctx: DispatchCtx,- config: Config,-}--impl OpenHumanSearch {- /// A search backend, or `None` when OpenHuman cannot search right now.- pub(crate) fn available(ctx: &DispatchCtx, config: &Config) -> Option<Self> {- if !crate::search::is_active(config) {- return None;- }- if crate::search::tools::local_only_search_block(TOOL).is_some() {- return None;- }- let role = tinysearch_bus::role_for_tool(TOOL)?;- let resolved = crate::search::providers::resolve(config);- if crate::search::providers::effective_role_providers(&resolved, config, role).is_empty() {- return None;- }- Some(Self {- ctx: ctx.clone(),- config: config.clone(),- })- }-}--impl OpenHumanSearch {- /// Run one search through the search module.- pub(crate) async fn search(- &self,- query: &str,- max_results: usize,- ) -> Result<Vec<tinymemes_bus::SearchResult>, String> {- let request = tinysearch_bus::ExecuteToolRequest {- name: TOOL.to_string(),- arguments: json!({ "query": query, "max_results": max_results.clamp(1, 20) }),- };- let response = crate::modules::search::execute_tool(&self.ctx, &self.config, request)- .await- .map_err(|e| crate::search::tools::user_facing_error(&e))?;- Ok(response- .results- .into_iter()- .map(|r| tinymemes_bus::SearchResult {- title: r.title,- url: r.url,- snippet: r.snippet,- })- .collect())- }-}--#[cfg(test)]-#[path = "search_tests.rs"]-mod tests;diff --git a/crates/openhuman-core/src/tinymemes/search_tests.rs b/crates/openhuman-core/src/tinymemes/search_tests.rsdeleted file mode 100644index e01c29f90c..0000000000--- a/crates/openhuman-core/src/tinymemes/search_tests.rs+++ /dev/null@@ -1,25 +0,0 @@-use super::*;--#[test]-fn search_switched_off_in_settings_is_unavailable() {- let mut config = Config::default();- config.search.enabled = Some(false);- assert!(OpenHumanSearch::available(- &crate::core::runtime::DispatchCtx::host_default(),- &config- )- .is_none());-}--#[test]-fn availability_follows_the_configured_providers() {- // Whatever the default providers resolve to, a backend is returned only- // when search is on; it never panics on a default config.- let mut config = Config::default();- config.search.enabled = Some(true);- if let Some(search) =- OpenHumanSearch::available(&crate::core::runtime::DispatchCtx::host_default(), &config)- {- assert!(search.config.search.is_enabled());- }-}diff --git a/crates/openhuman-core/src/tinymemes/service.rs b/crates/openhuman-core/src/tinymemes/service.rsdeleted file mode 100644index dadd69a5a3..0000000000--- a/crates/openhuman-core/src/tinymemes/service.rs+++ /dev/null@@ -1,162 +0,0 @@-//! The bus half of the `tinymemes` module: the host callbacks it is served-//! (`Host` interface) and the client call that starts a remix.--use async_trait::async_trait;-use tinybus::{CallContext, Connection, InterfaceName, MemberName, ObjectPath};-use tinymemes_bus::{- host_methods, remix_methods, RemixRefusal, RemixRequest, RemixResponse, RemixResult,- HOST_INTERFACE, HOST_METHODS, HOST_PATH, REMIX_INTERFACE, REMIX_PATH, STATE_INTERFACE,-};--use super::callbacks;-use crate::config::Config;--/// Registry id of the module the callbacks serve.-pub(crate) const MODULE_ID: &str = "tinymemes";--struct HostService {- connection: Connection,-}--#[async_trait]-impl tinybus::Interface for HostService {- fn name(&self) -> InterfaceName {- InterfaceName::new(HOST_INTERFACE).expect("contract interface name is well formed")- }-- fn members(&self) -> Vec<MemberName> {- HOST_METHODS- .iter()- .filter_map(|member| MemberName::new(*member).ok())- .collect()- }-- async fn call(- &self,- _member: &MemberName,- _args: serde_json::Value,- ) -> tinybus::Result<serde_json::Value> {- // Without the broker's context there is no caller to authorize.- Err(tinybus::Error::failed("unauthenticated tinymemes caller"))- }-- async fn call_with_context(- &self,- member: &MemberName,- args: serde_json::Value,- context: &CallContext,- ) -> tinybus::Result<serde_json::Value> {- // Only the loaded `tinymemes` module may ask: its bus name's owner- // must be the authenticated sender.- let Some(sender) = context.authenticated_sender() else {- return Err(tinybus::Error::failed("unauthenticated tinymemes caller"));- };- let owner = self- .connection- .name_owner(tinymemes_bus::STATE_INTERFACE)- .await- .ok()- .flatten();- if owner.as_ref() != Some(sender) {- log::warn!("[tinymemes] refused a host callback from a peer that is not the module");- return Err(tinybus::Error::failed("unknown tinymemes caller"));- }- // The module is the only caller, but it serves many remixes: the- // correlation id says which workspace this callback answers for.- let correlation = callbacks::correlation_of(&args).map(str::to_owned);- if member.as_str() == host_methods::END {- // Forgetting an unknown id is harmless, so `End` needs no session.- if let Some(correlation) = &correlation {- callbacks::end(correlation);- }- return serde_json::to_value(tinymemes_bus::HostResult::<()>::Ok(()))- .map_err(|_| tinybus::Error::failed("invalid tinymemes host response"));- }- let Some(session) = correlation.as_deref().and_then(callbacks::session) else {- log::debug!("[tinymemes] host callback with no live remix for its correlation id");- return Err(tinybus::Error::failed("no such tinymemes remix"));- };- callbacks::dispatch(&session, member.as_str(), args).await- }-}--/// Serve the module's host callbacks on the module bus.-pub(crate) async fn install(connection: &Connection) -> tinybus::Result<()> {- connection- .serve_at(- ObjectPath::new(HOST_PATH)?,- HostService {- connection: connection.clone(),- },- )- .await-}--/// One foreground remix at a time per workspace.-///-/// The module reads its learned-state documents at the start of a remix and-/// writes them at the end, so two remixes for one scope at once would each-/// save a stale snapshot over the other. Different scopes never wait for each-/// other. Background research that outlives a call is not covered: it can only-/// lose counters, never a remixed id (the module serializes those itself).-static FOREGROUND: std::sync::LazyLock<- std::sync::Mutex<std::collections::HashMap<String, std::sync::Arc<tokio::sync::Mutex<()>>>>,-> = std::sync::LazyLock::new(Default::default);--fn scope_lock(config: &Config) -> std::sync::Arc<tokio::sync::Mutex<()>> {- let key = config.workspace_dir.display().to_string();- FOREGROUND- .lock()- .unwrap_or_else(|e| e.into_inner())- .entry(key)- .or_default()- .clone()-}--/// Remix one reply through the loaded module, serving its callbacks for-/// `config`'s workspace meanwhile. `request.correlation` is set here.-pub(crate) async fn remix(- ctx: &crate::core::runtime::DispatchCtx,- config: &Config,- mut request: RemixRequest,-) -> Result<RemixResponse, String> {- if !config.components.memes {- return Err("the memes component is off".to_owned());- }- crate::modules::ensure_loaded(config, MODULE_ID).await?;- let runtime = crate::modules::runtime::runtime()- .await- .map_err(|error| format!("the module bus is not running: {error}"))?;- let proxy = runtime- .connection()- .proxy(STATE_INTERFACE, REMIX_PATH, REMIX_INTERFACE)- .map_err(|error| error.to_string())?;- let registration = callbacks::register(ctx, config);- request.correlation = registration.correlation().to_owned();- // A disabled request makes no callbacks and starts no research, so there- // is nothing to keep the registration for.- let may_research = request.enabled;- // One foreground remix at a time per scope; see [`FOREGROUND`].- let lock = scope_lock(config);- let _foreground = lock.lock().await;- let outcome: tinybus::Result<RemixResult> = proxy.call(remix_methods::REMIX, (request,)).await;- match outcome {- Ok(Ok(response)) => {- // Background research may still call back; the module's `End`- // (or the age sweep) retires the entry.- if may_research {- registration.keep_for_background();- }- Ok(response)- }- Ok(Err(refusal)) => Err(match refusal {- RemixRefusal::Closing => "the tinymemes module is closing".to_owned(),- RemixRefusal::Unauthenticated => "the tinymemes module refused the caller".to_owned(),- }),- Err(error) => Err(format!("tinymemes remix call failed: {error}")),- }-}--#[cfg(test)]-#[path = "service_tests.rs"]-mod tests;diff --git a/crates/openhuman-core/src/tinymemes/service_tests.rs b/crates/openhuman-core/src/tinymemes/service_tests.rsdeleted file mode 100644index 63c0c7f439..0000000000--- a/crates/openhuman-core/src/tinymemes/service_tests.rs+++ /dev/null@@ -1,262 +0,0 @@-use super::*;-use serde_json::{json, Value};-use tinybus::{broker::Broker, transport::memory::MemoryBus};-use tinymemes_bus::{HostFailure, HostResult};--fn config_in(dir: &std::path::Path) -> Config {- let mut config = Config::default();- config.config_path = dir.join("config.toml");- config.workspace_dir = dir.join("workspace");- config.secrets.encrypt = false;- config-}--/// A host connection serving the callbacks, the peer that owns the module's-/// bus name, and a peer that does not.-struct Bus {- host: Connection,- module: Connection,- intruder: Connection,-}--async fn bus() -> Bus {- let bus = MemoryBus::new();- Broker::new().spawn(bus.clone());- let connect = || async {- Connection::connect(bus.connect().await.unwrap())- .await- .unwrap()- };- let (host, module, intruder) = (connect().await, connect().await, connect().await);- install(&host).await.unwrap();- module.request_name(STATE_INTERFACE).await.unwrap();- Bus {- host,- module,- intruder,- }-}--impl Bus {- async fn call(- &self,- from: &Connection,- member: &str,- payload: Value,- ) -> tinybus::Result<Value> {- let host = self.host.unique_name().unwrap();- from.proxy(host.as_str(), HOST_PATH, HOST_INTERFACE)- .unwrap()- .call(member, (payload,))- .await- }-}--fn decode<T: serde::de::DeserializeOwned>(value: Value) -> HostResult<T> {- serde_json::from_value(value).unwrap()-}--#[tokio::test]-async fn only_the_module_may_call_back_and_only_for_a_live_remix() {- let dir = tempfile::tempdir().unwrap();- let bus = bus().await;- let registration = callbacks::register(- &crate::core::runtime::DispatchCtx::host_default(),- &config_in(dir.path()),- );- let correlation = registration.correlation().to_owned();- let deliver = json!({ "correlation": correlation, "reply": "hi", "remixed": true });-- // The module, for its own live remix.- let ok = bus- .call(&bus.module, host_methods::DELIVER, deliver.clone())- .await- .unwrap();- assert_eq!(decode::<()>(ok), Ok(()));-- // A peer that does not own the module's bus name, with a valid id.- let refused = bus- .call(&bus.intruder, host_methods::DELIVER, deliver)- .await;- assert!(refused.is_err(), "a stranger must not reach the callbacks");-- // The module, with an id nobody registered, or none at all.- for payload in [- json!({ "correlation": "not-a-live-remix", "reply": "hi", "remixed": true }),- json!({ "reply": "hi", "remixed": true }),- json!({ "correlation": "", "reply": "hi", "remixed": true }),- ] {- let refused = bus.call(&bus.module, host_methods::DELIVER, payload).await;- assert!(refused.is_err(), "no live remix, no answer");- }-}--#[tokio::test]-async fn a_direct_call_without_the_brokers_context_is_unauthenticated() {- let bus = bus().await;- let service = HostService {- connection: bus.host.clone(),- };- let error = tinybus::Interface::call(- &service,- &MemberName::new(host_methods::DELIVER).unwrap(),- json!([{}]),- )- .await- .unwrap_err();- assert!(error.to_string().contains("unauthenticated"), "{error}");-}--#[tokio::test]-async fn remixes_for_different_workspaces_are_served_at_once_each_for_its_own() {- let (dir_a, dir_b) = (tempfile::tempdir().unwrap(), tempfile::tempdir().unwrap());- let bus = bus().await;- let a = callbacks::register(- &crate::core::runtime::DispatchCtx::host_default(),- &config_in(dir_a.path()),- );- let b = callbacks::register(- &crate::core::runtime::DispatchCtx::host_default(),- &config_in(dir_b.path()),- );- assert_ne!(a.correlation(), b.correlation());-- // Both are live together: neither waits for the other.- let save = |registration: &callbacks::Registration, json: &str| {- let payload =- json!({ "correlation": registration.correlation(), "kind": "slang", "json": json });- bus.call(&bus.module, host_methods::SAVE_INDEX, payload)- };- let (saved_a, saved_b) = tokio::join!(save(&a, "{\"a\":1}"), save(&b, "{\"b\":1}"));- assert_eq!(decode::<()>(saved_a.unwrap()), Ok(()));- assert_eq!(decode::<()>(saved_b.unwrap()), Ok(()));-- let load = |registration: &callbacks::Registration| {- let payload = json!({ "correlation": registration.correlation(), "kind": "slang" });- bus.call(&bus.module, host_methods::LOAD_INDEX, payload)- };- assert_eq!(- decode::<Option<String>>(load(&a).await.unwrap()),- Ok(Some("{\"a\":1}".into()))- );- assert_eq!(- decode::<Option<String>>(load(&b).await.unwrap()),- Ok(Some("{\"b\":1}".into()))- );-}--#[tokio::test]-async fn end_retires_the_remix_and_is_harmless_when_repeated_or_unknown() {- let dir = tempfile::tempdir().unwrap();- let bus = bus().await;- let registration = callbacks::register(- &crate::core::runtime::DispatchCtx::host_default(),- &config_in(dir.path()),- );- let correlation = registration.correlation().to_owned();- registration.keep_for_background();-- let ended = bus- .call(- &bus.module,- host_methods::END,- json!({ "correlation": correlation }),- )- .await- .unwrap();- assert_eq!(decode::<()>(ended), Ok(()));- let after = bus- .call(- &bus.module,- host_methods::EVALUATE,- json!({ "correlation": correlation, "body": {} }),- )- .await;- assert!(after.is_err(), "an ended remix answers nothing");-- for correlation in [correlation.as_str(), "never-registered"] {- let again = bus- .call(- &bus.module,- host_methods::END,- json!({ "correlation": correlation }),- )- .await- .unwrap();- assert_eq!(decode::<()>(again), Ok(()));- }- // A stranger cannot end somebody else's remix.- let dir2 = tempfile::tempdir().unwrap();- let live = callbacks::register(- &crate::core::runtime::DispatchCtx::host_default(),- &config_in(dir2.path()),- );- let refused = bus- .call(- &bus.intruder,- host_methods::END,- json!({ "correlation": live.correlation() }),- )- .await;- assert!(refused.is_err());- assert!(callbacks::session(live.correlation()).is_some());-}--#[tokio::test]-async fn an_unavailable_capability_is_reported_not_faked() {- let dir = tempfile::tempdir().unwrap();- let bus = bus().await;- let registration = callbacks::register(- &crate::core::runtime::DispatchCtx::host_default(),- &config_in(dir.path()),- );- let reply = bus- .call(- &bus.module,- host_methods::EVALUATE,- json!({ "correlation": registration.correlation(), "body": { "questions": {} } }),- )- .await- .unwrap();- assert_eq!(- decode::<tinymemes_bus::EvaluateEnvelope>(reply),- Err(HostFailure::Unsupported)- );-}--#[tokio::test]-async fn component_off_refuses_before_any_module_load() {- let mut config = Config::default();- config.components.memes = false;- let request: RemixRequest =- serde_json::from_str(r#"{"conversation":[],"reply":"hi"}"#).unwrap();- let error = remix(- &crate::core::runtime::DispatchCtx::host_default(),- &config,- request,- )- .await- .unwrap_err();- assert!(error.contains("component is off"), "{error}");-}--#[test]-fn foreground_remixes_share_a_lock_per_workspace_and_never_across_workspaces() {- let (dir_a, dir_b) = (tempfile::tempdir().unwrap(), tempfile::tempdir().unwrap());- let (a, b) = (config_in(dir_a.path()), config_in(dir_b.path()));- assert!(std::sync::Arc::ptr_eq(&scope_lock(&a), &scope_lock(&a)));- assert!(!std::sync::Arc::ptr_eq(&scope_lock(&a), &scope_lock(&b)));-}--#[tokio::test]-async fn a_second_remix_for_one_workspace_waits_for_the_first_but_another_workspace_does_not() {- let (dir_a, dir_b) = (tempfile::tempdir().unwrap(), tempfile::tempdir().unwrap());- let (a, b) = (config_in(dir_a.path()), config_in(dir_b.path()));- let held = scope_lock(&a);- let _first = held.lock().await;- assert!(scope_lock(&a).try_lock().is_err(), "same workspace waits");- assert!(- scope_lock(&b).try_lock().is_ok(),- "another workspace does not"- );-}