@ai-matrx/chat 0.5.18 → 0.6.0

package/dist/agents/identity/settings-store.js

@@ -0,0 +1,49 @@
+"use client";
+import { useMemo } from "react";
+import { selectModelById, selectModelClassConfig } from "@ai-matrx/agents/models";
+import {
+  createSettingsStore,
+  effectiveOfferingPinOf,
+  parseModelControls,
+  readEffectiveModelId
+} from "@ai-matrx/agents/settings";
+import { useSettingsEntry } from "@ai-matrx/agents/settings/react";
+import { readModelRecords, useModelRecords } from "./model-catalog.js";
+const KEY = /* @__PURE__ */ Symbol.for("ai-matrx.chat.settings-store");
+function getSettingsStore() {
+  const g = globalThis;
+  if (g[KEY]) return g[KEY];
+  const store = createSettingsStore({
+    lookupModel: (modelId) => {
+      const model = selectModelById(readModelRecords(), modelId);
+      if (!model) return void 0;
+      return {
+        id: model.id,
+        name: model.common_name || model.name || model.id,
+        controls: model.controls ?? null
+      };
+    }
+  });
+  g[KEY] = store;
+  return store;
+}
+function useAgentSettingsEntry(agentId) {
+  return useSettingsEntry(getSettingsStore(), agentId);
+}
+function useNormalizedControls(agentId) {
+  const entry = useAgentSettingsEntry(agentId);
+  const modelId = readEffectiveModelId(entry);
+  const pin = effectiveOfferingPinOf(entry) ?? null;
+  const model = useModelRecords((s) => selectModelById(s, modelId));
+  const classConfig = useModelRecords((s) => selectModelClassConfig(s, modelId, pin));
+  return useMemo(() => {
+    if (!model) return null;
+    const controls = classConfig ? classConfig.controls : model.controls;
+    return parseModelControls(controls);
+  }, [model, classConfig]);
+}
+export {
+  getSettingsStore,
+  useAgentSettingsEntry,
+  useNormalizedControls
+};

package/dist/agents/identity/skill-catalog.d.ts

@@ -0,0 +1,27 @@
+import { type SkillCatalog, type SkillRow } from "@ai-matrx/agents/skills";
+import { type UseSkillsArgs } from "@ai-matrx/agents/skills/react";
+export declare function getSkillCatalog(): SkillCatalog;
+export interface ChatSkillsResult {
+    skills: SkillRow[];
+    grouped: Record<string, SkillRow[]>;
+    count: number;
+    loading: boolean;
+    error: string | null;
+    reload: () => Promise<void>;
+}
+/** The skills list, grouped by type; reloads and announces when a skill stream event lands. */
+export declare function useSkills(args?: UseSkillsArgs): ChatSkillsResult;
+/** The skills already loaded, without a read: `ready` + rows, or the status while not ready. */
+export declare function readLoadedSkills(): {
+    status: string;
+    skills: SkillRow[];
+};
+/** True when a `resource_changed` kind is skill-related. */
+export declare function isSkillStreamEvent(kind: string | undefined): boolean;
+/** Hand a skill `resource_changed` event to the catalog (it bumps `lastIngestAt`; lists reload). */
+export declare function applySkillStreamEvent(payload: {
+    kind?: string;
+    action?: string;
+    resource_id?: string;
+    metadata?: Record<string, unknown>;
+}): void;

package/dist/agents/identity/skill-catalog.js

