Skip to content

The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.

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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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.rs
deleted file mode 100644
index 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"
- );
-}