Something went wrong. Try again.
small gleam coding and persistent agent daemon with a detachable cli and a canvas ui forked from okami.mom/albedo
Something went wrong. Try again.
14 kB · 457 lines
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458import albedo/harness/compactionimport albedo/harness/extensionsimport albedo/harness/extensions/rolling/extension as rollingimport albedo/harness/runtimeimport albedo/openai_api/typesimport gleam/erlang/processimport gleam/listimport gleam/option.{None, Some}import gleam/stringimport gleeunit/should
@external(erlang, "albedo_runtime_test_support", "temporary_database")fn temporary_database() -> String
@external(erlang, "albedo_runtime_test_support", "cleanup")fn cleanup(path: String) -> Nil
fn host(config: rolling.Config) { let installed = [rolling.configured_extension(config)] let assert Ok(host) = runtime.start_with_config( ":memory:", extensions.Config(installed, ["rolling"]), ) let assert Ok(session) = runtime.open_session(host, "rolling-test", "/tmp") #(host, session)}
fn summarize(text: String) { fn(_: compaction.SummaryRequest) { Ok(text) }}
fn long_history() { [ types.User("u1 " <> string.repeat("a", 380)), types.Assistant("a1 " <> string.repeat("b", 380)), types.User("u2 " <> string.repeat("c", 380)), types.Assistant("a2 " <> string.repeat("d", 380)), types.User("u3 " <> string.repeat("e", 380)), types.Assistant("a3 " <> string.repeat("f", 380)), ]}
pub fn manual_compaction_uses_active_strategy_below_trigger_test() { let #(host, session) = host(rolling.Config(Some(10_000), 90, 25)) let history = long_history() let summaries = process.new_subject() let assert Ok(projected) = runtime.compact_history_scoped( host, session, "model-a", "model-a", "", "system", fn(request) { process.send(summaries, request) Ok("kept facts") }, history, ) let assert Ok(compaction.SummaryRequest(_, None, evicted, _)) = process.receive(summaries, 0) list.is_empty(evicted) |> should.be_false let assert [types.User(summary), types.User(_), ..tail] = projected string.contains(summary, "kept facts") |> should.be_true tail |> should.equal(list.drop(history, list.length(evicted))) let assert Ok(Some(observation)) = rolling.observation(runtime.ledger(host), "rolling-test") observation.status |> should.equal("compacted") // A normal next request reuses the saved projection without summarizing again. runtime.prepare_history_with( host, session, "model-a", "system", fn(_) { Error("unexpected summary") }, history, ) |> should.equal(Ok(projected)) runtime.stop(host)}
pub fn manual_compaction_works_without_known_model_capacity_test() { let #(host, session) = host(rolling.Config(None, 90, 25)) let history = long_history() let assert Ok(projected) = runtime.compact_history_scoped( host, session, "model-a", "model-a", "", "system", summarize("manual facts"), history, ) let assert [types.User(summary), ..] = projected string.contains(summary, "manual facts") |> should.be_true // The saved projection outlives the manual run: the next ordinary request // uses it even though no context window is known, and grows its tail. let grown = list.append(history, [types.User("newer"), types.Assistant("reply")]) let assert Ok(reused) = runtime.prepare_history_with( host, session, "model-a", "system", fn(_) { Error("must not summarize again") }, grown, ) let assert [types.User(kept), types.User(_recap), ..reused_tail] = reused string.contains(kept, "manual facts") |> should.be_true reused_tail |> should.equal(list.drop(grown, 4)) let assert Ok(Some(observation)) = rolling.observation(runtime.ledger(host), "rolling-test") observation.status |> should.equal("compacted") runtime.stop(host)}
pub fn below_threshold_is_an_exact_no_op_test() { let #(host, session) = host(rolling.Config(Some(10_000), 90, 25)) let history = [types.User("hello"), types.Assistant("hi")] runtime.prepare_history_with( host, session, "model-a", "system", fn(_) { Error("must not summarize") }, history, ) |> should.equal(Ok(history)) let assert Ok(Some(observation)) = rolling.observation(runtime.ledger(host), "rolling-test") observation.status |> should.equal("not_needed") observation.source |> string.contains("estimated") |> should.be_true runtime.stop(host)}
pub fn trigger_projects_summary_then_recap_then_whole_tail_test() { let #(host, session) = host(rolling.Config(Some(700), 90, 25)) let history = long_history() let assert Ok(projected) = runtime.prepare_history_with( host, session, "model-a", "system", summarize("older facts"), history, ) let assert [types.User(summary), types.User(recap), ..tail] = projected string.starts_with(summary, "[older conversation summary") |> should.be_true string.contains(summary, "older facts") |> should.be_true string.starts_with(recap, "[recent user excerpts") |> should.be_true tail |> should.equal(list.drop(history, 4)) let assert Ok(Some(observation)) = rolling.observation(runtime.ledger(host), "rolling-test") observation.status |> should.equal("compacted") observation.summary_items |> should.equal(1) observation.recap_items |> should.equal(1) observation.tail_items |> should.equal(2) // Reusing a valid cursor does not call the summarizer again. runtime.prepare_history_with( host, session, "model-a", "system", fn(_) { Error("must not summarize again") }, history, ) |> should.equal(Ok(projected)) runtime.stop(host)}
pub fn tool_output_stays_with_its_assistant_unit_test() { let #(host, session) = host(rolling.Config(Some(650), 40, 20)) let history = [ types.User("old " <> string.repeat("a", 500)), types.Assistant("tool call representation"), types.ToolOutput("call-1", string.repeat("x", 300), []), types.User("new"), types.Assistant("answer"), ] let assert Ok(projected) = runtime.prepare_history_with( host, session, "model-a", "", summarize("summarized tool turn"), history, ) let assert [types.User(_), types.User(_), ..tail] = projected tail |> should.equal([types.User("new"), types.Assistant("answer")]) runtime.stop(host)}
pub fn source_or_model_change_resets_summary_before_recompacting_test() { let #(host, session) = host(rolling.Config(Some(700), 90, 25)) let history = long_history() let assert Ok(_) = runtime.prepare_history_scoped( host, session, "model-b", "provider-a:model-b", "", "", summarize("first"), history, ) let requests = process.new_subject() let assert Ok(_) = runtime.prepare_history_scoped( host, session, "model-b", "provider-b:model-b", "", "", fn(request) { process.send(requests, request) Ok("second") }, history, ) let assert Ok(compaction.SummaryRequest("model-b", None, evicted, _)) = process.receive(requests, 0) evicted |> should.equal(list.take(history, 4)) runtime.stop(host)}
pub fn summarizer_failure_keeps_previous_state_usable_test() { let #(host, session) = host(rolling.Config(Some(700), 90, 25)) let history = long_history() let assert Ok(saved_projection) = runtime.prepare_history_with( host, session, "model-a", "", summarize("saved"), history, ) let extended = list.append(history, [ types.User("u4 " <> string.repeat("g", 380)), types.Assistant("a4 " <> string.repeat("h", 380)), types.User("u5 " <> string.repeat("i", 380)), types.Assistant("a5 " <> string.repeat("j", 380)), ])
runtime.prepare_history_with( host, session, "model-a", "", fn(_) { Error("provider unavailable") }, extended, ) |> should.equal(Error("compaction rolling: provider unavailable")) runtime.prepare_history_with( host, session, "model-a", "", fn(_) { Error("must retain the saved projection") }, history, ) |> should.equal(Ok(saved_projection))
let requests = process.new_subject() let assert Ok(_) = runtime.prepare_history_with( host, session, "model-a", "", fn(request) { process.send(requests, request) Ok("recovered") }, extended, ) let assert Ok(compaction.SummaryRequest(_, Some("saved"), _, _)) = process.receive(requests, 0) runtime.stop(host)}
pub fn unknown_capacity_is_observable_and_never_summarizes_test() { let #(host, session) = host(rolling.Config(None, 90, 25)) let history = long_history() runtime.prepare_history_with( host, session, "model-a", "", fn(_) { Error("must not summarize") }, history, ) |> should.equal(Ok(history)) let assert Ok(Some(observation)) = rolling.observation(runtime.ledger(host), "rolling-test") observation.status |> should.equal("unknown") observation.capacity_tokens |> should.equal(None) runtime.stop(host)}
pub fn pinned_overhead_reports_limitation_test() { let #(host, session) = host(rolling.Config(Some(100), 90, 25)) let assert Error(error) = runtime.prepare_history_with( host, session, "model-a", string.repeat("system", 100), fn(_) { Error("must not summarize") }, [types.User("hello")], ) string.contains(error, "pinned system") |> should.be_true let assert Ok(Some(observation)) = rolling.observation(runtime.ledger(host), "rolling-test") observation.status |> should.equal("limitation") runtime.stop(host)}
pub fn image_estimate_uses_dimensions_not_base64_transport_size_test() { let payload = string.repeat("A", 5 * 1024 * 1024) let assert Ok(image) = types.image("image/png", payload, 1024, 1024, 3 * 1024 * 1024) let input = types.UserImage("inspect", image) let transport_includes_payload = compaction.input_bytes(input) > 5 * 1024 * 1024 transport_includes_payload |> should.equal(True) let estimate_excludes_payload = compaction.estimate_input(input) < 1000 estimate_excludes_payload |> should.equal(True)}
pub fn image_recap_omits_binary_but_tail_preserves_image_test() { let assert Ok(image) = types.image("image/png", string.repeat("A", 400), 10, 10, 300) let #(host, session) = host(rolling.Config(Some(350), 65, 30)) let history = [ types.UserImage("inspect this", image), types.Assistant(string.repeat("old", 200)), types.User("latest"), types.Assistant("done"), ] let assert Ok([types.User(_), types.User(recap), ..tail]) = runtime.prepare_history_with( host, session, "model-a", "", summarize("image facts"), history, ) string.contains(recap, "[image omitted from recap]") |> should.be_true string.contains(recap, string.repeat("A", 100)) |> should.be_false tail |> should.equal([types.User("latest"), types.Assistant("done")]) runtime.stop(host)}
pub fn later_trigger_folds_previous_summary_and_only_newly_evicted_test() { let #(host, session) = host(rolling.Config(Some(700), 90, 25)) let history = long_history() let assert Ok(_) = runtime.prepare_history_with( host, session, "model-a", "", summarize("first"), history, ) let extended = list.append(history, [ types.User("u4 " <> string.repeat("g", 380)), types.Assistant("a4 " <> string.repeat("h", 380)), types.User("u5 " <> string.repeat("i", 380)), types.Assistant("a5 " <> string.repeat("j", 380)), ]) let requests = process.new_subject() let assert Ok(_) = runtime.prepare_history_with( host, session, "model-a", "", fn(request) { process.send(requests, request) Ok("second") }, extended, ) let assert Ok(compaction.SummaryRequest(_, Some("first"), evicted, _)) = process.receive(requests, 0) evicted |> should.equal(list.take(list.drop(extended, 4), 4)) runtime.stop(host)}
pub fn rolling_state_survives_restart_when_projection_prefix_matches_test() { let path = temporary_database() let config = rolling.Config(Some(700), 90, 25) let installed = [rolling.configured_extension(config)] let extensions = extensions.Config(installed, ["rolling"]) let assert Ok(first) = runtime.start_with_config(path, extensions) let assert Ok(session) = runtime.open_session(first, "restart", "/tmp") let history = long_history() let assert Ok(expected) = runtime.prepare_history_with( first, session, "model-a", "", summarize("saved"), history, ) runtime.stop(first)
let assert Ok(second) = runtime.start_with_config(path, extensions) let assert Ok(session) = runtime.open_session(second, "restart", "/tmp") runtime.prepare_history_with( second, session, "model-a", "", fn(_) { Error("must reuse saved summary") }, history, ) |> should.equal(Ok(expected)) runtime.stop(second) cleanup(path)}
pub fn rolling_config_defaults_and_validation_test() { rolling.default_config() |> should.equal(rolling.Config(None, 90, 25)) let #(host, session) = host(rolling.Config(Some(1000), 25, 25)) let assert Error(error) = runtime.prepare_history_with( host, session, "model", "", summarize("unused"), [types.User("hello")], ) string.contains(error, "0 < tailPercent < triggerPercent < 100") |> should.be_true runtime.stop(host)}