@nebulaos/core 0.1.1

package/dist/multi-agent/hierarchical-team/HierarchicalTeam.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HierarchicalTeam = void 0;
+const BaseAgent_js_1 = require("../../agent/BaseAgent.js");
+const AgentAsTool_js_1 = require("../agent-as-tool/AgentAsTool.js");
+const HandoffTeam_js_1 = require("../handoff-team/HandoffTeam.js");
+const memory_js_1 = require("../utils/memory.js");
+const index_js_1 = require("../../tracing/index.js");
+class HierarchicalTeam extends BaseAgent_js_1.BaseAgent {
+    config;
+    kind = 'team:hierarchical';
+    manager;
+    workers;
+    teamMemory;
+    allowHandoff;
+    workerCollaboration;
+    constructor(config) {
+        super(config.id, config.name, undefined, config.memory ?? config.manager.config.memory);
+        this.config = config;
+        this.manager = config.manager;
+        this.workers = config.workers;
+        this.teamMemory = config.memory;
+        this.allowHandoff = config.allowHandoff ?? false;
+        this.workerCollaboration = config.workerCollaboration ?? false;
+    }
+    async execute(input, options) {
+        const correlationId = `hierarchical_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+        const startTime = Date.now();
+        return index_js_1.Tracing.withSpan({
+            kind: "agent",
+            name: `team:hierarchical:${this.name}`,
+            correlationId,
+            executionId: options?.executionId,
+            data: { agentName: this.name, input },
+        }, async (teamSpan) => {
+            this.emit("agent:execution:start", {
+                correlationId,
+                executionId: options?.executionId,
+                data: {
+                    agentId: this.id,
+                    agentName: this.name,
+                    input: input,
+                },
+            });
+            try {
+                const result = this.allowHandoff
+                    ? await this.executeWithHandoff(input, options)
+                    : await this.executeDelegationOnly(input, options);
+                this.emit("agent:execution:end", {
+                    correlationId,
+                    executionId: options?.executionId,
+                    data: {
+                        agentId: this.id,
+                        agentName: this.name,
+                        status: result.truncated ? "truncated" : "success",
+                        output: result.content,
+                        durationMs: Date.now() - startTime,
+                    },
+                });
+                await teamSpan.end({
+                    status: result.truncated ? "cancelled" : "success",
+                    data: { output: result.content },
+                });
+                return result;
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                this.emit("agent:execution:error", {
+                    correlationId,
+                    executionId: options?.executionId,
+                    data: {
+                        agentId: this.id,
+                        agentName: this.name,
+                        error: {
+                            message: err.message,
+                            stack: err.stack,
+                            name: err.name,
+                        },
+                        durationMs: Date.now() - startTime,
+                    },
+                });
+                await teamSpan.end({ status: "error" });
+                throw error;
+            }
+        });
+    }
+    async executeDelegationOnly(input, options) {
+        const teamMemory = this.teamMemory ?? this.manager.config.memory;
+        const tools = this.buildWorkerTools(teamMemory);
+        const originalTools = this.manager.config.tools ?? [];
+        this.manager.config.tools = [...originalTools, ...tools];
+        const restoreMemory = (0, memory_js_1.overrideAgentMemory)(this.manager, teamMemory);
+        try {
+            if (input) {
+                await this.addMessage({ role: "user", content: input });
+            }
+            return await this.manager.execute(undefined, {
+                ...(options ?? {}),
+                executionId: options?.executionId,
+            });
+        }
+        finally {
+            this.manager.config.tools = originalTools;
+            restoreMemory();
+            tools.forEach((t) => t.setCallingMemory(undefined));
+        }
+    }
+    async executeWithHandoff(input, options) {
+        const teamMemory = this.teamMemory ?? this.manager.config.memory;
+        if (this.workerCollaboration) {
+            this.workers.forEach((worker) => {
+                const originalTools = worker.config.tools ?? [];
+                const peerTools = this.workers
+                    .filter((w) => w !== worker)
+                    .map((w) => new AgentAsTool_js_1.AgentAsTool({
+                    agent: w,
+                    memory: { type: "shared" },
+                    additionalPrompt: "Use this to consult another specialist.",
+                }));
+                worker.config.tools = [...originalTools, ...peerTools];
+            });
+        }
+        const team = new HandoffTeam_js_1.HandoffTeam({
+            id: `${this.config.id}-internal-handoff`,
+            name: `${this.config.name}-internal-handoff`,
+            agents: [this.manager, ...this.workers],
+            edges: [
+                ...this.workers.map((w) => ({
+                    from: this.manager,
+                    to: w,
+                    toolId: `handoff_to_${w.name.toLowerCase()}`,
+                    description: `Pass control to worker ${w.name}`,
+                })),
+                ...this.workers.map((w) => ({
+                    from: w,
+                    to: this.manager,
+                    toolId: `back_to_manager`,
+                    description: `Return control to manager`,
+                })),
+            ],
+            initialAgent: this.manager,
+            memory: teamMemory,
+            additionalPrompt: this.config.additionalPrompt,
+            maxTransfers: 10,
+        });
+        return team.execute(input, {
+            ...(options ?? {}),
+            executionId: options?.executionId,
+        });
+    }
+    buildWorkerTools(teamMemory) {
+        return this.workers.map((worker) => {
+            const tool = new AgentAsTool_js_1.AgentAsTool({
+                agent: worker,
+                id: `delegate_${worker.name.toLowerCase()}`,
+                memory: { type: "shared" },
+                additionalPrompt: "Delegate a subtask to this specialist.",
+            });
+            tool.setCallingMemory(teamMemory);
+            return tool;
+        });
+    }
+}
+exports.HierarchicalTeam = HierarchicalTeam;

package/dist/multi-agent/hierarchical-team/HierarchicalTeam.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/multi-agent/hierarchical-team/HierarchicalTeam.spec.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Agent_js_1 = require("../../agent/Agent.js");
+const in_memory_js_1 = require("../../agent/memory/in-memory.js");
+const mock_provider_js_1 = require("../../__tests__/mocks/mock-provider.js");
+const HierarchicalTeam_js_1 = require("./HierarchicalTeam.js");
+function agentWithToolCall(name, toolName) {
+    const provider = new mock_provider_js_1.MockProvider();
+    provider.enqueueResponse({
+        content: "",
+        toolCalls: [
+            {
+                id: "call-1",
+                type: "function",
+                function: { name: toolName, arguments: "{}" },
+            },
+        ],
+    });
+    return new Agent_js_1.Agent({
+        id: name,
+        name,
+        model: provider,
+        memory: new in_memory_js_1.InMemory(),
+        instructions: `${name} instructions`,
+    });
+}
+function agentWithFinal(name, content) {
+    const provider = new mock_provider_js_1.MockProvider();
+    provider.enqueueResponse({ content });
+    return new Agent_js_1.Agent({
+        id: name,
+        name,
+        model: provider,
+        memory: new in_memory_js_1.InMemory(),
+        instructions: `${name} instructions`,
+    });
+}
+describe("HierarchicalTeam", () => {
+    it("supports handoff from manager to worker", async () => {
+        const manager = agentWithToolCall("Manager", "handoff_to_worker");
+        const worker = agentWithFinal("Worker", "worker-output");
+        const team = new HierarchicalTeam_js_1.HierarchicalTeam({
+            id: "test-hierarchical",
+            name: "test-hierarchical",
+            manager,
+            workers: [worker],
+            allowHandoff: true,
+            memory: new in_memory_js_1.InMemory(),
+        });
+        const result = await team.execute("customer request");
+        expect(result.content).toBe("worker-output");
+    });
+});

package/dist/multi-agent/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./types/index.js";
+export * from "./agent-as-tool/AgentAsTool.js";
+export * from "./router-team/RouterTeam.js";
+export * from "./handoff-team/HandoffTeam.js";
+export * from "./hierarchical-team/HierarchicalTeam.js";
+export * from "./pipeline-team/PipelineTeam.js";
+export * from "./committee-team/CommitteeTeam.js";
+export * from "./utils/guardrails.js";
+export * from "./utils/memory.js";
+export * from "./utils/prompts.js";

package/dist/multi-agent/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types/index.js"), exports);
+__exportStar(require("./agent-as-tool/AgentAsTool.js"), exports);
+__exportStar(require("./router-team/RouterTeam.js"), exports);
+__exportStar(require("./handoff-team/HandoffTeam.js"), exports);
+__exportStar(require("./hierarchical-team/HierarchicalTeam.js"), exports);
+__exportStar(require("./pipeline-team/PipelineTeam.js"), exports);
+__exportStar(require("./committee-team/CommitteeTeam.js"), exports);
+__exportStar(require("./utils/guardrails.js"), exports);
+__exportStar(require("./utils/memory.js"), exports);
+__exportStar(require("./utils/prompts.js"), exports);

package/dist/multi-agent/pipeline-team/PipelineTeam.d.ts

@@ -0,0 +1,13 @@
+import type { AgentResult } from "../../agent/Agent.js";
+import { BaseAgent } from "../../agent/BaseAgent.js";
+import type { AgentExecuteOptions } from "../../agent/Agent.js";
+import type { PipelineTeamConfig } from "../types/index.js";
+export declare class PipelineTeam extends BaseAgent {
+    private readonly config;
+    readonly kind: "team:pipeline";
+    private readonly stages;
+    private readonly teamMemory?;
+    constructor(config: PipelineTeamConfig);
+    execute(input?: string, options?: AgentExecuteOptions): Promise<AgentResult>;
+    private buildEdges;
+}

package/dist/multi-agent/pipeline-team/PipelineTeam.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineTeam = void 0;
+const BaseAgent_js_1 = require("../../agent/BaseAgent.js");
+const HandoffTeam_js_1 = require("../handoff-team/HandoffTeam.js");
+const index_js_1 = require("../../tracing/index.js");
+class PipelineTeam extends BaseAgent_js_1.BaseAgent {
+    config;
+    kind = 'team:pipeline';
+    stages;
+    teamMemory;
+    constructor(config) {
+        super(config.id, config.name, undefined, config.memory ?? config.stages?.[0]?.config?.memory);
+        this.config = config;
+        this.stages = config.stages;
+        this.teamMemory = config.memory;
+    }
+    async execute(input, options) {
+        const correlationId = `pipeline_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+        const startTime = Date.now();
+        return index_js_1.Tracing.withSpan({
+            kind: "agent",
+            name: `team:pipeline:${this.name}`,
+            correlationId,
+            executionId: options?.executionId,
+            data: { agentName: this.name, input },
+        }, async (teamSpan) => {
+            this.emit("agent:execution:start", {
+                correlationId,
+                executionId: options?.executionId,
+                data: {
+                    agentId: this.id,
+                    agentName: this.name,
+                    input: input,
+                },
+            });
+            try {
+                const edges = this.buildEdges();
+                const team = new HandoffTeam_js_1.HandoffTeam({
+                    id: `${this.config.id}-internal-handoff`,
+                    name: `${this.config.name}-internal-handoff`,
+                    agents: this.stages,
+                    edges,
+                    initialAgent: this.stages[0],
+                    memory: this.teamMemory,
+                    additionalPrompt: this.config.additionalPrompt,
+                    maxTransfers: edges.length + 2,
+                });
+                const result = await team.execute(input, {
+                    ...(options ?? {}),
+                    executionId: options?.executionId,
+                });
+                this.emit("agent:execution:end", {
+                    correlationId,
+                    executionId: options?.executionId,
+                    data: {
+                        agentId: this.id,
+                        agentName: this.name,
+                        status: result.truncated ? "truncated" : "success",
+                        output: result.content,
+                        durationMs: Date.now() - startTime,
+                    },
+                });
+                await teamSpan.end({
+                    status: result.truncated ? "cancelled" : "success",
+                    data: { output: result.content },
+                });
+                return result;
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                this.emit("agent:execution:error", {
+                    correlationId,
+                    executionId: options?.executionId,
+                    data: {
+                        agentId: this.id,
+                        agentName: this.name,
+                        error: {
+                            message: err.message,
+                            stack: err.stack,
+                            name: err.name,
+                        },
+                        durationMs: Date.now() - startTime,
+                    },
+                });
+                await teamSpan.end({ status: "error" });
+                throw error;
+            }
+        });
+    }
+    buildEdges() {
+        const edges = this.stages.slice(0, -1).map((from, idx) => {
+            const to = this.stages[idx + 1];
+            return {
+                from,
+                to,
+                toolId: `next_${to.name.toLowerCase()}`,
+                description: `Pass work to ${to.name}`,
+            };
+        });
+        return edges;
+    }
+}
+exports.PipelineTeam = PipelineTeam;

