pipeline-moe 0.1.0

package/src/registry.ts

@@ -0,0 +1,317 @@
+// The participant registry: the live roster of agents. Create / activate /
+// deactivate / kick all happen here. Emits a "roster" SSE event on any change.
+
+import { config } from "./config.js"
+import { isAllowedModel as isAllowedModel_ } from "./model.js"
+import { Participant } from "./participant.js"
+import type { ResolvedModel } from "./model.js"
+import type { RoomOrchestrator } from "./orchestrator.js"
+import type { SseHub } from "./sse.js"
+import type { Persona, PersonaState } from "./types.js"
+
+export interface RosterItem {
+  id: string
+  name: string
+  color: string
+  icon: string
+  tools: string[]
+  active: boolean
+  status: string
+  /** Per-agent model "provider/id", or undefined when on the default. */
+  model?: string
+  /** Per-agent thinking level, or undefined when inheriting from global config. */
+  thinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh"
+  /** May run concurrently with adjacent parallel-flagged agents. */
+  parallel: boolean
+}
+
+export class Registry {
+  private participants = new Map<string, Participant>()
+  /** Fired after any roster mutation (create/activate/kick). Used for autosave. */
+  onChange: (() => void) | null = null
+
+  constructor(
+    private readonly resolved: ResolvedModel,
+    private readonly hub: SseHub,
+    /** Providers the user has explicitly enabled via /api/providers. */
+    private readonly explicitlyEnabledProviders: Set<string> = new Set(),
+    /** Directory each participant's file tools are confined to. Defaults to the
+     *  pipeline workspace; per-room scopes override it. */
+    private readonly workspaceDir: string = config.workspaceDir,
+    /** Logical room this registry belongs to. Tags roster + participant SSE
+     *  events so room-filtered clients don't receive another room's roster. */
+    private readonly roomId: string = "default",
+    /** Capability surface for spawning sub-rooms. Passed to each participant so
+     *  orchestrator personas (the planner) get spawn/check/destroy_room tools.
+     *  Undefined in tests and before the server wires it up. */
+    private readonly orchestrator?: RoomOrchestrator,
+  ) {}
+
+  /** Default thinking level for new participants without a per-agent override.
+   *  Mutable — the Room can change it at runtime and existing participants
+   *  keep their current level; only new participants pick up the change. */
+  private defaultThinkingLevel: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" = config.thinkingLevel
+
+  setDefaultThinkingLevel(level: "off" | "minimal" | "low" | "medium" | "high" | "xhigh"): void {
+    this.defaultThinkingLevel = level
+  }
+
+  getDefaultThinkingLevel(): "off" | "minimal" | "low" | "medium" | "high" | "xhigh" {
+    return this.defaultThinkingLevel
+  }
+
+  /** Whether cloud models are allowed in this room. Mutable — the Room can
+   *  change it at runtime; only new participants pick up the change. */
+  private allowCloud: boolean = config.allowCloud
+
+  setAllowCloud(value: boolean): void {
+    this.allowCloud = value
+  }
+
+  getAllowCloud(): boolean {
+    return this.allowCloud
+  }
+
+  /** Reserve tokens for auto-compaction. Mutable — the Room can change it at
+   *  runtime; only new participants pick up the change. */
+  private compactionReserveTokens: number = 38000
+
+  setCompactionReserveTokens(value: number): void {
+    this.compactionReserveTokens = value
+  }
+
+  getCompactionReserveTokens(): number {
+    return this.compactionReserveTokens
+  }
+
+  /** Participants that should take part in the loop, in insertion order. */
+  activeParticipants(): Participant[] {
+    return [...this.participants.values()].filter((p) => p.active)
+  }
+
+  /** Snapshot of the roster as personas + runtime flags, for persistence. */
+  personaStates(): PersonaState[] {
+    return [...this.participants.values()].map((p) => ({
+      ...p.persona,
+      active: p.active,
+      parallel: p.parallel,
+    }))
+  }
+
+  get(id: string): Participant | undefined {
+    return this.participants.get(id)
+  }
+
+  has(id: string): boolean {
+    return this.participants.has(id)
+  }
+
+  roster(): RosterItem[] {
+    return [...this.participants.values()].map((p) => ({
+      id: p.persona.id,
+      name: p.persona.name,
+      color: p.persona.color,
+      icon: p.persona.icon,
+      tools: p.persona.tools,
+      active: p.active,
+      status: p.status,
+      model: p.persona.model,
+      thinkingLevel: p.persona.thinkingLevel,
+      parallel: p.parallel,
+    }))
+  }
+
+  broadcastRoster(): void {
+    this.hub.broadcast("roster", this.roster(), this.roomId)
+  }
+
+  async create(persona: Persona, active = true, parallel = false): Promise<Participant> {
+    if (this.participants.has(persona.id)) {
+      throw new Error(`participant "${persona.id}" already exists`)
+    }
+    console.log(`[Registry.create] persona=${persona.id} has orchestrator=${!!this.orchestrator}`)
+    const participant = await Participant.create(
+      persona,
+      this.resolved,
+      (event, data) => this.hub.broadcast(event, data, this.roomId),
+      this.workspaceDir,
+      this.orchestrator,
+      this.defaultThinkingLevel,
+      this.allowCloud,
+      this.compactionReserveTokens,
+    )
+    // Catch a new participant up on everything said so far before its first turn.
+    participant.cursor = 0
+    participant.active = active
+    participant.parallel = parallel
+    this.participants.set(persona.id, participant)
+    this.broadcastRoster()
+    this.onChange?.()
+    return participant
+  }
+
+  /** Editable persona fields (id is immutable — it is the @mention handle). */
+  async update(
+    id: string,
+    patch: Partial<Pick<Persona, "name" | "color" | "icon" | "tools" | "systemPrompt" | "model" | "thinkingLevel">>,
+  ): Promise<Participant> {
+    const existing = this.participants.get(id)
+    if (!existing) throw new Error(`unknown participant "${id}"`)
+    const order = [...this.participants.keys()]
+    const wasActive = existing.active
+    const persona: Persona = { ...existing.persona, ...patch, id }
+
+    // A new system prompt = a new identity, so we rebuild the pi session now
+    // rather than mutating the running one. cursor=0 → it replays the room
+    // transcript on its next turn with the new persona.
+    existing.dispose()
+    const replacement = await Participant.create(
+      persona,
+      this.resolved,
+      (event, data) => this.hub.broadcast(event, data, this.roomId),
+      this.workspaceDir,
+      this.orchestrator,
+      this.defaultThinkingLevel,
+      this.allowCloud,
+      this.compactionReserveTokens,
+    )
+    replacement.cursor = 0
+    replacement.active = wasActive
+
+    // Rebuild the Map in the original order (a plain set() would move it last,
+    // reordering @all / first-active routing).
+    const rebuilt = new Map<string, Participant>()
+    for (const key of order) {
+      rebuilt.set(key, key === id ? replacement : this.participants.get(key)!)
+    }
+    this.participants = rebuilt
+
+    this.broadcastRoster()
+    this.onChange?.()
+    return replacement
+  }
+
+  /** Reorder the roster to match the given id sequence. This is the first-turn /
+   *  @all execution order (and the first-active fallback default). Ids not listed
+   *  keep their relative order, appended after the listed ones. No session is
+   *  recreated — only references move — so it is safe to call mid-turn. */
+  reorder(orderedIds: string[]): void {
+    const seen = new Set<string>()
+    const next: string[] = []
+    for (const id of orderedIds) {
+      if (this.participants.has(id) && !seen.has(id)) {
+        next.push(id)
+        seen.add(id)
+      }
+    }
+    for (const id of this.participants.keys()) if (!seen.has(id)) next.push(id)
+
+    const rebuilt = new Map<string, Participant>()
+    for (const id of next) rebuilt.set(id, this.participants.get(id)!)
+    this.participants = rebuilt
+
+    this.broadcastRoster()
+    this.onChange?.()
+  }
+
+  setActive(id: string, active: boolean): Participant {
+    const p = this.participants.get(id)
+    if (!p) throw new Error(`unknown participant "${id}"`)
+    p.active = active
+    p.status = "idle"
+    this.broadcastRoster()
+    this.onChange?.()
+    return p
+  }
+
+  /** Toggle whether an agent may run concurrently. Pure runtime flag — no
+   *  session recreation, so it is safe to flip anytime (takes effect next turn). */
+  setParallel(id: string, parallel: boolean): Participant {
+    const p = this.participants.get(id)
+    if (!p) throw new Error(`unknown participant "${id}"`)
+    p.parallel = parallel
+    this.broadcastRoster()
+    this.onChange?.()
+    return p
+  }
+
+  /** In-place thinking level change — no session recreation. Takes effect next turn. */
+  async setThinkingLevel(
+    id: string,
+    level: "off" | "minimal" | "low" | "medium" | "high" | "xhigh",
+  ): Promise<Participant> {
+    const p = this.participants.get(id)
+    if (!p) throw new Error(`unknown participant "${id}"`)
+    await p.setThinkingLevel(level)
+    this.broadcastRoster()
+    this.onChange?.()
+    return p
+  }
+
+  kick(id: string): void {
+    const p = this.participants.get(id)
+    if (!p) throw new Error(`unknown participant "${id}"`)
+    p.dispose()
+    this.participants.delete(id)
+    this.broadcastRoster()
+    this.onChange?.()
+  }
+
+  /** Replace the whole roster with a saved persona set (fresh pi sessions).
+   *  Used when loading/switching conversations. Does not fire onChange. */
+  async reset(states: PersonaState[]): Promise<void> {
+    const cb = this.onChange
+    this.onChange = null // suppress per-participant autosave during a bulk swap
+    try {
+      for (const p of this.participants.values()) p.dispose()
+      this.participants.clear()
+      for (const s of states) {
+        const { active, parallel, ...persona } = s
+        await this.create(persona, active, parallel ?? false)
+      }
+    } finally {
+      this.onChange = cb
+    }
+    this.broadcastRoster()
+  }
+
+  disposeAll(): void {
+    for (const p of this.participants.values()) p.dispose()
+    this.participants.clear()
+  }
+
+  /** True if a "provider/id" ref is a model the UI is allowed to assign. */
+  isAllowedModel(ref: string): boolean {
+    return isAllowedModel_(this.resolved, this.allowCloud, ref, this.explicitlyEnabledProviders)
+  }
+
+  // ── Provider auth (for /provider slash command) ──────────────────────────
+
+  /** Get all providers with their auth status (no secrets). */
+  getProviderList(): Array<{ name: string; displayName: string; configured: boolean; models: number }> {
+    const all = this.resolved.modelRegistry.getAll()
+    const providerSet = new Set(all.map((m) => m.provider))
+    return Array.from(providerSet).map((name) => ({
+      name,
+      displayName: this.resolved.modelRegistry.getProviderDisplayName(name),
+      configured: this.resolved.modelRegistry.getProviderAuthStatus(name).configured,
+      models: all.filter((m) => m.provider === name).length,
+    }))
+  }
+
+  /** Set an API key for a provider (persisted). Returns auth status, not the key. */
+  setProviderKey(name: string, key: string): { name: string; configured: boolean } {
+    this.resolved.authStorage.set(name, { type: "api_key", key })
+    this.explicitlyEnabledProviders.add(name)
+    this.resolved.modelRegistry.refresh()
+    return { name, configured: this.resolved.modelRegistry.getProviderAuthStatus(name).configured }
+  }
+
+  /** Remove credentials for a provider. Returns auth status. */
+  removeProviderKey(name: string): { name: string; configured: boolean } {
+    this.resolved.authStorage.remove(name)
+    this.explicitlyEnabledProviders.delete(name)
+    this.resolved.modelRegistry.refresh()
+    return { name, configured: this.resolved.modelRegistry.getProviderAuthStatus(name).configured }
+  }
+}