feat(shared): MS23-P1-001 IAgentProvider interface + agent session/message types

- IAgentProvider interface: listSessions, getSession, getMessages, injectMessage, pause/resume/kill, streamMessages
- AgentSession, AgentMessage, AgentSessionStatus, AgentMessageRole types
- AgentProviderConfig type for DB-stored provider configs
- All exported from @mosaic/shared

apps/orchestrator/src/api/agent-providers/agent-providers.controller.ts

@@ -1,54 +0,0 @@
-import {
-  Body,
-  Controller,
-  Delete,
-  Get,
-  Param,
-  Patch,
-  Post,
-  UseGuards,
-  UsePipes,
-  ValidationPipe,
-} from "@nestjs/common";
-import type { AgentProviderConfig } from "@prisma/client";
-import { OrchestratorApiKeyGuard } from "../../common/guards/api-key.guard";
-import { OrchestratorThrottlerGuard } from "../../common/guards/throttler.guard";
-import { AgentProvidersService } from "./agent-providers.service";
-import { CreateAgentProviderDto } from "./dto/create-agent-provider.dto";
-import { UpdateAgentProviderDto } from "./dto/update-agent-provider.dto";
-
-@Controller("agent-providers")
-@UseGuards(OrchestratorApiKeyGuard, OrchestratorThrottlerGuard)
-export class AgentProvidersController {
-  constructor(private readonly agentProvidersService: AgentProvidersService) {}
-
-  @Get()
-  async list(): Promise<AgentProviderConfig[]> {
-    return this.agentProvidersService.list();
-  }
-
-  @Get(":id")
-  async getById(@Param("id") id: string): Promise<AgentProviderConfig> {
-    return this.agentProvidersService.getById(id);
-  }
-
-  @Post()
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  async create(@Body() dto: CreateAgentProviderDto): Promise<AgentProviderConfig> {
-    return this.agentProvidersService.create(dto);
-  }
-
-  @Patch(":id")
-  @UsePipes(new ValidationPipe({ transform: true, whitelist: true }))
-  async update(
-    @Param("id") id: string,
-    @Body() dto: UpdateAgentProviderDto
-  ): Promise<AgentProviderConfig> {
-    return this.agentProvidersService.update(id, dto);
-  }
-
-  @Delete(":id")
-  async delete(@Param("id") id: string): Promise<AgentProviderConfig> {
-    return this.agentProvidersService.delete(id);
-  }
-}

apps/orchestrator/src/api/agent-providers/agent-providers.module.ts

@@ -1,12 +0,0 @@
-import { Module } from "@nestjs/common";
-import { PrismaModule } from "../../prisma/prisma.module";
-import { OrchestratorApiKeyGuard } from "../../common/guards/api-key.guard";
-import { AgentProvidersController } from "./agent-providers.controller";
-import { AgentProvidersService } from "./agent-providers.service";
-
-@Module({
-  imports: [PrismaModule],
-  controllers: [AgentProvidersController],
-  providers: [OrchestratorApiKeyGuard, AgentProvidersService],
-})
-export class AgentProvidersModule {}

apps/orchestrator/src/api/agent-providers/agent-providers.service.spec.ts

