@elizaos/plugin-action-bench 1.4.2 → 1.4.4

package/dist/index.cjs

@@ -866,15 +866,811 @@ var multiverseMathActions = [
   transferAction
 ];
 
+// src/actions/relationalData.ts
+function getRelationalState(state) {
+  return {
+    entities: state?.values?.entities || {},
+    relationships: state?.values?.relationships || {},
+    currentEntity: state?.values?.currentEntity || null,
+    queryResults: state?.values?.queryResults || []
+  };
+}
+function generateId(prefix) {
+  const timestamp = Date.now();
+  const random = Math.floor(Math.random() * 1e3);
+  return `${prefix}_${timestamp}_${random}`;
+}
+var createEntityAction = {
+  name: "CREATE_ENTITY",
+  similes: ["NEW_ENTITY", "ADD_ENTITY", "MAKE_ENTITY"],
+  description: "Create a new entity with a type and name. Entities are the nodes in our relational graph.",
+  validate: async () => true,
+  handler: async (_runtime, message, state, _options, callback) => {
+    const relState = getRelationalState(state);
+    const content = message.content.text?.toLowerCase() || "";
+    let entityType = "generic";
+    let entityName = "unnamed";
+    if (content.includes("person")) entityType = "person";
+    else if (content.includes("company")) entityType = "company";
+    else if (content.includes("product")) entityType = "product";
+    else if (content.includes("location")) entityType = "location";
+    else if (content.includes("project")) entityType = "project";
+    else if (content.includes("department")) entityType = "department";
+    else if (content.includes("task")) entityType = "task";
+    else if (content.includes("document")) entityType = "document";
+    const nameMatch = content.match(/named?\s+["']?([^"']+)["']?/i) || content.match(/called\s+["']?([^"']+)["']?/i) || content.match(/:\s*["']?([^"']+)["']?/i);
+    if (nameMatch) {
+      entityName = nameMatch[1].trim();
+    }
+    const entityId = generateId("entity");
+    const entity = {
+      id: entityId,
+      type: entityType,
+      name: entityName,
+      attributes: {},
+      created: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    relState.entities[entityId] = entity;
+    relState.currentEntity = entityId;
+    const text = `Created entity: ${entityName} (${entityType}) with ID: ${entityId}`;
+    if (callback) {
+      await callback({ text, source: message.content.source });
+    }
+    return {
+      success: true,
+      text,
+      values: {
+        ...state?.values,
+        entities: relState.entities,
+        currentEntity: entityId,
+        lastOperation: "create_entity"
+      },
+      data: {
+        operation: "create_entity",
+        entity,
+        totalEntities: Object.keys(relState.entities).length
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user}}",
+        content: { text: "create person entity named John" }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "Created entity: John (person) with ID: entity_...",
+          actions: ["CREATE_ENTITY"]
+        }
+      }
+    ]
+  ]
+};
+var createRelationshipAction = {
+  name: "CREATE_RELATIONSHIP",
+  similes: ["LINK", "CONNECT", "RELATE"],
+  description: "Create a relationship between two entities. Relationships are the edges in our relational graph.",
+  validate: async (_runtime, _message, state) => {
+    const relState = getRelationalState(state);
+    return Object.keys(relState.entities).length >= 2;
+  },
+  handler: async (_runtime, message, state, _options, callback) => {
+    const relState = getRelationalState(state);
+    const entities = Object.values(relState.entities);
+    if (entities.length < 2) {
+      return {
+        success: false,
+        text: "Error: Need at least 2 entities to create a relationship",
+        values: state?.values || {}
+      };
+    }
+    const content = message.content.text?.toLowerCase() || "";
+    let relationType = "related_to";
+    if (content.includes("parent") || content.includes("child")) relationType = "parent_child";
+    else if (content.includes("sibling")) relationType = "sibling";
+    else if (content.includes("friend")) relationType = "friend";
+    else if (content.includes("employee") || content.includes("works")) relationType = "employment";
+    else if (content.includes("owns") || content.includes("owner")) relationType = "ownership";
+    else if (content.includes("manages") || content.includes("reports")) relationType = "management";
+    else if (content.includes("partner")) relationType = "partnership";
+    else if (content.includes("member")) relationType = "membership";
+    else if (content.includes("located")) relationType = "location";
+    else if (content.includes("assigned")) relationType = "assignment";
+    let fromEntity;
+    let toEntity;
+    if (relState.currentEntity && relState.entities[relState.currentEntity]) {
+      fromEntity = relState.entities[relState.currentEntity];
+      toEntity = entities.filter((e) => e.id !== relState.currentEntity)[entities.length - 2] || entities[0];
+    } else {
+      fromEntity = entities[entities.length - 1];
+      toEntity = entities[entities.length - 2];
+    }
+    const relationshipId = generateId("rel");
+    const relationship = {
+      id: relationshipId,
+      type: relationType,
+      fromEntity: fromEntity.id,
+      toEntity: toEntity.id,
+      properties: {},
+      created: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    relState.relationships[relationshipId] = relationship;
+    const text = `Created ${relationType} relationship: ${fromEntity.name} \u2192 ${toEntity.name}`;
+    if (callback) {
+      await callback({ text, source: message.content.source });
+    }
+    return {
+      success: true,
+      text,
+      values: {
+        ...state?.values,
+        relationships: relState.relationships,
+        lastOperation: "create_relationship"
+      },
+      data: {
+        operation: "create_relationship",
+        relationship,
+        fromEntity: fromEntity.name,
+        toEntity: toEntity.name,
+        totalRelationships: Object.keys(relState.relationships).length
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user}}",
+        content: { text: "create parent relationship" }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "Created parent_child relationship: Entity1 \u2192 Entity2",
+          actions: ["CREATE_RELATIONSHIP"]
+        }
+      }
+    ]
+  ]
+};
+var setAttributeAction = {
+  name: "SET_ATTRIBUTE",
+  similes: ["ADD_ATTRIBUTE", "SET_PROPERTY", "UPDATE_ATTRIBUTE"],
+  description: "Set an attribute on the current entity. Attributes store additional data on entities.",
+  validate: async (_runtime, _message, state) => {
+    const relState = getRelationalState(state);
+    return relState.currentEntity !== null && relState.entities[relState.currentEntity] !== void 0;
+  },
+  handler: async (_runtime, message, state, _options, callback) => {
+    const relState = getRelationalState(state);
+    if (!relState.currentEntity || !relState.entities[relState.currentEntity]) {
+      return {
+        success: false,
+        text: "Error: No current entity selected",
+        values: state?.values || {}
+      };
+    }
+    const entity = relState.entities[relState.currentEntity];
+    const content = message.content.text || "";
+    let key = "property";
+    let value = "value";
+    const ageMatch = content.match(/age[:\s]+(\d+)/i);
+    const emailMatch = content.match(/email[:\s]+([^\s]+)/i);
+    const phoneMatch = content.match(/phone[:\s]+([^\s]+)/i);
+    const statusMatch = content.match(/status[:\s]+([^\s]+)/i);
+    const roleMatch = content.match(/role[:\s]+([^\s]+)/i);
+    const departmentMatch = content.match(/department[:\s]+([^\s]+)/i);
+    const salaryMatch = content.match(/salary[:\s]+(\d+)/i);
+    const locationMatch = content.match(/location[:\s]+([^\s]+)/i);
+    if (ageMatch) {
+      key = "age";
+      value = parseInt(ageMatch[1]);
+    } else if (emailMatch) {
+      key = "email";
+      value = emailMatch[1];
+    } else if (phoneMatch) {
+      key = "phone";
+      value = phoneMatch[1];
+    } else if (statusMatch) {
+      key = "status";
+      value = statusMatch[1];
+    } else if (roleMatch) {
+      key = "role";
+      value = roleMatch[1];
+    } else if (departmentMatch) {
+      key = "department";
+      value = departmentMatch[1];
+    } else if (salaryMatch) {
+      key = "salary";
+      value = parseInt(salaryMatch[1]);
+    } else if (locationMatch) {
+      key = "location";
+      value = locationMatch[1];
+    } else {
+      const genericMatch = content.match(/(\w+)[:\s=]+([^\s]+)/i);
+      if (genericMatch) {
+        key = genericMatch[1];
+        value = genericMatch[2];
+        const numValue = parseFloat(value);
+        if (!isNaN(numValue)) value = numValue;
+      }
+    }
+    entity.attributes[key] = value;
+    const text = `Set attribute on ${entity.name}: ${key} = ${value}`;
+    if (callback) {
+      await callback({ text, source: message.content.source });
+    }
+    return {
+      success: true,
+      text,
+      values: {
+        ...state?.values,
+        entities: relState.entities,
+        lastOperation: "set_attribute"
+      },
+      data: {
+        operation: "set_attribute",
+        entityId: entity.id,
+        entityName: entity.name,
+        attribute: { key, value },
+        totalAttributes: Object.keys(entity.attributes).length
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user}}",
+        content: { text: "set age 25" }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "Set attribute on Entity: age = 25",
+          actions: ["SET_ATTRIBUTE"]
+        }
+      }
+    ]
+  ]
+};
+var queryRelationshipsAction = {
+  name: "QUERY_RELATIONSHIPS",
+  similes: ["FIND_RELATIONSHIPS", "GET_CONNECTIONS", "SHOW_LINKS"],
+  description: "Query relationships of a specific type or for a specific entity.",
+  validate: async () => true,
+  handler: async (_runtime, message, state, _options, callback) => {
+    const relState = getRelationalState(state);
+    const content = message.content.text?.toLowerCase() || "";
+    let results = [];
+    let queryDescription = "";
+    if (content.includes("parent")) {
+      results = Object.values(relState.relationships).filter((r) => r.type === "parent_child").map((r) => ({
+        type: r.type,
+        from: relState.entities[r.fromEntity]?.name || r.fromEntity,
+        to: relState.entities[r.toEntity]?.name || r.toEntity
+      }));
+      queryDescription = "parent-child relationships";
+    } else if (content.includes("sibling")) {
+      results = Object.values(relState.relationships).filter((r) => r.type === "sibling").map((r) => ({
+        type: r.type,
+        from: relState.entities[r.fromEntity]?.name || r.fromEntity,
+        to: relState.entities[r.toEntity]?.name || r.toEntity
+      }));
+      queryDescription = "sibling relationships";
+    } else if (content.includes("all")) {
+      results = Object.values(relState.relationships).map((r) => ({
+        type: r.type,
+        from: relState.entities[r.fromEntity]?.name || r.fromEntity,
+        to: relState.entities[r.toEntity]?.name || r.toEntity
+      }));
+      queryDescription = "all relationships";
+    } else if (relState.currentEntity) {
+      results = Object.values(relState.relationships).filter((r) => r.fromEntity === relState.currentEntity || r.toEntity === relState.currentEntity).map((r) => ({
+        type: r.type,
+        from: relState.entities[r.fromEntity]?.name || r.fromEntity,
+        to: relState.entities[r.toEntity]?.name || r.toEntity,
+        direction: r.fromEntity === relState.currentEntity ? "outgoing" : "incoming"
+      }));
+      queryDescription = `relationships for ${relState.entities[relState.currentEntity]?.name}`;
+    }
+    const text = `Found ${results.length} ${queryDescription}`;
+    if (callback) {
+      await callback({ text, source: message.content.source });
+    }
+    return {
+      success: true,
+      text,
+      values: {
+        ...state?.values,
+        queryResults: results,
+        lastOperation: "query_relationships"
+      },
+      data: {
+        operation: "query_relationships",
+        query: queryDescription,
+        results,
+        count: results.length
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user}}",
+        content: { text: "query parent relationships" }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "Found 0 parent-child relationships",
+          actions: ["QUERY_RELATIONSHIPS"]
+        }
+      }
+    ]
+  ]
+};
+var queryEntitiesAction = {
+  name: "QUERY_ENTITIES",
+  similes: ["FIND_ENTITIES", "SEARCH_ENTITIES", "LIST_ENTITIES"],
+  description: "Query entities by type or attribute values.",
+  validate: async () => true,
+  handler: async (_runtime, message, state, _options, callback) => {
+    const relState = getRelationalState(state);
+    const content = message.content.text?.toLowerCase() || "";
+    let results = [];
+    let queryDescription = "";
+    if (content.includes("person")) {
+      results = Object.values(relState.entities).filter((e) => e.type === "person");
+      queryDescription = "person entities";
+    } else if (content.includes("company")) {
+      results = Object.values(relState.entities).filter((e) => e.type === "company");
+      queryDescription = "company entities";
+    } else if (content.includes("product")) {
+      results = Object.values(relState.entities).filter((e) => e.type === "product");
+      queryDescription = "product entities";
+    } else if (content.includes("all")) {
+      results = Object.values(relState.entities);
+      queryDescription = "all entities";
+    } else {
+      const ageMatch = content.match(/age\s*[><=]+\s*(\d+)/);
+      if (ageMatch) {
+        const age = parseInt(ageMatch[1]);
+        results = Object.values(relState.entities).filter((e) => {
+          const entityAge = e.attributes.age;
+          if (typeof entityAge !== "number") return false;
+          if (content.includes(">")) return entityAge > age;
+          if (content.includes("<")) return entityAge < age;
+          return entityAge === age;
+        });
+        queryDescription = `entities with age ${ageMatch[0]}`;
+      } else {
+        results = Object.values(relState.entities);
+        queryDescription = "all entities";
+      }
+    }
+    const resultSummary = results.map((e) => ({
+      id: e.id,
+      name: e.name,
+      type: e.type,
+      attributes: e.attributes
+    }));
+    const text = `Found ${results.length} ${queryDescription}`;
+    if (callback) {
+      await callback({ text, source: message.content.source });
+    }
+    return {
+      success: true,
+      text,
+      values: {
+        ...state?.values,
+        queryResults: resultSummary,
+        lastOperation: "query_entities"
+      },
+      data: {
+        operation: "query_entities",
+        query: queryDescription,
+        results: resultSummary,
+        count: results.length
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user}}",
+        content: { text: "query person entities" }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "Found 0 person entities",
+          actions: ["QUERY_ENTITIES"]
+        }
+      }
+    ]
+  ]
+};
+var selectEntityAction = {
+  name: "SELECT_ENTITY",
+  similes: ["CHOOSE_ENTITY", "FOCUS_ENTITY", "SET_CURRENT_ENTITY"],
+  description: "Select an entity as the current entity for operations.",
+  validate: async (_runtime, _message, state) => {
+    const relState = getRelationalState(state);
+    return Object.keys(relState.entities).length > 0;
+  },
+  handler: async (_runtime, message, state, _options, callback) => {
+    const relState = getRelationalState(state);
+    const content = message.content.text || "";
+    if (Object.keys(relState.entities).length === 0) {
+      return {
+        success: false,
+        text: "Error: No entities exist to select",
+        values: state?.values || {}
+      };
+    }
+    let selectedEntity;
+    for (const entity of Object.values(relState.entities)) {
+      if (content.toLowerCase().includes(entity.name.toLowerCase())) {
+        selectedEntity = entity;
+        break;
+      }
+    }
+    if (!selectedEntity) {
+      const entities = Object.values(relState.entities);
+      selectedEntity = entities[entities.length - 1];
+    }
+    relState.currentEntity = selectedEntity.id;
+    const text = `Selected entity: ${selectedEntity.name} (${selectedEntity.type})`;
+    if (callback) {
+      await callback({ text, source: message.content.source });
+    }
+    return {
+      success: true,
+      text,
+      values: {
+        ...state?.values,
+        currentEntity: selectedEntity.id,
+        lastOperation: "select_entity"
+      },
+      data: {
+        operation: "select_entity",
+        entity: selectedEntity
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user}}",
+        content: { text: "select entity John" }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "Selected entity: John (person)",
+          actions: ["SELECT_ENTITY"]
+        }
+      }
+    ]
+  ]
+};
+var deleteEntityAction = {
+  name: "DELETE_ENTITY",
+  similes: ["REMOVE_ENTITY", "DESTROY_ENTITY"],
+  description: "Delete the current entity and all its relationships.",
+  validate: async (_runtime, _message, state) => {
+    const relState = getRelationalState(state);
+    return relState.currentEntity !== null && relState.entities[relState.currentEntity] !== void 0;
+  },
+  handler: async (_runtime, message, state, _options, callback) => {
+    const relState = getRelationalState(state);
+    if (!relState.currentEntity || !relState.entities[relState.currentEntity]) {
+      return {
+        success: false,
+        text: "Error: No current entity selected",
+        values: state?.values || {}
+      };
+    }
+    const entity = relState.entities[relState.currentEntity];
+    const entityName = entity.name;
+    delete relState.entities[relState.currentEntity];
+    const relationshipsToDelete = [];
+    for (const [relId, rel] of Object.entries(relState.relationships)) {
+      if (rel.fromEntity === relState.currentEntity || rel.toEntity === relState.currentEntity) {
+        relationshipsToDelete.push(relId);
+      }
+    }
+    for (const relId of relationshipsToDelete) {
+      delete relState.relationships[relId];
+    }
+    relState.currentEntity = null;
+    const text = `Deleted entity: ${entityName} and ${relationshipsToDelete.length} relationships`;
+    if (callback) {
+      await callback({ text, source: message.content.source });
+    }
+    return {
+      success: true,
+      text,
+      values: {
+        ...state?.values,
+        entities: relState.entities,
+        relationships: relState.relationships,
+        currentEntity: null,
+        lastOperation: "delete_entity"
+      },
+      data: {
+        operation: "delete_entity",
+        deletedEntity: entityName,
+        deletedRelationships: relationshipsToDelete.length,
+        remainingEntities: Object.keys(relState.entities).length
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user}}",
+        content: { text: "delete current entity" }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "Deleted entity: EntityName and 0 relationships",
+          actions: ["DELETE_ENTITY"]
+        }
+      }
+    ]
+  ]
+};
+var countStatisticsAction = {
+  name: "COUNT_STATISTICS",
+  similes: ["STATS", "STATISTICS", "COUNT"],
+  description: "Get statistics about the current relational data graph.",
+  validate: async () => true,
+  handler: async (_runtime, message, state, _options, callback) => {
+    const relState = getRelationalState(state);
+    const totalEntities = Object.keys(relState.entities).length;
+    const totalRelationships = Object.keys(relState.relationships).length;
+    const entityTypes = {};
+    for (const entity of Object.values(relState.entities)) {
+      entityTypes[entity.type] = (entityTypes[entity.type] || 0) + 1;
+    }
+    const relationshipTypes = {};
+    for (const rel of Object.values(relState.relationships)) {
+      relationshipTypes[rel.type] = (relationshipTypes[rel.type] || 0) + 1;
+    }
+    let totalAttributes = 0;
+    for (const entity of Object.values(relState.entities)) {
+      totalAttributes += Object.keys(entity.attributes).length;
+    }
+    const stats = {
+      totalEntities,
+      totalRelationships,
+      totalAttributes,
+      entityTypes,
+      relationshipTypes,
+      currentEntity: relState.currentEntity ? relState.entities[relState.currentEntity]?.name : "none"
+    };
+    const text = `Graph statistics: ${totalEntities} entities, ${totalRelationships} relationships, ${totalAttributes} attributes`;
+    if (callback) {
+      await callback({ text, source: message.content.source });
+    }
+    return {
+      success: true,
+      text,
+      values: {
+        ...state?.values,
+        queryResults: [stats],
+        lastOperation: "count_statistics"
+      },
+      data: {
+        operation: "count_statistics",
+        statistics: stats
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user}}",
+        content: { text: "show statistics" }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "Graph statistics: 0 entities, 0 relationships, 0 attributes",
+          actions: ["COUNT_STATISTICS"]
+        }
+      }
+    ]
+  ]
+};
+var clearGraphAction = {
+  name: "CLEAR_GRAPH",
+  similes: ["RESET_GRAPH", "CLEAR_ALL", "DELETE_ALL"],
+  description: "Clear all entities and relationships from the graph.",
+  validate: async () => true,
+  handler: async (_runtime, message, _state, _options, callback) => {
+    const text = "Cleared all entities and relationships";
+    if (callback) {
+      await callback({ text, source: message.content.source });
+    }
+    return {
+      success: true,
+      text,
+      values: {
+        entities: {},
+        relationships: {},
+        currentEntity: null,
+        queryResults: [],
+        lastOperation: "clear_graph"
+      },
+      data: {
+        operation: "clear_graph"
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user}}",
+        content: { text: "clear graph" }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "Cleared all entities and relationships",
+          actions: ["CLEAR_GRAPH"]
+        }
+      }
+    ]
+  ]
+};
+var findPathAction = {
+  name: "FIND_PATH",
+  similes: ["PATH", "ROUTE", "CONNECTION_PATH"],
+  description: "Find the shortest path between two entities in the relationship graph.",
+  validate: async (_runtime, _message, state) => {
+    const relState = getRelationalState(state);
+    return Object.keys(relState.entities).length >= 2;
+  },
+  handler: async (_runtime, message, state, _options, callback) => {
+    const relState = getRelationalState(state);
+    if (Object.keys(relState.entities).length < 2) {
+      return {
+        success: false,
+        text: "Error: Need at least 2 entities to find a path",
+        values: state?.values || {}
+      };
+    }
+    const entities = Object.values(relState.entities);
+    const start = entities[0];
+    const end = entities[entities.length - 1];
+    const adjacency = {};
+    for (const entity of entities) {
+      adjacency[entity.id] = /* @__PURE__ */ new Set();
+    }
+    for (const rel of Object.values(relState.relationships)) {
+      adjacency[rel.fromEntity]?.add(rel.toEntity);
+      adjacency[rel.toEntity]?.add(rel.fromEntity);
+    }
+    const queue = [{ node: start.id, path: [start.id] }];
+    const visited = /* @__PURE__ */ new Set();
+    let foundPath = [];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (current.node === end.id) {
+        foundPath = current.path;
+        break;
+      }
+      if (visited.has(current.node)) continue;
+      visited.add(current.node);
+      for (const neighbor of adjacency[current.node] || []) {
+        if (!visited.has(neighbor)) {
+          queue.push({
+            node: neighbor,
+            path: [...current.path, neighbor]
+          });
+        }
+      }
+    }
+    const pathNames = foundPath.map((id) => relState.entities[id]?.name || id);
+    const text = foundPath.length > 0 ? `Found path: ${pathNames.join(" \u2192 ")}` : `No path found between ${start.name} and ${end.name}`;
+    if (callback) {
+      await callback({ text, source: message.content.source });
+    }
+    return {
+      success: true,
+      text,
+      values: {
+        ...state?.values,
+        queryResults: [{ path: pathNames, length: foundPath.length }],
+        lastOperation: "find_path"
+      },
+      data: {
+        operation: "find_path",
+        from: start.name,
+        to: end.name,
+        path: pathNames,
+        pathLength: foundPath.length
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user}}",
+        content: { text: "find path between entities" }
+      },
+      {
+        name: "{{agent}}",
+        content: {
+          text: "Found path: Entity1 \u2192 Entity2",
+          actions: ["FIND_PATH"]
+        }
+      }
+    ]
+  ]
+};
+var relationalDataActions = [
+  createEntityAction,
+  createRelationshipAction,
+  setAttributeAction,
+  queryRelationshipsAction,
+  queryEntitiesAction,
+  selectEntityAction,
+  deleteEntityAction,
+  countStatisticsAction,
+  clearGraphAction,
+  findPathAction
+];
+
 // src/index.ts
