@nebulaos/core 0.1.1

package/dist/multi-agent/agent-as-tool/AgentAsTool.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentAsTool = void 0;
+const index_js_1 = require("../../agent/tools/index.js");
+const memory_js_1 = require("../utils/memory.js");
+class AgentAsTool extends index_js_1.Tool {
+    callingMemory;
+    target;
+    memoryConfig;
+    extraPrompt;
+    constructor(config) {
+        const toolId = config.id ??
+            `delegate_${config.agent.name.toLowerCase().replace(/\s+/g, "_")}`;
+        const description = config.description ??
+            `Delegate to specialist agent: ${config.agent.name}`;
+        super({
+            id: toolId,
+            description,
+            inputSchema: config.inputSchema,
+            handler: async (_, input) => {
+                return this.runDelegated(input);
+            },
+        });
+        this.target = config.agent;
+        this.memoryConfig = config.memory;
+        this.extraPrompt = config.additionalPrompt;
+    }
+    /**
+     * Allows orchestrators to set the calling agent/team memory when using
+     * `memory: { type: "shared" }`.
+     */
+    setCallingMemory(memory) {
+        this.callingMemory = memory;
+    }
+    async runDelegated(input) {
+        const { restore } = await (0, memory_js_1.resolveDelegationMemory)(this.target, this.memoryConfig, this.callingMemory);
+        try {
+            const formattedInput = typeof input === "string" ? input : JSON.stringify(input);
+            const userContent = this.extraPrompt
+                ? `${this.extraPrompt}\nInput: ${formattedInput}`
+                : formattedInput;
+            await this.target.config.memory.addMessage({
+                role: "user",
+                content: userContent,
+            });
+            const result = await this.target.execute();
+            return result.content;
+        }
+        finally {
+            restore();
+        }
+    }
+}
+exports.AgentAsTool = AgentAsTool;

package/dist/multi-agent/agent-as-tool/AgentAsTool.spec.d.ts

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

package/dist/multi-agent/agent-as-tool/AgentAsTool.spec.js

@@ -0,0 +1,76 @@
+"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 AgentAsTool_js_1 = require("./AgentAsTool.js");
+const mock_provider_js_1 = require("../../__tests__/mocks/mock-provider.js");
+const zod_1 = require("zod");
+function agentWithResponse(name, content, memory) {
+    const provider = new mock_provider_js_1.MockProvider();
+    provider.enqueueResponse({ content });
+    return new Agent_js_1.Agent({
+        id: name,
+        name,
+        model: provider,
+        memory: memory ?? new in_memory_js_1.InMemory(),
+        instructions: `${name} instructions`,
+    });
+}
+describe("AgentAsTool", () => {
+    it("delegates to target agent and returns its content", async () => {
+        const target = agentWithResponse("Target", "target-content");
+        const tool = new AgentAsTool_js_1.AgentAsTool({ agent: target, id: "delegate_target" });
+        const output = await tool.execute({}, { question: "hi" });
+        expect(output).toBe("target-content");
+    });
+    it("supports custom memory for delegation", async () => {
+        const customMemory = new in_memory_js_1.InMemory();
+        const target = agentWithResponse("Target", "custom-memory");
+        const tool = new AgentAsTool_js_1.AgentAsTool({
+            agent: target,
+            memory: { type: "custom", memory: customMemory },
+        });
+        await tool.execute({}, "hello");
+        const stored = await customMemory.getMessages();
+        expect(stored[0]?.content).toContain("hello");
+    });
+    it("propagates calling memory when using shared delegation", async () => {
+        const callingMemory = new in_memory_js_1.InMemory();
+        await callingMemory.addMessage({ role: "user", content: "history" });
+        const targetMemory = new in_memory_js_1.InMemory();
+        const target = agentWithResponse("Target", "ok", targetMemory);
+        const tool = new AgentAsTool_js_1.AgentAsTool({
+            agent: target,
+            memory: { type: "shared" },
+        });
+        tool.setCallingMemory(callingMemory);
+        await tool.execute({}, "question");
+        const stored = await targetMemory.getMessages();
+        // history from calling memory + new input
+        expect(stored.some((m) => m.content === "history")).toBe(true);
+        expect(stored.some((m) => String(m.content).includes("question"))).toBe(true);
+    });
+    it("isolated delegation should not leak calling memory", async () => {
+        const callingMemory = new in_memory_js_1.InMemory();
+        await callingMemory.addMessage({ role: "user", content: "history" });
+        const targetMemory = new in_memory_js_1.InMemory();
+        const target = agentWithResponse("Target", "ok", targetMemory);
+        const tool = new AgentAsTool_js_1.AgentAsTool({
+            agent: target,
+            memory: { type: "isolated" },
+        });
+        tool.setCallingMemory(callingMemory);
+        await tool.execute({}, "question");
+        const stored = await targetMemory.getMessages();
+        expect(stored.some((m) => m.content === "history")).toBe(false);
+    });
+    it("validates input via inputSchema", async () => {
+        const target = agentWithResponse("Target", "ok");
+        const tool = new AgentAsTool_js_1.AgentAsTool({
+            agent: target,
+            id: "delegate_target",
+            inputSchema: zod_1.z.object({ question: zod_1.z.string() }),
+        });
+        await expect(tool.execute({}, 123)).rejects.toThrow(/Invalid input/);
+    });
+});

