1
// src/platform/agent-registry.ts — Central registry for all agents
2

3
export interface AgentDefinition {
4
  id: string;
5
  name: string;                     // "github-issue-manager"
6
  displayName: string;              // "GitHub Issue Manager"
7
  description: string;
8
  version: string;                  // SemVer
9
  owner: string;                    // Team name
10
  status: "draft" | "active" | "deprecated" | "retired";
11

12
  // Tool bindings
13
  tools: Array<{
14
    name: string;                   // "list_issues"
15
    source: "built-in" | "mcp-server" | "custom";
16
    mcpServerUrl?: string;          // If external MCP server
17
    required: boolean;              // Can agent run without this tool?
18
    permissions: string[];          // ["issues:read", "issues:write"]
19
  }>;
20

21
  // Deployment config
22
  deployment: {
23
    replicas: number;
24
    regions: string[];              // ["us-east-1", "eu-west-1"]
25
    resources: {
26
      cpu: string;                  // "0.5"
27
      memory: string;               // "512Mi"
28
    };
29
    environment: "development" | "staging" | "production";
30
  };
31

32
  // References to platform components (Days 1-5)
33
  promptVersionId: string | null;
34
  experimentName: string | null;
35

36
  createdAt: number;
37
  updatedAt: number;
38
}
39

40
export class AgentRegistry {
41
  private agents: Map<string, AgentDefinition> = new Map();
42

43
  /**
44
   * Register a new agent.
45
   */
46
  async register(definition: Omit<AgentDefinition, "id" | "createdAt" | "updatedAt">): Promise<AgentDefinition> {
47
    const id = definition.name.toLowerCase().replace(/[^a-z0-9-]/g, "-");
48

49
    const agent: AgentDefinition = {
50
      ...definition,
51
      id,
52
      createdAt: Date.now(),
53
      updatedAt: Date.now(),
54
    };
55

56
    // Validate
57
    this.validate(agent);
58
    this.agents.set(id, agent);
59

60
    console.log(`[Registry] Registered agent: ${agent.name} v${agent.version}`);
61
    return agent;
62
  }
63

64
  /**
65
   * Update an existing agent definition.
66
   */
67
  async update(id: string, patch: Partial<AgentDefinition>): Promise<AgentDefinition> {
68
    const existing = this.agents.get(id);
69
    if (!existing) throw new Error(`Agent "${id}" not found`);
70

71
    const updated: AgentDefinition = { ...existing, ...patch, id, updatedAt: Date.now() };
72
    this.validate(updated);
73
    this.agents.set(id, updated);
74

75
    return updated;
76
  }
77

78
  /**
79
   * Get agent by ID.
80
   */
81
  get(id: string): AgentDefinition | undefined {
82
    return this.agents.get(id);
83
  }
84

85
  /**
86
   * List all agents, optionally filtered by status.
87
   */
88
  list(filters?: { status?: string; environment?: string; owner?: string }): AgentDefinition[] {
89
    let results = Array.from(this.agents.values());
90

91
    if (filters?.status) results = results.filter(a => a.status === filters.status);
92
    if (filters?.environment) results = results.filter(a => a.deployment.environment === filters.environment);
93
    if (filters?.owner) results = results.filter(a => a.owner === filters.owner);
94

95
    return results.sort((a, b) => b.updatedAt - a.updatedAt);
96
  }
97

98
  /**
99
   * Find which tools are used across all agents (for impact analysis).
100
   */
101
  getToolUsage(): Map<string, string[]> {
102
    const usage = new Map<string, string[]>();
103

104
    for (const agent of this.agents.values()) {
105
      for (const tool of agent.tools) {
106
        const agents = usage.get(tool.name) || [];
107
        agents.push(agent.name);
108
        usage.set(tool.name, agents);
109
      }
110
    }
111

112
    return usage;
113
  }
114

115
  private validate(agent: AgentDefinition): void {
116
    if (!agent.name) throw new Error("Agent name is required");
117
    if (!agent.version) throw new Error("Agent version is required");
118

119
    // Validate tools have unique names
120
    const toolNames = agent.tools.map(t => t.name);
121
    if (new Set(toolNames).size !== toolNames.length) {
122
      throw new Error(`Duplicate tool names in agent "${agent.name}"`);
123
    }
124
  }
125
}

