char-slop/berry

multipurpose self-modifiable agentic harness

git clone https://git.t4t.associates/char-slop/berry

Charlotte Somallow built in provider replacement0bacd13

main
branchesmainall refs →
5.3 KiB165 linesraw
1import { assert, assertEquals, assertRejects } from "@std/assert";
2import { createModels, type Provider } from "@earendil-works/pi-ai";
3import { fauxProvider } from "@earendil-works/pi-ai/providers/faux";
4import { MemoryStorage } from "@earendil-works/pi-durable";
5import { defineExtension } from "@berry/api";
6import { until } from "@berry/util";
7import { openBerry } from "./berry.ts";
8
9Deno.test("providers registered during a failed setup never replace the running load", async () => {
10  const models = createModels();
11  const berry = await openBerry(new MemoryStorage(), models);
12  const original = { ...fauxProvider().provider, id: "custom" };
13  const extension = (provider: Provider) =>
14    defineExtension({
15      name: "provider",
16      initial: () => null,
17      setup(ext) {
18        ext.provider(provider);
19      },
20    });
21  try {
22    await berry.install(extension(original));
23    await assertRejects(() =>
24      berry.install(defineExtension({
25        ...extension({ ...original }),
26        setup(ext) {
27          ext.provider({ ...original });
28          ext.provider({ ...original, id: "new" });
29          throw new Error("setup failed");
30        },
31      }))
32    );
33    assertEquals(models.getProvider("custom"), original);
34    assertEquals(models.getProvider("new"), undefined);
35  } finally {
36    await berry.close();
37  }
38});
39
40Deno.test("builtin overrides survive reload and restore originals on release", async () => {
41  const models = createModels();
42  const builtin = fauxProvider().provider;
43  const second = { ...builtin, id: "second" };
44  models.setProvider(builtin);
45  models.setProvider(second);
46  const berry = await openBerry(new MemoryStorage(), models);
47  const override = { ...builtin, name: "override" };
48  const replacement = { ...builtin, name: "replacement" };
49  const extension = (providers: Provider[]) =>
50    defineExtension({
51      name: "provider",
52      initial: () => null,
53      setup(ext) {
54        for (const provider of providers) ext.provider(provider);
55      },
56    });
57  try {
58    await berry.install(extension([override, { ...second }]));
59    assertEquals(models.getProvider(builtin.id), override);
60    assert(models.getProvider("second") !== second);
61    await berry.install(extension([replacement]));
62    assertEquals(models.getProvider(builtin.id), replacement);
63    assertEquals(models.getProvider("second"), second);
64    berry.uninstall("provider");
65    assertEquals(models.getProvider(builtin.id), builtin);
66    await berry.install(extension([override]));
67  } finally {
68    await berry.close();
69  }
70  assertEquals(models.getProvider(builtin.id), builtin);
71});
72
73Deno.test("provider conflicts leave staged overrides and the running load untouched", async () => {
74  const models = createModels();
75  const builtin = fauxProvider().provider;
76  models.setProvider(builtin);
77  const berry = await openBerry(new MemoryStorage(), models);
78  const owned = { ...builtin, id: "custom" };
79  try {
80    await berry.install(defineExtension({
81      name: "owner",
82      initial: () => null,
83      setup: (ext) => ext.provider(owned),
84    }));
85    await assertRejects(() =>
86      berry.install(defineExtension({
87        name: "conflict",
88        initial: () => null,
89        setup(ext) {
90          ext.provider({ ...builtin });
91          ext.provider({ ...owned });
92        },
93      }))
94    );
95    assertEquals(models.getProvider(builtin.id), builtin);
96    assertEquals(models.getProvider("custom"), owned);
97    await assertRejects(() =>
98      berry.install(defineExtension({
99        name: "owner",
100        initial: () => null,
101        setup(ext) {
102          ext.provider({ ...builtin });
103          ext.provider({ ...builtin });
104        },
105      }))
106    );
107    assertEquals(models.getProvider(builtin.id), builtin);
108    assertEquals(models.getProvider("custom"), owned);
109  } finally {
110    await berry.close();
111  }
112});
113
114Deno.test("reload and uninstall release only the providers owned by that extension load", async () => {
115  const models = createModels();
116  const berry = await openBerry(new MemoryStorage(), models);
117  const original = { ...fauxProvider().provider, id: "custom" };
118  const replacement = { ...original, name: "replacement" };
119  let disposed = false;
120  try {
121    await berry.install(defineExtension({
122      name: "provider",
123      initial: () => null,
124      setup(ext) {
125        ext.provider(original);
126        ext.provider({ ...original, id: "removed" });
127        ext.onDispose(() => void (disposed = true));
128      },
129    }));
130    await berry.install(defineExtension({
131      name: "provider",
132      initial: () => null,
133      setup(ext) {
134        ext.provider(replacement);
135      },
136    }));
137    await until(() => disposed);
138    assertEquals(models.getProvider("custom"), replacement);
139    assertEquals(models.getProvider("removed"), undefined);
140    await assertRejects(() =>
141      berry.install(defineExtension({
142        name: "other",
143        initial: () => null,
144        setup(ext) {
145          ext.provider({ ...replacement });
146        },
147      }))
148    );
149    assertEquals(models.getProvider("custom"), replacement);
150    berry.uninstall("provider");
151    assertEquals(models.getProvider("custom"), undefined);
152
153    await berry.install(defineExtension({
154      name: "provider",
155      initial: () => null,
156      setup(ext) {
157        ext.provider(replacement);
158      },
159    }));
160    assert(models.getProvider("custom"));
161  } finally {
162    await berry.close();
163  }
164  assertEquals(models.getProvider("custom"), undefined);
165});