@lupaflow/multi-agent 0.1.0

package/package.json

@@ -0,0 +1,32 @@
+{
+    "name":  "@lupaflow/multi-agent",
+    "version":  "0.1.0",
+    "type":  "module",
+    "license":  "MIT",
+    "publishConfig":  {
+                          "access":  "public"
+                      },
+    "main":  "./dist/index.js",
+    "module":  "./dist/index.js",
+    "types":  "./dist/index.d.ts",
+    "exports":  {
+                    ".":  {
+                              "types":  "./dist/index.d.ts",
+                              "require":  "./dist/index.js",
+                              "import":  "./dist/index.js"
+                          }
+                },
+    "scripts":  {
+                    "build":  "tsup",
+                    "dev":  "tsup --watch"
+                },
+    "dependencies":  {
+                         "@lupaflow/core":  "workspace:*",
+                         "@lupaflow/types":  "workspace:*",
+                         "@lupaflow/agent":  "workspace:*"
+                     },
+    "devDependencies":  {
+                            "tsup":  "^8.3.0",
+                            "typescript":  "^5.6.0"
+                        }
+}

package/src/communication.ts

@@ -0,0 +1,89 @@
+import { generateId } from "@lupaflow/core"
+
+export interface AgentMessage {
+  id: string
+  from: string
+  to: string
+  content: string
+  type: "request" | "response" | "broadcast"
+  timestamp: number
+  metadata?: Record<string, unknown>
+}
+
+export class AgentCommunicator {
+  private messages: AgentMessage[] = []
+  private listeners: Map<string, Set<(msg: AgentMessage) => void>> = new Map()
+
+  send(from: string, to: string, content: string, metadata?: Record<string, unknown>): AgentMessage {
+    const msg: AgentMessage = {
+      id: generateId(),
+      from,
+      to,
+      content,
+      type: "request",
+      timestamp: Date.now(),
+      metadata,
+    }
+    this.messages.push(msg)
+    const listeners = this.listeners.get(to)
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(msg)
+      }
+    }
+    return msg
+  }
+
+  broadcast(from: string, content: string): void {
+    const msg: AgentMessage = {
+      id: generateId(),
+      from,
+      to: "*",
+      content,
+      type: "broadcast",
+      timestamp: Date.now(),
+    }
+    this.messages.push(msg)
+    for (const listeners of this.listeners.values()) {
+      for (const listener of listeners) {
+        listener(msg)
+      }
+    }
+  }
+
+  respond(to: string, originalId: string, content: string): AgentMessage {
+    const original = this.messages.find((m) => m.id === originalId)
+    const msg: AgentMessage = {
+      id: generateId(),
+      from: to,
+      to: original?.from || to,
+      content,
+      type: "response",
+      timestamp: Date.now(),
+    }
+    this.messages.push(msg)
+    const listeners = this.listeners.get(msg.to)
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(msg)
+      }
+    }
+    return msg
+  }
+
+  on(agentId: string, handler: (msg: AgentMessage) => void): () => void {
+    if (!this.listeners.has(agentId)) {
+      this.listeners.set(agentId, new Set())
+    }
+    this.listeners.get(agentId)!.add(handler)
+    return () => this.listeners.get(agentId)?.delete(handler)
+  }
+
+  getHistory(): AgentMessage[] {
+    return [...this.messages]
+  }
+
+  clear(): void {
+    this.messages = []
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export { Orchestrator } from "./orchestrator"
+export { Team } from "./team"
+export { AgentCommunicator } from "./communication"
+export type { TeamMember, TeamConfig } from "./team"
+export type { AgentMessage } from "./communication"

package/src/orchestrator.ts

@@ -0,0 +1,89 @@
+import { Agent } from "@lupaflow/agent"
+import { AgentCommunicator, type AgentMessage } from "./communication"
+import { Team, type TeamMember } from "./team"
+import { generateId } from "@lupaflow/core"
+
+export interface OrchestrationResult {
+  id: string
+  output: string
+  memberOutputs: Map<string, string>
+  messages: AgentMessage[]
+  durationMs: number
+}
+
+export class Orchestrator {
+  private team: Team
+  private communicator: AgentCommunicator
+  private agents: Map<string, Agent> = new Map()
+  private agentsReady: Map<string, Promise<void>> = new Map()
+
+  constructor(team: Team) {
+    this.team = team
+    this.communicator = new AgentCommunicator()
+    for (const member of team.config.members) {
+      const agent = new Agent(member.agentConfig)
+      this.agents.set(member.id, agent)
+    }
+  }
+
+  private async runMember(member: TeamMember, task: string): Promise<string> {
+    const agent = this.agents.get(member.id)!
+    const result = await agent.run(task)
+    return result.output
+  }
+
+  async run(task: string): Promise<OrchestrationResult> {
+    const start = Date.now()
+    const id = generateId()
+    const memberOutputs = new Map<string, string>()
+
+    const leader = this.team.getLeader()
+    if (!leader) throw new Error("No leader found in team")
+
+    const leaderResult = await this.runMember(leader, `As the ${leader.role}, oversee this task: ${task}`)
+    memberOutputs.set(leader.id, leaderResult)
+
+    const otherMembers = this.team.config.members.filter((m) => m.id !== leader.id)
+    for (const member of otherMembers) {
+      const msg = this.communicator.send(
+        leader.id,
+        member.id,
+        `Task: ${task}\nLeader's plan: ${leaderResult}\nYour role: ${member.role}\nExecute your part.`
+      )
+
+      const memberResult = await this.runMember(member, msg.content)
+      memberOutputs.set(member.id, memberResult)
+
+      this.communicator.respond(leader.id, msg.id, memberResult)
+    }
+
+    const allOutputs = Array.from(memberOutputs.values()).join("\n\n")
+    let finalOutput: string
+
+    if (otherMembers.length > 0) {
+      const finalResult = await this.runMember(
+        leader,
+        `Original task: ${task}\n\nHere are all the outputs from your team:\n${allOutputs}\n\nSynthesize a final cohesive response.`
+      )
+      finalOutput = finalResult
+    } else {
+      finalOutput = leaderResult
+    }
+
+    return {
+      id,
+      output: finalOutput,
+      memberOutputs,
+      messages: this.communicator.getHistory(),
+      durationMs: Date.now() - start,
+    }
+  }
+
+  getCommunicator(): AgentCommunicator {
+    return this.communicator
+  }
+
+  getTeam(): Team {
+    return this.team
+  }
+}

package/src/team.ts

@@ -0,0 +1,40 @@
+import type { AgentConfig } from "@lupaflow/types"
+import { generateId } from "@lupaflow/core"
+
+export interface TeamMember {
+  id: string
+  name: string
+  role: string
+  agentConfig: AgentConfig
+}
+
+export interface TeamConfig {
+  name: string
+  members: TeamMember[]
+  leader?: string
+  description?: string
+}
+
+export class Team {
+  public config: TeamConfig
+
+  constructor(config: TeamConfig) {
+    this.config = {
+      ...config,
+      members: config.members.map((m) => ({ ...m, id: m.id || generateId() })),
+    }
+  }
+
+  getMember(idOrName: string): TeamMember | undefined {
+    return this.config.members.find((m) => m.id === idOrName || m.name === idOrName)
+  }
+
+  getLeader(): TeamMember | undefined {
+    if (!this.config.leader) return this.config.members[0]
+    return this.getMember(this.config.leader)
+  }
+
+  getByRole(role: string): TeamMember[] {
+    return this.config.members.filter((m) => m.role === role)
+  }
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "tsup"
+export default defineConfig({
+  entry: { index: "src/index.ts" },
+  format: ["cjs", "esm"],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  external: [/node_modules/],
+})