@frockbot/plugin-custom-models 0.0.0 → 0.3.12

package/src/client/ProviderPackageSettings.vue

@@ -0,0 +1,188 @@
+<script setup lang="ts">
+import { UiButton } from "@frockbot/client-ui";
+import type {
+  PackageSettingDefinition,
+  PackageSettingSchema,
+} from "@frockbot/kernel-composition";
+import {
+  frockBotWebDataKey,
+  type PluginCatalogItem,
+} from "@frockbot/plugin-shell/shared";
+import { computed, inject, ref, watch } from "vue";
+
+const props = defineProps<{ item: PluginCatalogItem }>();
+
+const providedWeb = inject(frockBotWebDataKey);
+if (!providedWeb) throw new Error("shell client data was not provided");
+const web = providedWeb;
+
+type FieldKind = "enum" | "boolean" | "number" | "text";
+type DraftValue = string | number | boolean;
+
+function fieldKind(schema: PackageSettingSchema): FieldKind {
+  if (schema.enum && schema.enum.length > 0) return "enum";
+  if (schema.type === "boolean") return "boolean";
+  if (schema.type === "number" || schema.type === "integer") return "number";
+  return "text";
+}
+
+function label(definition: PackageSettingDefinition): string {
+  return definition.schema.title ?? definition.id;
+}
+
+const definitions = computed(() =>
+  (props.item.settings ?? []).filter(
+    (definition) =>
+      definition.role !== "model" && definition.scopes.includes("user"),
+  ),
+);
+const stored = computed<Record<string, unknown>>(() => {
+  const installation = web.value.userSettings?.packages.find(
+    (candidate) => candidate.packageId === props.item.packageId,
+  );
+  return (installation?.values ?? {}) as Record<string, unknown>;
+});
+const draft = ref<Record<string, DraftValue>>({});
+
+watch(
+  [definitions, stored],
+  () => {
+    draft.value = Object.fromEntries(
+      definitions.value.map((definition) => {
+        const value = stored.value[definition.id];
+        if (
+          typeof value === "string" ||
+          typeof value === "number" ||
+          typeof value === "boolean"
+        ) {
+          return [definition.id, value];
+        }
+        return [
+          definition.id,
+          fieldKind(definition.schema) === "boolean" ? false : "",
+        ];
+      }),
+    );
+  },
+  { immediate: true },
+);
+
+function values(): Record<string, DraftValue> {
+  const result: Record<string, DraftValue> = {};
+  for (const definition of definitions.value) {
+    const kind = fieldKind(definition.schema);
+    const value = draft.value[definition.id];
+    if (kind === "boolean") {
+      result[definition.id] = value === true;
+    } else if (value !== "" && value !== undefined) {
+      const normalized = kind === "number" ? Number(value) : String(value);
+      if (typeof normalized !== "number" || Number.isFinite(normalized)) {
+        result[definition.id] = normalized;
+      }
+    }
+  }
+  return result;
+}
+
+async function save(): Promise<void> {
+  const patch = values();
+  if (Object.keys(patch).length === 0) return;
+  try {
+    await web.value.savePackageSettings(props.item.packageId, patch);
+  } catch (error) {
+    web.value.settingsError =
+      error instanceof Error
+        ? error.message
+        : "Could not save the provider settings";
+  }
+}
+</script>
+
+<template>
+  <form
+    v-if="definitions.length > 0"
+    class="provider-settings"
+    @submit.prevent="save"
+  >
+    <label v-for="definition in definitions" :key="definition.id">
+      <span>{{ label(definition) }}</span>
+      <select
+        v-if="fieldKind(definition.schema) === 'enum'"
+        v-model="draft[definition.id]"
+      >
+        <option value="">Default</option>
+        <option
+          v-for="choice in definition.schema.enum ?? []"
+          :key="String(choice)"
+          :value="choice ?? ''"
+        >
+          {{ String(choice) }}
+        </option>
+      </select>
+      <input
+        v-else-if="fieldKind(definition.schema) === 'boolean'"
+        v-model="draft[definition.id]"
+        type="checkbox"
+      />
+      <input
+        v-else-if="fieldKind(definition.schema) === 'number'"
+        v-model="draft[definition.id]"
+        type="number"
+        inputmode="numeric"
+        :min="definition.schema.minimum"
+        :max="definition.schema.maximum"
+        :step="definition.schema.type === 'integer' ? 1 : 'any'"
+      />
+      <input
+        v-else
+        v-model="draft[definition.id]"
+        type="text"
+        :maxlength="definition.schema.maxLength"
+      />
+      <small v-if="definition.schema.description">
+        {{ definition.schema.description }}
+      </small>
+    </label>
+    <div class="provider-settings__actions">
+      <UiButton type="submit" variant="primary">Save settings</UiButton>
+    </div>
+  </form>
+</template>
+
+<style scoped>
+.provider-settings {
+  display: grid;
+  gap: 12px;
+  margin: 0 8px;
+  padding: 12px 0 8px;
+  border-top: 1px solid var(--frock-border);
+}
+
+.provider-settings label {
+  display: grid;
+  gap: 6px;
+}
+
+.provider-settings span,
+.provider-settings small {
+  color: var(--frock-text-muted);
+  font-size: var(--frock-text-sm);
+}
+
+.provider-settings input,
+.provider-settings select {
+  min-width: 0;
+  padding: 8px 11px;
+  border: 1px solid var(--frock-border);
+  border-radius: var(--frock-radius-control);
+  background: var(--frock-surface-raised);
+  color: var(--frock-text);
+  font-size: var(--frock-text-base);
+}
+
+.provider-settings__actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+}
+</style>