package/dist/multi-agent/committee-team/CommitteeTeam.d.ts

@@ -0,0 +1,16 @@
+import type { AgentResult } from "../../agent/Agent.js";
+import { BaseAgent } from "../../agent/BaseAgent.js";
+import type { AgentExecuteOptions } from "../../agent/Agent.js";
+import type { CommitteeTeamConfig } from "../types/index.js";
+export declare class CommitteeTeam extends BaseAgent {
+    private readonly config;
+    private readonly coordinator;
+    private readonly members;
+    private readonly strategy;
+    private readonly teamMemory?;
+    constructor(config: CommitteeTeamConfig);
+    execute(input?: string, options?: AgentExecuteOptions): Promise<AgentResult>;
+    private collectOpinions;
+    private aggregate;
+    private buildResult;
+}

package/dist/multi-agent/committee-team/CommitteeTeam.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommitteeTeam = void 0;
+const BaseAgent_js_1 = require("../../agent/BaseAgent.js");
+const memory_js_1 = require("../utils/memory.js");
+const index_js_1 = require("../../tracing/index.js");
+class CommitteeTeam extends BaseAgent_js_1.BaseAgent {
+    config;
+    coordinator;
+    members;
+    strategy;
+    teamMemory;
+    constructor(config) {
+        super(config.id, config.name, undefined, config.memory ?? config.coordinator.config.memory);
+        this.config = config;
+        this.coordinator = config.coordinator;
+        this.members = config.members;
+        this.strategy = config.strategy;
+        this.teamMemory = config.memory;
+    }
+    async execute(input, options) {
+        const correlationId = `committee_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+        const startTime = Date.now();
+        return index_js_1.Tracing.withSpan({
+            kind: "agent",
+            name: `team:committee:${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 teamMemory = this.teamMemory ?? this.coordinator.config.memory;
+                const opinions = await this.collectOpinions(teamMemory, input, options);
+                const aggregated = this.aggregate(opinions);
+                const restoreMemory = (0, memory_js_1.overrideAgentMemory)(this.coordinator, teamMemory);
+                let result;
+                try {
+                    await this.addMessage({
+                        role: "user",
+                        content: `Members opinions:\n${opinions
+                            .map((o) => `- ${o.agent}: ${o.content}`)
+                            .join("\n")}\nStrategy: ${this.strategy}`,
+                    });
+                    if (input) {
+                        await this.addMessage({ role: "user", content: input });
+                    }
+                    const coordinatorResult = await this.coordinator.execute(undefined, {
+                        ...(options ?? {}),
+                        executionId: options?.executionId,
+                    });
+                    result = coordinatorResult ?? this.buildResult(aggregated);
+                }
+                finally {
+                    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,
+                    },
+                });
+                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 collectOpinions(memory, input, options) {
+        const opinions = [];
+        for (const member of this.members) {
+            const restoreMemory = (0, memory_js_1.overrideAgentMemory)(member, memory);
+            try {
+                if (input) {
+                    await memory.addMessage({ role: "user", content: input });
+                }
+                const result = await member.execute(undefined, {
+                    ...(options ?? {}),
+                    executionId: options?.executionId,
+                });
+                opinions.push({ agent: member.name, content: result.content });
+            }
+            finally {
+                restoreMemory();
+            }
+        }
+        return opinions;
+    }
+    aggregate(opinions) {
+        if (this.strategy === "first") {
+            return opinions[0]?.content;
+        }
+        if (this.strategy === "vote") {
+            const counts = opinions.reduce((acc, o) => {
+                const key = String(o.content);
+                acc[key] = (acc[key] || 0) + 1;
+                return acc;
+            }, {});
+            return Object.entries(counts).sort((a, b) => b[1] - a[1])[0]?.[0];
+        }
+        if (this.strategy === "confidence") {
+            return opinions[0]?.content;
+        }
+        return opinions.map((o) => `${o.agent}: ${o.content}`).join(" | ");
+    }
+    buildResult(content) {
+        return {
+            content,
+            toolExecutions: [],
+            llmCalls: 0,
+            totalDurationMs: 0,
+            truncated: false,
+        };
+    }
+}
+exports.CommitteeTeam = CommitteeTeam;