@@ -1,211 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { NotFoundException } from "@nestjs/common";
-import { AgentProvidersService } from "./agent-providers.service";
-import { PrismaService } from "../../prisma/prisma.service";
-
-describe("AgentProvidersService", () => {
-  let service: AgentProvidersService;
-  let prisma: {
-    agentProviderConfig: {
-      findMany: ReturnType<typeof vi.fn>;
-      findUnique: ReturnType<typeof vi.fn>;
-      create: ReturnType<typeof vi.fn>;
-      update: ReturnType<typeof vi.fn>;
-      delete: ReturnType<typeof vi.fn>;
-    };
-  };
-
-  beforeEach(() => {
-    prisma = {
-      agentProviderConfig: {
-        findMany: vi.fn(),
-        findUnique: vi.fn(),
-        create: vi.fn(),
-        update: vi.fn(),
-        delete: vi.fn(),
-      },
-    };
-
-    service = new AgentProvidersService(prisma as unknown as PrismaService);
-  });
-
-  it("lists all provider configs", async () => {
-    const expected = [
-      {
-        id: "cfg-1",
-        workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-        name: "Primary",
-        provider: "openai",
-        gatewayUrl: "https://gateway.example.com",
-        credentials: {},
-        isActive: true,
-        createdAt: new Date("2026-03-07T18:00:00.000Z"),
-        updatedAt: new Date("2026-03-07T18:00:00.000Z"),
-      },
-    ];
-    prisma.agentProviderConfig.findMany.mockResolvedValue(expected);
-
-    const result = await service.list();
-
-    expect(prisma.agentProviderConfig.findMany).toHaveBeenCalledWith({
-      orderBy: [{ createdAt: "desc" }, { id: "desc" }],
-    });
-    expect(result).toEqual(expected);
-  });
-
-  it("returns a single provider config", async () => {
-    const expected = {
-      id: "cfg-1",
-      workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-      name: "Primary",
-      provider: "openai",
-      gatewayUrl: "https://gateway.example.com",
-      credentials: { apiKeyRef: "vault:openai" },
-      isActive: true,
-      createdAt: new Date("2026-03-07T18:00:00.000Z"),
-      updatedAt: new Date("2026-03-07T18:00:00.000Z"),
-    };
-    prisma.agentProviderConfig.findUnique.mockResolvedValue(expected);
-
-    const result = await service.getById("cfg-1");
-
-    expect(prisma.agentProviderConfig.findUnique).toHaveBeenCalledWith({
-      where: { id: "cfg-1" },
-    });
-    expect(result).toEqual(expected);
-  });
-
-  it("throws NotFoundException when provider config is missing", async () => {
-    prisma.agentProviderConfig.findUnique.mockResolvedValue(null);
-
-    await expect(service.getById("missing")).rejects.toBeInstanceOf(NotFoundException);
-  });
-
-  it("creates a provider config with default credentials", async () => {
-    const created = {
-      id: "cfg-created",
-      workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-      name: "New Provider",
-      provider: "claude",
-      gatewayUrl: "https://gateway.example.com",
-      credentials: {},
-      isActive: true,
-      createdAt: new Date("2026-03-07T18:00:00.000Z"),
-      updatedAt: new Date("2026-03-07T18:00:00.000Z"),
-    };
-    prisma.agentProviderConfig.create.mockResolvedValue(created);
-
-    const result = await service.create({
-      workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-      name: "New Provider",
-      provider: "claude",
-      gatewayUrl: "https://gateway.example.com",
-    });
-
-    expect(prisma.agentProviderConfig.create).toHaveBeenCalledWith({
-      data: {
-        workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-        name: "New Provider",
-        provider: "claude",
-        gatewayUrl: "https://gateway.example.com",
-        credentials: {},
-      },
-    });
-    expect(result).toEqual(created);
-  });
-
-  it("updates a provider config", async () => {
-    prisma.agentProviderConfig.findUnique.mockResolvedValue({
-      id: "cfg-1",
-      workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-      name: "Primary",
-      provider: "openai",
-      gatewayUrl: "https://gateway.example.com",
-      credentials: {},
-      isActive: true,
-      createdAt: new Date("2026-03-07T18:00:00.000Z"),
-      updatedAt: new Date("2026-03-07T18:00:00.000Z"),
-    });
-
-    const updated = {
-      id: "cfg-1",
-      workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-      name: "Secondary",
-      provider: "openai",
-      gatewayUrl: "https://gateway2.example.com",
-      credentials: { apiKeyRef: "vault:new" },
-      isActive: false,
-      createdAt: new Date("2026-03-07T18:00:00.000Z"),
-      updatedAt: new Date("2026-03-07T19:00:00.000Z"),
-    };
-    prisma.agentProviderConfig.update.mockResolvedValue(updated);
-
-    const result = await service.update("cfg-1", {
-      name: "Secondary",
-      gatewayUrl: "https://gateway2.example.com",
-      credentials: { apiKeyRef: "vault:new" },
-      isActive: false,
-    });
-
-    expect(prisma.agentProviderConfig.update).toHaveBeenCalledWith({
-      where: { id: "cfg-1" },
-      data: {
-        name: "Secondary",
-        gatewayUrl: "https://gateway2.example.com",
-        credentials: { apiKeyRef: "vault:new" },
-        isActive: false,
-      },
-    });
-    expect(result).toEqual(updated);
-  });
-
-  it("throws NotFoundException when updating a missing provider config", async () => {
-    prisma.agentProviderConfig.findUnique.mockResolvedValue(null);
-
-    await expect(service.update("missing", { name: "Updated" })).rejects.toBeInstanceOf(
-      NotFoundException
-    );
-    expect(prisma.agentProviderConfig.update).not.toHaveBeenCalled();
-  });
-
-  it("deletes a provider config", async () => {
-    prisma.agentProviderConfig.findUnique.mockResolvedValue({
-      id: "cfg-1",
-      workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-      name: "Primary",
-      provider: "openai",
-      gatewayUrl: "https://gateway.example.com",
-      credentials: {},
-      isActive: true,
-      createdAt: new Date("2026-03-07T18:00:00.000Z"),
-      updatedAt: new Date("2026-03-07T18:00:00.000Z"),
-    });
-
-    const deleted = {
-      id: "cfg-1",
-      workspaceId: "8bcd7eda-a122-4d6c-adfd-b152f6f75369",
-      name: "Primary",
-      provider: "openai",
-      gatewayUrl: "https://gateway.example.com",
-      credentials: {},
-      isActive: true,
-      createdAt: new Date("2026-03-07T18:00:00.000Z"),
-      updatedAt: new Date("2026-03-07T18:00:00.000Z"),
-    };
-    prisma.agentProviderConfig.delete.mockResolvedValue(deleted);
-
-    const result = await service.delete("cfg-1");
-
-    expect(prisma.agentProviderConfig.delete).toHaveBeenCalledWith({
-      where: { id: "cfg-1" },
-    });
-    expect(result).toEqual(deleted);
-  });
-
-  it("throws NotFoundException when deleting a missing provider config", async () => {
-    prisma.agentProviderConfig.findUnique.mockResolvedValue(null);
-
-    await expect(service.delete("missing")).rejects.toBeInstanceOf(NotFoundException);
-    expect(prisma.agentProviderConfig.delete).not.toHaveBeenCalled();
-  });
-});

apps/orchestrator/src/api/agent-providers/agent-providers.service.ts

@@ -1,71 +0,0 @@
-import { Injectable, NotFoundException } from "@nestjs/common";
-import type { AgentProviderConfig, Prisma } from "@prisma/client";
-import { PrismaService } from "../../prisma/prisma.service";
-import { CreateAgentProviderDto } from "./dto/create-agent-provider.dto";
-import { UpdateAgentProviderDto } from "./dto/update-agent-provider.dto";
-
-@Injectable()
-export class AgentProvidersService {
-  constructor(private readonly prisma: PrismaService) {}
-
-  async list(): Promise<AgentProviderConfig[]> {
-    return this.prisma.agentProviderConfig.findMany({
-      orderBy: [{ createdAt: "desc" }, { id: "desc" }],
-    });
-  }
-
-  async getById(id: string): Promise<AgentProviderConfig> {
-    const providerConfig = await this.prisma.agentProviderConfig.findUnique({
-      where: { id },
-    });
-
-    if (!providerConfig) {
-      throw new NotFoundException(`Agent provider config with id ${id} not found`);
-    }
-
-    return providerConfig;
-  }
-
-  async create(dto: CreateAgentProviderDto): Promise<AgentProviderConfig> {
-    return this.prisma.agentProviderConfig.create({
-      data: {
-        workspaceId: dto.workspaceId,
-        name: dto.name,
-        provider: dto.provider,
-        gatewayUrl: dto.gatewayUrl,
-        credentials: this.toJsonValue(dto.credentials ?? {}),
-        ...(dto.isActive !== undefined ? { isActive: dto.isActive } : {}),
-      },
-    });
-  }
-
-  async update(id: string, dto: UpdateAgentProviderDto): Promise<AgentProviderConfig> {
-    await this.getById(id);
-
-    const data: Prisma.AgentProviderConfigUpdateInput = {
-      ...(dto.workspaceId !== undefined ? { workspaceId: dto.workspaceId } : {}),
-      ...(dto.name !== undefined ? { name: dto.name } : {}),
-      ...(dto.provider !== undefined ? { provider: dto.provider } : {}),
-      ...(dto.gatewayUrl !== undefined ? { gatewayUrl: dto.gatewayUrl } : {}),
-      ...(dto.isActive !== undefined ? { isActive: dto.isActive } : {}),
-      ...(dto.credentials !== undefined ? { credentials: this.toJsonValue(dto.credentials) } : {}),
-    };
-
-    return this.prisma.agentProviderConfig.update({
-      where: { id },
-      data,
-    });
-  }
-
-  async delete(id: string): Promise<AgentProviderConfig> {
-    await this.getById(id);
-
-    return this.prisma.agentProviderConfig.delete({
-      where: { id },
-    });
-  }
-
-  private toJsonValue(value: Record<string, unknown>): Prisma.InputJsonValue {
-    return value as Prisma.InputJsonValue;
-  }
-}

