@xandreed/plugin-models 0.13.0 → 0.15.0

package/dist/settings/localSettings.js

@@ -1,72 +1,29 @@
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
+import { join } from "node:path";
 import { Effect, Layer, Option } from "effect";
-import { asJsonRecord, EngineSettings, parseJsonWarn, parseModelSelection, SettingsError, SettingsStore } from "@xandreed/core";
+import { SettingsError, SettingsStore } from "../ports/settings-store.port.js";
+import { readJsonObject, withFileLock, writeJsonObject } from "../storage/json-file.js";
+import { coerceSettingValue, ROLE_FIELDS, roleSelection, settingsFromRecord } from "./settings-value.entity.functions.js";
 const configPaths = (cwd, home) => [
   join(home, ".efferent", "config.json"),
   join(cwd, ".efferent", "config.json")
-], readConfig = (path) => Effect.tryPromise({ try: () => readFile(path, "utf-8"), catch: () => "missing" }).pipe(Effect.flatMap((text) => parseJsonWarn(text, path)), Effect.map(asJsonRecord), Effect.orElseSucceed(() => ({}))), asString = (value) => typeof value === "string" && value.length > 0 ? Option.some(value) : Option.none(), asBoolean = (value) => typeof value === "boolean" ? Option.some(value) : Option.none(), asNumber = (value) => typeof value === "number" && Number.isFinite(value) ? Option.some(value) : Option.none(), asReasoningEffort = (value) => value === "none" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max" ? Option.some(value) : Option.none(), coerceSettingValue = (key, raw) => {
-  if (key === "fallbackModel")
-    return Option.match(parseModelSelection(raw), {
-      onNone: () => Effect.fail(new SettingsError({
-        message: `fallbackModel must be "<provider>:<modelId>" \u2014 got "${raw}"`
-      })),
-      onSome: () => Effect.succeed(raw)
+], readConfig = (path) => readJsonObject(path, (reason) => new SettingsError({
+  code: "settings.corrupt",
+  message: `${path} ${reason}: fix or remove it; nothing was read from it or written to it`
+})).pipe(Effect.map(Option.getOrElse(() => ({})))), writeKey = (cwd, key, value) => {
+  const path = join(cwd, ".efferent", "config.json");
+  return withFileLock(path)(Effect.gen(function* () {
+    const current = yield* readConfig(path), next = Option.match(value, {
+      onNone: () => Object.fromEntries(Object.entries(current).filter(([k]) => k !== key)),
+      onSome: (v) => ({ ...current, [key]: v })
     });
-  if (key === "sandbox" || key === "viMode") {
-    if (raw === "true" || raw === "on")
-      return Effect.succeed(!0);
-    if (raw === "false" || raw === "off")
-      return Effect.succeed(!1);
-    return Effect.fail(new SettingsError({ message: `${key} must be true/false \u2014 got "${raw}"` }));
-  }
-  if (key === "reasoningEffort" || key === "codeReasoningEffort" || key === "fastReasoningEffort")
-    return Option.match(asReasoningEffort(raw), {
-      onNone: () => Effect.fail(new SettingsError({ message: `reasoningEffort is not supported: "${raw}"` })),
-      onSome: Effect.succeed
-    });
-  const parsed = Number(raw);
-  return Number.isInteger(parsed) && parsed >= 1 ? Effect.succeed(parsed) : Effect.fail(new SettingsError({ message: `${key} must be a positive integer \u2014 got "${raw}"` }));
-}, writeKey = (cwd, key, value) => Effect.gen(function* () {
-  const path = join(cwd, ".efferent", "config.json"), current = yield* readConfig(path), next = Option.match(value, {
-    onNone: () => Object.fromEntries(Object.entries(current).filter(([k]) => k !== key)),
-    onSome: (v) => ({ ...current, [key]: v })
-  });
-  yield* writeConfigAtomic(path, next);
-});
+    yield* writeJsonObject(path, next, Option.none(), (reason) => new SettingsError({ message: `config.json write failed: ${reason}` }));
+  }));
+};
 export const LocalSettingsStoreLive = (cwd, home) => Layer.succeed(SettingsStore, {
-  load: Effect.gen(function* () {
-    const merged = (yield* Effect.forEach(configPaths(cwd, home), readConfig)).reduce((acc, c) => ({ ...acc, ...c }), {});
-    return new EngineSettings({
-      model: asString(merged.model),
-      codeModel: asString(merged.codeModel),
-      fastModel: asString(merged.fastModel),
-      fallbackModel: asString(merged.fallbackModel),
-      sandbox: asBoolean(merged.sandbox),
-      viMode: asBoolean(merged.viMode),
-      maxAttempts: asNumber(merged.maxAttempts),
-      budgetMillis: asNumber(merged.budgetMillis),
-      reasoningEffort: Option.orElse(asReasoningEffort(merged.reasoningEffort), () => asReasoningEffort(merged.openAiReasoningEffort)),
-      codeReasoningEffort: asReasoningEffort(merged.codeReasoningEffort),
-      fastReasoningEffort: asReasoningEffort(merged.fastReasoningEffort)
-    });
-  }),
-  setRole: (role, selection) => writeKey(cwd, ROLE_KEYS[role], selection),
+  load: Effect.forEach(configPaths(cwd, home), readConfig, { concurrency: 1 }).pipe(Effect.map((configs) => settingsFromRecord(configs.reduce((acc, c) => ({ ...acc, ...c }), {})))),
+  setRole: (role, selection) => roleSelection(role, selection).pipe(Effect.flatMap((checked) => writeKey(cwd, ROLE_FIELDS[role], checked))),
   set: (key, value) => Option.match(value, {
     onNone: () => writeKey(cwd, key, Option.none()),
     onSome: (raw) => coerceSettingValue(key, raw).pipe(Effect.flatMap((coerced) => writeKey(cwd, key, Option.some(coerced))))
   })
 });
