//// Payload decode counts are a performance invariant invisible to HTTP E2E.
//// A long archived prefix must not be decoded by an ordinary preparation.
import albedo/daemon/conversation
import albedo/daemon/store
import albedo/harness/extensions
import albedo/harness/extensions/lcm/extension as lcm
import albedo/harness/extensions/lcm/graph
import albedo/harness/extensions/lcm/memory
import albedo/harness/runtime
import albedo/openai_api/types
import gleam/erlang/process
import gleam/list
import gleam/option.{None, Some}
import gleam/string
import gleeunit/should
@external(erlang, "albedo_lcm_preparation_test_support", "count_decodes")
fn count_decodes(owner: process.Pid, run: fn() -> a) -> #(a, Int)
pub fn below_trigger_and_stored_prior_do_not_decode_archived_payloads_test() -> Nil {
let installed = [
memory.extension(),
lcm.configured_extension(lcm.Config(Some(2000), 90, 1)),
]
let assert Ok(host) =
runtime.start_with_config(
":memory:",
extensions.Config(installed, ["lcm-memory", "lcm"]),
)
let ledger = runtime.ledger(host)
let assert Ok(_) = conversation.initialise(ledger)
let assert Ok(_) =
conversation.create(
ledger,
conversation.Info(
"preparation",
"test",
"/tmp",
"provider",
"model",
types.Responses,
conversation.Idle,
None,
None,
),
)
let archived =
list.repeat(Nil, 400)
|> list.flat_map(fn(_) {
[types.User("archived user"), types.Assistant("archived answer")]
})
let inputs =
list.append(archived, [types.User("latest"), types.Assistant("tail")])
let assert Ok(_) =
conversation.commit_from(
ledger,
"preparation",
inputs,
conversation.Idle,
Some("provider"),
)
let assert Ok(rows) = conversation.load_sources(ledger, "preparation")
let assert [first, ..] = rows
let assert Ok(last) = list.last(list.take(rows, 800))
let assert Ok(_) =
graph.save_leaves(ledger, "preparation", [
graph.Leaf(first.source.seq, last.source.seq, "archived prefix"),
])
let #(control, positive_decodes) =
count_decodes(store.owner(ledger), fn() {
conversation.load_sources(ledger, "preparation")
})
let assert Ok(_) = control
should.be_true(positive_decodes >= 802)
let assert Ok(session) = runtime.open_session(host, "preparation", "/tmp")
let #(prepared, decodes) =
count_decodes(store.owner(ledger), fn() {
runtime.prepare_history_with(
host,
session,
"model",
"",
fn(_) { panic as "below-trigger preparation must not summarize" },
inputs,
)
})
let assert Ok([
types.User(summary),
types.User("latest"),
types.Assistant("tail"),
]) = prepared
should.be_true(string.contains(summary, "archived prefix"))
decodes |> should.equal(0)
let #(prior, decodes) =
count_decodes(store.owner(ledger), fn() {
lcm.stored_prior(ledger, "preparation", inputs)
})
let assert Ok(_) = prior
decodes |> should.equal(0)
let assert Ok(_) =
conversation.commit_from(
ledger,
"preparation",
[types.User("next")],
conversation.Idle,
Some("provider"),
)
let next = list.append(inputs, [types.User("next")])
let #(failed, decodes) =
count_decodes(store.owner(ledger), fn() {
runtime.compact_history_scoped(
host,
session,
"model",
"model",
None,
"",
fn(_) { Error("summary unavailable") },
next,
)
})
failed |> should.equal(Error("compaction lcm: summary unavailable"))
decodes |> should.equal(2)
graph.last_seq(ledger, "preparation") |> should.equal(Ok(last.source.seq))
let #(compacted, decodes) =
count_decodes(store.owner(ledger), fn() {
runtime.compact_history_scoped(
host,
session,
"model",
"model",
None,
"",
fn(_) { Ok("short") },
next,
)
})
let assert Ok(_) = compacted
decodes |> should.equal(2)
graph.last_seq(ledger, "preparation") |> should.equal(Ok(last.source.seq + 2))
runtime.stop(host)
}