@yrpri/api 9.0.122 → 9.0.124

package/agents/managers/newAiModelSetup.js

@@ -575,7 +575,7 @@ export class NewAiModelSetup {
         });
         const gemini25ProPreview1Config = {
             type: PsAiModelType.TextReasoning,
-            modelSize: PsAiModelSize.Medium,
+            modelSize: PsAiModelSize.Large,
             provider: "google",
             prices: {
                 costInTokensPerMillion: 1.25,
@@ -612,7 +612,7 @@ export class NewAiModelSetup {
         });
         const gemini25ProConfig = {
             type: PsAiModelType.TextReasoning,
-            modelSize: PsAiModelSize.Medium,
+            modelSize: PsAiModelSize.Large,
             provider: "google",
             prices: {
                 costInTokensPerMillion: 1.25,
@@ -644,6 +644,43 @@ export class NewAiModelSetup {
             await gemini25ProPreview2.save();
             console.log("Google model already exists: Gemini 2.5 Pro");
         }
+        const gemini25FlashPreview1 = await PsAiModel.findOne({
+            where: { name: "Gemini 2.5 Flash Preview 1" },
+        });
+        const gemini25FlashPreview1Config = {
+            type: PsAiModelType.TextReasoning,
+            modelSize: PsAiModelSize.Medium,
+            provider: "google",
+            prices: {
+                costInTokensPerMillion: 0.15,
+                costOutTokensPerMillion: 0.6,
+                costInCachedContextTokensPerMillion: 0.09,
+                longContextTokenThreshold: 200000,
+                longContextCostInTokensPerMillion: 0.3,
+                longContextCostInCachedContextTokensPerMillion: 0.21,
+                longContextCostOutTokensPerMillion: 2.4,
+                currency: "USD",
+            },
+            model: "gemini-2.5-flash-preview-05-20",
+            active: true,
+            maxTokensOut: 100000,
+            defaultTemperature: 0.0
+        };
+        if (!gemini25FlashPreview1) {
+            await PsAiModel.create({
+                name: "Gemini 2.5 Flash Preview 1",
+                organization_id: 1,
+                user_id: userId,
+                configuration: gemini25FlashPreview1Config,
+            });
+            console.log("Created Google model: Gemini 2.5 Flash Preview 1");
+        }
+        else {
+            gemini25FlashPreview1.set("configuration", gemini25FlashPreview1Config);
+            gemini25FlashPreview1.changed("configuration", true);
+            await gemini25FlashPreview1.save();
+            console.log("Google model already exists: Gemini 2.5 Pro");
+        }
     }
     /**
      * Master seeding function which calls the provider-specific functions
@@ -753,6 +790,7 @@ export class NewAiModelSetup {
             { name: "Gemini 2.0 Flash", envKey: "GEMINI_API_KEY" },
             { name: "Gemini 2.5 Pro Preview 1", envKey: "GEMINI_API_KEY" },
             { name: "Gemini 2.5 Pro Preview 2", envKey: "GEMINI_API_KEY" },
+            { name: "Gemini 2.5 Flash Preview 1", envKey: "GEMINI_API_KEY" },
             { name: "o1 24", envKey: "OPENAI_API_KEY" },
             { name: "o3 mini", envKey: "OPENAI_API_KEY" },
             { name: "o4 mini", envKey: "OPENAI_API_KEY" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yrpri/api",
-  "version": "9.0.122",
+  "version": "9.0.124",
   "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,106 @@
+import { initializeModels, 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 initializeModels();
+        await NewAiModelSetup.seedAiModels(1);
+        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 top level agent for the workflow
+        const topLevelUuid = process.env.CLASS_ID_FOR_TOP_LEVEL_AGENT;
+        if (!topLevelUuid) {
+            throw new Error("CLASS_ID_FOR_TOP_LEVEL_AGENT environment variable not set");
+        }
+        const topLevelClass = await PsAgentClass.findOne({
+            where: { class_base_id: topLevelUuid },
+        });
+        if (!topLevelClass) {
+            throw new Error("Top level agent class not found");
+        }
+        const topLevelAgent = await PsAgent.create({
+            user_id: topLevelClass.user_id,
+            class_id: topLevelClass.id,
+            group_id: group.id,
+            configuration: { name: `${group.name} Top-Level Agent` },
+        });
+        // Update group configuration with top level agent id
+        group.configuration.agents = { topLevelAgentId: topLevelAgent.id };
+        group.changed("configuration", true);
+        await group.save();
+        await NewAiModelSetup.setupApiKeysForGroup(group);
+        // Create working agent from class and attach to top level agent
+        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,
+            parent_agent_id: topLevelAgent.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");
+        }
+        console.log(`Created community ${community.id}, group ${group.id}, top-level agent ${topLevelAgent.id}, working 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);
+    }
+})();