@axiom-lattice/core 2.1.99 → 2.1.100

package/dist/index.mjs

@@ -9974,7 +9974,7 @@ import {
   asyncScheduler
 } from "rxjs";
 import { eachValueFrom } from "rxjs-for-await";
-import { filter, takeWhile } from "rxjs/operators";
+import { takeWhile, skip } from "rxjs/operators";
 var InMemoryChunkBuffer = class extends ChunkBuffer {
   constructor(config) {
     super();
@@ -10184,17 +10184,18 @@ var InMemoryChunkBuffer = class extends ChunkBuffer {
       MessageChunkTypes.THREAD_IDLE
     ];
     const typesToStop = stopTypes ?? defaultStopTypes;
-    let startYieldChunk = false;
-    console.log("start from messageId", messageId);
+    let startIndex = 0;
+    for (let i = buffer2.chunks.length - 1; i >= 0; i--) {
+      if (buffer2.chunks[i].data?.id === messageId) {
+        startIndex = i;
+        break;
+      }
+    }
+    const stopSet = new Set(typesToStop);
     const filtered$ = buffer2.chunks$.pipe(
       observeOn(asyncScheduler),
-      // 1. 从指定 messageId 开始
-      filter((chunk) => {
-        if (chunk.data?.id === messageId) startYieldChunk = true;
-        return startYieldChunk;
-      }),
-      // 2. 包含指定的停止类型，但收到后停止
-      takeWhile((chunk) => !typesToStop.includes(chunk.type), true)
+      skip(startIndex),
+      takeWhile((chunk) => !stopSet.has(chunk.type), true)
     );
     yield* eachValueFrom(filtered$);
   }
@@ -26719,6 +26720,230 @@ var PersonalAssistantConfig = class {
 };
 PersonalAssistantConfig._config = deepClone(DEFAULT_CONFIG);
 
+// src/export_import/ExportableEntityRegistry.ts
+var ExportableEntityRegistry = class _ExportableEntityRegistry {
+  constructor() {
+    this.definitions = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Returns the singleton registry instance, creating it if necessary.
+   *
+   * @returns The singleton {@link ExportableEntityRegistry} instance.
+   */
+  static getInstance() {
+    if (!_ExportableEntityRegistry.instance) {
+      _ExportableEntityRegistry.instance = new _ExportableEntityRegistry();
+    }
+    return _ExportableEntityRegistry.instance;
+  }
+  /**
+   * Registers an exportable entity type definition.
+   *
+   * @param def - The entity definition to register.
+   *
+   * @throws If an entity type with the same `entityType` is already registered.
+   */
+  register(def) {
+    if (this.definitions.has(def.entityType)) {
+      throw new Error(
+        `Exportable entity type "${def.entityType}" is already registered`
+      );
+    }
+    this.definitions.set(def.entityType, def);
+  }
+  /**
+   * Retrieves a registered entity definition by type name.
+   *
+   * @param entityType - The entity type identifier (e.g. `'skill'`, `'agent'`).
+   *
+   * @returns The registered {@link ExportableEntityDefinition}.
+   *
+   * @throws If no definition is registered for the given type.
+   */
+  get(entityType) {
+    const def = this.definitions.get(entityType);
+    if (!def) {
+      throw new Error(`Exportable entity type "${entityType}" not found`);
+    }
+    return def;
+  }
+  /**
+   * Returns lightweight metadata for all registered types (for the frontend).
+   *
+   * @returns An array of {@link ExportableTypeInfo} objects.
+   */
+  listTypes() {
+    return [...this.definitions.values()].map((d) => ({
+      entityType: d.entityType,
+      label: d.label,
+      category: d.category,
+      dependsOn: d.dependsOn,
+      cascadeParents: d.cascadeParents
+    }));
+  }
+  /**
+   * Returns all registered entity definitions.
+   *
+   * @returns An array of all registered {@link ExportableEntityDefinition} objects.
+   */
+  getAll() {
+    return [...this.definitions.values()];
+  }
+  /**
+   * Removes a registered entity type definition.
+   *
+   * @param entityType - The entity type identifier to remove.
+   */
+  unregister(entityType) {
+    this.definitions.delete(entityType);
+  }
+};
+
+// src/export_import/DependencyResolver.ts
+var DependencyResolver = class {
+  /**
+   * Topological sort of entity types based on their {@link ExportableEntityDefinition.dependsOn}
+   * declarations.  Entities with no dependencies come first.
+   *
+   * @param defs - All registered exportable entity definitions.
+   * @returns Entity type names in dependency-first order.
+   */
+  static resolveOrder(defs) {
+    const typeMap = new Map(defs.map((d) => [d.entityType, d]));
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    function visit(type) {
+      if (visited.has(type)) return;
+      visited.add(type);
+      const def = typeMap.get(type);
+      if (def) {
+        for (const dep of def.dependsOn) {
+          if (typeMap.has(dep)) {
+            visit(dep);
+          }
+        }
+      }
+      result.push(type);
+    }
+    for (const def of defs) {
+      visit(def.entityType);
+    }
+    return result;
+  }
+  /**
+   * Given a set of selected entity types, expand to include all CASCADE
+   * parents.  Only walks **upward** (parents), never downward (children).
+   *
+   * @param defs    - All registered exportable entity definitions.
+   * @param selected - Entity type names the user explicitly chose.
+   * @returns The original selection plus every reachable cascade parent.
+   */
+  static expandCascade(defs, selected) {
+    const typeMap = new Map(defs.map((d) => [d.entityType, d]));
+    const result = new Set(selected);
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const type of [...result]) {
+        const def = typeMap.get(type);
+        if (def) {
+          for (const parent of def.cascadeParents) {
+            if (!result.has(parent)) {
+              result.add(parent);
+              changed = true;
+            }
+          }
+        }
+      }
+    }
+    return [...result];
+  }
+  /**
+   * Compute which required dependencies are missing from the selected types.
+   *
+   * Only considers dependencies that are themselves registered as exportable
+   * entity types.  Unregistered dependencies (e.g. `Workspace`, `Project` —
+   * infrastructure types) are silently excluded.
+   *
+   * @param defs    - All registered exportable entity definitions.
+   * @param selected - Entity type names the user has selected.
+   * @returns The list of entity types that must also be selected (or
+   *          auto-included).
+   */
+  static computeDependencies(defs, selected) {
+    const typeMap = new Map(defs.map((d) => [d.entityType, d]));
+    const selectedSet = new Set(selected);
+    const missing = /* @__PURE__ */ new Set();
+    function collectMissing(type) {
+      if (selectedSet.has(type)) return;
+      const def = typeMap.get(type);
+      if (!def) return;
+      missing.add(type);
+      for (const dep of def.dependsOn) {
+        collectMissing(dep);
+      }
+    }
+    for (const type of selected) {
+      const def = typeMap.get(type);
+      if (def) {
+        for (const dep of def.dependsOn) {
+          collectMissing(dep);
+        }
+      }
+    }
+    return { missing: [...missing] };
+  }
+};
+
+// src/export_import/IdRemapper.ts
+var REF_PATTERN = /^@(\w+)\/(.+)$/;
+var IdRemapper = class {
+  constructor(idMap) {
+    this.idMap = idMap;
+  }
+  /**
+   * Deep-traverse an object/array and replace all @type/exportId string values
+   * with their corresponding real IDs from the idMap.
+   * Values not matching the @type/exportId pattern are returned unchanged.
+   */
+  remapReferences(value) {
+    if (value === null || value === void 0) return value;
+    if (typeof value === "string") {
+      const match = value.match(REF_PATTERN);
+      if (match) {
+        const exportId = match[2];
+        if (this.idMap[exportId] !== void 0) {
+          return this.idMap[exportId];
+        }
+      }
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.remapReferences(item));
+    }
+    if (typeof value === "object") {
+      const result = {};
+      for (const [key4, val] of Object.entries(value)) {
+        result[key4] = this.remapReferences(val);
+      }
+      return result;
+    }
+    return value;
+  }
+  /**
+   * Replace raw skill IDs in an agent's graphDefinition.skillIds array.
+   * This handles the implicit agent->skill reference that uses raw skill IDs
+   * (not @type/exportId format). Agents reference skills by their string ID.
+   */
+  remapSkillIds(graphDefinition, skillRemap) {
+    const cloned = structuredClone(graphDefinition);
+    if (Array.isArray(cloned.skillIds)) {
+      cloned.skillIds = cloned.skillIds.map((id) => skillRemap[id] ?? id);
+    }
+    return cloned;
+  }
+};
+
 // src/index.ts
 registerBuiltinPlugins();
 export {
@@ -26741,13 +26966,16 @@ export {
   DaytonaInstance,
   DaytonaProvider,
   DefaultScheduleClient,
+  DependencyResolver,
   E2BInstance,
   E2BProvider,
   EMPTY_CONTENT_WARNING,
   EmbeddingsLatticeManager,
+  ExportableEntityRegistry,
   FileSystemSkillStore,
   FilesystemBackend,
   HumanMessage4 as HumanMessage,
+  IdRemapper,
   InMemoryA2AApiKeyStore,
   InMemoryAssistantStore,
   InMemoryBindingStore,