apps/orchestrator/src/api/agent-providers/dto/create-agent-provider.dto.ts

@@ -1,26 +0,0 @@
-import { IsBoolean, IsNotEmpty, IsObject, IsOptional, IsString, IsUUID } from "class-validator";
-
-export class CreateAgentProviderDto {
-  @IsUUID()
-  workspaceId!: string;
-
-  @IsString()
-  @IsNotEmpty()
-  name!: string;
-
-  @IsString()
-  @IsNotEmpty()
-  provider!: string;
-
-  @IsString()
-  @IsNotEmpty()
-  gatewayUrl!: string;
-
-  @IsOptional()
-  @IsObject()
-  credentials?: Record<string, unknown>;
-
-  @IsOptional()
-  @IsBoolean()
-  isActive?: boolean;
-}

apps/orchestrator/src/api/agent-providers/dto/update-agent-provider.dto.ts

@@ -1,30 +0,0 @@
-import { IsBoolean, IsNotEmpty, IsObject, IsOptional, IsString, IsUUID } from "class-validator";
-
-export class UpdateAgentProviderDto {
-  @IsOptional()
-  @IsUUID()
-  workspaceId?: string;
-
-  @IsOptional()
-  @IsString()
-  @IsNotEmpty()
-  name?: string;
-
-  @IsOptional()
-  @IsString()
-  @IsNotEmpty()
-  provider?: string;
-
-  @IsOptional()
-  @IsString()
-  @IsNotEmpty()
-  gatewayUrl?: string;
-
-  @IsOptional()
-  @IsObject()
-  credentials?: Record<string, unknown>;
-
-  @IsOptional()
-  @IsBoolean()
-  isActive?: boolean;
-}

apps/orchestrator/src/api/agents/agent-control.service.spec.ts

@@ -1,7 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import { AgentControlService } from "./agent-control.service";
 import { PrismaService } from "../../prisma/prisma.service";
-import { KillswitchService } from "../../killswitch/killswitch.service";
 
 describe("AgentControlService", () => {
   let service: AgentControlService;
@@ -17,9 +16,6 @@ describe("AgentControlService", () => {
       create: ReturnType<typeof vi.fn>;
     };
   };
-  let killswitchService: {
-    killAgent: ReturnType<typeof vi.fn>;
-  };
 
   beforeEach(() => {
     prisma = {
@@ -35,14 +31,7 @@ describe("AgentControlService", () => {
       },
     };
 
-    killswitchService = {
+    service = new AgentControlService(prisma as unknown as PrismaService);
-      killAgent: vi.fn().mockResolvedValue(undefined),
-    };
-
-    service = new AgentControlService(
-      prisma as unknown as PrismaService,
-      killswitchService as unknown as KillswitchService
-    );
   });
 
   afterEach(() => {
@@ -148,25 +137,4 @@ describe("AgentControlService", () => {
       });
     });
   });
-
-  describe("killAgent", () => {
-    it("delegates kill to killswitch and logs audit", async () => {
-      await service.killAgent("agent-654", "operator-kill", false);
-
-      expect(killswitchService.killAgent).toHaveBeenCalledWith("agent-654");
-      expect(prisma.operatorAuditLog.create).toHaveBeenCalledWith({
-        data: {
-          sessionId: "agent-654",
-          userId: "operator-kill",
-          provider: "internal",
-          action: "kill",
-          metadata: {
-            payload: {
-              force: false,
-            },
-          },
-        },
-      });
-    });
-  });
 });

apps/orchestrator/src/api/agents/agent-control.service.ts

@@ -1,14 +1,10 @@
 import { Injectable } from "@nestjs/common";
 import type { Prisma } from "@prisma/client";