package/dist/multi-agent/pipeline-team/PipelineTeam.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/multi-agent/pipeline-team/PipelineTeam.spec.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Agent_js_1 = require("../../agent/Agent.js");
+const in_memory_js_1 = require("../../agent/memory/in-memory.js");
+const mock_provider_js_1 = require("../../__tests__/mocks/mock-provider.js");
+const PipelineTeam_js_1 = require("./PipelineTeam.js");
+function agentWithToolCall(name, toolName, repeats = 1) {
+    const provider = new mock_provider_js_1.MockProvider();
+    for (let i = 0; i < repeats; i++) {
+        provider.enqueueResponse({
+            content: "",
+            toolCalls: [
+                {
+                    id: `call-${i + 1}`,
+                    type: "function",
+                    function: { name: toolName, arguments: "{}" },
+                },
+            ],
+        });
+    }
+    return new Agent_js_1.Agent({
+        id: name,
+        name,
+        model: provider,
+        memory: new in_memory_js_1.InMemory(),
+        instructions: `${name} instructions`,
+    });
+}
+function agentWithFinal(name, content) {
+    const provider = new mock_provider_js_1.MockProvider();
+    provider.enqueueResponse({ content });
+    return new Agent_js_1.Agent({
+        id: name,
+        name,
+        model: provider,
+        memory: new in_memory_js_1.InMemory(),
+        instructions: `${name} instructions`,
+    });
+}
+describe("PipelineTeam", () => {
+    it("executes linear stages via handoff", async () => {
+        const stage1 = agentWithToolCall("Stage1", "next_stage2");
+        const stage2 = agentWithToolCall("Stage2", "next_stage3");
+        const stage3 = agentWithFinal("Stage3", "final-output");
+        const team = new PipelineTeam_js_1.PipelineTeam({
+            id: "test-pipeline",
+            name: "test-pipeline",
+            stages: [stage1, stage2, stage3],
+            memory: new in_memory_js_1.InMemory(),
+        });
+        const result = await team.execute("do work");
+        expect(result.content).toBe("final-output");
+    });
+});

