@ai-matrx/chat 0.5.18 → 0.6.1

package/dist/agents/components/run-controls/RunConfigOverrides.js

@@ -29,7 +29,7 @@ import {
 import {
   buildSettingsRows
 } from "../../redux/agent-settings/settings-catalogue.js";
-import { SettingControlInput } from "../../../host/ui-slots.js";
+import { SettingControlInput } from "@ai-matrx/agents/settings/react";
 import { Label, ErrorBox } from "@ai-matrx/design-system";
 import { cn } from "@ai-matrx/design-system";
 import { Tabs, TabsContent, TabsList, TabsTrigger } from "../../../ui/tabs.js";

package/dist/agents/components/run-controls/RunInputCapabilities.js

@@ -1,7 +1,7 @@
 "use client";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { useAppDispatch, useAppSelector } from "../../../store/hooks.js";
-import { InputCapabilitiesEditor } from "../../../host/ui-slots.js";
+import { InputCapabilitiesEditor } from "@ai-matrx/agents/settings/react";
 import { selectInputCapabilitiesState } from "../../redux/execution-system/instance-input-capabilities/instance-input-capabilities.selectors.js";
 import {
   resetInputCapabilityOverride,

package/dist/agents/components/run-controls/panels/shared.d.ts

@@ -30,7 +30,6 @@ export declare function makeSelectConversationRequests(conversationId: string):
     agentShortcut: import("../../../redux/agent-shortcuts/types.js").AgentShortcutSliceState;
     agentShortcutCategory: import("../../../redux/agent-shortcut-categories/types.js").AgentShortcutCategorySliceState;
     surfaceUserState: import("../../../../surfaces/redux/userStateSlice.js").SurfaceUserStateSlice;
-    tools: import("../../../redux/tools/tools.slice.js").ToolsSliceState;
     conversations: import("../../../redux/execution-system/conversations/conversations.slice.js").ConversationsState;
     chatIncognito: import("../../../redux/chat/chat-incognito.slice.js").ChatIncognitoState;
     chatRoute: import("../../../redux/chat/chat-route.slice.js").ChatRouteState;
@@ -62,7 +61,6 @@ export declare function makeSelectConversationRequests(conversationId: string):
     agentAssistantMarkdownDraft: import("../../../redux/agent-assistant-markdown-draft.slice.js").AgentAssistantMarkdownDraftState;
     mcp: import("../../../redux/mcp/mcp.slice.js").McpSliceState;
     proposedDirectives: import("../../../redux/proposed-directives/proposedDirectivesSlice.js").ProposedDirectivesState;
-    agentSettings: import("../../../redux/agent-settings/types.js").AgentSettingsState;
     conversationAttachments: import("../../../connectors/attachments.slice.js").AttachmentsSliceState;
     chatHost: import("../../../../store/chat-host.slice.js").ChatHostState;
     hostConversations: import("../../../redux/execution-system/host-conversations/host-conversations.slice.js").HostConversationsState;

package/dist/agents/hooks/useDiffEnrichment.js

@@ -1,15 +1,12 @@
 "use client";
 import { useMemo } from "react";
 import { useAppSelector } from "../../store/hooks.js";
-import {
-  selectAllTools,
-  selectToolIdentityMap
-} from "../redux/tools/tools.selectors.js";
 import { selectMcpCatalog } from "../redux/mcp/mcp.slice.js";
 import { useModelRecords } from "../identity/model-catalog.js";
+import { selectAllTools, selectToolIdentityMap, useToolCatalog } from "../identity/tool-catalog.js";
 function useDiffEnrichment() {
-  const allTools = useAppSelector(selectAllTools);
-  const toolIdentities = useAppSelector(selectToolIdentityMap);
+  const allTools = useToolCatalog(selectAllTools);
+  const toolIdentities = useToolCatalog(selectToolIdentityMap);
   const mcpCatalog = useAppSelector(selectMcpCatalog);
   const modelEntities = useModelRecords((s) => s.entities);
   const modelIdentities = useModelRecords((s) => s.identityById);

package/dist/agents/identity/agent-catalog-lists.js

@@ -1,6 +1,7 @@
 "use client";
 import { useEffect, useMemo, useSyncExternalStore } from "react";
-import { getAgentCatalog } from "../../host/ui-slots.js";
+import { getChatHost } from "../../host/configure.js";
+const getAgentCatalog = () => getChatHost().catalog();
 import { ensureAgentCatalog } from "./agent-identity.js";
 const EMPTY_ROWS = [];
 const EMPTY_BY_ID = {};

package/dist/agents/identity/agent-identity.js

@@ -1,5 +1,6 @@
 "use client";
-import { getAgentCatalog } from "../../host/ui-slots.js";
+import { getChatHost } from "../../host/configure.js";
+const getAgentCatalog = () => getChatHost().catalog();
 import { useAppSelector } from "../../store/hooks.js";
 import { useEffect, useMemo, useSyncExternalStore } from "react";
 import { hasField } from "@ai-matrx/agents/field-flags";

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

@@ -35,3 +35,12 @@ export type ModelClassControls = undefined | {
     config: ModelClassConfig;
 };
 export declare function useModelClassControls(modelId: string | null | undefined, offeringId: string | null | undefined): ModelClassControls;
+/** The active model options; loads them once (idempotent, shared with every picker). */
+export declare function useModelOptions(): {
+    options: import("@ai-matrx/agents/models").ModelOption[];
+    isLoading: boolean;
+    error: string | null;
+    isReady: boolean;
+};
+/** One model's FULL record (controls included), or undefined until it has loaded. */
+export declare function useModelFull(modelId: string | null | undefined): ModelRecord | undefined;

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

@@ -4,8 +4,11 @@ import {
   classConfigKey,
   createModelCatalog,
   EMPTY_MODEL_RECORDS,
+  selectActiveModelsReady,
   selectModelById,
+  selectModelFullyLoaded,
   selectModelLabelById,
+  selectModelOptions,
   selectModelLabelWithClass
 } from "@ai-matrx/agents/models";
 import { useModelRecordsSelector } from "@ai-matrx/agents/models/react";
@@ -92,14 +95,36 @@ function useModelClassControls(modelId, offeringId) {
   if (status === "failed") return { failed: true };
   return { pending: true };
 }
+function useModelOptions() {
+  const options = useModelRecords(selectModelOptions);
+  const isLoading = useModelRecords((s) => s.isLoading);
+  const error = useModelRecords((s) => s.error);
+  const isReady = useModelRecords(selectActiveModelsReady);
+  useEffect(() => {
+    if (chatHostHasDatabase()) void getModelRecords().loadOptions();
+  }, []);
+  return { options, isLoading, error, isReady };
+}
+function useModelFull(modelId) {
+  const record = useModelRecords((s) => selectModelById(s, modelId));
+  const isFull = useModelRecords((s) => selectModelFullyLoaded(s, modelId));
+  useEffect(() => {
+    if (!chatHostHasDatabase()) return;
+    void getModelRecords().loadOptions();
+    if (modelId && !isFull) void getModelRecords().loadModel(modelId);
+  }, [modelId, isFull]);
+  return isFull ? record : void 0;
+}
 export {
   getModelCatalog,
   getModelRecords,
   readModelRecords,
   useModelClassControls,
   useModelClassLabels,
+  useModelFull,
   useModelLabel,
   useModelLabelWithClass,
+  useModelOptions,
   useModelRecord,
   useModelRecords
 };

package/dist/agents/identity/preferred-chat-model.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The person's preferred chat model (agent core B6 — chat resolves it itself; the
+ * `resolvePreferredChatModel` host slot is retired). `agents.model_prefs.chat_default_model` and
+ * its class companion, through the settings ladder (organization → user → device) of the host's
+ * knobs port. Null when nobody set one — the Holder's own model answers. A read failure is
+ * announced and answers null: a run never blocks on a preference.
+ */
+import { type PreferredModelChoice } from "@ai-matrx/agents/models";
+export declare function resolvePreferredChatModel(): Promise<PreferredModelChoice | null>;

package/dist/agents/identity/preferred-chat-model.js

@@ -0,0 +1,33 @@
+import {
+  CHAT_DEFAULT_MODEL_KNOB,
+  modelClassKnobFor,
+  modelClassPinOf,
+  resolvePreferredModelChoice
+} from "@ai-matrx/agents/models";
+import { supabase } from "../../host/db.js";
+import { ensureEffectiveKnob } from "../../host/prefs.js";
+import { getActiveOrgId } from "../../host/org.js";
+import { getUserId } from "../../host/identity.js";
+async function resolvePreferredChatModel() {
+  try {
+    return await resolvePreferredModelChoice(
+      {
+        client: () => supabase,
+        resolveKnob: (fullKey) => ensureEffectiveKnob(getActiveOrgId(), getUserId(), fullKey),
+        classKnobFor: modelClassKnobFor,
+        classPinOf: (value) => modelClassPinOf(value) ?? null
+      },
+      CHAT_DEFAULT_MODEL_KNOB,
+      "preferredChatModel"
+    );
+  } catch (error) {
+    console.error(
+      `[preferredChatModel] ${CHAT_DEFAULT_MODEL_KNOB} could not be resolved \u2014 the Holder's own model answers this run:`,
+      error
+    );
+    return null;
+  }
+}
+export {
+  resolvePreferredChatModel
+};

package/dist/agents/identity/settings-store.d.ts

@@ -0,0 +1,10 @@
+import { type NormalizedControls, type SettingsStore } from "@ai-matrx/agents/settings";
+export declare function getSettingsStore(): SettingsStore;
+/** One agent's settings entry from the page's store. */
+export declare function useAgentSettingsEntry(agentId: string | null | undefined): import("@ai-matrx/agents/settings").AgentSettingsEntry | undefined;
+/**
+ * Parsed controls for a settings entry's effective model: the pinned CLASS's controls when a pin
+ * is set and loaded (a model's classes run through different APIs), else the model's own. Null
+ * until the record (full, with controls) is loaded or when the agent has no entry.
+ */
+export declare function useNormalizedControls(agentId: string): NormalizedControls | null;

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;