1
// src/platform/agent-builder.ts — Self-service agent factory
2

3
import { AgentRegistry, AgentDefinition } from "./agent-registry.js";
4
import { PromptStore } from "../experiments/prompt-store.js";
5
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
6

7
interface AgentTemplate {
8
  id: string;
9
  name: string;
10
  description: string;
11
  tools: string[];             // Tool names this template needs
12
  defaultPrompt: string;       // Default system prompt template
13
  icon: string;                // Emoji or URL
14
}
15

16
export class AgentBuilder {
17
  private registry: AgentRegistry;
18
  private promptStore: PromptStore;
19
  private templates: Map<string, AgentTemplate> = new Map();
20

21
  constructor(registry: AgentRegistry, promptStore: PromptStore) {
22
    this.registry = registry;
23
    this.promptStore = promptStore;
24
  }
25

26
  /**
27
   * Register a template for agent creation.
28
   */
29
  registerTemplate(template: AgentTemplate): void {
30
    this.templates.set(template.id, template);
31
  }
32

33
  /**
34
   * List available templates.
35
   */
36
  listTemplates(): AgentTemplate[] {
37
    return Array.from(this.templates.values());
38
  }
39

40
  /**
41
   * Create an agent from a template.
42
   */
43
  async createFromTemplate(params: {
44
    templateId: string;
45
    name: string;
46
    team: string;
47
    environment?: string;
48
  }): Promise<{ agent: AgentDefinition; promptVersionId: string }> {
49
    const template = this.templates.get(params.templateId);
50
    if (!template) throw new Error(`Template "${params.templateId}" not found`);
51

52
    // Generate agent definition
53
    const agent: Omit<AgentDefinition, "id" | "createdAt" | "updatedAt"> = {
54
      name: params.name.toLowerCase().replace(/[^a-z0-9-]/g, "-"),
55
      displayName: params.name,
56
      description: template.description,
57
      version: "1.0.0",
58
      owner: params.team,
59
      status: "draft",
60
      tools: template.tools.map(toolName => ({
61
        name: toolName,
62
        source: "built-in" as const,
63
        required: true,
64
        permissions: ["read"],
65
      })),
66
      deployment: {
67
        replicas: 1,
68
        regions: ["us-east-1"],
69
        resources: { cpu: "0.5", memory: "512Mi" },
70
        environment: (params.environment as any) || "development",
71
      },
72
      promptVersionId: null,
73
      experimentName: null,
74
    };
75

76
    const registered = await this.registry.register(agent);
77

78
    // Create default prompt
79
    const promptVersion = await this.promptStore.save({
80
      name: registered.name,
81
      content: template.defaultPrompt.replace("{{name}}", params.name),
82
      tags: ["default", "initial"],
83
      metadata: {
84
        author: "platform",
85
        createdAt: Date.now(),
86
        parentId: null,
87
        model: "gpt-4o",
88
        description: `Default prompt for ${params.name}`,
89
      },
90
    });
91

92
    // Activate prompt
93
    await this.promptStore.activate(registered.name, promptVersion.id, 100);
94

95
    return {
96
      agent: { ...registered, promptVersionId: promptVersion.id },
97
      promptVersionId: promptVersion.id,
98
    };
99
  }
100
}

1
// Register built-in templates
2
const builder = new AgentBuilder(registry, promptStore);
3

4
builder.registerTemplate({
5
  id: "github-issue-manager",
6
  name: "GitHub Issue Manager",
7
  description: "Manage GitHub issues: list, create, update, search, comment",
8
  tools: ["list_issues", "get_issue", "create_issue", "update_issue", "search_issues", "add_comment"],
9
  defaultPrompt: `You are {{name}}, a GitHub issue management agent.
10
Help users find, create, and manage issues in their repositories.
11

12
Always validate issue numbers before referencing them.
13
When creating issues, ask for title and description.
14
Group related issues together in responses.`,
15
  icon: "🐙",
16
});
17