-const ROLE_KEYS = {
-  general: "model",
-  code: "codeModel",
-  fast: "fastModel"
-}, writeConfigAtomic = (path, config) => Effect.tryPromise({
-  try: async () => {
-    await mkdir(dirname(path), { recursive: !0 });
-    const tmp = `${path}.tmp-${process.pid}`;
-    await writeFile(tmp, JSON.stringify(config, null, 2), "utf-8");
-    await rename(tmp, path);
-  },
-  catch: (e) => new SettingsError({ message: `config.json write failed: ${String(e)}` })
-});

package/dist/settings/memory-settings.adapter.d.ts

@@ -0,0 +1,12 @@
+import { Layer } from "effect";
+import { EngineSettings, SettingsStore } from "../ports/settings-store.port.js";
+/**
+ * `MemorySettingsStoreLive(initial)` — a SettingsStore that never touches
+ * disk: one writable value for the layer's lifetime, starting at `initial`.
+ * `setRole` and `set` check their value the way the file store does
+ * (a `"<provider>:<modelId>"` selection; each key's string form) and refuse
+ * one that does not parse, leaving the settings as they were.
+ *
+ * @public
+ */
+export declare const MemorySettingsStoreLive: (initial?: EngineSettings) => Layer.Layer<SettingsStore>;

package/dist/settings/memory-settings.adapter.js

@@ -0,0 +1,11 @@
+import { Effect, Layer, SynchronizedRef } from "effect";
+import { EngineSettings, SettingsStore } from "../ports/settings-store.port.js";
+import { applyRole, applySetting } from "./settings-value.entity.functions.js";
+export const MemorySettingsStoreLive = (initial = new EngineSettings({})) => Layer.effect(SettingsStore, Effect.gen(function* () {
+  const state = yield* SynchronizedRef.make(initial);
+  return SettingsStore.of({
+    load: SynchronizedRef.get(state),
+    setRole: (role, selection) => SynchronizedRef.updateEffect(state, (settings) => applyRole(settings, role, selection)),
+    set: (key, value) => SynchronizedRef.updateEffect(state, (settings) => applySetting(settings, key, value))
+  });
+}));

package/dist/settings/roleView.d.ts

@@ -1,5 +1,5 @@
 import { Layer } from "effect";
-import { SettingsStore } from "@xandreed/core";
+import { SettingsStore } from "../ports/settings-store.port.js";
 /**
  * A role-scoped VIEW of the settings store: `load` re-maps the general
  * `model` to the role's selection (falling back to `model` when the role is
@@ -7,5 +7,7 @@ import { SettingsStore } from "@xandreed/core";
  * LanguageModel router above all — runs on that role WITHOUT knowing roles
  * exist. Compose it under `LanguageModelLive` for the scope that should use
  * the role (e.g. the forge implementor on "code"); writes pass through.
+ *
+ * @public
  */
 export declare const roleModelView: (role: "code" | "fast") => Layer.Layer<SettingsStore, never, SettingsStore>;

package/dist/settings/roleView.js

@@ -1,5 +1,5 @@
 import { Effect, Layer, Option } from "effect";
