@ai-matrx/chat 0.3.26 → 0.3.27

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @ai-matrx/chat
 
+## 0.3.27
+
+Automatic changed-only republish (docs/metadata drift since the last tag — see
+`git diff npm/chat/v0.3.26..npm/chat/v0.3.27 -- apps/shared/chat`).
+No source changes intended and no consumer action required.
+
 ## 0.3.26 — 2026-10-07
 
 - `useDomCapturePrint` calls `captureDocumentPdf` (alchemy 0.20.2) — 0.3.22–0.3.25 imported the unpublished `documentToPdf`, so the PDF export reported an error.

package/dist/agents/redux/agent-definition/run-tier-record.d.ts

@@ -0,0 +1,27 @@
+/**
+ * THE RUN TIER HAS ONE HOLDER (agent core B2 tail): the core run tier store
+ * (`@ai-matrx/agents/runtime`, bound by `agents/identity/run-tier-store.ts`). Chat's agent record
+ * never receives a copy of its answer. The record holds what the agent's OWN reads put there (the
+ * builder's full definition and unsaved edits, the fetch status the run thunks set); every field the
+ * record has not read is completed here, at read time, from the store's last answer:
+ *
+ *   field the record READ (builder / edit)  >  run tier (`agx_get_run_tier`)  >  run controls
+ *   access level: the dedicated `agx_get_access_level` answer  >  the record  >  the run tier
+ *
+ * The completed record is derived and cached per (record, answers) — the same object until one of
+ * them changes, so memoized selectors stay stable. The run thunks resolve the store BEFORE they
+ * dispatch (fetch status / fulfilled), so every `useAppSelector` re-reads after an answer lands.
+ */
+import type { RunTierState } from "@ai-matrx/agents/runtime";
+import type { AccessLevel, AgentDefinitionRecord } from "../../types/agent-definition.types.js";
+export declare function toRegistryAccessLevel(value: string | null | undefined): AccessLevel | null;
+/**
+ * The store's state — the one place chat reads run tier answers from. A host with no database
+ * bound yet (a unit test, the first render before the host binds) has no answers: the records
+ * read as they are.
+ */
+export declare function readRunTierState(): RunTierState;
+/** One record completed from the store's answers (unchanged when the store holds none). */
+export declare function completeAgentRecord(record: AgentDefinitionRecord, state: RunTierState): AgentDefinitionRecord;
+/** Every record completed — the map `selectAllAgents` returns. Same object until either input changes. */
+export declare function completeAgentRecords(agents: Record<string, AgentDefinitionRecord>, state: RunTierState): Record<string, AgentDefinitionRecord>;

package/dist/agents/redux/agent-definition/run-tier-record.js

@@ -0,0 +1,95 @@
+import { addField, hasField } from "@ai-matrx/agents/field-flags";
+import { getRunTierStore } from "../../identity/run-tier-store.js";
+import { parseSkillConfigJson } from "./converters.js";
+const REGISTRY_ACCESS_LEVELS = ["owner", "admin", "editor", "viewer", "system"];
+function toRegistryAccessLevel(value) {
+  return REGISTRY_ACCESS_LEVELS.find((level) => level === value) ?? null;
+}
+const NO_ANSWERS = Object.freeze({
+  runTier: {},
+  runControls: {},
+  accessLevel: {},
+  sharedWithMe: { status: "idle", data: null, error: null },
+  sharedForChat: { status: "idle", data: null, error: null }
+});
+function readRunTierState() {
+  try {
+    return getRunTierStore().getState();
+  } catch {
+    return NO_ANSWERS;
+  }
+}
+const cache = /* @__PURE__ */ new WeakMap();
+function answersFor(state, id) {
+  return {
+    rt: state.runTier[id]?.data ?? null,
+    rc: state.runControls[id]?.data ?? null,
+    al: state.accessLevel[id]?.data ?? null
+  };
+}
+function completeAgentRecord(record, state) {
+  const answers = answersFor(state, record.id);
+  if (!answers.rt && !answers.rc && !answers.al) return record;
+  const hit = cache.get(record);
+  if (hit && hit.rt === answers.rt && hit.rc === answers.rc && hit.al === answers.al) return hit.out;
+  const loaded = { ...record._loadedFields };
+  const out = { ...record, _loadedFields: loaded };
+  const unread = (field) => !hasField(record._loadedFields, field);
+  const fill = (field, value) => {
+    out[field] = value;
+    addField(loaded, field);
+  };
+  const rt = answers.rt;
+  if (rt) {
+    if (unread("variableDefinitions")) fill("variableDefinitions", rt.variable_definitions);
+    if (unread("contextPolicies")) fill("contextPolicies", rt.context_policies ?? []);
+    if (unread("autoContextDisabled")) fill("autoContextDisabled", rt.auto_context_disabled === true);
+    if (rt.model_id && unread("modelId")) fill("modelId", rt.model_id);
+    if (unread("uiGates")) fill("uiGates", rt.ui_gates ?? {});
+    if (rt.tool_ids && unread("tools")) fill("tools", rt.tool_ids);
+    if (!out.name && unread("name")) fill("name", rt.name);
+    if (out.description == null && unread("description")) fill("description", rt.description ?? "");
+    if (!out.accessLevel) fill("accessLevel", toRegistryAccessLevel(rt.access_level));
+    fill("runCounts", {
+      customTools: rt.custom_tool_count ?? 0,
+      skills: rt.skill_count ?? 0,
+      connections: rt.connection_count ?? 0
+    });
+  }
+  const rc = answers.rc;
+  if (rc) {
+    fill("runControls", { customToolNames: rc.custom_tool_names ?? [] });
+    if (!hasField(loaded, "tools")) fill("tools", rc.tool_ids ?? []);
+    if (!hasField(loaded, "autoToolsDisabled")) fill("autoToolsDisabled", rc.auto_tools_disabled === true);
+    if (!hasField(loaded, "skillConfig")) fill("skillConfig", parseSkillConfigJson(rc.skill_config));
+    if (!hasField(loaded, "mcpServers")) fill("mcpServers", rc.mcp_servers ?? []);
+  }
+  const al = answers.al;
+  if (al) {
+    fill("isOwner", al.is_owner);
+    fill("accessLevel", al.access_level);
+  }
+  cache.set(record, { ...answers, out });
+  return out;
+}
+const mapCache = /* @__PURE__ */ new WeakMap();
+function completeAgentRecords(agents, state) {
+  const hit = mapCache.get(agents);
+  if (hit && hit.state === state) return hit.out;
+  let changed = false;
+  const out = {};
+  for (const [id, record] of Object.entries(agents)) {
+    const done = completeAgentRecord(record, state);
+    if (done !== record) changed = true;
+    out[id] = done;
+  }
+  const result = changed ? out : agents;
+  mapCache.set(agents, { state, out: result });
+  return result;
+}
+export {
+  completeAgentRecord,
+  completeAgentRecords,
+  readRunTierState,
+  toRegistryAccessLevel
+};