package/dist/multi-agent/committee-team/CommitteeTeam.spec.d.ts

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

package/dist/multi-agent/committee-team/CommitteeTeam.spec.js

@@ -0,0 +1,43 @@
+"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 CommitteeTeam_js_1 = require("./CommitteeTeam.js");
+function agentWithResponse(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("CommitteeTeam", () => {
+    it("aggregates member opinions and returns coordinator response", async () => {
+        const coordinatorProvider = new mock_provider_js_1.MockProvider();
+        coordinatorProvider.enqueueResponse({ content: "coordinator-final" });
+        const coordinator = new Agent_js_1.Agent({
+            id: "Coordinator",
+            name: "Coordinator",
+            model: coordinatorProvider,
+            memory: new in_memory_js_1.InMemory(),
+            instructions: "Aggregate",
+        });
+        const legal = agentWithResponse("Legal", "approve");
+        const tech = agentWithResponse("Tech", "approve");
+        const risk = agentWithResponse("Risk", "deny");
+        const team = new CommitteeTeam_js_1.CommitteeTeam({
+            id: "test-committee",
+            name: "test-committee",
+            coordinator,
+            members: [legal, tech, risk],
+            strategy: "summarize",
+            memory: new in_memory_js_1.InMemory(),
+        });
+        const result = await team.execute("Approve contract?");
+        expect(result.content).toBe("coordinator-final");
+    });
+});

package/dist/multi-agent/handoff-team/HandoffTeam.d.ts

@@ -0,0 +1,16 @@
+import type { AgentResult } from "../../agent/Agent.js";
+import { BaseAgent } from "../../agent/BaseAgent.js";
+import type { AgentExecuteOptions } from "../../agent/Agent.js";
+import type { HandoffTeamConfig } from "../types/index.js";
+export declare class HandoffTeam extends BaseAgent {
+    private readonly config;
+    readonly kind: "team:handoff";
+    private readonly edgeMap;
+    private readonly agentByName;
+    private readonly stickyStateKey;
+    constructor(config: HandoffTeamConfig);
+    execute(input?: string, options?: AgentExecuteOptions): Promise<AgentResult>;
+    private buildEdgeMap;
+    private attachHandoffTools;
+    private findHandoffSignal;
+}

package/dist/multi-agent/handoff-team/HandoffTeam.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HandoffTeam = void 0;
+const BaseAgent_js_1 = require("../../agent/BaseAgent.js");
+const index_js_1 = require("../../agent/tools/index.js");
+const zod_1 = require("zod");
+const guardrails_js_1 = require("../utils/guardrails.js");
+const memory_js_1 = require("../utils/memory.js");
+const index_js_2 = require("../../tracing/index.js");
+class HandoffTeam extends BaseAgent_js_1.BaseAgent {
+    config;
+    kind = 'team:handoff';
+    edgeMap;
+    agentByName;
+    stickyStateKey;
+    constructor(config) {
+        super(config.id, config.name, undefined, config.memory ?? config.initialAgent.config.memory);
+        this.config = config;
+        this.edgeMap = this.buildEdgeMap(config.edges);
+        this.agentByName = new Map(config.agents.map((a) => [a.name.toLowerCase(), a]));
+        this.stickyStateKey = `nebulaos:handoff:${this.name}:activeAgent`;
+    }
+    async execute(input, options) {
+        const correlationId = `handoff_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+        const startTime = Date.now();
+        return index_js_2.Tracing.withSpan({
+            kind: "agent",
+            name: `team:handoff:${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 teamMemory = this.config.memory ?? this.config.initialAgent.config.memory;
+                let current = this.config.initialAgent;
+                let transfers = 0;
+                // Resume from last active agent if the configured memory supports state storage.
+                // This makes handoff "stick" across subsequent execute() calls (process-local memory).
+                if (typeof teamMemory.getState === "function") {
+                    const lastAgentName = await teamMemory.getState(this.stickyStateKey);
+                    if (lastAgentName) {
+                        const last = this.agentByName.get(lastAgentName.toLowerCase());
+                        if (last)
+                            current = last;
+                    }
+                }
+                if (input) {
+                    await this.addMessage({ role: "user", content: input });
+                }
+                let lastResult;
+                while (true) {
+                    (0, guardrails_js_1.enforceMaxTransfers)(transfers, this.config.maxTransfers);
+                    const { tools, restoreTools } = this.attachHandoffTools(current);
+                    const restoreMemory = (0, memory_js_1.overrideAgentMemory)(current, teamMemory);
+                    try {
+                        const result = await (0, guardrails_js_1.enforceTimeout)(current.execute(undefined, {
+                            ...(options ?? {}),
+                            executionId: options?.executionId,
+                        }), this.config.timeoutMs, "handoff-execution");
+                        lastResult = result;
+                        const handoff = this.findHandoffSignal(result, tools);
+                        if (!handoff) {
+                            // Persist the last active agent for resume (if supported by memory).
+                            if (typeof teamMemory.setState === "function") {
+                                await teamMemory.setState(this.stickyStateKey, current.name);
+                            }
+                            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;
+                        }
+                        transfers++;
+                        (0, guardrails_js_1.enforceAllowedTransition)(current.name, handoff.to, this.config.allowedTransitions);
+                        if (this.config.onTransfer) {
+                            const target = this.agentByName.get(handoff.to.toLowerCase());
+                            if (target) {
+                                await this.config.onTransfer(current, target);
+                            }
+                        }
+                        const next = this.agentByName.get(handoff.to.toLowerCase());
+                        if (!next) {
+                            throw new Error(`Handoff target not found: ${handoff.to}`);
+                        }
+                        current = next;
+                        // Persist current agent immediately after handoff so the next external execute()
+                        // call resumes from the correct agent.
+                        if (typeof teamMemory.setState === "function") {
+                            await teamMemory.setState(this.stickyStateKey, current.name);
+                        }
+                        continue;
+                    }
+                    finally {
+                        restoreTools();
+                        restoreMemory();
+                    }
+                }
+            }
+            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;
+            }
+        });
+    }
+    buildEdgeMap(edges) {
+        const map = new Map();
+        edges.forEach((edge) => {
+            const list = map.get(edge.from) ?? [];
+            list.push(edge);
+            map.set(edge.from, list);
+        });
+        return map;
+    }
+    attachHandoffTools(agent) {
+        const edges = this.edgeMap.get(agent) ?? [];
+        const newTools = edges.map((edge) => new index_js_1.Tool({
+            id: edge.toolId,
+            description: edge.description ??
+                `Transfer control to ${edge.to.name} (${edge.to.config.instructions})`,
+            inputSchema: zod_1.z.object({
+                context: zod_1.z.string().optional().describe("Additional context to pass to the receiving agent"),
+            }),
+            handler: async (_ctx, input) => ({
+                handoff: true,
+                to: edge.to.name,
+                context: input?.context,
+            }),
+        }));
+        const originalTools = agent.config.tools ?? [];
+        agent.config.tools = [...originalTools, ...newTools];
+        return {
+            tools: newTools,
+            restoreTools: () => {
+                agent.config.tools = originalTools;
+            },
+        };
+    }
+    findHandoffSignal(result, tools) {
+        if (!result.toolExecutions?.length)
+            return undefined;
+        const toolIds = new Set(tools.map((t) => t.id));
+        for (const exec of result.toolExecutions) {
+            if (toolIds.has(exec.name) && exec.output && exec.output.handoff) {
+                return exec.output;
+            }
+        }
+        return undefined;
+    }
+}
+exports.HandoffTeam = HandoffTeam;