package/src/client/index.test.ts

@@ -0,0 +1,182 @@
+import { describe, expect, test } from "bun:test";
+import type {
+  ClientPluginContext,
+  ClientSlotRegistration,
+} from "@frockbot/client-core";
+import {
+  decodeConfigurationCommandV1,
+  initializeBotSettingsV1,
+  type ConfigurationCommandV1,
+  type ModelBindingV1,
+  type UserSettingsViewV1,
+} from "@frockbot/configuration-core";
+import {
+  frockBotWebDataKey,
+  type FrockBotWebData,
+} from "@frockbot/plugin-shell/shared";
+import { ref, type Ref } from "vue";
+import {
+  customModelsClientPlugin,
+  customModelsClientStateKey,
+  type CustomModelsClientState,
+} from "./index.js";
+
+function fixture(accountModel?: ModelBindingV1): {
+  slots: ClientSlotRegistration[];
+  commands: ConfigurationCommandV1[];
+  state: CustomModelsClientState;
+  userLoads(): number;
+  botLoads(): number;
+  dispose(): void;
+} {
+  const slots: ClientSlotRegistration[] = [];
+  const commands: ConfigurationCommandV1[] = [];
+  const user: UserSettingsViewV1 = {
+    schemaVersion: 1,
+    revision: 3,
+    profile: { name: "User" },
+    packages: [
+      {
+        packageId: "custom-models",
+        version: "0.0.1",
+        state: "installed",
+        ...(accountModel ? { values: { "account-model": accountModel } } : {}),
+      },
+    ],
+    connections: [],
+  };
+  const bot = initializeBotSettingsV1("scout");
+  let userLoadCount = 0;
+  let botLoadCount = 0;
+  const web = ref({
+    activeBotId: bot.botId,
+    botSettings: bot,
+    userSettings: user,
+    loadUserSettings: () => {
+      userLoadCount += 1;
+      return Promise.resolve();
+    },
+    loadBotSettings: () => {
+      botLoadCount += 1;
+      return Promise.resolve();
+    },
+  }) as unknown as Ref<FrockBotWebData>;
+  let state: CustomModelsClientState | undefined;
+  const context: ClientPluginContext = {
+    transport: {
+      turn: () => Promise.resolve({ runId: "run", text: "", events: [] }),
+      executeConfiguration: (input) => {
+        const command = decodeConfigurationCommandV1(input);
+        commands.push(command);
+        return Promise.resolve({
+          schemaVersion: 1,
+          commandId: command.commandId,
+          revision: command.expectedRevision + 1,
+          status: "applied",
+        });
+      },
+    },
+    inject: ((key: unknown) => {
+      if (key === frockBotWebDataKey) return web;
+      throw new Error("unexpected client provider");
+    }) as ClientPluginContext["inject"],
+    provide: ((key: unknown, value: unknown) => {
+      if (key === customModelsClientStateKey) {
+        state = value as CustomModelsClientState;
+      }
+      return () => {};
+    }) as ClientPluginContext["provide"],
+    slot: (registration) => {
+      slots.push(registration);
+      return () => slots.splice(slots.indexOf(registration), 1);
+    },
+  };
+  const result = customModelsClientPlugin(context);
+  if (result instanceof Promise) throw new Error("expected synchronous plugin");
+  if (!state) throw new Error("Custom models state was not provided");
+  return {
+    slots,
+    commands,
+    state,
+    userLoads: () => userLoadCount,
+    botLoads: () => botLoadCount,
+    dispose: () => {
+      if (Array.isArray(result)) {
+        for (const dispose of result.toReversed()) dispose();
+      } else if (typeof result === "function") {
+        result();
+      }
+    },
+  };
+}
+
+describe("Custom models client Contribution", () => {
+  test("mounts the account and Bot model sections", () => {
+    const mounted = fixture();
+    expect(mounted.slots.map((slot) => slot.slot)).toEqual([
+      "frockbot.models-sections",
+      "frockbot.bot-settings-sections",
+    ]);
+    mounted.dispose();
+  });
+
+  test("round-trips selections and clears through User and Bot Package-setting commands", async () => {
+    const mounted = fixture();
+    const model: ModelBindingV1 = {
+      connectionId: "flock-ai",
+      providerModelId: "@frock/manual",
+    };
+
+    await mounted.state.setAccountModel(model);
+    await mounted.state.setAccountModel(undefined);
+    await mounted.state.setBotModel(model);
+    await mounted.state.setBotModel(undefined);
+
+    expect(mounted.commands).toMatchObject([
+      {
+        type: "user/set-package-settings",
+        packageId: "custom-models",
+        values: { "account-model": model },
+      },
+      {
+        type: "user/set-package-settings",
+        packageId: "custom-models",
+        unset: ["account-model"],
+      },
+      {
+        type: "bot/set-package-settings",
+        botId: "scout",
+        packageId: "custom-models",
+        values: { model },
+      },
+      {
+        type: "bot/set-package-settings",
+        botId: "scout",
+        packageId: "custom-models",
+        unset: ["model"],
+      },
+    ]);
+    expect(mounted.userLoads()).toBe(2);
+    expect(mounted.botLoads()).toBe(2);
+    mounted.dispose();
+  });
+
+  test("clears an account model whose Connection no longer resolves", async () => {
+    const mounted = fixture({
+      connectionId: "ollama-legacy",
+      providerModelId: "glm-5.3-flash:cloud",
+    });
+
+    await mounted.state.setAccountModel(undefined);
+
+    expect(mounted.commands).toMatchObject([
+      {
+        type: "user/set-package-settings",
+        packageId: "custom-models",
+        unset: ["account-model"],
+      },
+    ]);
+    expect(mounted.userLoads()).toBe(1);
+    mounted.dispose();
+  });
+});