@@ -0,0 +1,100 @@
+"use client";
+import { useEffect, useMemo, useRef } from "react";
+import { createSkillCatalog } from "@ai-matrx/agents/skills";
+import { useSkillCatalogSelector, useSkills as useCoreSkills } from "@ai-matrx/agents/skills/react";
+import { supabase } from "../../host/db.js";
+import { captureError } from "../../host/diagnostics.js";
+import { toast } from "../../host/notify.js";
+import { associationsService, isScopesRpcErr } from "../../context/sources/scopes.js";
+import { chatHostHasDatabase } from "../../host/configure.js";
+const KEY = /* @__PURE__ */ Symbol.for("ai-matrx.chat.skill-catalog");
+function getSkillCatalog() {
+  const g = globalThis;
+  if (g[KEY]) return g[KEY];
+  const catalog = createSkillCatalog({
+    client: supabase,
+    associations: {
+      async skillIdsForProject(projectId) {
+        const res = await associationsService.listForTargets("project", [projectId]);
+        if (isScopesRpcErr(res)) return { ok: false, message: res.error.message };
+        return {
+          ok: true,
+          ids: res.data.edges.filter((e) => e.sourceType === "skill" && e.role === "member").map((e) => e.sourceId)
+        };
+      },
+      async projectIdsBySkill(skillIds) {
+        const out = {};
+        if (skillIds.length === 0) return out;
+        const res = await associationsService.listForSources("skill", [...skillIds], "project");
+        if (isScopesRpcErr(res)) return out;
+        for (const edge of res.data.edges) {
+          if (edge.role !== "member") continue;
+          (out[edge.sourceId] ??= []).push(edge.targetId);
+        }
+        return out;
+      }
+    },
+    errorSink: (event) => {
+      captureError({ source: "supabase-postgrest", schema: "skill", message: event.message, code: event.code });
+    }
+  });
+  g[KEY] = catalog;
+  return catalog;
+}
+function useSkills(args = {}) {
+  const catalog = getSkillCatalog();
+  const result = useCoreSkills(catalog, { ...args, skipAutoFetch: Boolean(args.skipAutoFetch) || !chatHostHasDatabase() });
+  const lastIngestAt = useSkillCatalogSelector(catalog, (s) => s.lastIngestAt);
+  const lastReport = useSkillCatalogSelector(catalog, (s) => s.lastStreamReport);
+  const seen = useRef(lastIngestAt);
+  useEffect(() => {
+    if (!lastIngestAt || lastIngestAt === seen.current) return;
+    seen.current = lastIngestAt;
+    const created = lastReport?.created ?? 0;
+    const updated = lastReport?.updated ?? 0;
+    const total = created + updated;
+    if (total > 0) {
+      const parts = [];
+      if (created) parts.push(`${created} new`);
+      if (updated) parts.push(`${updated} updated`);
+      toast.success(`Discovered ${parts.join(", ")} skill${total === 1 ? "" : "s"}`);
+    }
+  }, [lastIngestAt, lastReport]);
+  const all = useSkillCatalogSelector(catalog, (s) => s.skills);
+  const grouped = useMemo(() => {
+    const groups = {};
+    for (const id of all.allIds) {
+      const row = all.byId[id];
+      if (!row) continue;
+      (groups[row.skillType || "reference"] ??= []).push(row);
+    }
+    return groups;
+  }, [all]);
+  return { ...result, grouped };
+}
+function readLoadedSkills() {
+  const { skills } = getSkillCatalog().getState();
+  return {
+    status: skills.status,
+    skills: skills.allIds.map((id) => skills.byId[id]).filter((r) => Boolean(r))
+  };
+}
+function isSkillStreamEvent(kind) {
+  return Boolean(kind && kind.startsWith("skill"));
+}
+function applySkillStreamEvent(payload) {
+  if (!isSkillStreamEvent(payload.kind)) return;
+  getSkillCatalog().applyStreamEvent({
+    kind: payload.kind,
+    action: payload.action ?? "modified",
+    resourceId: payload.resource_id ?? "",
+    metadata: payload.metadata ?? {}
+  });
+}
+export {
+  applySkillStreamEvent,
+  getSkillCatalog,
+  isSkillStreamEvent,
+  readLoadedSkills,
+  useSkills
+};

package/dist/agents/identity/tool-catalog.d.ts

@@ -0,0 +1,15 @@
+import { type ToolCatalog, type ToolCatalogState } from "@ai-matrx/agents/tools";
+import type { DatabaseTool } from "../../ui/database-tool.js";
+export { selectAllTools, selectToolsStatus, selectToolsError, selectToolsReady, selectToolIdentityMap, selectToolById, selectToolLookupStatus, } from "@ai-matrx/agents/tools";
+export type ChatToolCatalogState = ToolCatalogState<DatabaseTool>;
+export declare function getToolCatalog(): ToolCatalog<DatabaseTool>;
+/** Subscribe to a slice of the tool catalogue. `select` must return a stable value for unchanged state. */
+export declare function useToolCatalog<T>(select: (state: ChatToolCatalogState) => T): T;
+/** Read the active catalogue (once per session). A failure lands in the state's `error`. */
+export declare function loadAvailableTools(options?: {
+    force?: boolean;
+}): Promise<void>;
+/** Resolve one tool reference (inactive included). */
+export declare function loadToolById(toolId: string): Promise<DatabaseTool | undefined>;
+/** One tool by id (active list, else a resolved historical reference); resolves it when unknown. */
+export declare function useToolById(toolId: string | null | undefined): DatabaseTool | undefined;

