@yrpri/api 9.0.122 → 9.0.123

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yrpri/api",
-  "version": "9.0.122",
+  "version": "9.0.123",
   "license": "MIT",
   "author": "Robert Bjarnason & Citizens Foundation",
   "repository": {

package/scripts/agents/generateAgentWorkflowTemplateFromAgentClass.d.ts

@@ -0,0 +1 @@
+export {};

package/scripts/agents/generateAgentWorkflowTemplateFromAgentClass.js

@@ -0,0 +1,86 @@
+import { PsAgentClass, PsAgent, PsAiModel } from "@policysynth/agents/dbModels/index.js";
+import models from "../../models/index.cjs";
+import { NewAiModelSetup } from "../../agents/managers/newAiModelSetup.js";
+(async () => {
+    const [domainIdArg, agentClassIdArg] = process.argv.slice(2);
+    if (!domainIdArg || !agentClassIdArg) {
+        console.error("Usage: ts-node generateAgentWorkflowTemplateFromAgentClass.ts <domainId> <psAgentClassId>");
+        process.exit(1);
+    }
+    const domainId = Number(domainIdArg);
+    const agentClassId = Number(agentClassIdArg);
+    if (isNaN(domainId) || isNaN(agentClassId)) {
+        console.error("Both domainId and psAgentClassId must be valid numbers");
+        process.exit(1);
+    }
+    try {
+        await NewAiModelSetup.initializeModels();
+        const domain = await models.Domain.findByPk(domainId);
+        if (!domain) {
+            throw new Error(`Domain ${domainId} not found`);
+        }
+        // Create Community
+        const community = await models.Community.create({
+            domain_id: domainId,
+            name: `Agent Workflow Template ${Date.now()}`,
+            hostname: `agent-workflow-${Date.now()}`,
+            access: 1,
+            user_id: 1,
+            ip_address: "127.0.0.1",
+            user_agent: "generateAgentWorkflowTemplateFromAgentClass.ts",
+            configuration: {},
+        });
+        // Create Workflow Group
+        const group = await models.Group.create({
+            community_id: community.id,
+            name: "Agent Workflow",
+            access: 0,
+            user_id: 1,
+            ip_address: "127.0.0.1",
+            user_agent: "generateAgentWorkflowTemplateFromAgentClass.ts",
+            configuration: { groupType: 3, agents: {} },
+        });
+        // Create PsAgent from class
+        const agentClass = await PsAgentClass.findByPk(agentClassId);
+        if (!agentClass) {
+            throw new Error(`PsAgentClass ${agentClassId} not found`);
+        }
+        const psAgent = await PsAgent.create({
+            user_id: agentClass.user_id,
+            class_id: agentClass.id,
+            group_id: group.id,
+            configuration: {},
+        });
+        // Add Gemini 2.5 Pro Preview 2 model
+        const geminiReasoning = await PsAiModel.findOne({
+            where: { name: "Gemini 2.5 Pro Preview 2" },
+        });
+        if (geminiReasoning) {
+            await psAgent.addAiModel(geminiReasoning);
+        }
+        else {
+            throw new Error("Gemini 2.5 Pro Preview 2 model not found");
+        }
+        // Add Gemini 2.0 Flash model
+        const geminiFlash = await PsAiModel.findOne({
+            where: { name: "Gemini 2.0 Flash" },
+        });
+        if (geminiFlash) {
+            await psAgent.addAiModel(geminiFlash);
+        }
+        else {
+            throw new Error("Gemini 2.0 Flash model not found");
+        }
+        // Update group configuration with top level agent id
+        group.configuration.agents = { topLevelAgentId: psAgent.id };
+        group.changed("configuration", true);
+        await group.save();
+        console.log(`Created community ${community.id}, group ${group.id}, agent ${psAgent.id}`);
+    }
+    catch (error) {
+        console.error(error);
+    }
+    finally {
+        await models.sequelize.close();
+    }
+})();

package/scripts/domains/createDomain.d.ts

@@ -0,0 +1 @@
+export {};

package/scripts/domains/createDomain.js

@@ -0,0 +1,31 @@
+import models from '../../models/index.cjs';
+(async () => {
+    try {
+        const [userId, domainName, name] = process.argv.slice(2);
+        if (!domainName || !name) {
+            console.log('Usage: node createDomain.js <user_id> <domain_name> "<name>"');
+            process.exit(1);
+        }
+        const existing = await models.Domain.findOne({ where: { domain_name: domainName } });
+        if (existing) {
+            console.error(`Domain with domain_name ${domainName} already exists`);
+            process.exit(1);
+        }
+        const domain = await models.Domain.create({
+            domain_name: domainName,
+            name,
+            access: 1,
+            user_id: parseInt(userId),
+            ip_address: '127.0.0.1',
+            user_agent: 'cli-script',
+            default_locale: 'en',
+            configuration: {}
+        });
+        console.log(`Created domain ${domain.name} with id ${domain.id}`);
+        process.exit(0);
+    }
+    catch (err) {
+        console.error(err);
+        process.exit(1);
+    }
+})();