package/src/client/index.ts

@@ -0,0 +1,47 @@
+/// <reference path="../env.d.ts" />
+
+import type { ClientPlugin } from "@frockbot/client-core";
+import { frockBotWebDataKey } from "@frockbot/plugin-shell/shared";
+import AccountModelsSection from "./AccountModelsSection.vue";
+import BotModelSection from "./BotModelSection.vue";
+import {
+  createCustomModelsClientState,
+  customModelsClientStateKey,
+} from "./state.js";
+import { defineClientContribution } from "@frockbot/kernel-contracts/contributions";
+
+export const customModelsClientPlugin: ClientPlugin = (ctx) => {
+  const web = ctx.inject(frockBotWebDataKey);
+  const state = createCustomModelsClientState(ctx.transport, web);
+  return [
+    ctx.provide(customModelsClientStateKey, state),
+    ctx.slot({
+      slot: "frockbot.models-sections",
+      order: 0,
+      component: AccountModelsSection,
+    }),
+    ctx.slot({
+      slot: "frockbot.bot-settings-sections",
+      order: 0,
+      component: BotModelSection,
+    }),
+  ];
+};
+
+export {
+  createCustomModelsClientState,
+  customModelsClientStateKey,
+  type CustomModelsClientState,
+} from "./state.js";
+
+export default customModelsClientPlugin;
+
+/**
+ * The manifest's `client` entry, resolved by specifier. The application looks
+ * this descriptor up in its Contribution table; it never branches on which
+ * Package it belongs to.
+ */
+export const clientContribution = defineClientContribution<ClientPlugin>({
+  specifier: "@frockbot/plugin-custom-models/client",
+  plugin: customModelsClientPlugin,
+});

package/src/client/state.ts

