Something went wrong. Try again.
small gleam coding and (not yet) persistent agent daemon with a detachable cli
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337import albedo/daemon/conversationimport albedo/harness/compactionimport albedo/harness/extensionimport albedo/harness/extensionsimport albedo/harness/extensions/python/extension as pythonimport albedo/harness/runtimeimport albedo/openai_api/typesimport gleam/erlang/processimport gleam/jsonimport gleam/listimport gleam/option.{None}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 no_op(_) { Ok(Nil)}
fn fixture_tool(name: String) -> extension.Tool { extension.Tool( types.Tool( name, "fixture", json.object([#("type", json.string("object"))]), True, ), fn(_, _) { Ok(extension.text("fixture")) }, fn(_) { None }, )}
fn bundle(load) -> extension.Extension { extension.Extension( "bundle", "fixture mixed extension", ["python"], [ extension.ContextPlugin(load), extension.ToolPlugin( "bundle instructions", [fixture_tool("fixture_tool")], ["bash"], [], ), ], no_op, )}
pub fn context_loads_once_and_is_prefixed_after_compaction_test() { let loaded = process.new_subject() let context = fn(workspace) { process.send(loaded, workspace) Ok("fixture context") } let strategy = compaction.Strategy("fixture", fn(_, _) { Ok([types.User("compacted conversation")]) }) let compact = extension.Extension( "compact", "fixture compactor", [], [extension.CompactionPlugin(strategy)], no_op, ) let installed = [python.extension(), bundle(context), compact] let assert Ok(host) = runtime.start_with_config( ":memory:", extensions.Config(installed, ["python", "bundle", "compact"]), ) let assert Ok(session) = runtime.open_session(host, "context", "/tmp") process.receive(loaded, 0) |> should.equal(Ok("/tmp")) let history = [types.User("durable")] let assert Ok([types.User(prefix), types.User("compacted conversation")]) = runtime.prepare_history(host, session, "fixture", history) string.contains(prefix, "fixture context") |> should.be_true let assert Ok(_) = runtime.prepare_history(host, session, "fixture", history) process.receive(loaded, 0) |> should.equal(Error(Nil)) runtime.stop(host)}
pub fn reload_disables_every_bundle_contribution_and_persists_test() { let path = temporary_database() let installed = [python.extension(), bundle(fn(_) { Ok("bundle context") })] let config = extensions.Config(installed, ["python", "bundle"]) let assert Ok(host) = runtime.start_with_config(path, config) let assert Ok(session) = runtime.open_session(host, "toggle", "/tmp") runtime.tools(session) |> list.map(fn(tool) { tool.name }) |> should.equal(["python", "fixture_tool"]) let assert Ok(execution) = runtime.execute(host, session, "'bash' in globals()", 1000) let assert Ok(outcome) = execution.result outcome.value |> should.equal("True") let assert Ok(reloaded) = runtime.reload_extension(host, "toggle", "/tmp", "bundle", False) runtime.tools(reloaded) |> list.map(fn(tool) { tool.name }) |> should.equal(["python"]) string.contains(runtime.instructions(reloaded), "bundle instructions") |> should.be_false runtime.prepare_history(host, reloaded, "fixture", [ types.User("conversation"), ]) |> should.equal(Ok([types.User("conversation")])) let assert Ok(execution) = runtime.execute(host, reloaded, "'bash' in globals()", 1000) let assert Ok(outcome) = execution.result outcome.value |> should.equal("False") runtime.stop(host)
let assert Ok(restarted) = runtime.start_with_config(path, config) let assert Ok([_, summary]) = runtime.extension_summaries(restarted, "toggle") summary.name |> should.equal("bundle") summary.enabled |> should.be_false let assert Ok(reopened) = runtime.open_session(restarted, "toggle", "/tmp") runtime.tools(reopened) |> list.map(fn(tool) { tool.name }) |> should.equal(["python"]) runtime.stop(restarted) cleanup(path)}
pub fn dependencies_and_reload_readiness_guard_selection_test() { let dependent = bundle(fn(_) { Ok("") }) let broken = extension.python_module( "broken", "missing module fixture", "albedo_missing_fixture.tools", "", ["python"], ) let installed = [python.extension(), dependent, broken] let config = extensions.Config(installed, ["python", "bundle"]) let assert Ok(host) = runtime.start_with_config(":memory:", config) let assert Ok(_) = runtime.open_session(host, "guard", "/tmp") runtime.reload_extension(host, "guard", "/tmp", "python", False) |> should.equal(Error("bundle requires enabled extension python")) let assert Error(error) = runtime.reload_extension(host, "guard", "/tmp", "broken", True) string.contains(error, "could not reload extensions") |> should.be_true let assert Ok(summaries) = runtime.extension_summaries(host, "guard") let assert Ok(broken) = list.find(summaries, fn(item) { item.name == "broken" }) broken.enabled |> should.be_false runtime.stop(host)}
pub fn registry_supports_disabled_compaction_alternatives_test() { let one = extension.Extension( "one", "first strategy", [], [ extension.CompactionPlugin( compaction.Strategy("one", fn(_, value) { Ok(value) }), ), ], no_op, ) let two = extension.Extension( "two", "second strategy", [], [ extension.CompactionPlugin( compaction.Strategy("two", fn(_, value) { Ok(value) }), ), ], no_op, ) let assert Ok(host) = runtime.start_with_config( ":memory:", extensions.Config([python.extension(), one, two], ["python", "one"]), ) let assert Ok(_) = runtime.open_session(host, "compact", "/tmp") let assert Error(error) = runtime.reload_extension(host, "compact", "/tmp", "two", True) string.contains(error, "multiple compaction") |> should.be_true runtime.stop(host)}
pub fn transcript_remains_durable_when_context_is_request_only_test() { let assert Ok(host) = runtime.start_with_extensions(":memory:", [ python.extension(), bundle(fn(_) { Ok("ephemeral") }), ]) let assert Ok(_) = conversation.initialise(runtime.ledger(host)) let info = conversation.Info( "durable", "title", "/tmp", "fixture", "model", types.Responses, conversation.Idle, None, ) let assert Ok(_) = conversation.create(runtime.ledger(host), info) let history = [types.User("saved")] let assert Ok(_) = conversation.commit( runtime.ledger(host), "durable", history, conversation.Idle, ) let assert Ok(session) = runtime.open_session(host, "durable", "/tmp") let assert Ok([types.User(prefix), types.User("saved")]) = runtime.prepare_history(host, session, "model", history) string.contains(prefix, "ephemeral") |> should.be_true conversation.load(runtime.ledger(host), "durable") |> should.equal(Ok(history)) runtime.stop(host)}
// `remote` is a bundled default: one connection turns the session's tools into// remote ones, and it degrades to plain commands rather than failing a session.pub fn remote_is_installed_and_default_test() { let config = extensions.defaults() config.extensions |> list.map(fn(extension) { extension.name }) |> list.contains("remote") |> should.be_true config.default_enabled |> list.contains("remote") |> should.be_true}
pub fn model_provider_extensions_form_catalog_openai_codex_chain_test() { let config = extensions.defaults() let assert Ok(openai) = list.find(config.extensions, fn(item) { item.name == "openai" }) let assert Ok(codex) = list.find(config.extensions, fn(item) { item.name == "codex" }) openai.requires |> should.equal(["models"]) codex.requires |> should.equal(["openai"]) let catalog = extension.Extension( "catalog", "fixture catalog", [], [ extension.ModelsPlugin( extension.ModelCatalog(fn(_, _) { None }, fn(provider, _) { case provider { "future-provider" -> ["catalog-model"] _ -> [] } }), ), ], no_op, ) let provider = extension.Extension( "future", "fixture provider", ["catalog"], [ extension.ModelProviderPlugin( extension.ModelProvider("future-provider", fn(_) { None }), ), ], no_op, ) extension.provider_model_names([catalog, provider], "future", "") |> should.equal(["catalog-model"]) let assert Ok(host) = runtime.start_with_config(":memory:", config) let assert Ok(_) = runtime.open_session(host, "model-chain", "/tmp") runtime.reload_extension(host, "model-chain", "/tmp", "openai", False) |> should.equal(Error("codex requires enabled extension openai")) runtime.reload_extension(host, "model-chain", "/tmp", "models", False) |> should.equal(Error("openai requires enabled extension models")) runtime.stop(host)}
// A context load that fails must not strand resources a managed plugin// already opened: the failed composition owns nothing afterwards.pub fn failed_context_leaves_no_prepared_resources_test() { let events = process.new_subject() let managed = extension.Extension( "managed", "fixture managed plugin", [], [ extension.ManagedPlugin(fn(_, _, _) { process.send(events, "prepared") Ok( extension.Managed("", "", [], [], [], [], fn() { process.send(events, "closed") }), ) }), ], no_op, ) let failing = extension.Extension( "failing", "fixture context failure", [], [extension.ContextPlugin(fn(_) { Error("unreadable") })], no_op, ) let assert Ok(host) = runtime.start_with_extensions(":memory:", [ python.extension(), managed, failing, ]) let assert Error(error) = runtime.open_session(host, "leak", "/tmp") string.inspect(error) |> string.contains("failing: unreadable") |> should.be_true let prepared = process.receive(events, 0) == Ok("prepared") case prepared { True -> process.receive(events, 0) |> should.equal(Ok("closed")) False -> Nil } runtime.stop(host)}