@ai-matrx/chat 0.3.33 → 0.4.0

package/dist/agents/model-registry/modelRegistrySlice.js

@@ -1,574 +0,0 @@
-import {
-  createSlice,
-  createAsyncThunk,
-  createSelector
-} from "@reduxjs/toolkit";
-import { createClient } from "../../host/db.js";
-import { extractErrorMessage } from "@ai-matrx/data/net";
-import { recordUnavailable } from "../../host/diagnostics.js";
-import { normalizeModel } from "@ai-matrx/agents/models";
-import { requireCanonicalCapabilities } from "./parse.js";
-import {
-  buildModelClassIndex,
-  modelClassName,
-  withModelClass
-} from "./model-classes.js";
-const classConfigKey = (modelId, offeringId) => `${modelId}:${offeringId}`;
-const initialState = {
-  entities: {},
-  activeIds: [],
-  deprecatedIds: [],
-  fetchScope: null,
-  isLoading: false,
-  error: null,
-  lastFetched: null,
-  detailStatusById: {},
-  detailErrorById: {},
-  identityById: {},
-  identityStatusById: {},
-  classConfigByOffering: {},
-  classConfigStatusByOffering: {},
-  modelClassIndex: null
-};
-const fetchModelOptions = createAsyncThunk(
-  "modelRegistry/fetchModelOptions",
-  async (_, { rejectWithValue }) => {
-    try {
-      const supabase = createClient();
-      const { data: offeringRows, error: offeringError } = await supabase.schema("ai").from("model_offering").select("model_id");
-      if (offeringError) throw offeringError;
-      const routableIds = [
-        ...new Set(
-          (offeringRows ?? []).map((r) => r.model_id).filter(
-            (id) => typeof id === "string" && id.length > 0
-          )
-        )
-      ];
-      if (routableIds.length === 0) {
-        return [];
-      }
-      const { data, error } = await supabase.schema("ai").from("model_public").select(
-        "id, name, common_name, maker, cost_rating, speed_rating, is_primary, capabilities, is_deprecated, retired_at, successor_id"
-      ).in("id", routableIds).order("common_name", { ascending: true, nullsFirst: false });
-      if (error) throw error;
-      return (data ?? []).filter(
-        (r) => typeof r.id === "string" && typeof r.name === "string"
-      ).map((r) => ({
-        id: r.id,
-        name: r.name,
-        common_name: r.common_name,
-        maker: r.maker,
-        cost_rating: r.cost_rating,
-        speed_rating: r.speed_rating,
-        is_primary: r.is_primary,
-        capabilities: requireCanonicalCapabilities(r.capabilities, {
-          modelId: r.id,
-          modelName: r.name
-        }),
-        is_deprecated: r.is_deprecated,
-        retired_at: r.retired_at,
-        successor_id: r.successor_id
-      }));
-    } catch (err) {
-      return rejectWithValue(
-        extractErrorMessage(err, "Unknown error")
-      );
-    }
-  },
-  {
-    condition: (_, { getState }) => {
-      const { fetchScope, isLoading } = getState().modelRegistry;
-      const shouldFetch = fetchScope !== "active" && fetchScope !== "all" && !isLoading;
-      if (!shouldFetch) {
-      }
-      return shouldFetch;
-    }
-  }
-);
-const fetchModelClassConfig = createAsyncThunk(
-  "modelRegistry/fetchModelClassConfig",
-  async ({ modelId, offeringId }, { rejectWithValue }) => {
-    try {
-      const supabase = createClient();
-      const { data, error } = await supabase.schema("ai").rpc("resolve_model_config", {
-        p_model_id: modelId,
-        p_offering_id: offeringId
-      });
-      if (error) throw error;
-      const cfg = data && typeof data === "object" && !Array.isArray(data) ? data : null;
-      return {
-        key: classConfigKey(modelId, offeringId),
-        config: {
-          modelId,
-          controls: cfg?.controls ?? null,
-          constraints: cfg?.constraints ?? null
-        }
-      };
-    } catch (err) {
-      return rejectWithValue(
-        `Model class configuration ${modelId} / ${offeringId}: ${extractErrorMessage(err)}`
-      );
-    }
-  },
-  {
-    // A failed load (refused pin, network) is retried the next time a surface
-    // asks — never cached as a permanent "not available".
-    condition: ({ modelId, offeringId }, { getState }) => {
-      const status = getState().modelRegistry?.classConfigStatusByOffering?.[classConfigKey(modelId, offeringId)];
-      return status !== "loading" && status !== "succeeded";
-    }
-  }
-);
-const fetchModelClasses = createAsyncThunk(
-  "modelRegistry/fetchModelClasses",
-  async (_, { rejectWithValue }) => {
-    try {
-      const supabase = createClient();
-      const { data, error } = await supabase.schema("ai").from("model_offering").select("model_id, offering_id, served_via, served_via_endpoint_id, priority");
-      if (error) throw error;
-      return buildModelClassIndex(data ?? []);
-    } catch (err) {
-      return rejectWithValue(`Model classes: ${extractErrorMessage(err)}`);
-    }
-  },
-  {
-    condition: (_, { getState }) => {
-      const status = getState().modelRegistry?.modelClassStatus;
-      return status !== "loading" && status !== "succeeded";
-    }
-  }
-);
-const fetchModelIdentityById = createAsyncThunk(
-  "modelRegistry/fetchIdentityById",
-  async (modelId) => {
-    const supabase = createClient();
-    const { data, error } = await supabase.schema("ai").from("model_definition").select("id, name, common_name, is_deprecated").eq("id", modelId).maybeSingle();
-    if (error) throw error;
-    if (!data)
-      throw recordUnavailable({
-        entity: "AI model",
-        reason: "unknown",
-        recordId: modelId,
-        token: "ai_model",
-        relation: "model_definition"
-      });
-    return data;
-  },
-  {
-    condition: (modelId, { getState }) => {
-      const state = getState().modelRegistry;
-      if (state.entities[modelId]) return false;
-      if (state.identityById[modelId]) return false;
-      const status = state.identityStatusById[modelId];
-      return status !== "loading" && status !== "succeeded" && status !== "failed";
-    }
-  }
-);
-const MODEL_CONFIG_COLUMNS = "id, name, common_name, maker, cost_rating, speed_rating, is_premium, is_primary, context_window, max_tokens, capabilities, controls, constraints, is_deprecated, retired_at, successor_id";
-const fetchModelById = createAsyncThunk(
-  "modelRegistry/fetchModelById",
-  async (modelId, { rejectWithValue, getState }) => {
-    console.log(
-      "[modelRegistry] fetchModelById \u2014 fetching full record for",
-      modelId
-    );
-    const auth = getState();
-    const relation = auth.userAuth?.accessToken ? "model_config" : "model_public";
-    try {
-      const supabase = createClient();
-      const { data, error } = await supabase.schema("ai").from(relation).select(MODEL_CONFIG_COLUMNS).eq("id", modelId).maybeSingle();
-      if (error) throw error;
-      if (!data) {
-        throw recordUnavailable({
-          entity: "AI model",
-          reason: "unknown",
-          recordId: modelId,
-          token: "ai_model",
-          relation
-        });
-      }
-      if (!data.id || !data.name) {
-        throw new Error(
-          `ai.${relation} returned a row without id/name for model ${modelId}`
-        );
-      }
-      return normalizeModel({
-        id: data.id,
-        name: data.name,
-        common_name: data.common_name,
-        maker: data.maker,
-        cost_rating: data.cost_rating,
-        speed_rating: data.speed_rating,
-        is_premium: data.is_premium,
-        is_primary: data.is_primary,
-        context_window: data.context_window,
-        max_tokens: data.max_tokens,
-        capabilities: requireCanonicalCapabilities(data.capabilities, {
-          modelId: data.id,
-          modelName: data.name
-        }),
-        controls: data.controls,
-        constraints: data.constraints,
-        is_deprecated: data.is_deprecated,
-        retired_at: data.retired_at,
-        successor_id: data.successor_id
-      });
-    } catch (err) {
-      return rejectWithValue(
-        `Model configuration ${modelId}: ${extractErrorMessage(err)}`
-      );
-    }
-  },
-  {
-    condition: (modelId, { getState }) => {
-      const { entities, detailStatusById } = getState().modelRegistry;
-      const existing = entities[modelId];
-      if (detailStatusById?.[modelId] === "loading" || detailStatusById?.[modelId] === "failed")
-        return false;
-      if (existing?._fetchType === "full") {
-        console.log(
-          "[modelRegistry] fetchModelById skipped \u2014 already full for",
-          modelId
-        );
-        return false;
-      }
-      return true;
-    }
-  }
-);
-const modelRegistrySlice = createSlice({
-  name: "modelRegistry",
-  initialState,
-  reducers: {
-    retryModelDetail(state, action) {
-      delete state.detailStatusById[action.payload];
-      delete state.detailErrorById[action.payload];
-    },
-    /**
-     * SSR hydration path.
-     * Supply options-level or full records from the server shell.
-     * fetchType tells the slice how much data each record carries.
-     */
-    hydrateModels(state, action) {
-      const { models, fetchType, fetchScope, lastFetched } = action.payload;
-      for (const raw of models) {
-        const id = raw.id;
-        const existing = state.entities[id];
-        if (existing?._fetchType === "full" && fetchType === "options")
-          continue;
-        state.entities[id] = {
-          ...emptyModelRecord(),
-          ...normalizeModel(raw),
-          _fetchType: fetchType
-        };
-      }
-      rebuildIdLists(state);
-      state.fetchScope = fetchScope;
-      state.lastFetched = lastFetched;
-      state.isLoading = false;
-      state.error = null;
-    }
-  },
-  extraReducers: (builder) => {
-    builder.addCase(fetchModelOptions.pending, (state) => {
-      state.isLoading = true;
-      state.error = null;
-    }).addCase(fetchModelOptions.fulfilled, (state, action) => {
-      state.isLoading = false;
-      state.error = null;
-      for (const row of action.payload) {
-        const existing = state.entities[row.id];
-        if (existing?._fetchType === "full") continue;
-        state.entities[row.id] = {
-          // Spread a skeleton so all AIModelRow fields exist (null for unfetched ones)
-          ...emptyModelRecord(),
-          ...existing,
-          ...row,
-          _fetchType: "options"
-        };
-      }
-      rebuildIdLists(state);
-      if (state.fetchScope !== "all" && state.fetchScope !== "deprecated") {
-        state.fetchScope = "active";
-      }
-      state.lastFetched = Date.now();
-    }).addCase(fetchModelOptions.rejected, (state, action) => {
-      state.isLoading = false;
-      state.error = action.payload;
-    });
-    builder.addCase(fetchModelById.pending, (state, action) => {
-      state.detailStatusById[action.meta.arg] = "loading";
-      delete state.detailErrorById[action.meta.arg];
-    }).addCase(fetchModelById.fulfilled, (state, action) => {
-      state.detailStatusById[action.meta.arg] = "succeeded";
-      delete state.detailErrorById[action.meta.arg];
-      const record = action.payload;
-      const existing = state.entities[record.id];
-      state.entities[record.id] = {
-        ...emptyModelRecord(),
-        ...existing,
-        ...record,
-        maker: record.maker ?? existing?.maker ?? null,
-        _fetchType: "full"
-      };
-      rebuildIdLists(state);
-    }).addCase(fetchModelById.rejected, (state, action) => {
-      state.detailStatusById[action.meta.arg] = "failed";
-      state.detailErrorById[action.meta.arg] = typeof action.payload === "string" ? action.payload : action.error.message ?? "Model configuration request failed";
-    });
-    builder.addCase(fetchModelClassConfig.pending, (state, action) => {
-      state.classConfigStatusByOffering[classConfigKey(action.meta.arg.modelId, action.meta.arg.offeringId)] = "loading";
-    }).addCase(fetchModelClassConfig.fulfilled, (state, action) => {
-      state.classConfigStatusByOffering[action.payload.key] = "succeeded";
-      state.classConfigByOffering[action.payload.key] = action.payload.config;
-    }).addCase(fetchModelClassConfig.rejected, (state, action) => {
-      state.classConfigStatusByOffering[classConfigKey(action.meta.arg.modelId, action.meta.arg.offeringId)] = "failed";
-    });
-    builder.addCase(fetchModelClasses.pending, (state) => {
-      state.modelClassStatus = "loading";
-    }).addCase(fetchModelClasses.fulfilled, (state, action) => {
-      state.modelClassStatus = "succeeded";
-      state.modelClassIndex = action.payload;
-    }).addCase(fetchModelClasses.rejected, (state, action) => {
-      state.modelClassStatus = "failed";
-      console.error("[modelRegistry]", action.payload ?? action.error.message);
-    });
-    builder.addCase(fetchModelIdentityById.pending, (state, action) => {
-      state.identityStatusById[action.meta.arg] = "loading";
-    }).addCase(fetchModelIdentityById.fulfilled, (state, action) => {
-      const row = action.payload;
-      state.identityById[row.id] = row;
-      state.identityStatusById[row.id] = "succeeded";
-    }).addCase(fetchModelIdentityById.rejected, (state, action) => {
-      state.identityStatusById[action.meta.arg] = "failed";
-    });
-  }
-});
-function emptyModelRecord() {
-  return {
-    id: "",
-    name: "",
-    common_name: null,
-    maker: null,
-    capabilities: null,
-    constraints: [],
-    context_window: null,
-    controls: null,
-    is_deprecated: null,
-    is_premium: null,
-    is_primary: null,
-    max_tokens: null,
-    provider_id: null,
-    guest_fallback_id: null,
-    mid_fallback_id: null,
-    // 2026-07-10 ai-schema reshape additions
-    cost_rating: null,
-    speed_rating: null,
-    retry_fallback_id: null,
-    retry_max_attempts: 0,
-    organization_id: "",
-    created_by: null,
-    deleted_at: null,
-    retired_at: null,
-    successor_id: null,
-    visibility: "personal",
-    shown_to: null,
-    published_to_web: false,
-    published_to_web_at: null,
-    published_to_web_by: null,
-    // Canonical base columns (2026-07-02 AI-catalog reshape)
-    is_system: false,
-    created_at: "",
-    updated_at: "",
-    updated_by: null,
-    version: 0,
-    metadata: {},
-    description: null,
-    release_date: null
-  };
-}
-function rebuildIdLists(state) {
-  const active = [];
-  const deprecated = [];
-  for (const [id, record] of Object.entries(state.entities)) {
-    if (record.is_deprecated === true) {
-      deprecated.push(id);
-    } else {
-      active.push(id);
-    }
-  }
-  const sort = (ids) => ids.sort(
-    (a, b) => (state.entities[a].common_name ?? state.entities[a].name ?? "").localeCompare(
-      state.entities[b].common_name ?? state.entities[b].name ?? ""
-    )
-  );
-  state.activeIds = sort(active);
-  state.deprecatedIds = sort(deprecated);
-}
-const { hydrateModels, retryModelDetail } = modelRegistrySlice.actions;
-var modelRegistrySlice_default = modelRegistrySlice.reducer;
-const selectRegistrySlice = (state) => state.modelRegistry;
-const selectEntities = (state) => state.modelRegistry.entities;
-const selectActiveIds = (state) => state.modelRegistry.activeIds;
-const selectDeprecatedIds = (state) => state.modelRegistry.deprecatedIds;
-const selectModelFetchScope = (state) => state.modelRegistry.fetchScope;
-const selectModelRegistryLoading = (state) => state.modelRegistry.isLoading;
-const selectModelRegistryError = (state) => state.modelRegistry.error;
-const selectModelRegistryLastFetched = (state) => state.modelRegistry.lastFetched;
-const selectModelIdentityLookupStatus = (state, modelId) => state.modelRegistry.identityStatusById[modelId] ?? "idle";
-const selectModelIdentityById = (state, modelId) => state.modelRegistry.identityById[modelId];
-const selectModelIdentityMap = (state) => state.modelRegistry.identityById;
-const selectActiveModels = createSelector(
-  [selectEntities, selectActiveIds],
-  (entities, ids) => ids.map((id) => entities[id]).filter(Boolean)
-);
-const selectDeprecatedModels = createSelector(
-  [selectEntities, selectDeprecatedIds],
-  (entities, ids) => ids.map((id) => entities[id]).filter(Boolean)
-);
-const selectAllModels = createSelector(
-  [selectEntities],
-  (entities) => Object.values(entities)
-);
-const selectModelOptions = createSelector(
-  [selectActiveModels],
-  (models) => models.map((m) => ({
-    value: m.id,
-    label: m.common_name || m.name || m.id,
-    maker: m.maker,
-    costRating: m.cost_rating,
-    speedRating: m.speed_rating
-  }))
-);
-const selectAllModelOptions = createSelector(
-  [selectEntities],
-  (entities) => Object.values(entities).map((m) => ({
-    value: m.id,
-    label: m.common_name || m.name || m.id,
-    maker: m.maker,
-    isDeprecated: m.is_deprecated ?? false,
-    isRetired: m.retired_at != null,
-    successorId: m.successor_id ?? null
-  }))
-);
-const selectModelLabelById = createSelector(
-  [
-    selectEntities,
-    selectModelIdentityMap,
-    (_state, modelId) => modelId
-  ],
-  (entities, identities, modelId) => {
-    if (!modelId) return void 0;
-    const m = entities[modelId];
-    const identity = identities[modelId];
-    return m?.common_name || m?.name || identity?.common_name || identity?.name || void 0;
-  }
-);
-const selectModelClassName = (state, modelId, offeringId) => modelClassName(state.modelRegistry?.modelClassIndex, modelId, offeringId);
-const selectModelLabelWithClass = (state, modelId, offeringId) => {
-  const label = selectModelLabelById(state, modelId);
-  return label ? withModelClass(label, selectModelClassName(state, modelId, offeringId)) : void 0;
-};
-const selectModelNameById = createSelector(
-  [
-    selectEntities,
-    (_state, modelId) => modelId
-  ],
-  (entities, modelId) => {
-    if (!modelId) return void 0;
-    return entities[modelId]?.name;
-  }
-);
-const selectModelById = createSelector(
-  [
-    selectEntities,
-    (_state, modelId) => modelId
-  ],
-  (entities, modelId) => entities[modelId]
-);
-const makeSelectModelById = () => createSelector(
-  [
-    selectEntities,
-    (_state, modelId) => modelId
-  ],
-  (entities, modelId) => entities[modelId]
-);
-const selectModelControls = createSelector(
-  [
-    selectEntities,
-    (_state, modelId) => modelId
-  ],
-  (entities, modelId) => entities[modelId]?.controls
-);
-const selectModelFetchType = createSelector(
-  [
-    selectEntities,
-    (_state, modelId) => modelId
-  ],
-  (entities, modelId) => entities[modelId]?._fetchType
-);
-const selectActiveModelsReady = createSelector(
-  [selectRegistrySlice],
-  ({ fetchScope, activeIds }) => (fetchScope === "active" || fetchScope === "all") && activeIds.length > 0
-);
-const selectDeprecatedModelsReady = createSelector(
-  [selectRegistrySlice],
-  ({ fetchScope, deprecatedIds }) => (fetchScope === "deprecated" || fetchScope === "all") && deprecatedIds.length > 0
-);
-const selectAllModelsReady = createSelector(
-  [selectRegistrySlice],
-  ({ fetchScope }) => fetchScope === "all"
-);
-const selectModelFullyLoaded = createSelector(
-  [
-    selectEntities,
-    (_state, modelId) => modelId
-  ],
-  (entities, modelId) => {
-    if (!modelId) return false;
-    return entities[modelId]?._fetchType === "full";
-  }
-);
-const selectModelDetailError = createSelector(
-  [
-    (state) => state.modelRegistry.detailErrorById,
-    (_state, modelId) => modelId
-  ],
-  (errors, modelId) => errors?.[modelId] ?? null
-);
-export {
-  classConfigKey,
-  modelRegistrySlice_default as default,
-  fetchModelById,
-  fetchModelClassConfig,
-  fetchModelClasses,
-  fetchModelIdentityById,
-  fetchModelOptions,
-  hydrateModels,
-  makeSelectModelById,
-  retryModelDetail,
-  selectActiveModels,
-  selectActiveModelsReady,
-  selectAllModelOptions,
-  selectAllModels,
-  selectAllModelsReady,
-  selectDeprecatedModels,
-  selectDeprecatedModelsReady,
-  selectModelById,
-  selectModelClassName,
-  selectModelControls,
-  selectModelDetailError,
-  selectModelFetchScope,
-  selectModelFetchType,
-  selectModelFullyLoaded,
-  selectModelIdentityById,
-  selectModelIdentityLookupStatus,
-  selectModelIdentityMap,
-  selectModelLabelById,
-  selectModelLabelWithClass,
-  selectModelNameById,
-  selectModelOptions,
-  selectModelRegistryError,
-  selectModelRegistryLastFetched,
-  selectModelRegistryLoading
-};