package/dist/agents/identity/tool-catalog.js

@@ -0,0 +1,67 @@
+"use client";
+import { useEffect, useSyncExternalStore } from "react";
+import {
+  createToolCatalog,
+  selectToolById
+} from "@ai-matrx/agents/tools";
+import { supabase } from "../../host/db.js";
+import { captureError } from "../../host/diagnostics.js";
+import { chatHostHasDatabase } from "../../host/configure.js";
+import {
+  selectAllTools,
+  selectToolsStatus,
+  selectToolsError,
+  selectToolsReady,
+  selectToolIdentityMap,
+  selectToolById as selectToolById2,
+  selectToolLookupStatus
+} from "@ai-matrx/agents/tools";
+const KEY = /* @__PURE__ */ Symbol.for("ai-matrx.chat.tool-catalog");
+function getToolCatalog() {
+  const g = globalThis;
+  if (g[KEY]) return g[KEY];
+  const catalog = createToolCatalog({
+    client: () => supabase,
+    isAvailable: () => chatHostHasDatabase(),
+    errorSink: (event) => {
+      captureError({ source: "supabase-postgrest", schema: "tool", code: event.code, message: event.message });
+    }
+  });
+  g[KEY] = catalog;
+  return catalog;
+}
+function useToolCatalog(select) {
+  const catalog = getToolCatalog();
+  return useSyncExternalStore(
+    catalog.subscribe,
+    () => select(catalog.getState()),
+    () => select(catalog.getState())
+  );
+}
+function loadAvailableTools(options) {
+  return getToolCatalog().load(options).then(() => void 0, () => void 0);
+}
+function loadToolById(toolId) {
+  return getToolCatalog().loadById(toolId);
+}
+function useToolById(toolId) {
+  const tool = useToolCatalog((s) => selectToolById(s, toolId));
+  useEffect(() => {
+    if (toolId && !tool) void loadToolById(toolId);
+  }, [toolId, tool]);
+  return tool;
+}
+export {
+  getToolCatalog,
+  loadAvailableTools,
+  loadToolById,
+  selectAllTools,
+  selectToolById2 as selectToolById,
+  selectToolIdentityMap,
+  selectToolLookupStatus,
+  selectToolsError,
+  selectToolsReady,
+  selectToolsStatus,
+  useToolById,
+  useToolCatalog
+};

package/dist/agents/redux/agent-definition/cache-bust-middleware.d.ts

@@ -16,7 +16,6 @@
  *   - `agentDefinition/promoteVersion/fulfilled`    (past version → live)
  *   - `agentDefinition/updateFromSource/fulfilled`  (derived reset)
  *   - `agentDefinition/purgeVersions/fulfilled`     (version history trim)
- *   - `agentSettings/saveAgentSettings/fulfilled`   (settings/variables writer)
  *
  * NOT the only layer, and deliberately not the load-bearing one. This call can
  * only evict the ONE python process that answers it, and we run several

package/dist/agents/redux/agent-definition/cache-bust-middleware.js

@@ -8,19 +8,7 @@ const WATCHED_ACTION_TYPES = /* @__PURE__ */ new Set([
   "agentDefinition/saveField/fulfilled",
   "agentDefinition/promoteVersion/fulfilled",
   "agentDefinition/updateFromSource/fulfilled",
-  "agentDefinition/purgeVersions/fulfilled",
-  // Second agent-save path, living in a DIFFERENT slice: `saveAgentSettings`
-  // (`packages/chat/src/agents/redux/agent-settings/agentSettingsSlice.ts`) writes `settings`
-  // + `variable_definitions` straight to `agent.definition` and never dispatches
-  // an `agentDefinition/*` action. `settings` is where model choice, reasoning
-  // effort and GROUNDING live — so this was the client write that made D159's
-  // "grounding stayed on in production" reproducible while the Builder's own
-  // saves busted correctly. `meta.arg` is `{ agentId }`, already handled below.
-  //
-  // ⚠️ This entry makes the miss harmless; it does not make the path right. Two
-  // parallel writers of one row is the real defect — see FOUND_DEFECTS D159/D160
-  // for the recommendation to fold this onto `agentDefinition/saveField`.
-  "agentSettings/saveAgentSettings/fulfilled"
+  "agentDefinition/purgeVersions/fulfilled"
 ]);
 function extractAgentId(action) {
   if (!action || typeof action !== "object") return null;