-import { EngineSettings, SettingsStore } from "@xandreed/core";
+import { EngineSettings, SettingsStore } from "../ports/settings-store.port.js";
 export const roleModelView = (role) => Layer.effect(SettingsStore, Effect.map(SettingsStore, (inner) => ({
   load: Effect.map(inner.load, (s) => new EngineSettings({
     ...s,

package/dist/settings/settings-store.conformance.d.ts

@@ -0,0 +1,47 @@
+import { Effect } from "effect";
+import type { Context, Scope } from "effect";
+import type { ConformanceCheck } from "@xandreed/core/conformance";
+import type { SettingsStore } from "../ports/settings-store.port.js";
+type Store = Context.Service.Shape<typeof SettingsStore>;
+/**
+ * What the kit is told about a store, and can do to it beyond calling it.
+ *
+ * @public
+ */
+export interface SettingsStoreConformanceOptions {
+    /** Whether `setRole` and `set` write, or every write is refused. */
+    readonly writable: boolean;
+    /**
+     * Damage the store's backing data (a file that is not JSON) for the
+     * scope's lifetime, and repair it when the scope closes: the corrupt check.
+     * Damage what the store writes to, so a write that ignores the damage shows.
+     * A store with nothing to damage, such as one in memory, leaves it out.
+     */
+    readonly corrupt?: Effect.Effect<void, never, Scope.Scope>;
+}
+/**
+ * The SettingsStore contract. Every store: `load` is stable. A writable
+ * store: each role reads back what `setRole` wrote and clearing it returns
+ * the value before the set; `set` accepts each key's canonical string form
+ * and `load` gives it typed; `None` clears a key back to the value before the
+ * set; a value that does not parse (a selection that is not
+ * `"<provider>:<modelId>"`, a count that is not a whole number of at least
+ * 1, an unknown effort) fails with a `SettingsError` and changes
+ * nothing, through `set` and `setRole` alike. A read-only store refuses
+ * every write with a `SettingsError` and changes nothing.
+ *
+ * The kit writes the store's shared keys (settings have no per-check ids),
+ * and restores each key it touches; do not run it against settings that are
+ * in use. A key it would touch that holds a value the store must refuse (a
+ * selection that is not `"<provider>:<modelId>"`, a count below 1, left by
+ * an older, unchecked write) could not be put back, so the check that would
+ * touch it fails before writing anything.
+ *
+ * With `options.corrupt`, a store whose backing data cannot be read fails
+ * `load` (and, writable, `setRole` and `set`) with a `SettingsError` of code
+ * `settings.corrupt` instead of reading it as defaults.
+ *
+ * @public
+ */
+export declare const settingsStoreConformance: (store: Store, options: SettingsStoreConformanceOptions) => ReadonlyArray<ConformanceCheck>;
+export {};

package/dist/settings/settings-store.conformance.js

@@ -0,0 +1,100 @@
+import { Effect, Option } from "effect";
+import { canonicalJson, harnessCodeOf, parseModelSelection } from "@xandreed/core";
+import { check, ConformanceFailure } from "@xandreed/core/conformance";
+import { randomUuid } from "@xandreed/core/internal";
+import { SETTINGS_KEYS } from "../ports/settings-store.port.js";
+const fail = (id, message) => Effect.fail(new ConformanceFailure({ check: id, message })), expect = (id, holds, message) => holds ? Effect.void : fail(id, message), ROLE_FIELDS = { general: "model", code: "codeModel", fast: "fastModel" }, ROLES = ["general", "code", "fast"], FIELDS = ["model", "codeModel", "fastModel", ...SETTINGS_KEYS], fieldOf = (settings, field) => settings[field], valueOf = (settings, field) => Option.map(fieldOf(settings, field), String), snapshot = (settings) => canonicalJson(Object.fromEntries(FIELDS.map((field) => [field, Option.getOrNull(valueOf(settings, field))]))), others = (settings, except) => canonicalJson(Object.fromEntries(FIELDS.filter((field) => field !== except).map((field) => [field, Option.getOrNull(valueOf(settings, field))]))), selection = (label) => Effect.map(randomUuid, (id) => `conformance:${label}-${id}`), SELECTIONS = new Set(["model", "codeModel", "fastModel", "fallbackModel"]), COUNTS = new Set(["maxAttempts", "budgetMillis"]), restorable = (field, value) => SELECTIONS.has(field) ? Option.isSome(parseModelSelection(value)) : COUNTS.has(field) ? Number.isInteger(Number(value)) && Number(value) >= 1 : !0, restoring = (store, id, field, write) => (body) => store.load.pipe(Effect.flatMap((before) => Option.match(Option.filter(valueOf(before, field), (value) => !restorable(field, value)), {
+  onSome: (value) => fail(id, `the store holds ${field} "${value}", which a conforming store refuses to write, so the kit could not put it back; it changed nothing. Correct the value, then run the kit`),
+  onNone: () => body.pipe(Effect.ensuring(store.load.pipe(Effect.flatMap((after) => Option.getOrNull(valueOf(after, field)) === Option.getOrNull(valueOf(before, field)) ? Effect.void : write(valueOf(before, field))), Effect.ignore({ log: "Warn", message: `the kit could not put back ${field}` }))))
+}))), restoringRole = (store, id, role) => restoring(store, id, ROLE_FIELDS[role], (value) => store.setRole(role, value)), restoringKey = (store, id, key) => restoring(store, id, key, (value) => store.set(key, value)), refused = (store, id, what, write) => Effect.gen(function* () {
+  const before = snapshot(yield* store.load), result = yield* Effect.result(write);
+  if (result._tag === "Success")
+    return yield* fail(id, `${what} was accepted`);
+  const tag = typeof result.failure === "object" && result.failure !== null && "_tag" in result.failure ? String(result.failure._tag) : "an error";
+  yield* expect(id, tag === "SettingsError", `${what} failed with ${tag}, not a SettingsError`);
+  yield* expect(id, snapshot(yield* store.load) === before, `${what} changed the settings`);
+}), CANONICAL = [
+  { key: "maxAttempts", text: "3", reads: 3 },
+  { key: "budgetMillis", text: "60000", reads: 60000 },
+  { key: "reasoningEffort", text: "high", reads: "high" }
+], CLEARED = [
+  { key: "maxAttempts", texts: ["4", "5"] },
+  { key: "budgetMillis", texts: ["1000", "2000"] },
+  { key: "reasoningEffort", texts: ["low", "medium"] }
+], BAD = [
+  { key: "fallbackModel", text: "not-a-selection" },
+  { key: "maxAttempts", text: "0" },
+  { key: "maxAttempts", text: "two" },
+  { key: "budgetMillis", text: "1.5" },
+  { key: "reasoningEffort", text: "extreme" }
+], corrupted = (what, effect) => Effect.result(effect).pipe(Effect.flatMap((result) => {
+  if (result._tag === "Success")
+    return fail("corrupt", `${what} succeeded on a store whose backing data cannot be read`);
+  const error = result.failure, tag = typeof error === "object" && error !== null && "_tag" in error ? String(error._tag) : "an error", code = Option.getOrElse(harnessCodeOf(error), () => "no code");
+  return expect("corrupt", tag === "SettingsError" && code === "settings.corrupt", `${what} failed with ${tag} (${code}), not a SettingsError of code settings.corrupt`);
+})), corruptCheck = (store, writable, corrupt) => check("a store whose backing data cannot be read fails load and every write with a SettingsError of code settings.corrupt, never reads it as defaults", "corrupt", () => {
+  const body = Effect.gen(function* () {
+    const before = snapshot(yield* store.load);
+    yield* Effect.scoped(Effect.gen(function* () {
+      yield* corrupt;
+      yield* corrupted("load", store.load);
+      yield* writable ? Effect.all([
+        selection("corrupt").pipe(Effect.flatMap((value) => corrupted("setRole", store.setRole("general", Option.some(value))))),
+        corrupted("set", store.set("maxAttempts", Option.some("3")))
+      ], { concurrency: 1, discard: !0 }) : Effect.void;
+    }));
+    yield* expect("corrupt", snapshot(yield* store.load) === before, "once the backing data is repaired, the store does not read what it held before");
+  });
+  return writable ? body.pipe(restoringRole(store, "corrupt", "general"), restoringKey(store, "corrupt", "maxAttempts")) : body;
+});
+export const settingsStoreConformance = (store, options) => [
+  check("load is stable: two loads with no write between them agree", "load", () => Effect.gen(function* () {
+    const first = snapshot(yield* store.load);
+    yield* expect("load", snapshot(yield* store.load) === first, "two loads disagree");
+  })),
+  ...options.writable ? writableChecks(store) : readOnlyChecks(store),
+  ...Option.match(Option.fromNullishOr(options.corrupt), { onNone: () => [], onSome: (corrupt) => [corruptCheck(store, options.writable, corrupt)] })
+];
+const writableChecks = (store) => [
+  check("each role reads back what setRole wrote, and clearing it returns the value before the set", "role", () => Effect.forEach(ROLES, (role) => Effect.gen(function* () {
+    const field = ROLE_FIELDS[role];
+    yield* store.setRole(role, Option.none());
+    const base = yield* store.load, value = yield* selection(role);
+    yield* store.setRole(role, Option.some(value));
+    const set = yield* store.load;
+    yield* expect("role", Option.getOrUndefined(valueOf(set, field)) === value, `the ${role} role reads ${Option.getOrElse(valueOf(set, field), () => "nothing")}, not what was set`);
+    yield* expect("role", others(set, field) === others(base, field), `setting the ${role} role changed another value`);
+    yield* store.setRole(role, Option.none());
+    yield* expect("role", snapshot(yield* store.load) === snapshot(base), `clearing the ${role} role did not return the value before the set`);
+  }).pipe(restoringRole(store, "role", role)), { concurrency: 1, discard: !0 })),
+  check("set accepts each key's canonical string form and load reads it back typed", "values", () => selection("fallback").pipe(Effect.flatMap((fallback) => Effect.forEach([
+    ...CANONICAL,
+    { key: "fallbackModel", text: fallback, reads: void 0 }
+  ], ({ key, text, reads }) => Effect.gen(function* () {
+    const before = yield* store.load;
+    yield* store.set(key, Option.some(text));
+    const after = yield* store.load, expected = reads ?? text, read = Option.getOrNull(fieldOf(after, key));
+    yield* expect("values", read === expected, `${key} "${text}" reads back as ${JSON.stringify(read)}`);
+    yield* expect("values", others(after, key) === others(before, key), `setting ${key} changed another value`);
+  }).pipe(restoringKey(store, "values", key)), { concurrency: 1, discard: !0 })))),
+  check("None clears a key back to the value before the set", "clear", () => Effect.forEach(CLEARED, ({ key, texts }) => Effect.gen(function* () {
+    yield* store.set(key, Option.none());
+    const base = yield* store.load, text = texts.find((candidate) => Option.getOrNull(valueOf(base, key)) !== candidate) ?? texts[0];
+    yield* store.set(key, Option.some(text));
+    yield* store.set(key, Option.none());
+    yield* expect("clear", snapshot(yield* store.load) === snapshot(base), `clearing ${key} did not return the value before the set`);
+  }).pipe(restoringKey(store, "clear", key)), { concurrency: 1, discard: !0 })),
+  check("set refuses a value that does not parse with a SettingsError and changes nothing", "bad-values", () => Effect.forEach(BAD, ({ key, text }) => refused(store, "bad-values", `${key} "${text}"`, store.set(key, Option.some(text))).pipe(restoringKey(store, "bad-values", key)), { concurrency: 1, discard: !0 })),
+  check('setRole refuses a selection that is not "<provider>:<modelId>" with a SettingsError and changes nothing', "bad-role", () => Effect.forEach(ROLES, (role) => Effect.forEach(["not-a-selection", ":model", "provider:"], (text) => refused(store, "bad-role", `the ${role} role "${text}"`, store.setRole(role, Option.some(text))), { concurrency: 1, discard: !0 }).pipe(restoringRole(store, "bad-role", role)), { concurrency: 1, discard: !0 }))
+], readOnlyChecks = (store) => [
+  check("a read-only store refuses every write with a SettingsError and changes nothing", "read-only", () => Effect.gen(function* () {
+    yield* Effect.forEach(ROLES, (role) => Effect.all([
+      selection(role).pipe(Effect.flatMap((value) => refused(store, "read-only", `setRole ${role}`, store.setRole(role, Option.some(value))))),
+      refused(store, "read-only", `clearing the ${role} role`, store.setRole(role, Option.none()))
+    ], { concurrency: 1 }), { concurrency: 1, discard: !0 });
+    yield* Effect.forEach(CANONICAL, ({ key, text }) => Effect.all([
+      refused(store, "read-only", `set ${key}`, store.set(key, Option.some(text))),
+      refused(store, "read-only", `clearing ${key}`, store.set(key, Option.none()))
+    ], { concurrency: 1 }), { concurrency: 1, discard: !0 });
+  }))
+];

package/dist/settings/settings-value.entity.d.ts

@@ -0,0 +1,15 @@
+import { Schema } from "effect";
+/**
+ * A settings value as a config file holds it: a selection or other text, a switch, a count.
+ *
+ * @public
+ */
+export declare const SettingValue: Schema.Union<readonly [Schema.String, Schema.Boolean, Schema.Number]>;
+export type SettingValue = typeof SettingValue.Type;
+/**
+ * The settings field each model role is kept under.
+ *
+ * @public
+ */
+export declare const RoleField: Schema.Literals<readonly ["model", "codeModel", "fastModel"]>;
+export type RoleField = typeof RoleField.Type;

package/dist/settings/settings-value.entity.functions.d.ts

@@ -0,0 +1,51 @@
+import { Effect, Option } from "effect";
+import { EngineSettings, SettingsError } from "../ports/settings-store.port.js";
+import type { ModelRole, SettingsKey } from "../ports/settings-store.port.js";
+import type { RoleField, SettingValue } from "./settings-value.entity.js";
+/**
+ * The settings vocabulary every SettingsStore of this package shares: how a
+ * config record reads as `EngineSettings`, how a value's string form (what
+ * `set` receives: "true", "3", "provider:model") is checked and coerced, and
+ * how one key or role changes a settings value.
+ */
+/**
+ * The field each model role is kept under.
+ *
+ * @public
+ */
+export declare const ROLE_FIELDS: Readonly<Record<ModelRole, RoleField>>;
+/**
+ * Settings from a config record: values of the wrong type read as unset, keys it does not name are not read; the legacy `openAiReasoningEffort` key backs `reasoningEffort`.
+ *
+ * @public
+ */
+export declare const settingsFromRecord: (record: Readonly<Record<string, unknown>>) => EngineSettings;
+/** Settings as a config record: the set fields only. */
+export declare const recordOfSettings: (settings: EngineSettings) => Readonly<Record<string, SettingValue>>;
+/**
+ * One key's value from its string form, checked: a selection must be
+ * `"<provider>:<modelId>"`, an effort one the models accept, a count a
+ * positive integer. A value that does not parse is
+ * refused, not written and then ignored on load.
+ *
+ * @public
+ */
+export declare const coerceSettingValue: (key: SettingsKey, raw: string) => Effect.Effect<SettingValue, SettingsError>;
+/**
+ * A role's selection, checked: `None` clears the role; a value must be `"<provider>:<modelId>"`.
+ *
+ * @public
+ */
+export declare const roleSelection: (role: ModelRole, selection: Option.Option<string>) => Effect.Effect<Option.Option<string>, SettingsError>;
+/**
+ * `settings` with one key set from its string form (checked, as `set` takes it), or cleared with `None`.
+ *
+ * @public
+ */
+export declare const applySetting: (settings: EngineSettings, key: SettingsKey, value: Option.Option<string>) => Effect.Effect<EngineSettings, SettingsError>;
+/**
+ * `settings` with one role's selection set (checked, as `setRole` takes it), or cleared with `None`.
+ *
+ * @public
+ */
+export declare const applyRole: (settings: EngineSettings, role: ModelRole, selection: Option.Option<string>) => Effect.Effect<EngineSettings, SettingsError>;

package/dist/settings/settings-value.entity.functions.js

@@ -0,0 +1,42 @@
+import { Effect, Match, Option, Schema } from "effect";
+import { parseModelSelection, ReasoningEffort } from "@xandreed/core";
+import { EngineSettings, SETTINGS_KEYS, SettingsError } from "../ports/settings-store.port.js";
+export const ROLE_FIELDS = {
+  general: "model",
+  code: "codeModel",
+  fast: "fastModel"
+};
+const FIELDS = ["model", "codeModel", "fastModel", ...SETTINGS_KEYS], asString = Schema.decodeUnknownOption(Schema.NonEmptyString), asNumber = Schema.decodeUnknownOption(Schema.Finite), asReasoningEffort = Schema.decodeUnknownOption(ReasoningEffort);
+export const settingsFromRecord = (record) => new EngineSettings({
+  model: asString(record.model),
+  codeModel: asString(record.codeModel),
+  fastModel: asString(record.fastModel),
+  fallbackModel: asString(record.fallbackModel),
+  maxAttempts: asNumber(record.maxAttempts),
+  budgetMillis: asNumber(record.budgetMillis),
+  reasoningEffort: Option.orElse(asReasoningEffort(record.reasoningEffort), () => asReasoningEffort(record.openAiReasoningEffort)),
+  codeReasoningEffort: asReasoningEffort(record.codeReasoningEffort),
+  fastReasoningEffort: asReasoningEffort(record.fastReasoningEffort)
+}), recordOfSettings = (settings) => Object.fromEntries(FIELDS.flatMap((field) => Option.match(fieldOf(settings, field), {
+  onNone: () => [],
+  onSome: (value) => [[field, value]]
+})));
+const fieldOf = (settings, field) => settings[field], refuse = (message) => Effect.fail(new SettingsError({ message }));
+export const coerceSettingValue = (key, raw) => Match.value(key).pipe(Match.when("fallbackModel", () => Option.match(parseModelSelection(raw), {
+  onNone: () => refuse(`fallbackModel must be "<provider>:<modelId>" \u2014 got "${raw}"`),
+  onSome: () => Effect.succeed(raw)
+})), Match.whenOr("reasoningEffort", "codeReasoningEffort", "fastReasoningEffort", (effort) => Option.match(asReasoningEffort(raw), {
+  onNone: () => refuse(`${effort} is not supported: "${raw}"`),
+  onSome: (value) => Effect.succeed(value)
+})), Match.whenOr("maxAttempts", "budgetMillis", (count) => Number.isInteger(Number(raw)) && Number(raw) >= 1 ? Effect.succeed(Number(raw)) : refuse(`${count} must be a positive integer \u2014 got "${raw}"`)), Match.exhaustive), roleSelection = (role, selection) => Option.match(selection, {
+  onNone: () => Effect.succeed(Option.none()),
+  onSome: (raw) => Option.isSome(parseModelSelection(raw)) ? Effect.succeed(Option.some(raw)) : refuse(`the ${role} model must be "<provider>:<modelId>" \u2014 got "${raw}"`)
+});
+const withField = (settings, field, value) => {
+  const others = Object.fromEntries(Object.entries(recordOfSettings(settings)).filter(([key]) => key !== field));
+  return settingsFromRecord(Option.match(value, { onNone: () => others, onSome: (set) => ({ ...others, [field]: set }) }));
+};
+export const applySetting = (settings, key, value) => Option.match(value, {
+  onNone: () => Effect.succeed(withField(settings, key, Option.none())),
+  onSome: (raw) => coerceSettingValue(key, raw).pipe(Effect.map((coerced) => withField(settings, key, Option.some(coerced))))
+}), applyRole = (settings, role, selection) => roleSelection(role, selection).pipe(Effect.map((checked) => withField(settings, ROLE_FIELDS[role], checked)));

package/dist/settings/settings-value.entity.js

@@ -0,0 +1,2 @@
+import { Schema } from "effect";
+export const SettingValue = Schema.Union([Schema.String, Schema.Boolean, Schema.Number]), RoleField = Schema.Literals(["model", "codeModel", "fastModel"]);

package/dist/storage/json-file.d.ts

@@ -0,0 +1,18 @@
+import { Effect, Option, Schema, Semaphore } from "effect";
+/**
+ * Read the JSON object in `path`: `None` when no file is there. A file that
+ * cannot be read (any error but ENOENT: permissions, a directory) or does
+ * not hold a JSON object fails with `unusable(reason)`.
+ */
+export declare const readJsonObject: <E>(path: string, unusable: (reason: string) => E) => Effect.Effect<Option.Option<Schema.JsonObject>, E>;
+/**
+ * Replace `path` with `value`: written to a temp file of its own beside it
+ * (named by the process and a random number, so concurrent writes never
+ * share one), given `mode` when there is one, then renamed over. A failed
+ * write removes its temp file.
+ */
+export declare const writeJsonObject: <E>(path: string, value: Record<string, unknown>, mode: Option.Option<number>, failed: (reason: string) => E) => Effect.Effect<void, E>;
+/** A lock of its own for `name` at `path` (one refresh of a provider's token kept there, say). */
+export declare const namedLock: (path: string, name: string) => Effect.Effect<Semaphore.Semaphore>;
+/** Run `effect` holding the lock of `path`, which every store in the process that writes the file shares. */
+export declare const withFileLock: (path: string) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;

package/dist/storage/json-file.js

@@ -0,0 +1,26 @@
+import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { Effect, Option, Random, Schema, Semaphore } from "effect";
+import { errorCodeOf } from "@xandreed/core";
+const decodeJsonObject = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.JsonObject)), isMissing = (cause) => Option.contains(errorCodeOf(cause), "ENOENT");
+export const readJsonObject = (path, unusable) => Effect.tryPromise({ try: () => readFile(path, "utf-8"), catch: (cause) => cause }).pipe(Effect.map(Option.some), Effect.catchIf(isMissing, () => Effect.succeed(Option.none())), Effect.mapError((cause) => unusable(`could not be read (${Option.getOrElse(errorCodeOf(cause), () => String(cause))})`)), Effect.flatMap(Option.match({
+  onNone: () => Effect.succeed(Option.none()),
+  onSome: (text) => decodeJsonObject(text).pipe(Effect.map(Option.some), Effect.mapError(() => unusable("does not hold a JSON object")))
+}))), writeJsonObject = (path, value, mode, failed) => Random.nextIntBetween(0, Number.MAX_SAFE_INTEGER).pipe(Effect.flatMap((suffix) => {
+  const tmp = `${path}.tmp-${process.pid}-${suffix.toString(36)}`;
+  return Effect.tryPromise({
+    try: async () => {
+      await mkdir(dirname(path), { recursive: !0 });
+      await writeFile(tmp, JSON.stringify(value, null, 2), "utf-8");
+      await Option.match(mode, { onNone: () => Promise.resolve(), onSome: (bits) => chmod(tmp, bits) });
+      await rename(tmp, path);
+    },
+    catch: (cause) => failed(String(cause))
+  }).pipe(Effect.tapError(() => Effect.tryPromise({ try: () => rm(tmp, { force: !0 }), catch: (cause) => cause }).pipe(Effect.catch((cause) => Effect.logWarning(`could not remove the temporary file ${tmp}`, cause)))));
+}));
+const locks = new Map, lockOf = (key) => Effect.sync(() => Option.getOrElse(Option.fromNullishOr(locks.get(key)), () => {
+  const made = Semaphore.makeUnsafe(1);
+  locks.set(key, made);
+  return made;
+}));
+export const namedLock = (path, name) => lockOf(`${name}:${resolve(path)}`), withFileLock = (path) => (effect) => Effect.flatMap(namedLock(path, "file"), (lock) => lock.withPermit(effect));

package/dist/transport/http-proxy.entity.d.ts

@@ -0,0 +1,104 @@
+import { Schema } from "effect";
+/**
+ * A proxy URL as an option takes it: a string, or a `Redacted` one when it carries credentials.
+ *
+ * @public
+ */
+export declare const ProxyUrlOption: Schema.Union<readonly [Schema.String, Schema.Redacted<Schema.String>]>;
+export type ProxyUrlOption = typeof ProxyUrlOption.Type;
+/**
+ * The proxy a host gives the models plugin, as its `proxy` and `noProxy`
+ * options. `proxy` is one URL for every model and OAuth call (`http://` or
+ * `https://`; a value without a scheme reads as `http://`); it may carry
+ * credentials (`http://user:pass@proxy:8080`), so a host's code can pass it
+ * `Redacted`. Empty or absent, the environment's `https_proxy` /
+ * `HTTPS_PROXY` and `http_proxy` / `HTTP_PROXY` apply. `noProxy` lists the
+ * hosts that go direct, in NO_PROXY syntax, added to the environment's
+ * `no_proxy` / `NO_PROXY`; `"*"` turns the proxy off.
+ *
+ * @public
+ */
+export declare const HttpProxyOptions: Schema.Struct<{
+    readonly proxy: Schema.optionalKey<Schema.Union<readonly [Schema.String, Schema.Redacted<Schema.String>]>>;
+    readonly noProxy: Schema.optionalKey<Schema.String>;
+}>;
+export type HttpProxyOptions = typeof HttpProxyOptions.Type;
+/**
+ * The proxy variables of the environment, as read (an empty value counts as
+ * unset). Lower case is read before upper case, as undici (Node's
+ * environment proxy) and curl read them. `ALL_PROXY` is not read: SOCKS
+ * proxies are not supported.
+ */
+export declare const ProxyEnvironment: Schema.Struct<{
+    readonly https_proxy: Schema.optionalKey<Schema.String>;
+    readonly HTTPS_PROXY: Schema.optionalKey<Schema.String>;
+    readonly http_proxy: Schema.optionalKey<Schema.String>;
+    readonly HTTP_PROXY: Schema.optionalKey<Schema.String>;
+    readonly no_proxy: Schema.optionalKey<Schema.String>;
+    readonly NO_PROXY: Schema.optionalKey<Schema.String>;
+}>;
+export type ProxyEnvironment = typeof ProxyEnvironment.Type;
+/** The environment variables a `ProxyEnvironment` is read from. */
+export declare const PROXY_VARIABLES: readonly ["https_proxy", "HTTPS_PROXY", "http_proxy", "HTTP_PROXY", "no_proxy", "NO_PROXY"];
+/**
+ * One NO_PROXY entry: every host (`*`); a host name and its subdomains
+ * (`example.com`, `.example.com` and `*.example.com` alike); or an IP
+ * address, exact (`10.1.2.3`, `::1`, `[::1]`) or a range (`10.0.0.0/8`,
+ * `fd00::/8`, as `prefix` leading bits). A name or an exact address may
+ * carry a port (`example.com:8443`, `[::1]:8080`), which then must match.
+ */
+export declare const NoProxyRule: Schema.Union<readonly [Schema.TaggedStruct<"Everything", {}>, Schema.TaggedStruct<"Domain", {
+    readonly name: Schema.String;
+    readonly port: Schema.Option<Schema.Int>;
+}>, Schema.TaggedStruct<"Address", {
+    readonly bytes: Schema.$Array<Schema.Int>;
+    readonly prefix: Schema.Int;
+    readonly port: Schema.Option<Schema.Int>;
+}>]>;
+export type NoProxyRule = typeof NoProxyRule.Type;
+declare const ProxyConfig_base: Schema.Class<ProxyConfig, Schema.Struct<{
+    readonly https: Schema.Option<Schema.Redacted<Schema.String>>;
+    readonly http: Schema.Option<Schema.Redacted<Schema.String>>;
+    readonly noProxy: Schema.$Array<Schema.Union<readonly [Schema.TaggedStruct<"Everything", {}>, Schema.TaggedStruct<"Domain", {
+        readonly name: Schema.String;
+        readonly port: Schema.Option<Schema.Int>;
+    }>, Schema.TaggedStruct<"Address", {
+        readonly bytes: Schema.$Array<Schema.Int>;
+        readonly prefix: Schema.Int;
+        readonly port: Schema.Option<Schema.Int>;
+    }>]>>;
+}>, {}>;
+/**
+ * A resolved proxy setting: the proxy for `https:` (and `wss:`) targets,
+ * the one for `http:` (and `ws:`) targets, and the hosts that go direct.
+ * Proxy URLs stay `Redacted`, so a printed setting never shows credentials.
+ * Loopback hosts always go direct.
+ */
+export declare class ProxyConfig extends ProxyConfig_base {
+}
+declare const ProxyInvalid_base: Schema.Class<ProxyInvalid, Schema.TaggedStruct<"ProxyInvalid", {
+    readonly source: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A proxy URL that cannot be used: not a URL, or not `http://` / `https://`. `source` names where it came from.
+ *
+ * @public
+ */
+export declare class ProxyInvalid extends ProxyInvalid_base {
+}
+declare const ProxyUnsupported_base: Schema.Class<ProxyUnsupported, Schema.TaggedStruct<"ProxyUnsupported", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A proxy applies, but this runtime cannot send the call through it: the call is refused rather than sent direct.
+ *
+ * @public
+ */
+export declare class ProxyUnsupported extends ProxyUnsupported_base {
+}
+/** The first Bun whose native `WebSocket` sends through its `proxy` option (1.3.0 to 1.3.5 connect directly). */
+export declare const BUN_WEBSOCKET_PROXY_VERSION = "1.3.6";
+/** The first Node whose `https.Agent` tunnels through its `proxyEnv` option (earlier ones connect directly). */
+export declare const NODE_WEBSOCKET_PROXY_VERSION = "24.5.0";
+export {};

package/dist/transport/http-proxy.entity.functions.d.ts

@@ -0,0 +1,51 @@
+import { Option, Redacted, Result } from "effect";
+import { ProxyConfig, ProxyInvalid } from "./http-proxy.entity.js";
+import type { HttpProxyOptions, NoProxyRule, ProxyEnvironment } from "./http-proxy.entity.js";
+/**
+ * Credentials in the URLs of `text` (`scheme://user:pass@host`) replaced by
+ * `<redacted>`, for error messages that may quote a proxy URL.
+ */
+export declare const redactCredentials: (text: string) => string;
+/** A proxy URL as a message may show it: its scheme and host, its credentials (if any) as `<redacted>`. */
+export declare const displayProxy: (url: Redacted.Redacted<string>) => string;
+/**
+ * One proxy URL, checked: `None` when blank; a value without a scheme
+ * (`proxy.corp:8080`) reads as `http://`; anything that is not an `http://`
+ * or `https://` URL with a host fails with `ProxyInvalid` naming `source`,
+ * credentials redacted.
+ */
+export declare const proxyUrl: (raw: string, source: string) => Result.Result<Option.Option<Redacted.Redacted<string>>, ProxyInvalid>;
+/** The IPv4 address `text` spells, as its 4 bytes. */
+export declare const parseIpv4: (text: string) => Option.Option<ReadonlyArray<number>>;
+/** The IPv6 address `text` spells (brackets and a zone id allowed), as its 16 bytes. */
+export declare const parseIpv6: (text: string) => Option.Option<ReadonlyArray<number>>;
+/** A host is loopback: `localhost` (and its subdomains), `127.0.0.0/8`, `::1`, or IPv4 loopback mapped into IPv6. */
+export declare const isLoopback: (hostname: string) => boolean;
+/** A NO_PROXY value (entries separated by commas or white space), parsed. */
+export declare const parseNoProxy: (value: string) => ReadonlyArray<NoProxyRule>;
+/** Whether a NO_PROXY rule sends `target` direct. */
+export declare const bypassesProxy: (rules: ReadonlyArray<NoProxyRule>, target: URL) => boolean;
+/**
+ * The proxy settings of the models plugin's options over the environment's:
+ * an explicit `proxy` serves every target; otherwise `https_proxy` (then
+ * `HTTPS_PROXY`) serves `https:` targets, `http_proxy` (then `HTTP_PROXY`)
+ * `http:` ones, and an `https:` target falls back to the `http:` proxy, as
+ * undici's environment proxy (Node's, under `NODE_USE_ENV_PROXY`) does. The
+ * direct hosts are `no_proxy` (then `NO_PROXY`) and the `noProxy` option
+ * together; with `*` among them the environment's proxy variables are not
+ * read at all. Lower case comes first, as undici and curl read them. A proxy
+ * URL that cannot be used fails with `ProxyInvalid`.
+ */
+export declare const resolveProxy: (options: HttpProxyOptions, env: ProxyEnvironment) => Result.Result<ProxyConfig, ProxyInvalid>;
+/** Whether any target can go through a proxy. */
+export declare const usesProxy: (config: ProxyConfig) => boolean;
+/** Whether the setting turns the proxy off for every host (`*` in `noProxy` or `NO_PROXY`). */
+export declare const turnsProxyOff: (config: ProxyConfig) => boolean;
+/**
+ * The proxy a request to `target` goes through, or `None` for direct:
+ * loopback hosts and the `noProxy` hosts go direct; `https:` and `wss:`
+ * targets use the https proxy, `http:` and `ws:` ones the http proxy.
+ */
+export declare const proxyFor: (target: URL, config: ProxyConfig) => Option.Option<Redacted.Redacted<string>>;
+/** Whether a runtime `version` (`24.16.0`, `1.3.6`) is at least `minimum`; an unreadable one is not. */
+export declare const atLeastVersion: (version: string, minimum: string) => boolean;