package/dist/host/model-class.d.ts

@@ -1,33 +0,0 @@
-/**
- * host/model-class — the model "class" (offering) a run is pinned to, read through the host.
- *
- * The host loads a pinned class's controls and its display labels from its model registry.
- * A host with no registry answers `undefined` (callers keep the model's own controls) and
- * labels nothing. matrx-frontend registers its hooks (`providers/chatUiRegistration.ts`).
- */
-import type { Json } from "./db-types.js";
-export type ModelClassControls = undefined | {
-    pending: true;
-    failed?: false;
-    config?: undefined;
-} | {
-    pending?: false;
-    failed: true;
-    config?: undefined;
-} | {
-    pending?: false;
-    failed?: false;
-    config: {
-        modelId: string;
-        controls: Json | null;
-        constraints: Json | null;
-    };
-};
-export interface ChatModelClassHooks {
-    useModelClassControls(modelId: string | null | undefined, offeringId: string | null | undefined): ModelClassControls;
-    /** Loads the class labels the model pickers read (a side-effect hook). */
-    useModelClassLabels(): void;
-}
-export declare function registerChatModelClassHooks(next: ChatModelClassHooks | null): void;
-export declare const useModelClassControls: ChatModelClassHooks["useModelClassControls"];
-export declare const useModelClassLabels: ChatModelClassHooks["useModelClassLabels"];

package/dist/host/model-class.js

@@ -1,21 +0,0 @@
-import { reportUnregisteredHostSlot } from "./diagnostics.js";
-const NO_REGISTRY = {
-  useModelClassControls: () => void 0,
-  useModelClassLabels: () => void 0
-};
-let hooks = NO_REGISTRY;
-function registerChatModelClassHooks(next) {
-  hooks = next ?? NO_REGISTRY;
-}
-function current() {
-  if (hooks === NO_REGISTRY)
-    reportUnregisteredHostSlot("modelClassHooks", "pinned model classes keep the model's own controls and show no class labels");
-  return hooks;
-}
-const useModelClassControls = (modelId, offeringId) => current().useModelClassControls(modelId, offeringId);
-const useModelClassLabels = () => current().useModelClassLabels();
-export {
-  registerChatModelClassHooks,
-  useModelClassControls,
-  useModelClassLabels
-};