@xandreed/plugin-models 0.3.0

package/dist/plugin.adapter.js

@@ -0,0 +1,27 @@
+import { homedir } from "node:os";
+import { LanguageModel } from "@effect/ai";
+import { Effect, Layer, Option, Schema } from "effect";
+import { AuthStore, definePlugin, EngineSettings, ModelCatalog, SessionEnvironment, SettingsError, SettingsStore, UtilityLlm } from "@xandreed/core";
+import { LocalAuthStoreLive } from "./auth/localAuth.js";
+import { LanguageModelLive } from "./llm/router.js";
+import { UtilityLlmLive } from "./llm/utilityLlm.js";
+import { ConfiguredModelCatalogLive } from "./llm/modelCatalog.js";
+import { LocalSettingsStoreLive } from "./settings/localSettings.js";
+const Config = Schema.Struct({ model: Schema.String, fastModel: Schema.String, fallbackModel: Schema.String, inheritPrevious: Schema.Boolean });
+export const modelsPlugin = definePlugin({
+  id: "@xandreed/plugin-models",
+  version: "0.3.0",
+  config: Config,
+  defaults: { model: "", fastModel: "", fallbackModel: "", inheritPrevious: !0 },
+  requires: [SessionEnvironment],
+  provides: [LanguageModel.LanguageModel, UtilityLlm, AuthStore, SettingsStore, ModelCatalog],
+  layer: (config) => Layer.unwrapEffect(Effect.gen(function* () {
+    const { workspace } = yield* SessionEnvironment, previous = config.inheritPrevious ? yield* SettingsStore.pipe(Effect.flatMap((settings) => settings.load), Effect.provide(LocalSettingsStoreLive(workspace, homedir()))) : new EngineSettings({}), optional = (value) => value.length === 0 ? Option.none() : Option.some(value), settings = Layer.succeed(SettingsStore, {
+      load: Effect.succeed(new EngineSettings({ ...previous, model: Option.orElse(optional(config.model), () => previous.model), fastModel: Option.orElse(optional(config.fastModel), () => previous.fastModel), fallbackModel: Option.orElse(optional(config.fallbackModel), () => previous.fallbackModel) })),
+      setRole: () => Effect.fail(new SettingsError({ message: "Edit the models plugin configuration to change a model" })),
+      set: () => Effect.fail(new SettingsError({ message: "Edit the models plugin configuration to change settings" }))
+    }), base = Layer.merge(settings, LocalAuthStoreLive(workspace, homedir(), ".efferent/runtime", config.inheritPrevious ? ".efferent" : void 0));
+    return Layer.mergeAll(LanguageModelLive, UtilityLlmLive, ConfiguredModelCatalogLive).pipe(Layer.provideMerge(base));
+  }))
+});
+export default modelsPlugin;

package/dist/plugin.adapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/settings/localSettings.d.ts

@@ -0,0 +1,3 @@
+import { Layer } from "effect";
+import { SettingsStore } from "@xandreed/core";
+export declare const LocalSettingsStoreLive: (cwd: string, home: string) => Layer.Layer<SettingsStore, never, never>;

package/dist/settings/localSettings.js

@@ -0,0 +1,72 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { Effect, Layer, Option } from "effect";
+import { asJsonRecord, EngineSettings, parseJsonWarn, parseModelSelection, SettingsError, SettingsStore } from "@xandreed/core";
+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)
+    });
+  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);
+});
+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),
+  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/localSettings.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/settings/roleView.d.ts

@@ -0,0 +1,11 @@
+import { Layer } from "effect";
+import { SettingsStore } from "@xandreed/core";
+/**
+ * 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
+ * unset), so any consumer that routes on `settings.model` — the
+ * 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.
+ */
+export declare const roleModelView: (role: "code" | "fast") => Layer.Layer<SettingsStore, never, SettingsStore>;

package/dist/settings/roleView.js

@@ -0,0 +1,11 @@
+import { Effect, Layer, Option } from "effect";
+import { EngineSettings, SettingsStore } from "@xandreed/core";
+export const roleModelView = (role) => Layer.effect(SettingsStore, Effect.map(SettingsStore, (inner) => ({
+  load: Effect.map(inner.load, (s) => new EngineSettings({
+    ...s,
+    model: Option.orElse(role === "code" ? s.codeModel : s.fastModel, () => s.model),
+    reasoningEffort: Option.orElse(role === "code" ? s.codeReasoningEffort : s.fastReasoningEffort, () => s.reasoningEffort)
+  })),
+  setRole: inner.setRole,
+  set: inner.set
+})));

package/dist/settings/roleView.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@xandreed/plugin-models",
+  "version": "0.3.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./compat": {
+      "types": "./dist/llm/compat.d.ts",
+      "default": "./dist/llm/compat.js"
+    }
+  },
+  "dependencies": {
+    "@xandreed/core": "0.3.0",
+    "effect": "3.21.4",
+    "@effect/ai": "0.35.0",
+    "@effect/ai-anthropic": "^0.25.0",
+    "@effect/ai-google": "^0.14.0",
+    "@effect/ai-openai": "^0.39.2",
+    "@effect/platform": "0.96.1",
+    "ws": "^8.21.0"
+  },
+  "private": false,
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "skills",
+    "profiles",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "license": "MIT"
+}