@ai-matrx/agents 0.59.175 → 0.59.177

package/dist/versions/index.js

@@ -0,0 +1,208 @@
+// versions/constants.ts
+var AGENT_EXCLUDE_PATHS = /* @__PURE__ */ new Set([
+  "id",
+  "userId",
+  "organizationId",
+  "taskId",
+  "createdAt",
+  "updatedAt",
+  "isVersion",
+  "parentAgentId",
+  "sourceAgentId",
+  "sourceSnapshotAt",
+  // Lineage and record bookkeeping: who made the row and which version it was
+  // copied from never change what the agent does, so a copy never "differs" here.
+  "sourceVersion",
+  "followsSource",
+  "createdBy",
+  "runCounts",
+  "isOwner",
+  "accessLevel",
+  "sharedByEmail",
+  "agentType",
+  "version",
+  "changeNote",
+  "changedAt"
+]);
+var AGENT_IDENTITY_KEYS = {
+  variableDefinitions: "name",
+  contextPolicies: "key",
+  customTools: "name"
+};
+var AGENT_DIFF_OPTIONS = {
+  excludePaths: AGENT_EXCLUDE_PATHS,
+  identityKeys: AGENT_IDENTITY_KEYS,
+  // Output-schema property order is authored behavior: model providers often
+  // emit fields in schema order, so a reorder must be visible in version diffs.
+  orderSensitiveObjectPaths: /* @__PURE__ */ new Set(["outputSchema"]),
+  // Agent configuration is executable data. `_`/`__` keys (especially
+  // output-schema `__kind`) are contract fields, never hidden metadata.
+  skipUnderscorePrefix: false
+};
+
+// versions/compare.ts
+import { computeDiff } from "@ai-matrx/diff/structural";
+var AGENT_PROFILE_FIELDS = /* @__PURE__ */ new Set(["name", "description", "category", "tags"]);
+var AGENT_LOCAL_STATE_FIELDS = /* @__PURE__ */ new Set([
+  "isActive",
+  "isArchived",
+  "isFavorite"
+]);
+function toComparableAgentRecord(agent) {
+  return Object.fromEntries(
+    Object.entries(agent).filter(([key]) => !key.startsWith("_"))
+  );
+}
+function compareAgentDefinitions(systemAgent, personalAgent) {
+  const systemRecord = toComparableAgentRecord(systemAgent);
+  const personalRecord = toComparableAgentRecord(personalAgent);
+  const diffResult = computeDiff(
+    systemRecord,
+    personalRecord,
+    AGENT_DIFF_OPTIONS
+  );
+  const changedFields = diffResult.root.filter(
+    (node) => node.changeType !== "unchanged"
+  );
+  const profileFields = changedFields.filter(
+    (node) => AGENT_PROFILE_FIELDS.has(node.key)
+  );
+  const localStateFields = changedFields.filter(
+    (node) => AGENT_LOCAL_STATE_FIELDS.has(node.key)
+  );
+  const behaviorFields = changedFields.filter(
+    (node) => !AGENT_PROFILE_FIELDS.has(node.key) && !AGENT_LOCAL_STATE_FIELDS.has(node.key)
+  );
+  return {
+    diffResult,
+    changedFields,
+    behaviorFields,
+    profileFields,
+    localStateFields,
+    behaviorMatches: behaviorFields.length === 0,
+    comparedConfigurationMatches: !diffResult.hasChanges
+  };
+}
+
+// versions/promote-failure-message.ts
+var GENERIC = "Failed to promote version";
+function promoteFailureMessage(err) {
+  const raw = err instanceof Error ? err.message : err && typeof err === "object" && "message" in err ? String(err.message ?? "") : typeof err === "string" ? err : "";
+  const reason = raw.trim();
+  return reason ? `${GENERIC}: ${reason}` : GENERIC;
+}
+
+// versions/enrich.ts
+import { computeDiff as computeDiff2 } from "@ai-matrx/diff/structural";
+function computeVersionFetchTargets(versions) {
+  if (versions.length === 0) return [];
+  const sorted = [...versions].sort((a, b) => b.version_number - a.version_number);
+  const targets = /* @__PURE__ */ new Set();
+  for (const v of sorted.slice(0, 10)) targets.add(v.version_number);
+  if (sorted.length <= 10) return [...targets];
+  targets.add(sorted[sorted.length - 1].version_number);
+  const remaining = sorted.slice(10, -1);
+  if (remaining.length > 0) {
+    const step = Math.max(1, Math.floor(remaining.length / Math.ceil(remaining.length / 10)));
+    for (let i = 0; i < remaining.length; i += step) targets.add(remaining[i].version_number);
+  }
+  return [...targets];
+}
+function enrichVersions(versions, snapshotOf) {
+  const sorted = [...versions].sort((a, b) => b.version_number - a.version_number);
+  return sorted.map((v, i) => {
+    const snapshot = snapshotOf(v.version_number);
+    const prev = sorted[i + 1];
+    const prevSnapshot = prev ? snapshotOf(prev.version_number) : void 0;
+    let diffSummary;
+    if (snapshot && prevSnapshot) {
+      diffSummary = computeDiff2(
+        prevSnapshot,
+        snapshot,
+        AGENT_DIFF_OPTIONS
+      );
+    }
+    return { ...v, snapshotLoaded: !!snapshot, ...diffSummary ? { diffSummary } : {} };
+  });
+}
+var camel = (key) => key.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+function snapshotToComparable(row) {
+  const out = {};
+  for (const [key, value] of Object.entries(row)) {
+    const name = key === "version_number" ? "version" : camel(key);
+    out[name] = value;
+  }
+  return out;
+}
+
+// versions/data.ts
+var AgentVersionsError = class extends Error {
+  code;
+  detail;
+  hint;
+  constructor(error) {
+    super(error.message || "The agent's versions could not be read and the database gave no reason.");
+    this.name = "AgentVersionsError";
+    this.code = error.code ?? null;
+    this.detail = error.details ?? null;
+    this.hint = error.hint ?? null;
+  }
+};
+async function listAgentVersions(client, query) {
+  const { data, error } = await client.rpc("agx_get_version_history", {
+    p_agent_id: query.agentId,
+    p_limit: query.limit ?? 50,
+    p_offset: query.offset ?? 0
+  });
+  if (error) throw new AgentVersionsError(error);
+  return Array.isArray(data) ? data : [];
+}
+async function readAgentVersionSnapshot(client, query) {
+  const { data, error } = await client.rpc("agx_get_version_snapshot", {
+    p_agent_id: query.agentId,
+    p_version_number: query.version
+  });
+  if (error) throw new AgentVersionsError(error);
+  const raw = Array.isArray(data) ? data[0] : data;
+  return raw && typeof raw === "object" ? raw : null;
+}
+async function resolveAgentVersionId(client, versionId) {
+  const { data, error } = await client.schema("agent").from("definition_version").select("id, agent_id, version_number, name").eq("id", versionId).maybeSingle();
+  if (error) throw new AgentVersionsError(error);
+  if (!data) return null;
+  const row = data;
+  return { versionId: row.id, agentId: row.agent_id, versionNumber: row.version_number, agentName: row.name };
+}
+async function promoteAgentVersion(client, query) {
+  const { data, error } = await client.rpc("agx_promote_version", {
+    p_agent_id: query.agentId,
+    p_version_number: query.version
+  });
+  if (error) throw new AgentVersionsError(error);
+  const result = data ?? {};
+  return { ...result, success: result.success === true };
+}
+async function declareContractBreak(client, query) {
+  const { error } = await client.rpc("agx_declare_contract_break", {
+    p_agent_id: query.agentId,
+    p_version_number: query.version,
+    p_kind: query.kind ?? void 0
+  });
+  if (error) throw new AgentVersionsError(error);
+}
+export {
+  AGENT_DIFF_OPTIONS,
+  AGENT_EXCLUDE_PATHS,
+  AGENT_IDENTITY_KEYS,
+  AgentVersionsError,
+  compareAgentDefinitions,
+  computeVersionFetchTargets,
+  declareContractBreak,
+  enrichVersions,
+  listAgentVersions,
+  promoteAgentVersion,
+  promoteFailureMessage,
+  readAgentVersionSnapshot,
+  resolveAgentVersionId,
+  snapshotToComparable
+};