18
builder.registerTemplate({
19
  id: "code-review-assistant",
20
  name: "Code Review Assistant",
21
  description: "Review pull requests, suggest improvements, check for common issues",
22
  tools: ["list_prs", "get_pr_diff", "comment_on_pr", "check_lint", "run_tests"],
23
  defaultPrompt: `You are {{name}}, a code review assistant.
24
Review pull requests for code quality, security issues, and best practices.
25

26
Focus on:
27
- Security vulnerabilities (SQL injection, XSS, hardcoded secrets)
28
- Performance issues (N+1 queries, memory leaks)
29
- Code style consistency
30
- Missing error handling`,
31
  icon: "📝",
32
});

1
// src/platform/governance.ts — Approval workflows and policy enforcement
2

3
export interface ApprovalPolicy {
4
  id: string;
5
  name: string;
6
  conditions: {
7
    attribute: string;        // "deployment.environment" | "tools[].permissions"
8
    operator: "eq" | "in" | "contains";
9
    value: string | string[];
10
  }[];
11
  requiredApprovals: number;  // How many approvers needed
12
  approverTeams: string[];    // Which teams can approve
13
}
14

15
export interface ApprovalRequest {
16
  id: string;
17
  agentId: string;
18
  changeType: "deploy" | "prompt-change" | "tool-change" | "config-change";
19
  requestedBy: string;
20
  requestedAt: number;
21
  status: "pending" | "approved" | "rejected";
22
  approvedBy: string[];
23
  approvedAt: number | null;
24
  diff: string;               // What changed
25
}
26