@@ -0,0 +1,94 @@
+import type { ClientPluginContext } from "@frockbot/client-core";
+import type {
+  BotSettingsViewV1,
+  ModelBindingV1,
+  UserSettingsViewV1,
+} from "@frockbot/configuration-core";
+import type { FrockBotWebData } from "@frockbot/plugin-shell/shared";
+import type { InjectionKey, Ref } from "vue";
+import {
+  ACCOUNT_MODEL_SETTING_ID_V1,
+  BOT_MODEL_SETTING_ID_V1,
+} from "../model-settings.js";
+
+export interface CustomModelsClientState {
+  setAccountModel(model: ModelBindingV1 | undefined): Promise<void>;
+  setBotModel(model: ModelBindingV1 | undefined): Promise<void>;
+}
+
+export const customModelsClientStateKey: InjectionKey<CustomModelsClientState> =
+  Symbol("frockbot.custom-models.client-state");
+
+type CustomModelsWebData = Pick<
+  FrockBotWebData,
+  | "activeBotId"
+  | "botSettings"
+  | "loadBotSettings"
+  | "loadUserSettings"
+  | "userSettings"
+>;
+
+function settingChange(
+  settingId: string,
+  model: ModelBindingV1 | undefined,
+): { values: Record<string, ModelBindingV1> } | { unset: [settingId: string] } {
+  return model ? { values: { [settingId]: model } } : { unset: [settingId] };
+}
+
+async function rejectRefusal(
+  receipt: Awaited<
+    ReturnType<
+      NonNullable<ClientPluginContext["transport"]["executeConfiguration"]>
+    >
+  >,
+): Promise<void> {
+  if (receipt.status === "rejected") throw new Error(receipt.failure);
+}
+
+/**
+ * Package-local command actions. The User and Bot Durable Objects remain the
+ * authorities: each action submits one versioned command and re-reads the
+ * projection instead of editing client state optimistically.
+ */
+export function createCustomModelsClientState(
+  transport: ClientPluginContext["transport"],
+  web: Ref<CustomModelsWebData>,
+): CustomModelsClientState {
+  return {
+    async setAccountModel(model) {
+      const current: UserSettingsViewV1 | undefined = web.value.userSettings;
+      if (!current || !transport.executeConfiguration) {
+        throw new Error("Model settings are unavailable");
+      }
+      const receipt = await transport.executeConfiguration({
+        schemaVersion: 1,
+        type: "user/set-package-settings",
+        commandId: crypto.randomUUID(),
+        expectedRevision: current.revision,
+        packageId: "custom-models",
+        ...settingChange(ACCOUNT_MODEL_SETTING_ID_V1, model),
+      });
+      await web.value.loadUserSettings();
+      await rejectRefusal(receipt);
+    },
+
+    async setBotModel(model) {
+      const current: BotSettingsViewV1 | undefined = web.value.botSettings;
+      const botId = web.value.activeBotId;
+      if (!current || !botId || !transport.executeConfiguration) {
+        throw new Error("Bot model settings are unavailable");
+      }
+      const receipt = await transport.executeConfiguration({
+        schemaVersion: 1,
+        type: "bot/set-package-settings",
+        commandId: crypto.randomUUID(),
+        expectedRevision: current.revision,
+        botId,
+        packageId: "custom-models",
+        ...settingChange(BOT_MODEL_SETTING_ID_V1, model),
+      });
+      await web.value.loadBotSettings();
+      await rejectRefusal(receipt);
+    },
+  };
+}

package/src/env.d.ts

@@ -0,0 +1,6 @@
+declare module "*.vue" {
+  import type { DefineComponent } from "vue";
+
+  const component: DefineComponent;
+  export default component;
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export {
+  ACCOUNT_MODEL_SETTING_ID_V1,
+  BOT_MODEL_SETTING_ID_V1,
+} from "./model-settings.js";
+export { default as manifest } from "./manifest.js";

package/src/manifest.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, test } from "bun:test";
+import { decodeFrockBotManifest } from "@frockbot/kernel-composition";
+import type { PackageSettingSchema } from "@frockbot/kernel-composition";
+import foundationApplication from "../../../applications/foundation/frockbot.application.json" with { type: "json" };
+import ollamaManifest from "../../plugin-provider-ollama-cloud/frockbot.json" with { type: "json" };
+import rawManifest from "../frockbot.json" with { type: "json" };
+
+const MODEL_BINDING_SCHEMA = {
+  type: "object",
+  properties: {
+    connectionId: { type: "string" },
+    providerModelId: { type: "string" },
+  },
+  required: ["connectionId", "providerModelId"],
+  additionalProperties: false,
+} satisfies PackageSettingSchema;
+
+describe("Custom models manifest", () => {
+  test("is default-disabled and declares exact User and Bot model-role settings", () => {
+    const manifest = decodeFrockBotManifest(rawManifest);
+
+    expect(manifest).toMatchObject({
+      id: "custom-models",
+      displayName: "Custom models",
+      version: "0.0.1",
+      defaultEnablement: "disabled",
+    });
+    expect(manifest.configuration?.settings).toEqual([
+      {
+        id: "account-model",
+        schemaVersion: 1,
+        scopes: ["user"],
+        role: "model",
+        schema: MODEL_BINDING_SCHEMA,
+      },
+      {
+        id: "model",
+        schemaVersion: 1,
+        scopes: ["bot"],
+        role: "model",
+        schema: MODEL_BINDING_SCHEMA,
+      },
+    ]);
+  });
+
+  test("is registered first-party in Foundation", () => {
+    expect(foundationApplication.packages).toContainEqual({
+      specifier: "@frockbot/plugin-custom-models",
+      version: "0.0.1",
+      grants: [],
+    });
+  });
+
+  test("is the declared Ollama Cloud dependency", () => {
+    expect(ollamaManifest.dependencies["custom-models"]).toBe(">=0.0.1");
+  });
+});

package/src/manifest.ts

@@ -0,0 +1,3 @@
+import manifest from "../frockbot.json" with { type: "json" };
+
+export default manifest;