@yrpri/api 9.0.142 → 9.0.144

package/agents/controllers/agentTaskController.d.ts

@@ -0,0 +1,12 @@
+import WebSocket from "ws";
+export declare class AgentTaskController {
+    path: string;
+    router: import("express-serve-static-core").Router;
+    private taskManager;
+    constructor(wsClients: Map<string, WebSocket>);
+    private initializeRoutes;
+    private startTask;
+    private stopTask;
+    private agentStatus;
+    private getAgentMemory;
+}

package/agents/controllers/agentTaskController.js

@@ -0,0 +1,72 @@
+import express from "express";
+import auth from "../../authorization.cjs";
+import { TaskManager } from "../tasks/taskManager.js";
+import log from "../../utils/loggerTs.js";
+export class AgentTaskController {
+    constructor(wsClients) {
+        this.path = "/api/agentTasks";
+        this.router = express.Router();
+        this.startTask = async (req, res) => {
+            try {
+                const { communityIdToClone } = req.body;
+                const domainId = parseInt(req.params.domainId);
+                const agentId = await this.taskManager.startTask(communityIdToClone, domainId, req.user);
+                res.status(200).json({ agentId });
+            }
+            catch (error) {
+                log.error("Error starting task:", error);
+                res.status(500).json({ error: error.message });
+            }
+        };
+        this.stopTask = async (req, res) => {
+            try {
+                const { agentId, agentRunId, wsClientId } = req.body;
+                await this.taskManager.stopTask(agentId, agentRunId, wsClientId);
+                res.sendStatus(200);
+            }
+            catch (error) {
+                log.error("Error stopping task:", error);
+                res.status(500).json({ error: error.message });
+            }
+        };
+        this.agentStatus = async (req, res) => {
+            try {
+                const agentId = parseInt(req.params.agentId);
+                const status = await this.taskManager.agentStatus(agentId);
+                if (status) {
+                    res.json(status);
+                }
+                else {
+                    res.status(404).send("Agent status not found");
+                }
+            }
+            catch (error) {
+                log.error("Error fetching agent status:", error);
+                res.status(500).json({ error: error.message });
+            }
+        };
+        this.getAgentMemory = async (req, res) => {
+            try {
+                const { groupId, agentId } = req.params;
+                const memory = await this.taskManager.getAgentMemory(groupId, parseInt(agentId), req.redisClient);
+                if (!memory) {
+                    res.status(404).json({ error: "Memory not found" });
+                    return;
+                }
+                res.json(memory);
+            }
+            catch (error) {
+                log.error("Error getting agent memory:", error);
+                res.status(500).json({ error: error.message });
+            }
+        };
+        this.taskManager = new TaskManager(wsClients);
+        this.initializeRoutes();
+    }
+    initializeRoutes() {
+        this.router.post("/:domainId/start", auth.can("view domain"), this.startTask);
+        this.router.post("/:domainId/stop", auth.can("view domain"), this.stopTask);
+        this.router.get("/:domainId/:agentId/status", auth.can("view domain"), this.agentStatus);
+        this.router.get("/:groupId/:agentId/memory", auth.can("view domain"), this.getAgentMemory);
+    }
+}

package/agents/controllers/policySynthAgents.js