27
export class GovernanceEngine {
28
  private policies: ApprovalPolicy[] = [];
29
  private approvals: Map<string, ApprovalRequest> = new Map();
30

31
  /**
32
   * Register a policy.
33
   */
34
  addPolicy(policy: ApprovalPolicy): void {
35
    this.policies.push(policy);
36
  }
37

38
  /**
39
   * Check if a change needs approval.
40
   */
41
  needsApproval(agent: AgentDefinition, changeType: ApprovalRequest["changeType"]): boolean {
42
    for (const policy of this.policies) {
43
      const matches = policy.conditions.every(cond => {
44
        const value = this.getAttribute(agent, cond.attribute);
45
        if (cond.operator === "eq") return value === cond.value;
46
        if (cond.operator === "in") return Array.isArray(value) && cond.value.includes(value);
47
        if (cond.operator === "contains") return String(value).includes(String(cond.value));
48
        return false;
49
      });
50

51
      if (matches) return true;
52
    }
53

54
    return false;
55
  }
56

57
  /**
58
   * Create an approval request.
59
   */
60
  async requestApproval(
61
    agentId: string,
62
    changeType: ApprovalRequest["changeType"],
63
    requestedBy: string,
64
    diff: string
65
  ): Promise<ApprovalRequest> {
66
    const id = `apr-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
67
    const request: ApprovalRequest = {
68
      id, agentId, changeType, requestedBy,
69
      requestedAt: Date.now(), status: "pending",
70
      approvedBy: [], approvedAt: null, diff,
71
    };
72

73
    this.approvals.set(id, request);
74

75
    console.log(`[Governance] Approval request ${id}: ${changeType} for ${agentId}`);
76
    return request;
77
  }
78

79
  /**
80
   * Approve a request.
81
   */
82
  async approve(approvalId: string, by: string): Promise<ApprovalRequest> {
83
    const request = this.approvals.get(approvalId);
84
    if (!request) throw new Error(`Approval request "${approvalId}" not found`);
85
    if (request.status !== "pending") throw new Error("Request already processed");
86

87
    request.approvedBy.push(by);
88

89
    // Check if we have enough approvals
90
    const policy = this.policies.find(p =>
91
      request.agentId.startsWith(p.conditions[0]?.value as string)
92
    );
93
    const required = policy?.requiredApprovals || 1;
94

95
    if (request.approvedBy.length >= required) {
96
      request.status = "approved";
97
      request.approvedAt = Date.now();
98
    }
99

100
    return request;
101
  }
102

103
  /**
104
   * Reject a request.
105
   */
106
  async reject(approvalId: string, by: string): Promise<ApprovalRequest> {
107
    const request = this.approvals.get(approvalId);
108
    if (!request) throw new Error(`Approval request "${approvalId}" not found`);
109

110
    request.status = "rejected";
111
    return request;
112
  }
113

114
  private getAttribute(obj: any, path: string): any {
115
    return path.split(".").reduce((o, key) => o?.[key], obj);
116
  }
117
}

1
const governance = new GovernanceEngine();
2

3
// Production deployments need 2 approvals
4
governance.addPolicy({
5
  id: "prod-deploy-approval",
6
  name: "Production deployment requires approval",
7
  conditions: [
8
    { attribute: "deployment.environment", operator: "eq", value: "production" },
9
  ],
10
  requiredApprovals: 2,
11
  approverTeams: ["platform-engineering"],
12
});
13

14
// Tools with write permissions need review
15
governance.addPolicy({
16
  id: "write-tool-review",
17
  name: "Write tools require security review",
18
  conditions: [
19
    { attribute: "tools", operator: "contains", value: "write" },
20
  ],
21
  requiredApprovals: 1,
22
  approverTeams: ["security"],
23
});

1
// src/platform/dashboard-service.ts — Aggregation service for platform dashboard
2

3
import { AgentRegistry } from "./agent-registry.js";
4
import { GlobalStateStore } from "../multi-region/global-state.js";
5
import { RegionRouter } from "../multi-region/region-router.js";
6

7
export interface DashboardData {
8
  summary: {
9
    totalAgents: number;
10
    activeAgents: number;
11
    totalSessions: number;
12
    activeSessions: number;
13
    avgLatency: number;
14
    avgAccuracy: number;
15
    errorRate: number;
16
    cacheHitRate: number;
17
  };
18
  agents: AgentSummary[];
19
  regions: RegionSummary[];
20
}
21

22
export interface AgentSummary {
23
  id: string;
24
  name: string;
25
  status: string;
26
  environment: string;
27
  version: string;
28
  sessions: number;
29
  uptime: number;           // Percentage
30
}
31

32
export interface RegionSummary {
33
  name: string;
34
  status: string;
35
  sessions: number;
36
  failovers: number;
37
}
38

39
export class DashboardService {
40
  private registry: AgentRegistry;
41
  private globalState: GlobalStateStore;
42
  private regionRouter: RegionRouter;
43

44
  constructor(
45
    registry: AgentRegistry,
46
    globalState: GlobalStateStore,
47
    regionRouter: RegionRouter
48
  ) {
49
    this.registry = registry;
50
    this.globalState = globalState;
51
    this.regionRouter = regionRouter;
52
  }
53

54
  async getDashboard(): Promise<DashboardData> {
55
    const agents = this.registry.list();
56
    const sessionStats = await this.globalState.stats();
57
    const regionStatus = this.regionRouter.getStatus();
58

59
    return {
60
      summary: {
61
        totalAgents: agents.length,
62
        activeAgents: agents.filter(a => a.status === "active" && a.deployment.environment === "production").length,
63
        totalSessions: sessionStats.totalSessions,
64
        activeSessions: sessionStats.activeSessions,
65
        avgLatency: 0,      // From Prometheus
66
        avgAccuracy: 0,     // From experiment manager
67
        errorRate: 0,       // From Day 3 error handler
68
        cacheHitRate: 0,    // From Day 2 cache
69
      },
70
      agents: agents.map(a => ({
71
        id: a.id,
72
        name: a.displayName,
73
        status: a.status,
74
        environment: a.deployment.environment,
75
        version: a.version,
76
        sessions: 0,
77
        uptime: 99.9,
78
      })),
79
      regions: regionStatus.regions.map(r => ({
80
        name: r.name,
81
        status: r.status,
82
        sessions: sessionStats.byRegion[r.name] || 0,
83
        failovers: 0, // From failover history
84
      })),
85
    };
86
  }
87
}

1
import express from "express";
2
import { AgentRegistry } from "./agent-registry.js";
3
import { AgentBuilder } from "./agent-builder.js";
4
import { GovernanceEngine } from "./governance.js";
5
import { DashboardService } from "./dashboard-service.js";
6
import { createPlatformApi } from "./api.js";
7
import { PromptStore } from "../experiments/prompt-store.js";
8
import { ExperimentManager } from "../experiments/experiment-manager.js";
9
import { GradualRollout } from "../experiments/rollout.js";
10
import { RegionRouter } from "../multi-region/region-router.js";
11
import { GlobalStateStore } from "../multi-region/global-state.js";
12

13
async function main() {
14
  // Initialize platform components
15
  const registry = new AgentRegistry();
16
  const promptStore = new PromptStore("./data/prompts");
17
  await promptStore.init();
18
  const experimentManager = new ExperimentManager(promptStore);
19
  const rollout = new GradualRollout(promptStore);
20
  const regionRouter = new RegionRouter([
21
    { name: "us-east-1", endpoint: "https://agent-us.minixium.com", weight: 50, priority: 0, status: "active" },
22
    { name: "eu-west-1", endpoint: "https://agent-eu.minixium.com", weight: 30, priority: 1, status: "active" },
23
    { name: "ap-southeast-1", endpoint: "https://agent-ap.minixium.com", weight: 20, priority: 2, status: "active" },
24
  ]);
25
  const globalState = new GlobalStateStore(process.env.AWS_REGION || "us-east-1");
26
  const governance = new GovernanceEngine();
27
  const dashboard = new DashboardService(registry, globalState, regionRouter);
28

29
  // Initialize builder with templates
30
  const builder = new AgentBuilder(registry, promptStore);
31

32
  // Set up governance policies
33
  governance.addPolicy({
34
    id: "prod-deploy", name: "Production deployment requires approval",
35
    conditions: [{ attribute: "deployment.environment", operator: "eq", value: "production" }],
36
    requiredApprovals: 2, approverTeams: ["platform-engineering"],
37
  });
38

39
  // Create Express app
40
  const app = express();
41
  app.use(express.json());
42

43
  // Mount platform API
44
  const platformRouter = createPlatformApi(
45
    registry, promptStore, experimentManager, rollout, regionRouter
46
  );
47
  app.use("/v1", platformRouter);
48

49
  // Agent builder endpoint
50
  app.post("/v1/agents/create", async (req, res) => {
51
    try {
52
      const result = await builder.createFromTemplate(req.body);
53
      res.status(201).json(result);
54
    } catch (error) {
55
      res.status(400).json({ error: String(error) });
56
    }
57
  });
58

59
  // Governance endpoints
60
  app.get("/v1/approvals", (req, res) => {
61
    // List pending approvals
62
    res.json({ approvals: [] });
63
  });
64

65
  app.post("/v1/approvals/:id/approve", async (req, res) => {
66
    const approval = await governance.approve(req.params.id, req.body.approvedBy);
67
    res.json(approval);
68
  });
69

70
  app.post("/v1/approvals/:id/reject", async (req, res) => {
71
    const approval = await governance.reject(req.params.id, req.body.rejectedBy);
72
    res.json(approval);
73
  });
74

75
  // Dashboard
76
  app.get("/v1/dashboard", async (req, res) => {
77
    const data = await dashboard.getDashboard();
78
    res.json(data);
79
  });
80

81
  // Start server
82
  const PORT = process.env.PORT || 8080;
83
  app.listen(PORT, () => {
84
    console.log(`Agent Platform running on port ${PORT}`);
85
  });
86
}
87

88
main().catch(console.error);