package/dist/multi-agent/router-team/RouterTeam.d.ts

@@ -0,0 +1,15 @@
+import type { AgentResult } from "../../agent/Agent.js";
+import { BaseAgent } from "../../agent/BaseAgent.js";
+import type { AgentExecuteOptions } from "../../agent/Agent.js";
+import type { RouterTeamConfig } from "../types/index.js";
+export declare class RouterTeam extends BaseAgent {
+    private readonly config;
+    readonly kind: "team:router";
+    constructor(config: RouterTeamConfig);
+    /**
+     * Execute routing: choose an agent via model classification, then delegate execution.
+     */
+    execute(input?: string, options?: AgentExecuteOptions): Promise<AgentResult>;
+    private selectAgent;
+    private extractAgentName;
+}

package/dist/multi-agent/router-team/RouterTeam.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterTeam = void 0;
+const BaseAgent_js_1 = require("../../agent/BaseAgent.js");
+const prompts_js_1 = require("../utils/prompts.js");
+const memory_js_1 = require("../utils/memory.js");
+const guardrails_js_1 = require("../utils/guardrails.js");
+const index_js_1 = require("../../tracing/index.js");
+class RouterTeam extends BaseAgent_js_1.BaseAgent {
+    config;
+    kind = 'team:router';
+    constructor(config) {
+        super(config.id, config.name, undefined, config.memory ?? config.children?.[0]?.config?.memory);
+        this.config = config;
+    }
+    /**
+     * Execute routing: choose an agent via model classification, then delegate execution.
+     */
+    async execute(input, options) {
+        const correlationId = `router_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+        const startTime = Date.now();
+        return index_js_1.Tracing.withSpan({
+            kind: "agent",
+            name: `team:router:${this.name}`,
+            correlationId,
+            executionId: options?.executionId,
+            data: { agentName: this.name, input },
+        }, async (teamSpan) => {
+            this.emit("agent:execution:start", {
+                correlationId,
+                executionId: options?.executionId,
+                data: {
+                    agentId: this.id,
+                    agentName: this.name,
+                    input: input,
+                },
+            });
+            try {
+                const selected = await this.selectAgent(input);
+                const memoryToUse = this.config.memory ?? selected.config.memory;
+                const restoreMemory = (0, memory_js_1.overrideAgentMemory)(selected, memoryToUse);
+                if (input) {
+                    await this.addMessage({ role: "user", content: input });
+                }
+                const result = await selected.execute(undefined, {
+                    ...(options ?? {}),
+                    executionId: options?.executionId,
+                });
+                restoreMemory();
+                this.emit("agent:execution:end", {
+                    correlationId,
+                    executionId: options?.executionId,
+                    data: {
+                        agentId: this.id,
+                        agentName: this.name,
+                        status: result.truncated ? "truncated" : "success",
+                        output: result.content,
+                        durationMs: Date.now() - startTime,
+                        // Usage? Ideally aggregated, but for now passing result content is key
+                    },
+                });
+                await teamSpan.end({
+                    status: result.truncated ? "cancelled" : "success",
+                    data: { output: result.content },
+                });
+                return result;
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                this.emit("agent:execution:error", {
+                    correlationId,
+                    executionId: options?.executionId,
+                    data: {
+                        agentId: this.id,
+                        agentName: this.name,
+                        error: {
+                            message: err.message,
+                            stack: err.stack,
+                            name: err.name,
+                        },
+                        durationMs: Date.now() - startTime,
+                    },
+                });
+                await teamSpan.end({ status: "error" });
+                throw error;
+            }
+        });
+    }
+    async selectAgent(userInput) {
+        const system = (0, prompts_js_1.buildRouterSystemPrompt)(this.config.children, this.config.additionalPrompt);
+        const messages = [
+            { role: "system", content: system },
+            { role: "user", content: userInput ?? "" },
+        ];
+        const routerResponseSchema = {
+            type: "object",
+            properties: {
+                agent: {
+                    type: "string",
+                    description: "The name of the agent to route to",
+                },
+            },
+            required: ["agent"],
+            additionalProperties: false,
+        };
+        const response = await (0, guardrails_js_1.enforceTimeout)(index_js_1.Tracing.withSpan({
+            kind: "llm",
+            name: "llm:router-selection",
+            data: {
+                provider: this.config.model.providerName,
+                model: this.config.model.modelName,
+                messagesCount: messages.length,
+                toolsCount: 0,
+                responseFormat: { type: "json", schema: routerResponseSchema },
+            },
+        }, async (llmSpan) => {
+            const resp = await this.config.model.generate(messages, undefined, {
+                responseFormat: { type: "json", schema: routerResponseSchema },
+            });
+            await llmSpan.end({
+                status: "success",
+                data: {
+                    usage: resp.usage,
+                    outputPreview: typeof resp.content === "string" ? resp.content.substring(0, 200) : "json_content",
+                },
+            });
+            return resp;
+        }), this.config.timeoutMs, "router-selection");
+        const agentName = this.extractAgentName(response.content);
+        const found = this.config.children.find((c) => c.name.toLowerCase() === agentName?.toLowerCase()) ??
+            this.config.fallback ??
+            this.config.children[0];
+        return found;
+    }
+    extractAgentName(content) {
+        if (!content)
+            return undefined;
+        const trimmed = content.trim();
+        if (!trimmed)
+            return undefined;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed.agent === "string") {
+                return parsed.agent;
+            }
+        }
+        catch {
+            // ignore
+        }
+        return trimmed.split("\n")[0];
+    }
+}
+exports.RouterTeam = RouterTeam;

package/dist/multi-agent/router-team/RouterTeam.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/multi-agent/router-team/RouterTeam.spec.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const in_memory_js_1 = require("../../agent/memory/in-memory.js");
+const Agent_js_1 = require("../../agent/Agent.js");
+const RouterTeam_js_1 = require("./RouterTeam.js");
+const mock_provider_js_1 = require("../../__tests__/mocks/mock-provider.js");
+function createAgent(name, content) {
+    const provider = new mock_provider_js_1.MockProvider();
+    provider.enqueueResponse({ content });
+    return new Agent_js_1.Agent({
+        id: name,
+        name,
+        model: provider,
+        memory: new in_memory_js_1.InMemory(),
+        instructions: `${name} instructions`,
+    });
+}
+describe("RouterTeam", () => {
+    it("routes to the agent selected by the router model", async () => {
+        const routerModel = new mock_provider_js_1.MockProvider();
+        routerModel.enqueueResponse({ content: '{"agent":"Tech"}' });
+        const finance = createAgent("Finance", "finance-response");
+        const tech = createAgent("Tech", "tech-response");
+        const team = new RouterTeam_js_1.RouterTeam({
+            id: "test-router",
+            name: "test-router",
+            model: routerModel,
+            children: [finance, tech],
+        });
+        const result = await team.execute("System error");
+        expect(result.content).toBe("tech-response");
+        expect(routerModel.calls[0].messages[1].content).toBe("System error");
+    });
+    it("falls back to first agent if selection fails", async () => {
+        const routerModel = new mock_provider_js_1.MockProvider();
+        routerModel.enqueueResponse({ content: "unknown" });
+        const finance = createAgent("Finance", "finance-response");
+        const tech = createAgent("Tech", "tech-response");
+        const team = new RouterTeam_js_1.RouterTeam({
+            id: "test-router-2",
+            name: "test-router-2",
+            model: routerModel,
+            children: [finance, tech],
+        });
+        const result = await team.execute("Billing");
+        expect(result.content).toBe("finance-response");
+    });
+    it("uses team-level memory override during execution and restores agent memory", async () => {
+        const routerModel = new mock_provider_js_1.MockProvider();
+        routerModel.enqueueResponse({ content: '{"agent":"Tech"}' });
+        const originalMemory = new in_memory_js_1.InMemory();
+        const teamMemory = new in_memory_js_1.InMemory();
+        const tech = createAgent("Tech", "tech-response");
+        tech.config.memory = originalMemory;
+        const team = new RouterTeam_js_1.RouterTeam({
+            id: "test-router-memory",
+            name: "test-router-memory",
+            model: routerModel,
+            children: [tech],
+            memory: teamMemory,
+        });
+        await team.execute("Hello");
+        const teamMsgs = await teamMemory.getMessages();
+        expect(teamMsgs.some((m) => m.content === "Hello")).toBe(true);
+        // original memory stays empty (restored)
+        expect((await originalMemory.getMessages()).length).toBe(0);
+        expect(tech.config.memory).toBe(originalMemory);
+    });
+});