@@ -272,6 +272,10 @@ export class PolicySynthAgentsController {
             const action = req.body.action;
             try {
                 const message = await this.agentQueueManager.controlAgent(agentId, action);
+                if (action === "start") {
+                    await this.agentQueueManager.clearAgentStatusMessages(agentId);
+                    log.debug(`Cleared status messages for agent ${agentId}`);
+                }
                 res.json({ message });
             }
             catch (error) {

package/agents/managers/newAiModelSetup.js

@@ -66,6 +66,7 @@ export class NewAiModelSetup {
                 currency: "USD",
             },
             maxTokensOut: 8000,
+            maxContextTokens: 200000,
             defaultTemperature: 0.7,
             model: "claude-3-5-sonnet-20240620",
             active: true,
@@ -101,6 +102,7 @@ export class NewAiModelSetup {
                 currency: "USD",
             },
             maxTokensOut: 8000,
+            maxContextTokens: 200000,
             defaultTemperature: 0.7,
             model: "claude-3-7-sonnet-20250219",
             active: true,
@@ -142,6 +144,7 @@ export class NewAiModelSetup {
                 currency: "USD",
             },
             maxTokensOut: 16384,
+            maxContextTokens: 128000,
             defaultTemperature: 0.7,
             model: "gpt-4o",
             active: true,
@@ -176,6 +179,7 @@ export class NewAiModelSetup {
                 currency: "USD",
             },
             maxTokensOut: 16384,
+            maxContextTokens: 128000,
             defaultTemperature: 0.0,
             model: "gpt-4o-mini",
             active: true,
@@ -210,6 +214,7 @@ export class NewAiModelSetup {
                 currency: "USD",
             },
             maxTokensOut: 32000,
+            maxContextTokens: 128000,
             defaultTemperature: 0.0,
             model: "o1-mini",
             active: true,
@@ -244,6 +249,7 @@ export class NewAiModelSetup {
                 currency: "USD",
             },
             maxTokensOut: 32000,
+            maxContextTokens: 200000,
             defaultTemperature: 0.0,
             model: "o1-preview",
             active: true,
@@ -278,6 +284,7 @@ export class NewAiModelSetup {
                 currency: "USD",
             },
             maxTokensOut: 100000,
+            maxContextTokens: 200000,
             defaultTemperature: 0.0,
             model: "o1",
             active: true,
@@ -312,6 +319,7 @@ export class NewAiModelSetup {
                 currency: "USD",
             },
             maxTokensOut: 100000,
+            maxContextTokens: 200000,
             defaultTemperature: 0.0,
             model: "o3-mini",
             active: true,
@@ -345,6 +353,7 @@ export class NewAiModelSetup {
                 currency: "USD",
             },
             maxTokensOut: 100000,
+            maxContextTokens: 128000,
             defaultTemperature: 0.7,
             model: "gpt-4.5-preview",
             active: true,
@@ -378,6 +387,7 @@ export class NewAiModelSetup {
                 currency: "USD",
             },
             maxTokensOut: 100000,
+            maxContextTokens: 200000,
             defaultTemperature: 0.0,
             model: "o3",
             active: true,
@@ -411,6 +421,7 @@ export class NewAiModelSetup {
                 currency: "USD",
             },
             maxTokensOut: 100000,
+            maxContextTokens: 200000,
             defaultTemperature: 0.0,
             model: "o4-mini",
             active: true,
@@ -444,6 +455,7 @@ export class NewAiModelSetup {
                 costInCachedContextTokensPerMillion: 0.5,
             },
             maxTokensOut: 32768,
+            maxContextTokens: 1000000,
             defaultTemperature: 0.7,
             model: "gpt-4.1",
             active: true,
@@ -484,6 +496,7 @@ export class NewAiModelSetup {
                 currency: "USD",
             },
             maxTokensOut: 8192,
+            maxContextTokens: 1000000,
             defaultTemperature: 0.0,
             model: "gemini-1.5-pro-002",
             active: true,
@@ -518,6 +531,7 @@ export class NewAiModelSetup {
                 currency: "USD",
             },
             maxTokensOut: 8192,
+            maxContextTokens: 1000000,
             defaultTemperature: 0.0,
             model: "gemini-1.5-flash-002",
             active: true,
@@ -552,6 +566,7 @@ export class NewAiModelSetup {
                 currency: "USD",
             },
             maxTokensOut: 8192,
+            maxContextTokens: 1000000,
             defaultTemperature: 0.0,
             model: "gemini-2.0-flash",
             active: true,
@@ -591,6 +606,7 @@ export class NewAiModelSetup {
             model: "gemini-2.5-pro",
             active: true,
             maxTokensOut: 100000,
+            maxContextTokens: 1000000,
             defaultTemperature: 0.0
         };
         if (!gemini25Pro) {
@@ -628,6 +644,7 @@ export class NewAiModelSetup {
             model: "gemini-2.5-flash-preview-05-20",
             active: true,
             maxTokensOut: 100000,
+            maxContextTokens: 1000000,
             defaultTemperature: 0.0
         };
         if (!gemini25FlashPreview1) {
@@ -658,7 +675,8 @@ export class NewAiModelSetup {
                 costInCachedContextTokensPerMillion: 0.09,
                 currency: "USD",
             },
-            maxTokensOut: 8192,
+            maxTokensOut: 32000,
+            maxContextTokens: 1000000,
             defaultTemperature: 0.0,
             model: "gemini-2.5-flash-preview-05-20",
             active: true,

package/agents/tasks/taskManager.d.ts

@@ -0,0 +1,13 @@
+import WebSocket from "ws";
+import { User as UserClass } from "@policysynth/agents/dbModels/index.js";
+export declare class TaskManager {
+    private queueManager;
+    private agentManager;
+    constructor(wsClients: Map<string, WebSocket>);
+    private cloneCommunityTemplate;
+    private cloneAgentAssets;
+    startTask(communityIdToCloneFrom: number, domainId: number, currentUser: UserClass): Promise<number>;
+    stopTask(agentId: number, agentRunId: number, wsClientId: string): Promise<boolean>;
+    agentStatus(agentId: number): Promise<PsAgentStatus | null>;
+    getAgentMemory(groupId: string, agentId: number, redisClient: any): Promise<any>;
+}

package/agents/tasks/taskManager.js

@@ -0,0 +1,155 @@
+import { NotificationAgentQueueManager } from "../managers/notificationAgentQueueManager.js";
+import { AgentManager } from "@policysynth/agents/operations/agentManager.js";
+import models from "../../models/index.cjs";
+import { copyCommunity } from "../../utils/copy_utils.cjs";
+import { PsAgent, PsAgentConnector, PsAiModel, } from "@policysynth/agents/dbModels/index.js";
+export class TaskManager {
+    constructor(wsClients) {
+        this.queueManager = new NotificationAgentQueueManager(wsClients);
+        this.agentManager = new AgentManager();
+    }
+    async cloneCommunityTemplate(communityTemplateId, toDomainId) {
+        return new Promise((resolve, reject) => {
+            copyCommunity(communityTemplateId, toDomainId, {
+                copyGroups: true,
+                copyPosts: false,
+                copyPoints: false,
+                skipUsers: true,
+                recountGroupPosts: true,
+                skipEndorsementQualitiesAndRatings: true,
+                resetEndorsementCounters: true,
+                skipActivities: true,
+            }, null, (error, newCommunity) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(newCommunity);
+                }
+            });
+        });
+    }
+    async cloneAgentAssets(originalAgent, clonedAgent, groupId) {
+        // Clone AI Models
+        const originalAiModels = await originalAgent.getAiModels();
+        if (originalAiModels && originalAiModels.length > 0) {
+            await clonedAgent.setAiModels(originalAiModels);
+        }
+        // Clone Input Connectors
+        if (originalAgent.InputConnectors && originalAgent.InputConnectors.length > 0) {
+            for (const connector of originalAgent.InputConnectors) {
+                const connectorConfig = { ...connector.configuration };
+                const clonedConnector = await PsAgentConnector.create({
+                    user_id: clonedAgent.user_id,
+                    group_id: groupId,
+                    class_id: connector.class_id,
+                    configuration: connectorConfig,
+                });
+                await models.AgentInputConnectors.create({
+                    agent_id: clonedAgent.id,
+                    connector_id: clonedConnector.id,
+                });
+            }
+        }
+        // Clone Output Connectors
+        if (originalAgent.OutputConnectors && originalAgent.OutputConnectors.length > 0) {
+            for (const connector of originalAgent.OutputConnectors) {
+                const connectorConfig = { ...connector.configuration };
+                const clonedConnector = await PsAgentConnector.create({
+                    user_id: clonedAgent.user_id,
+                    group_id: groupId,
+                    class_id: connector.class_id,
+                    configuration: connectorConfig,
+                });
+                await models.AgentOutputConnectors.create({
+                    agent_id: clonedAgent.id,
+                    connector_id: clonedConnector.id,
+                });
+            }
+        }
+    }
+    async startTask(communityIdToCloneFrom, domainId, currentUser) {
+        const newCommunity = await this.cloneCommunityTemplate(communityIdToCloneFrom, domainId);
+        const groups = await models.Group.findAll({
+            where: { community_id: newCommunity.id },
+            include: [
+                {
+                    model: models.User,
+                    as: "GroupAdmins",
+                    attributes: ["id"],
+                    required: false,
+                },
+            ],
+        });
+        const workflowGroup = groups.find((g) => g.configuration?.agents?.topLevelAgentId);
+        if (!workflowGroup) {
+            throw new Error("Workflow group not found");
+        }
+        const topLevelAgentId = workflowGroup.configuration.agents.topLevelAgentId;
+        const originalTopLevelAgent = await PsAgent.findByPk(topLevelAgentId, {
+            include: [
+                {
+                    model: PsAgent,
+                    as: "SubAgents",
+                    include: [
+                        { model: PsAiModel, as: "AiModels", required: false },
+                        { model: PsAgentConnector, as: "InputConnectors", required: false },
+                        { model: PsAgentConnector, as: "OutputConnectors", required: false },
+                    ],
+                },
+            ],
+        });
+        if (!originalTopLevelAgent) {
+            throw new Error("Original top level agent not found");
+        }
+        const clonedTopLevelAgent = await PsAgent.create({
+            user_id: currentUser.id,
+            class_id: originalTopLevelAgent.class_id,
+            configuration: { ...originalTopLevelAgent.configuration },
+            group_id: workflowGroup.id,
+            parent_agent_id: undefined,
+        });
+        const clonedSubAgents = [];
+        if (originalTopLevelAgent.SubAgents && originalTopLevelAgent.SubAgents.length > 0) {
+            for (const subAgent of originalTopLevelAgent.SubAgents) {
+                let clonedSub = await PsAgent.create({
+                    user_id: currentUser.id,
+                    class_id: subAgent.class_id,
+                    configuration: { ...subAgent.configuration },
+                    group_id: workflowGroup.id,
+                    parent_agent_id: clonedTopLevelAgent.id,
+                });
+                await this.cloneAgentAssets(subAgent, clonedSub, workflowGroup.id);
+                clonedSubAgents.push(clonedSub);
+            }
+        }
+        workflowGroup.configuration.agents.topLevelAgentId = clonedTopLevelAgent.id;
+        workflowGroup.changed("configuration", true);
+        await workflowGroup.save();
+        const userInstance = await models.User.findByPk(currentUser.id);
+        if (userInstance) {
+            await newCommunity.addCommunityUsers(userInstance);
+            await workflowGroup.addGroupAdmins(userInstance);
+            await workflowGroup.addGroupUsers(userInstance);
+        }
+        if (clonedSubAgents.length === 0) {
+            throw new Error("No sub agents found to start");
+        }
+        const firstSubAgentId = clonedSubAgents[0].id;
+        await this.queueManager.startAgentProcessing(firstSubAgentId);
+        return firstSubAgentId;
+    }
+    async stopTask(agentId, agentRunId, wsClientId) {
+        return this.queueManager.stopAgentProcessing(agentId, wsClientId, agentRunId);
+    }
+    async agentStatus(agentId) {
+        return this.queueManager.getAgentStatus(agentId);
+    }
+    async getAgentMemory(groupId, agentId, redisClient) {
+        const key = await this.agentManager.getSubAgentMemoryKey(groupId, agentId);
+        if (!key)
+            return null;
+        const memoryContents = await redisClient.get(key);
+        return memoryContents ? JSON.parse(memoryContents) : null;
+    }
+}

package/app.js

@@ -578,6 +578,9 @@ export class YourPrioritiesApi {
         const { AssistantController } = await import("./agents/controllers/assistantsController.js");
         const assistantController = new AssistantController(this.wsClients);
         this.app.use(assistantController.path, assistantController.router);
+        const { AgentTaskController } = await import("./agents/controllers/agentTaskController.js");
+        const agentTaskController = new AgentTaskController(this.wsClients);
+        this.app.use(agentTaskController.path, agentTaskController.router);
         // Setup those here so they wont override the ES controllers
         this.setupErrorHandler();
     }

package/controllers/users.cjs

@@ -2374,7 +2374,7 @@ router.get('/auth/oidc/callback', function (req, res) {
     });
 });
 router.get('/auth/audkenni/callback', async function (req, res) {
-    await new Promise(resolve => setTimeout(resolve, 100));
+    await new Promise(resolve => setTimeout(resolve, 200));
     req.sso.authenticate('oidc-strategy-' + req.ypDomain.id, {}, req, res, function (error, user) {
         if (error) {
             log.error("Error from Audkenni login", { err: error });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yrpri/api",
-  "version": "9.0.142",
+  "version": "9.0.144",
   "license": "MIT",
   "author": "Robert Bjarnason & Citizens Foundation",
   "repository": {
@@ -25,7 +25,7 @@
     "@google-cloud/vertexai": "^1.10.0",
     "@google-cloud/vision": "^5.1.0",
     "@node-saml/passport-saml": "^5.0.1",
-    "@policysynth/agents": "^1.3.111",
+    "@policysynth/agents": "^1.3.115",
     "async": "^3.2.6",
     "authorized": "^1.0.0",
     "aws-sdk": "^2.1692.0",