+var TYPEWRITER_ENABLED = process.env.TYPEWRITER_ENABLED?.toLowerCase() !== "false";
+var MULTIVERSE_MATH_ENABLED = process.env.MULTIVERSE_MATH_ENABLED?.toLowerCase() !== "false";
+var RELATIONAL_DATA_ENABLED = process.env.RELATIONAL_DATA_ENABLED?.toLowerCase() !== "false";
+function buildActions() {
+  const actions = [];
+  if (TYPEWRITER_ENABLED) {
+    console.log("[plugin-action-bench] Typewriter actions enabled");
+    actions.push(...typewriterActions);
+  } else {
+    console.log("[plugin-action-bench] Typewriter actions disabled via TYPEWRITER_ENABLED=false");
+  }
+  if (MULTIVERSE_MATH_ENABLED) {
+    console.log("[plugin-action-bench] Multiverse math actions enabled");
+    actions.push(...multiverseMathActions);
+  } else {
+    console.log("[plugin-action-bench] Multiverse math actions disabled via MULTIVERSE_MATH_ENABLED=false");
+  }
+  if (RELATIONAL_DATA_ENABLED) {
+    console.log("[plugin-action-bench] Relational data actions enabled");
+    actions.push(...relationalDataActions);
+  } else {
+    console.log("[plugin-action-bench] Relational data actions disabled via RELATIONAL_DATA_ENABLED=false");
+  }
+  if (actions.length === 0) {
+    console.warn("[plugin-action-bench] WARNING: No benchmark actions are enabled. Set TYPEWRITER_ENABLED=true, MULTIVERSE_MATH_ENABLED=true, or RELATIONAL_DATA_ENABLED=true to enable benchmarks.");
+  }
+  console.log(`[plugin-action-bench] Total actions loaded: ${actions.length}`);
+  return actions;
+}
 var actionBenchPlugin = {
   name: "plugin-action-bench",
-  description: "Action benchmark plugin providing typewriter (A\u2013Z) and multiverse math operations where mathematical behavior changes based on dimensional constants, testing AI agents' ability to handle context-dependent operations and unknown mathematical scenarios.",
-  actions: [...typewriterActions, ...multiverseMathActions]
+  description: "Action benchmark plugin providing typewriter (A\u2013Z), multiverse math operations with dimensional constants, and relational data management, testing AI agents' ability to handle action chaining, context-dependent operations, and complex data relationships.",
+  actions: buildActions()
+};
+var benchmarkConfig = {
+  typewriterEnabled: TYPEWRITER_ENABLED,
+  multiverseMathEnabled: MULTIVERSE_MATH_ENABLED,
+  relationalDataEnabled: RELATIONAL_DATA_ENABLED,
+  totalActionsLoaded: actionBenchPlugin.actions?.length ?? 0
 };
 var index_default = actionBenchPlugin;
 
 exports.actionBenchPlugin = actionBenchPlugin;
+exports.benchmarkConfig = benchmarkConfig;
 exports.default = index_default;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map