-import { KillswitchService } from "../../killswitch/killswitch.service";
 import { PrismaService } from "../../prisma/prisma.service";
 
 @Injectable()
 export class AgentControlService {
-  constructor(
+  constructor(private readonly prisma: PrismaService) {}
-    private readonly prisma: PrismaService,
-    private readonly killswitchService: KillswitchService
-  ) {}
 
   private toJsonValue(value: Record<string, unknown>): Prisma.InputJsonValue {
     return value as Prisma.InputJsonValue;
@@ -17,7 +13,7 @@ export class AgentControlService {
   private async createOperatorAuditLog(
     agentId: string,
     operatorId: string,
-    action: "inject" | "pause" | "resume" | "kill",
+    action: "inject" | "pause" | "resume",
     payload: Record<string, unknown>
   ): Promise<void> {
     await this.prisma.operatorAuditLog.create({
@@ -69,9 +65,4 @@ export class AgentControlService {
 
     await this.createOperatorAuditLog(agentId, operatorId, "resume", {});
   }
-
-  async killAgent(agentId: string, operatorId: string, force = true): Promise<void> {
-    await this.killswitchService.killAgent(agentId);
-    await this.createOperatorAuditLog(agentId, operatorId, "kill", { force });
-  }
 }

apps/orchestrator/src/api/agents/agent-provider.registry.spec.ts

@@ -1,137 +0,0 @@
-import { Logger } from "@nestjs/common";
-import type {
-  AgentMessage,
-  AgentSession,
-  AgentSessionList,
-  IAgentProvider,
-  InjectResult,
-} from "@mosaic/shared";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { AgentProviderRegistry } from "./agent-provider.registry";
-import { InternalAgentProvider } from "./internal-agent.provider";
-
-type MockProvider = IAgentProvider & {
-  listSessions: ReturnType<typeof vi.fn>;
-};
-
-const emptyMessageStream = async function* (): AsyncIterable<AgentMessage> {
-  return;
-};
-
-const createProvider = (providerId: string, sessions: AgentSession[] = []): MockProvider => {
-  return {
-    providerId,
-    providerType: providerId,
-    displayName: providerId,
-    listSessions: vi.fn().mockResolvedValue({
-      sessions,
-      total: sessions.length,
-    } as AgentSessionList),
-    getSession: vi.fn().mockResolvedValue(null),
-    getMessages: vi.fn().mockResolvedValue([]),
-    injectMessage: vi.fn().mockResolvedValue({ accepted: true } as InjectResult),
-    pauseSession: vi.fn().mockResolvedValue(undefined),
-    resumeSession: vi.fn().mockResolvedValue(undefined),
-    killSession: vi.fn().mockResolvedValue(undefined),
-    streamMessages: vi.fn().mockReturnValue(emptyMessageStream()),
-    isAvailable: vi.fn().mockResolvedValue(true),
-  };
-};
-
-describe("AgentProviderRegistry", () => {
-  let registry: AgentProviderRegistry;
-  let internalProvider: MockProvider;
-
-  beforeEach(() => {
-    internalProvider = createProvider("internal");
-    registry = new AgentProviderRegistry(internalProvider as unknown as InternalAgentProvider);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("registers InternalAgentProvider on module init", () => {
-    registry.onModuleInit();
-
-    expect(registry.getProvider("internal")).toBe(internalProvider);
-  });
-
-  it("registers providers and returns null for unknown provider ids", () => {
-    const externalProvider = createProvider("openclaw");
-
-    registry.registerProvider(externalProvider);
-
-    expect(registry.getProvider("openclaw")).toBe(externalProvider);
-    expect(registry.getProvider("missing")).toBeNull();
-  });
-
-  it("aggregates and sorts sessions from all providers", async () => {
-    const internalSessions: AgentSession[] = [
-      {
-        id: "session-older",
-        providerId: "internal",
-        providerType: "internal",
-        status: "active",
-        createdAt: new Date("2026-03-07T10:00:00.000Z"),
-        updatedAt: new Date("2026-03-07T10:10:00.000Z"),
-      },
-    ];
-
-    const externalSessions: AgentSession[] = [
-      {
-        id: "session-newer",
-        providerId: "openclaw",
-        providerType: "external",
-        status: "paused",
-        createdAt: new Date("2026-03-07T09:00:00.000Z"),
-        updatedAt: new Date("2026-03-07T10:20:00.000Z"),
-      },
-    ];
-
-    internalProvider.listSessions.mockResolvedValue({
-      sessions: internalSessions,
-      total: internalSessions.length,
-    } as AgentSessionList);
-
-    const externalProvider = createProvider("openclaw", externalSessions);
-    registry.onModuleInit();
-    registry.registerProvider(externalProvider);
-
-    const result = await registry.listAllSessions();
-
-    expect(result.map((session) => session.id)).toEqual(["session-newer", "session-older"]);
-    expect(internalProvider.listSessions).toHaveBeenCalledTimes(1);
-    expect(externalProvider.listSessions).toHaveBeenCalledTimes(1);
-  });
-
-  it("skips provider failures and logs warning", async () => {
-    const warnSpy = vi.spyOn(Logger.prototype, "warn").mockImplementation(() => undefined);
-
-    const healthyProvider = createProvider("healthy", [
-      {
-        id: "session-1",
-        providerId: "healthy",
-        providerType: "external",
-        status: "active",
-        createdAt: new Date("2026-03-07T11:00:00.000Z"),
-        updatedAt: new Date("2026-03-07T11:00:00.000Z"),
-      },
-    ]);
-
-    const failingProvider = createProvider("failing");
-    failingProvider.listSessions.mockRejectedValue(new Error("provider offline"));
-
-    registry.onModuleInit();
-    registry.registerProvider(healthyProvider);
-    registry.registerProvider(failingProvider);
-
-    const result = await registry.listAllSessions();
-
-    expect(result).toHaveLength(1);
-    expect(result[0]?.id).toBe("session-1");
-    expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining("Failed to list sessions for provider failing")
-    );
-  });
-});

apps/orchestrator/src/api/agents/agent-provider.registry.ts

@@ -1,57 +0,0 @@
-import { Injectable, Logger, OnModuleInit } from "@nestjs/common";
-import type { AgentSession, IAgentProvider } from "@mosaic/shared";
-import { InternalAgentProvider } from "./internal-agent.provider";
-
-@Injectable()
-export class AgentProviderRegistry implements OnModuleInit {
-  private readonly logger = new Logger(AgentProviderRegistry.name);
-  private readonly providers = new Map<string, IAgentProvider>();
-
-  constructor(private readonly internalProvider: InternalAgentProvider) {}
-
-  onModuleInit(): void {
-    this.registerProvider(this.internalProvider);
-  }
-
-  registerProvider(provider: IAgentProvider): void {
-    const existingProvider = this.providers.get(provider.providerId);
-    if (existingProvider !== undefined) {
-      this.logger.warn(`Replacing existing provider registration for ${provider.providerId}`);
-    }
-
-    this.providers.set(provider.providerId, provider);
-  }
-
-  getProvider(providerId: string): IAgentProvider | null {
-    return this.providers.get(providerId) ?? null;
-  }
-
-  async listAllSessions(): Promise<AgentSession[]> {
-    const providers = [...this.providers.values()];
-    const sessionsByProvider = await Promise.all(
-      providers.map(async (provider) => {
-        try {
-          const { sessions } = await provider.listSessions();
-          return sessions;
-        } catch (error) {
-          this.logger.warn(
-            `Failed to list sessions for provider ${provider.providerId}: ${this.toErrorMessage(error)}`
-          );
-          return [];
-        }
-      })
-    );
-
-    return sessionsByProvider
-      .flat()
-      .sort((left, right) => right.updatedAt.getTime() - left.updatedAt.getTime());
-  }
-
-  private toErrorMessage(error: unknown): string {
-    if (error instanceof Error) {
-      return error.message;
-    }
-
-    return String(error);
-  }
-}

apps/orchestrator/src/api/agents/agent-tree.service.spec.ts

@@ -7,8 +7,6 @@ describe("AgentTreeService", () => {
   let prisma: {
     agentSessionTree: {
       findMany: ReturnType<typeof vi.fn>;
-      count: ReturnType<typeof vi.fn>;
-      findUnique: ReturnType<typeof vi.fn>;
     };
   };
 
@@ -16,8 +14,6 @@ describe("AgentTreeService", () => {
     prisma = {
       agentSessionTree: {
         findMany: vi.fn(),
-        count: vi.fn(),
-        findUnique: vi.fn(),
       },
     };
 
@@ -28,141 +24,6 @@ describe("AgentTreeService", () => {
     vi.clearAllMocks();
   });
 
-  describe("listSessions", () => {
-    it("returns paginated sessions and cursor", async () => {
-      const sessions = [
-        {
-          id: "tree-2",
-          sessionId: "agent-2",
-          parentSessionId: null,
-          provider: "internal",
-          missionId: null,
-          taskId: "task-2",
-          taskSource: "queue",
-          agentType: "worker",
-          status: "running",
-          spawnedAt: new Date("2026-03-07T11:00:00.000Z"),
-          completedAt: null,
-          metadata: {},
-        },
-        {
-          id: "tree-1",
-          sessionId: "agent-1",
-          parentSessionId: null,
-          provider: "internal",
-          missionId: null,
-          taskId: "task-1",
-          taskSource: "queue",
-          agentType: "worker",
-          status: "running",
-          spawnedAt: new Date("2026-03-07T10:00:00.000Z"),
-          completedAt: null,
-          metadata: {},
-        },
-      ];
-
-      prisma.agentSessionTree.findMany.mockResolvedValue(sessions);
-      prisma.agentSessionTree.count.mockResolvedValue(7);
-
-      const result = await service.listSessions(undefined, 2);
-
-      expect(prisma.agentSessionTree.findMany).toHaveBeenCalledWith({
-        where: undefined,
-        orderBy: [{ spawnedAt: "desc" }, { sessionId: "desc" }],
-        take: 2,
-      });
-      expect(prisma.agentSessionTree.count).toHaveBeenCalledWith();
-      expect(result.sessions).toEqual(sessions);
-      expect(result.total).toBe(7);
-      expect(result.cursor).toBeTypeOf("string");
-    });
-
-    it("applies cursor filter when provided", async () => {
-      prisma.agentSessionTree.findMany.mockResolvedValue([]);
-      prisma.agentSessionTree.count.mockResolvedValue(0);
-
-      const cursorDate = "2026-03-07T10:00:00.000Z";
-      const cursorSessionId = "agent-5";
-      const cursor = Buffer.from(
-        JSON.stringify({
-          spawnedAt: cursorDate,
-          sessionId: cursorSessionId,
-        }),
-        "utf8"
-      ).toString("base64url");
-
-      await service.listSessions(cursor, 25);
-
-      expect(prisma.agentSessionTree.findMany).toHaveBeenCalledWith({
-        where: {
-          OR: [
-            {
-              spawnedAt: {
-                lt: new Date(cursorDate),
-              },
-            },
-            {
-              spawnedAt: new Date(cursorDate),
-              sessionId: {
-                lt: cursorSessionId,
-              },
-            },
-          ],
-        },
-        orderBy: [{ spawnedAt: "desc" }, { sessionId: "desc" }],
-        take: 25,
-      });
-    });
-
-    it("ignores invalid cursor values", async () => {
-      prisma.agentSessionTree.findMany.mockResolvedValue([]);
-      prisma.agentSessionTree.count.mockResolvedValue(0);
-
-      await service.listSessions("invalid-cursor", 10);
-
-      expect(prisma.agentSessionTree.findMany).toHaveBeenCalledWith({
-        where: undefined,
-        orderBy: [{ spawnedAt: "desc" }, { sessionId: "desc" }],
-        take: 10,
-      });
-    });
-  });
-
-  describe("getSession", () => {
-    it("returns matching session entry", async () => {
-      const session = {
-        id: "tree-1",
-        sessionId: "agent-123",
-        parentSessionId: null,
-        provider: "internal",
-        missionId: null,
-        taskId: "task-1",
-        taskSource: "queue",
-        agentType: "worker",
-        status: "running",
-        spawnedAt: new Date("2026-03-07T11:00:00.000Z"),
-        completedAt: null,
-        metadata: {},
-      };
-      prisma.agentSessionTree.findUnique.mockResolvedValue(session);
-
-      const result = await service.getSession("agent-123");
-
-      expect(prisma.agentSessionTree.findUnique).toHaveBeenCalledWith({
-        where: { sessionId: "agent-123" },
-      });
-      expect(result).toEqual(session);
-    });
-
-    it("returns null when session does not exist", async () => {
-      prisma.agentSessionTree.findUnique.mockResolvedValue(null);
-
-      const result = await service.getSession("agent-missing");
-
-      expect(result).toBeNull();
-    });
-  });
-
   describe("getTree", () => {
     it("returns mapped entries from Prisma", async () => {
       prisma.agentSessionTree.findMany.mockResolvedValue([

apps/orchestrator/src/api/agents/agent-tree.service.ts

@@ -1,78 +1,11 @@
 import { Injectable } from "@nestjs/common";
-import type { AgentSessionTree, Prisma } from "@prisma/client";
-import { AgentTreeResponseDto } from "./dto/agent-tree-response.dto";
 import { PrismaService } from "../../prisma/prisma.service";
-
+import { AgentTreeResponseDto } from "./dto/agent-tree-response.dto";
-const DEFAULT_PAGE_LIMIT = 50;
-const MAX_PAGE_LIMIT = 200;
-
-interface SessionCursor {
-  spawnedAt: Date;
-  sessionId: string;
-}
-
-export interface AgentSessionTreeListResult {
-  sessions: AgentSessionTree[];
-  total: number;
-  cursor?: string;
-}
 
 @Injectable()
 export class AgentTreeService {
   constructor(private readonly prisma: PrismaService) {}
 
-  async listSessions(
-    cursor?: string,
-    limit = DEFAULT_PAGE_LIMIT
-  ): Promise<AgentSessionTreeListResult> {
-    const safeLimit = this.normalizeLimit(limit);
-    const parsedCursor = this.parseCursor(cursor);
-
-    const where: Prisma.AgentSessionTreeWhereInput | undefined = parsedCursor
-      ? {
-          OR: [
-            {
-              spawnedAt: {
-                lt: parsedCursor.spawnedAt,
-              },
-            },
-            {
-              spawnedAt: parsedCursor.spawnedAt,
-              sessionId: {
-                lt: parsedCursor.sessionId,
-              },
-            },
-          ],
-        }
-      : undefined;
-
-    const [sessions, total] = await Promise.all([
-      this.prisma.agentSessionTree.findMany({
-        where,
-        orderBy: [{ spawnedAt: "desc" }, { sessionId: "desc" }],
-        take: safeLimit,
-      }),
-      this.prisma.agentSessionTree.count(),
-    ]);
-
-    const nextCursor =
-      sessions.length === safeLimit
-        ? this.serializeCursor(sessions[sessions.length - 1])
-        : undefined;
-
-    return {
-      sessions,
-      total,
-      ...(nextCursor !== undefined ? { cursor: nextCursor } : {}),
-    };
-  }
-
-  async getSession(sessionId: string): Promise<AgentSessionTree | null> {
-    return this.prisma.agentSessionTree.findUnique({
-      where: { sessionId },
-    });
-  }
-
   async getTree(): Promise<AgentTreeResponseDto[]> {
     const entries = await this.prisma.agentSessionTree.findMany({
       orderBy: { spawnedAt: "desc" },
@@ -94,53 +27,4 @@ export class AgentTreeService {
 
     return response;
   }
-
-  private normalizeLimit(limit: number): number {
-    const normalized = Number.isFinite(limit) ? Math.trunc(limit) : DEFAULT_PAGE_LIMIT;
-    if (normalized < 1) {
-      return 1;
-    }
-
-    return Math.min(normalized, MAX_PAGE_LIMIT);
-  }
-
-  private serializeCursor(entry: Pick<AgentSessionTree, "spawnedAt" | "sessionId">): string {
-    return Buffer.from(
-      JSON.stringify({
-        spawnedAt: entry.spawnedAt.toISOString(),
-        sessionId: entry.sessionId,
-      }),
-      "utf8"
-    ).toString("base64url");
-  }
-
-  private parseCursor(cursor?: string): SessionCursor | null {
-    if (!cursor) {
-      return null;
-    }
-
-    try {
-      const decoded = Buffer.from(cursor, "base64url").toString("utf8");
-      const parsed = JSON.parse(decoded) as {
-        spawnedAt?: string;
-        sessionId?: string;
-      };
-
-      if (typeof parsed.spawnedAt !== "string" || typeof parsed.sessionId !== "string") {
-        return null;
-      }
-
-      const spawnedAt = new Date(parsed.spawnedAt);
-      if (Number.isNaN(spawnedAt.getTime())) {
-        return null;
-      }
-
-      return {
-        spawnedAt,
-        sessionId: parsed.sessionId,
-      };
-    } catch {
-      return null;
-    }
-  }
 }

apps/orchestrator/src/api/agents/agents.module.ts

@@ -10,8 +10,6 @@ import { PrismaModule } from "../../prisma/prisma.module";
 import { AgentMessagesService } from "./agent-messages.service";
 import { AgentControlService } from "./agent-control.service";
 import { AgentTreeService } from "./agent-tree.service";
-import { InternalAgentProvider } from "./internal-agent.provider";
-import { AgentProviderRegistry } from "./agent-provider.registry";
 
 @Module({
   imports: [QueueModule, SpawnerModule, KillswitchModule, ValkeyModule, PrismaModule],
@@ -22,9 +20,6 @@ import { AgentProviderRegistry } from "./agent-provider.registry";
     AgentMessagesService,
     AgentControlService,
     AgentTreeService,
-    InternalAgentProvider,
-    AgentProviderRegistry,
   ],
-  exports: [InternalAgentProvider, AgentProviderRegistry],
 })
 export class AgentsModule {}

apps/orchestrator/src/api/agents/internal-agent.provider.spec.ts

@@ -1,216 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { AgentConversationMessage, AgentSessionTree } from "@prisma/client";
-import { AgentControlService } from "./agent-control.service";
-import { AgentMessagesService } from "./agent-messages.service";
-import { AgentTreeService } from "./agent-tree.service";
-import { InternalAgentProvider } from "./internal-agent.provider";
-
-describe("InternalAgentProvider", () => {
-  let provider: InternalAgentProvider;
-  let messagesService: {
-    getMessages: ReturnType<typeof vi.fn>;
-    getReplayMessages: ReturnType<typeof vi.fn>;
-    getMessagesAfter: ReturnType<typeof vi.fn>;
-  };
-  let controlService: {
-    injectMessage: ReturnType<typeof vi.fn>;
-    pauseAgent: ReturnType<typeof vi.fn>;
-    resumeAgent: ReturnType<typeof vi.fn>;
-    killAgent: ReturnType<typeof vi.fn>;
-  };
-  let treeService: {
-    listSessions: ReturnType<typeof vi.fn>;
-    getSession: ReturnType<typeof vi.fn>;
-  };
-
-  beforeEach(() => {
-    messagesService = {
-      getMessages: vi.fn(),
-      getReplayMessages: vi.fn(),
-      getMessagesAfter: vi.fn(),
-    };
-
-    controlService = {
-      injectMessage: vi.fn().mockResolvedValue(undefined),
-      pauseAgent: vi.fn().mockResolvedValue(undefined),
-      resumeAgent: vi.fn().mockResolvedValue(undefined),
-      killAgent: vi.fn().mockResolvedValue(undefined),
-    };
-
-    treeService = {
-      listSessions: vi.fn(),
-      getSession: vi.fn(),
-    };
-
-    provider = new InternalAgentProvider(
-      messagesService as unknown as AgentMessagesService,
-      controlService as unknown as AgentControlService,
-      treeService as unknown as AgentTreeService
-    );
-  });
-
-  it("maps paginated sessions", async () => {
-    const sessionEntry: AgentSessionTree = {
-      id: "tree-1",
-      sessionId: "session-1",
-      parentSessionId: "parent-1",
-      provider: "internal",
-      missionId: null,
-      taskId: "task-123",
-      taskSource: "queue",
-      agentType: "worker",
-      status: "running",
-      spawnedAt: new Date("2026-03-07T10:00:00.000Z"),
-      completedAt: null,
-      metadata: { branch: "feat/test" },
-    };
-
-    treeService.listSessions.mockResolvedValue({
-      sessions: [sessionEntry],
-      total: 1,
-      cursor: "next-cursor",
-    });
-
-    const result = await provider.listSessions("cursor-1", 25);
-
-    expect(treeService.listSessions).toHaveBeenCalledWith("cursor-1", 25);
-    expect(result).toEqual({
-      sessions: [
-        {
-          id: "session-1",
-          providerId: "internal",
-          providerType: "internal",
-          label: "task-123",
-          status: "active",
-          parentSessionId: "parent-1",
-          createdAt: new Date("2026-03-07T10:00:00.000Z"),
-          updatedAt: new Date("2026-03-07T10:00:00.000Z"),
-          metadata: { branch: "feat/test" },
-        },
-      ],
-      total: 1,
-      cursor: "next-cursor",
-    });
-  });
-
-  it("returns null for missing session", async () => {
-    treeService.getSession.mockResolvedValue(null);
-
-    const result = await provider.getSession("missing-session");
-
-    expect(treeService.getSession).toHaveBeenCalledWith("missing-session");
-    expect(result).toBeNull();
-  });
-
-  it("maps message history and parses skip cursor", async () => {
-    const message: AgentConversationMessage = {
-      id: "msg-1",
-      sessionId: "session-1",
-      provider: "internal",
-      role: "agent",
-      content: "hello",
-      timestamp: new Date("2026-03-07T10:05:00.000Z"),
-      metadata: { tokens: 42 },
-    };
-
-    messagesService.getMessages.mockResolvedValue({
-      messages: [message],
-      total: 10,
-    });
-
-    const result = await provider.getMessages("session-1", 30, "2");
-
-    expect(messagesService.getMessages).toHaveBeenCalledWith("session-1", 30, 2);
-    expect(result).toEqual([
-      {
-        id: "msg-1",
-        sessionId: "session-1",
-        role: "assistant",
-        content: "hello",
-        timestamp: new Date("2026-03-07T10:05:00.000Z"),
-        metadata: { tokens: 42 },
-      },
-    ]);
-  });
-
-  it("routes control operations through AgentControlService", async () => {
-    const injectResult = await provider.injectMessage("session-1", "new instruction");
-
-    await provider.pauseSession("session-1");
-    await provider.resumeSession("session-1");
-    await provider.killSession("session-1", false);
-
-    expect(controlService.injectMessage).toHaveBeenCalledWith(
-      "session-1",
-      "internal-provider",
-      "new instruction"
-    );
-    expect(injectResult).toEqual({ accepted: true });
-    expect(controlService.pauseAgent).toHaveBeenCalledWith("session-1", "internal-provider");
-    expect(controlService.resumeAgent).toHaveBeenCalledWith("session-1", "internal-provider");
-    expect(controlService.killAgent).toHaveBeenCalledWith("session-1", "internal-provider", false);
-  });
-
-  it("streams replay and incremental messages", async () => {
-    const replayMessage: AgentConversationMessage = {
-      id: "msg-replay",
-      sessionId: "session-1",
-      provider: "internal",
-      role: "agent",
-      content: "replay",
-      timestamp: new Date("2026-03-07T10:00:00.000Z"),
-      metadata: {},
-    };
-    const incrementalMessage: AgentConversationMessage = {
-      id: "msg-live",
-      sessionId: "session-1",
-      provider: "internal",
-      role: "operator",
-      content: "live",
-      timestamp: new Date("2026-03-07T10:00:01.000Z"),
-      metadata: {},
-    };
-
-    messagesService.getReplayMessages.mockResolvedValue([replayMessage]);
-    messagesService.getMessagesAfter
-      .mockResolvedValueOnce([incrementalMessage])
-      .mockResolvedValueOnce([]);
-
-    const iterator = provider.streamMessages("session-1")[Symbol.asyncIterator]();
-
-    const first = await iterator.next();
-    const second = await iterator.next();
-
-    expect(first.done).toBe(false);
-    expect(first.value).toEqual({
-      id: "msg-replay",
-      sessionId: "session-1",
-      role: "assistant",
-      content: "replay",
-      timestamp: new Date("2026-03-07T10:00:00.000Z"),
-      metadata: {},
-    });
-    expect(second.done).toBe(false);
-    expect(second.value).toEqual({
-      id: "msg-live",
-      sessionId: "session-1",
-      role: "user",
-      content: "live",
-      timestamp: new Date("2026-03-07T10:00:01.000Z"),
-      metadata: {},
-    });
-
-    await iterator.return?.();
-
-    expect(messagesService.getReplayMessages).toHaveBeenCalledWith("session-1", 50);
-    expect(messagesService.getMessagesAfter).toHaveBeenCalledWith(
-      "session-1",
-      new Date("2026-03-07T10:00:00.000Z"),
-      "msg-replay"
-    );
-  });
-
-  it("reports provider availability", async () => {
-    await expect(provider.isAvailable()).resolves.toBe(true);
-  });
-});

apps/orchestrator/src/api/agents/internal-agent.provider.ts

@@ -1,218 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import type {
-  AgentMessage,
-  AgentMessageRole,
-  AgentSession,
-  AgentSessionList,
-  AgentSessionStatus,
-  IAgentProvider,
-  InjectResult,
-} from "@mosaic/shared";
-import type { AgentConversationMessage, AgentSessionTree } from "@prisma/client";
-import { AgentControlService } from "./agent-control.service";
-import { AgentMessagesService } from "./agent-messages.service";
-import { AgentTreeService } from "./agent-tree.service";
-
-const DEFAULT_SESSION_LIMIT = 50;
-const DEFAULT_MESSAGE_LIMIT = 50;
-const MAX_MESSAGE_LIMIT = 200;
-const STREAM_POLL_INTERVAL_MS = 1000;
-const INTERNAL_OPERATOR_ID = "internal-provider";
-
-@Injectable()
-export class InternalAgentProvider implements IAgentProvider {
-  readonly providerId = "internal";
-  readonly providerType = "internal";
-  readonly displayName = "Internal Orchestrator";
-
-  constructor(
-    private readonly messagesService: AgentMessagesService,
-    private readonly controlService: AgentControlService,
-    private readonly treeService: AgentTreeService
-  ) {}
-
-  async listSessions(cursor?: string, limit = DEFAULT_SESSION_LIMIT): Promise<AgentSessionList> {
-    const {
-      sessions,
-      total,
-      cursor: nextCursor,
-    } = await this.treeService.listSessions(cursor, limit);
-
-    return {
-      sessions: sessions.map((session) => this.toAgentSession(session)),
-      total,
-      ...(nextCursor !== undefined ? { cursor: nextCursor } : {}),
-    };
-  }
-
-  async getSession(sessionId: string): Promise<AgentSession | null> {
-    const session = await this.treeService.getSession(sessionId);
-    return session ? this.toAgentSession(session) : null;
-  }
-
-  async getMessages(
-    sessionId: string,
-    limit = DEFAULT_MESSAGE_LIMIT,
-    before?: string
-  ): Promise<AgentMessage[]> {
-    const safeLimit = this.normalizeMessageLimit(limit);
-    const skip = this.parseSkip(before);
-
-    const result = await this.messagesService.getMessages(sessionId, safeLimit, skip);
-    return result.messages.map((message) => this.toAgentMessage(message));
-  }
-
-  async injectMessage(sessionId: string, content: string): Promise<InjectResult> {
-    await this.controlService.injectMessage(sessionId, INTERNAL_OPERATOR_ID, content);
-
-    return {
-      accepted: true,
-    };
-  }
-
-  async pauseSession(sessionId: string): Promise<void> {
-    await this.controlService.pauseAgent(sessionId, INTERNAL_OPERATOR_ID);
-  }
-
-  async resumeSession(sessionId: string): Promise<void> {
-    await this.controlService.resumeAgent(sessionId, INTERNAL_OPERATOR_ID);
-  }
-
-  async killSession(sessionId: string, force = true): Promise<void> {
-    await this.controlService.killAgent(sessionId, INTERNAL_OPERATOR_ID, force);
-  }
-
-  async *streamMessages(sessionId: string): AsyncIterable<AgentMessage> {
-    const replayMessages = await this.messagesService.getReplayMessages(
-      sessionId,
-      DEFAULT_MESSAGE_LIMIT
-    );
-
-    let lastSeenTimestamp = new Date();
-    let lastSeenMessageId: string | null = null;
-
-    for (const message of replayMessages) {
-      yield this.toAgentMessage(message);
-      lastSeenTimestamp = message.timestamp;
-      lastSeenMessageId = message.id;
-    }
-
-    for (;;) {
-      const newMessages = await this.messagesService.getMessagesAfter(
-        sessionId,
-        lastSeenTimestamp,
-        lastSeenMessageId
-      );
-
-      for (const message of newMessages) {
-        yield this.toAgentMessage(message);
-        lastSeenTimestamp = message.timestamp;
-        lastSeenMessageId = message.id;
-      }
-
-      await this.delay(STREAM_POLL_INTERVAL_MS);
-    }
-  }
-
-  isAvailable(): Promise<boolean> {
-    return Promise.resolve(true);
-  }
-
-  private toAgentSession(session: AgentSessionTree): AgentSession {
-    const metadata = this.toMetadata(session.metadata);
-
-    return {
-      id: session.sessionId,
-      providerId: this.providerId,
-      providerType: this.providerType,
-      ...(session.taskId !== null ? { label: session.taskId } : {}),
-      status: this.toSessionStatus(session.status),
-      ...(session.parentSessionId !== null ? { parentSessionId: session.parentSessionId } : {}),
-      createdAt: session.spawnedAt,
-      updatedAt: session.completedAt ?? session.spawnedAt,
-      ...(metadata !== undefined ? { metadata } : {}),
-    };
-  }
-
-  private toAgentMessage(message: AgentConversationMessage): AgentMessage {
-    const metadata = this.toMetadata(message.metadata);
-
-    return {
-      id: message.id,
-      sessionId: message.sessionId,
-      role: this.toMessageRole(message.role),
-      content: message.content,
-      timestamp: message.timestamp,
-      ...(metadata !== undefined ? { metadata } : {}),
-    };
-  }
-
-  private toSessionStatus(status: string): AgentSessionStatus {
-    switch (status) {
-      case "running":
-        return "active";
-      case "paused":
-        return "paused";
-      case "completed":
-        return "completed";
-      case "failed":
-      case "killed":
-        return "failed";
-      case "spawning":
-      default:
-        return "idle";
-    }
-  }
-
-  private toMessageRole(role: string): AgentMessageRole {
-    switch (role) {
-      case "agent":
-      case "assistant":
-        return "assistant";
-      case "system":
-        return "system";
-      case "tool":
-        return "tool";
-      case "operator":
-      case "user":
-      default:
-        return "user";
-    }
-  }
-
-  private normalizeMessageLimit(limit: number): number {
-    const normalized = Number.isFinite(limit) ? Math.trunc(limit) : DEFAULT_MESSAGE_LIMIT;
-    if (normalized < 1) {
-      return 1;
-    }
-
-    return Math.min(normalized, MAX_MESSAGE_LIMIT);
-  }
-
-  private parseSkip(before?: string): number {
-    if (!before) {
-      return 0;
-    }
-
-    const parsed = Number.parseInt(before, 10);
-    if (Number.isNaN(parsed) || parsed < 0) {
-      return 0;
-    }
-
-    return parsed;
-  }
-
-  private toMetadata(value: unknown): Record<string, unknown> | undefined {
-    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-      return value as Record<string, unknown>;
-    }
-
-    return undefined;
-  }
-
-  private async delay(ms: number): Promise<void> {
-    await new Promise((resolve) => {
-      setTimeout(resolve, ms);
-    });
-  }
-}

apps/orchestrator/src/app.module.ts

@@ -5,7 +5,6 @@ import { ThrottlerModule } from "@nestjs/throttler";
 import { HealthModule } from "./api/health/health.module";
 import { AgentsModule } from "./api/agents/agents.module";
 import { QueueApiModule } from "./api/queue/queue-api.module";
-import { AgentProvidersModule } from "./api/agent-providers/agent-providers.module";
 import { CoordinatorModule } from "./coordinator/coordinator.module";
 import { BudgetModule } from "./budget/budget.module";
 import { CIModule } from "./ci";
@@ -52,7 +51,6 @@ import { orchestratorConfig } from "./config/orchestrator.config";
     ]),
     HealthModule,
     AgentsModule,
-    AgentProvidersModule,
     QueueApiModule,
     CoordinatorModule,
     BudgetModule,