package/dist/multi-agent/handoff-team/HandoffTeam.spec.d.ts

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

package/dist/multi-agent/handoff-team/HandoffTeam.spec.js

@@ -0,0 +1,105 @@
+"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 HandoffTeam_js_1 = require("./HandoffTeam.js");
+const mock_provider_js_1 = require("../../__tests__/mocks/mock-provider.js");
+function agentWithToolCall(name, toolName, toSelf = false) {
+    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("HandoffTeam", () => {
+    it("transfers control via handoff tool to target agent and returns final output", async () => {
+        const a = agentWithToolCall("A", "to_b");
+        const b = agentWithFinal("B", "done-b");
+        const team = new HandoffTeam_js_1.HandoffTeam({
+            id: "test-handoff",
+            name: "test-handoff",
+            agents: [a, b],
+            edges: [{ from: a, to: b, toolId: "to_b" }],
+            initialAgent: a,
+            maxTransfers: 3,
+        });
+        const result = await team.execute("hi");
+        expect(result.content).toBe("done-b");
+    });
+    it("enforces allowedTransitions and throws on disallowed handoff", async () => {
+        const a = agentWithToolCall("A", "to_c");
+        const b = agentWithFinal("B", "ok-b");
+        const c = agentWithFinal("C", "ok-c");
+        const team = new HandoffTeam_js_1.HandoffTeam({
+            id: "test-transitions",
+            name: "test-transitions",
+            agents: [a, b, c],
+            edges: [
+                { from: a, to: b, toolId: "to_b" },
+                { from: a, to: c, toolId: "to_c" },
+            ],
+            allowedTransitions: { A: ["B"] }, // disallow A -> C
+            initialAgent: a,
+            maxTransfers: 2,
+        });
+        await expect(team.execute("x")).rejects.toThrow(/not allowed/);
+    });
+    it("calls onTransfer when handoff occurs", async () => {
+        const a = agentWithToolCall("A", "to_b");
+        const b = agentWithFinal("B", "done-b");
+        const calls = [];
+        const team = new HandoffTeam_js_1.HandoffTeam({
+            id: "test-callback",
+            name: "test-callback",
+            agents: [a, b],
+            edges: [{ from: a, to: b, toolId: "to_b" }],
+            initialAgent: a,
+            onTransfer: (from, to) => {
+                calls.push(`${from.name}->${to.name}`);
+            },
+        });
+        const result = await team.execute("y");
+        expect(result.content).toBe("done-b");
+        expect(calls).toEqual(["A->B"]);
+    });
+    it("respects maxTransfers and throws when exceeded", async () => {
+        const a = agentWithToolCall("A", "to_b");
+        const b = agentWithToolCall("B", "to_a");
+        const team = new HandoffTeam_js_1.HandoffTeam({
+            id: "test-memory",
+            name: "test-memory",
+            agents: [a, b],
+            edges: [
+                { from: a, to: b, toolId: "to_b" },
+                { from: b, to: a, toolId: "to_a" },
+            ],
+            initialAgent: a,
+            maxTransfers: 1,
+        });
+        await expect(team.execute("loop")).rejects.toThrow(/Max transfers/);
+    });
+});

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

@@ -0,0 +1,18 @@
+import type { AgentResult } from "../../agent/Agent.js";
+import { BaseAgent } from "../../agent/BaseAgent.js";
+import type { AgentExecuteOptions } from "../../agent/Agent.js";
+import type { HierarchicalTeamConfig } from "../types/index.js";
+export declare class HierarchicalTeam extends BaseAgent {
+    private readonly config;
+    readonly kind: "team:hierarchical";
+    private readonly manager;
+    private readonly workers;
+    private readonly teamMemory?;
+    private readonly allowHandoff;
+    private readonly workerCollaboration;
+    constructor(config: HierarchicalTeamConfig);
+    execute(input?: string, options?: AgentExecuteOptions): Promise<AgentResult>;
+    private executeDelegationOnly;
+    private executeWithHandoff;
+    private buildWorkerTools;
+}