qlogicagent 0.2.1 → 0.4.0

package/dist/orchestration/team-orchestration.d.ts

@@ -1,195 +0,0 @@
-/**
- * Team Orchestration Strategy — multi-agent coordination layer.
- *
- * Extends the existing sidechain foundation with team/swarm semantics:
- * - Parallel agent spawning (multiple sidechains at once)
- * - Role-based agent assignment (planner / executor / reviewer)
- * - Shared knowledge pool via merge policies
- * - Budget-aware concurrency limits
- * - Lifecycle state machine for team coordination
- *
- * Architecture:
- *   Gateway ─── Hub ─── orchestration (this module, pure strategy)
- *                │
- *   ┌───────────┼───────────┐
- *   │   TeamCoordinator     │  ← Hub runtime (multi-sidechain-coordinator.ts)
- *   │   │                   │
- *   │   ├── Agent #1 (planner)
- *   │   ├── Agent #2 (executor)
- *   │   └── Agent #3 (reviewer)
- *   └───────────────────────┘
- *
- * This module provides:
- * 1. Type definitions (TeamPlan, AgentRole, TeamLifecycle)
- * 2. Pure strategy functions (plan resolution, role assignment, budget allocation)
- * 3. Merge/aggregation policies (how agent results combine)
- *
- * Hub consumes these types and strategy functions in its coordinator runtime.
- * Gateway consumes TeamPlan to spawn/manage multiple sidechain executions.
- */
-import type { SidechainType, SidechainMergePolicy, SidechainBudgetTier, SidechainToolAccessMode } from "./index.js";
-/** Roles an agent can take within a team execution. */
-export type AgentRole = "planner" | "executor" | "reviewer" | "researcher" | "custom";
-/** Execution mode for a team. */
-export type TeamExecutionMode = "parallel" | "sequential" | "pipeline" | "adaptive";
-/** How team results are aggregated into the parent execution. */
-export type TeamAggregationPolicy = "first-success" | "majority-vote" | "merge-all" | "reviewer-gate" | "planner-sync";
-/** Current lifecycle state of a team execution. */
-export type TeamLifecycleState = "planning" | "spawning" | "executing" | "aggregating" | "reviewing" | "completed" | "failed" | "cancelled";
-/** Specification for a single agent within a team. */
-export interface TeamAgentSpec {
-    /** Unique ID within the team (e.g., "agent-1", "researcher-a"). */
-    agentId: string;
-    /** Role this agent plays. */
-    role: AgentRole;
-    /** Human-readable label for tracing. */
-    label: string;
-    /** The sidechain type this agent maps to. */
-    sidechainType: SidechainType;
-    /** Task description / system prompt override for this agent. */
-    taskDescription: string;
-    /** Tool access mode for this agent's sidechain. */
-    toolAccessMode: SidechainToolAccessMode;
-    /** Budget tier for this agent. */
-    budgetTier: SidechainBudgetTier;
-    /** Which agents this one depends on (for sequential/pipeline modes). */
-    dependsOn: string[];
-    /** Maximum tokens this agent can consume. */
-    maxTokenBudget: number;
-    /** Maximum tool calls this agent can make. */
-    maxToolCalls: number;
-    /** Timeout in milliseconds (0 = inherit from team). */
-    timeoutMs: number;
-}
-/** A complete team execution plan. */
-export interface TeamPlan {
-    /** Unique team execution ID. */
-    teamId: string;
-    /** Execution mode for this team. */
-    mode: TeamExecutionMode;
-    /** How results from all agents are aggregated. */
-    aggregationPolicy: TeamAggregationPolicy;
-    /** All agent specs in this team. */
-    agents: TeamAgentSpec[];
-    /** Maximum concurrent agent executions (0 = unlimited). */
-    maxConcurrency: number;
-    /** Team-level timeout in ms (0 = no timeout). */
-    timeoutMs: number;
-    /** Total token budget across all agents. */
-    totalTokenBudget: number;
-    /** Whether early termination is allowed when one agent fails. */
-    failFast: boolean;
-    /** Shared context provided to all agents. */
-    sharedContext: string;
-    /** Merge policy for the final team output back to parent. */
-    mergePolicy: SidechainMergePolicy;
-}
-/** Result from a single agent within a team. */
-export interface TeamAgentResult {
-    agentId: string;
-    role: AgentRole;
-    status: "completed" | "failed" | "cancelled" | "timeout";
-    output: string;
-    tokenUsage: {
-        prompt: number;
-        completion: number;
-    };
-    toolCallCount: number;
-    durationMs: number;
-    error?: string;
-}
-/** Aggregated result from team execution. */
-export interface TeamResult {
-    teamId: string;
-    state: TeamLifecycleState;
-    agentResults: TeamAgentResult[];
-    aggregatedOutput: string;
-    totalTokenUsage: {
-        prompt: number;
-        completion: number;
-    };
-    totalDurationMs: number;
-}
-/** Maximum agents allowed in a team (safety bound). */
-export declare const TEAM_MAX_AGENTS = 8;
-/** Maximum recursion depth (teams spawning teams). */
-export declare const TEAM_MAX_DEPTH = 2;
-/**
- * Resolve a team plan from a high-level task decomposition.
- *
- * This is the main entry point: given a set of subtasks and constraints,
- * produce a concrete TeamPlan that the coordinator can execute.
- */
-export declare function resolveTeamPlan(params: {
-    teamId: string;
-    subtasks: Array<{
-        id: string;
-        role: AgentRole;
-        label: string;
-        task: string;
-        dependsOn?: string[];
-    }>;
-    mode?: TeamExecutionMode;
-    aggregationPolicy?: TeamAggregationPolicy;
-    totalTokenBudget?: number;
-    timeoutMs?: number;
-    failFast?: boolean;
-    sharedContext?: string;
-    mergePolicy?: SidechainMergePolicy;
-}): TeamPlan;
-/**
- * Map agent role to sidechain type for existing Hub plumbing compatibility.
- */
-export declare function mapRoleToSidechainType(role: AgentRole): SidechainType;
-/**
- * Resolve tool access mode for a given role.
- */
-export declare function resolveAgentToolAccess(role: AgentRole): SidechainToolAccessMode;
-/**
- * Allocate token budgets proportionally by role weight.
- */
-export declare function allocateTokenBudgets(agents: TeamAgentSpec[], totalBudget: number): TeamAgentSpec[];
-/**
- * Infer execution mode from agent dependency graph.
- */
-export declare function inferExecutionMode(agents: TeamAgentSpec[]): TeamExecutionMode;
-/**
- * Infer aggregation policy from mode and agent composition.
- */
-export declare function inferAggregationPolicy(mode: TeamExecutionMode, agents: TeamAgentSpec[]): TeamAggregationPolicy;
-/**
- * Determine the execution order for agents given their dependency graph.
- * Returns groups of agent IDs that can execute concurrently.
- *
- * Example: [[planner], [executor-a, executor-b], [reviewer]]
- */
-export declare function resolveExecutionOrder(agents: TeamAgentSpec[]): string[][];
-/**
- * Aggregate team results into a single output string.
- */
-export declare function aggregateTeamResults(results: TeamAgentResult[], policy: TeamAggregationPolicy): string;
-/**
- * Validate a team plan before execution.
- * Returns a list of issues (empty = valid).
- */
-export declare function validateTeamPlan(plan: TeamPlan): string[];
-/**
- * Determine if a team execution should be cancelled early based on current state.
- */
-export declare function shouldCancelTeam(params: {
-    plan: TeamPlan;
-    results: TeamAgentResult[];
-    elapsedMs: number;
-}): {
-    cancel: boolean;
-    reason: string;
-};
-/**
- * Build the task prompt for a specific agent, incorporating shared context
- * and outputs from dependency agents.
- */
-export declare function buildAgentTaskPrompt(params: {
-    agent: TeamAgentSpec;
-    plan: TeamPlan;
-    dependencyResults: TeamAgentResult[];
-}): string;

package/dist/orchestration/team-orchestration.js

@@ -1,369 +0,0 @@
-/**
- * Team Orchestration Strategy — multi-agent coordination layer.
- *
- * Extends the existing sidechain foundation with team/swarm semantics:
- * - Parallel agent spawning (multiple sidechains at once)
- * - Role-based agent assignment (planner / executor / reviewer)
- * - Shared knowledge pool via merge policies
- * - Budget-aware concurrency limits
- * - Lifecycle state machine for team coordination
- *
- * Architecture:
- *   Gateway ─── Hub ─── orchestration (this module, pure strategy)
- *                │
- *   ┌───────────┼───────────┐
- *   │   TeamCoordinator     │  ← Hub runtime (multi-sidechain-coordinator.ts)
- *   │   │                   │
- *   │   ├── Agent #1 (planner)
- *   │   ├── Agent #2 (executor)
- *   │   └── Agent #3 (reviewer)
- *   └───────────────────────┘
- *
- * This module provides:
- * 1. Type definitions (TeamPlan, AgentRole, TeamLifecycle)
- * 2. Pure strategy functions (plan resolution, role assignment, budget allocation)
- * 3. Merge/aggregation policies (how agent results combine)
- *
- * Hub consumes these types and strategy functions in its coordinator runtime.
- * Gateway consumes TeamPlan to spawn/manage multiple sidechain executions.
- */
-// ---------------------------------------------------------------------------
-// Strategy Functions — Pure, no I/O
-// ---------------------------------------------------------------------------
-/** Budget allocation weights per role (relative). */
-const ROLE_BUDGET_WEIGHTS = {
-    planner: 3,
-    executor: 4,
-    reviewer: 2,
-    researcher: 3,
-    custom: 2,
-};
-/** Default concurrency limits by execution mode. */
-const MODE_CONCURRENCY_DEFAULTS = {
-    parallel: 4,
-    sequential: 1,
-    pipeline: 1,
-    adaptive: 3,
-};
-/** Maximum agents allowed in a team (safety bound). */
-export const TEAM_MAX_AGENTS = 8;
-/** Maximum recursion depth (teams spawning teams). */
-export const TEAM_MAX_DEPTH = 2;
-/**
- * Resolve a team plan from a high-level task decomposition.
- *
- * This is the main entry point: given a set of subtasks and constraints,
- * produce a concrete TeamPlan that the coordinator can execute.
- */
-export function resolveTeamPlan(params) {
-    const agents = params.subtasks.slice(0, TEAM_MAX_AGENTS).map((sub) => {
-        const budgetTier = resolveAgentBudgetTier(sub.role);
-        return {
-            agentId: sub.id,
-            role: sub.role,
-            label: sub.label,
-            sidechainType: mapRoleToSidechainType(sub.role),
-            taskDescription: sub.task,
-            toolAccessMode: resolveAgentToolAccess(sub.role),
-            budgetTier,
-            dependsOn: sub.dependsOn ?? [],
-            maxTokenBudget: 0, // Will be allocated below
-            maxToolCalls: resolveMaxToolCalls(sub.role),
-            timeoutMs: 0,
-        };
-    });
-    const mode = params.mode ?? inferExecutionMode(agents);
-    const totalBudget = params.totalTokenBudget ?? 100_000;
-    const allocatedAgents = allocateTokenBudgets(agents, totalBudget);
-    return {
-        teamId: params.teamId,
-        mode,
-        aggregationPolicy: params.aggregationPolicy ?? inferAggregationPolicy(mode, agents),
-        agents: allocatedAgents,
-        maxConcurrency: MODE_CONCURRENCY_DEFAULTS[mode],
-        timeoutMs: params.timeoutMs ?? 300_000, // 5 min default
-        totalTokenBudget: totalBudget,
-        failFast: params.failFast ?? (mode === "pipeline"),
-        sharedContext: params.sharedContext ?? "",
-        mergePolicy: params.mergePolicy ?? "summary-only",
-    };
-}
-/**
- * Map agent role to sidechain type for existing Hub plumbing compatibility.
- */
-export function mapRoleToSidechainType(role) {
-    switch (role) {
-        case "planner": return "planner";
-        case "executor": return "code-repair";
-        case "reviewer": return "research";
-        case "researcher": return "research";
-        case "custom": return "research";
-    }
-}
-/**
- * Resolve tool access mode for a given role.
- */
-export function resolveAgentToolAccess(role) {
-    switch (role) {
-        case "planner": return "none"; // Planner thinks, doesn't act
-        case "executor": return "full"; // Executor needs full tool access
-        case "reviewer": return "read-only"; // Reviewer inspects, doesn't modify
-        case "researcher": return "read-only";
-        case "custom": return "read-only";
-    }
-}
-/**
- * Resolve maximum tool calls for a given role.
- */
-function resolveMaxToolCalls(role) {
-    switch (role) {
-        case "planner": return 0;
-        case "executor": return 30;
-        case "reviewer": return 10;
-        case "researcher": return 15;
-        case "custom": return 10;
-    }
-}
-/**
- * Resolve budget tier for a given role.
- */
-function resolveAgentBudgetTier(role) {
-    switch (role) {
-        case "planner": return "high";
-        case "executor": return "high";
-        case "reviewer": return "medium";
-        case "researcher": return "medium";
-        case "custom": return "low";
-    }
-}
-/**
- * Allocate token budgets proportionally by role weight.
- */
-export function allocateTokenBudgets(agents, totalBudget) {
-    const totalWeight = agents.reduce((sum, a) => sum + ROLE_BUDGET_WEIGHTS[a.role], 0);
-    if (totalWeight === 0)
-        return agents;
-    return agents.map((agent) => ({
-        ...agent,
-        maxTokenBudget: Math.floor((ROLE_BUDGET_WEIGHTS[agent.role] / totalWeight) * totalBudget),
-    }));
-}
-/**
- * Infer execution mode from agent dependency graph.
- */
-export function inferExecutionMode(agents) {
-    const hasDeps = agents.some((a) => a.dependsOn.length > 0);
-    if (!hasDeps)
-        return "parallel";
-    // If every agent depends on the previous → pipeline
-    const isLinearChain = agents.every((a, i) => i === 0 ? a.dependsOn.length === 0 : a.dependsOn.includes(agents[i - 1].agentId));
-    if (isLinearChain)
-        return "pipeline";
-    return "sequential";
-}
-/**
- * Infer aggregation policy from mode and agent composition.
- */
-export function inferAggregationPolicy(mode, agents) {
-    const hasReviewer = agents.some((a) => a.role === "reviewer");
-    const hasPlanner = agents.some((a) => a.role === "planner");
-    if (hasReviewer)
-        return "reviewer-gate";
-    if (hasPlanner && mode === "adaptive")
-        return "planner-sync";
-    if (mode === "parallel" && agents.length >= 3)
-        return "majority-vote";
-    return "merge-all";
-}
-/**
- * Determine the execution order for agents given their dependency graph.
- * Returns groups of agent IDs that can execute concurrently.
- *
- * Example: [[planner], [executor-a, executor-b], [reviewer]]
- */
-export function resolveExecutionOrder(agents) {
-    const idSet = new Set(agents.map((a) => a.agentId));
-    const depMap = new Map(agents.map((a) => [a.agentId, a.dependsOn.filter((d) => idSet.has(d))]));
-    const completed = new Set();
-    const groups = [];
-    let remaining = new Set(idSet);
-    let iterations = 0;
-    const maxIterations = agents.length + 1;
-    while (remaining.size > 0 && iterations < maxIterations) {
-        const ready = [];
-        for (const id of remaining) {
-            const deps = depMap.get(id) ?? [];
-            if (deps.every((d) => completed.has(d))) {
-                ready.push(id);
-            }
-        }
-        if (ready.length === 0) {
-            // Circular dependency — break by picking first remaining
-            const first = remaining.values().next().value;
-            if (first)
-                ready.push(first);
-        }
-        for (const id of ready) {
-            remaining.delete(id);
-            completed.add(id);
-        }
-        groups.push(ready);
-        iterations++;
-    }
-    return groups;
-}
-/**
- * Aggregate team results into a single output string.
- */
-export function aggregateTeamResults(results, policy) {
-    const completed = results.filter((r) => r.status === "completed");
-    switch (policy) {
-        case "first-success":
-            return completed[0]?.output ?? "[No successful agent output]";
-        case "majority-vote":
-            // Simple: return the most common non-empty output
-            if (completed.length === 0)
-                return "[No successful agent output]";
-            const counts = new Map();
-            for (const r of completed) {
-                const key = r.output.trim();
-                counts.set(key, (counts.get(key) ?? 0) + 1);
-            }
-            let best = "";
-            let bestCount = 0;
-            for (const [output, count] of counts) {
-                if (count > bestCount) {
-                    best = output;
-                    bestCount = count;
-                }
-            }
-            return best || completed[0].output;
-        case "merge-all":
-            return completed
-                .map((r) => `[${r.role}:${r.agentId}]\n${r.output}`)
-                .join("\n\n---\n\n");
-        case "reviewer-gate": {
-            const reviewer = completed.find((r) => r.role === "reviewer");
-            const executors = completed.filter((r) => r.role !== "reviewer");
-            if (reviewer) {
-                return `[Review]\n${reviewer.output}\n\n[Execution]\n${executors.map((e) => e.output).join("\n")}`;
-            }
-            return executors.map((e) => e.output).join("\n\n");
-        }
-        case "planner-sync": {
-            const planner = completed.find((r) => r.role === "planner");
-            const others = completed.filter((r) => r.role !== "planner");
-            if (planner) {
-                return `[Plan]\n${planner.output}\n\n[Results]\n${others.map((o) => `- ${o.agentId}: ${o.output.slice(0, 500)}`).join("\n")}`;
-            }
-            return others.map((o) => o.output).join("\n\n");
-        }
-    }
-}
-/**
- * Validate a team plan before execution.
- * Returns a list of issues (empty = valid).
- */
-export function validateTeamPlan(plan) {
-    const issues = [];
-    if (plan.agents.length === 0) {
-        issues.push("Team plan has no agents");
-    }
-    if (plan.agents.length > TEAM_MAX_AGENTS) {
-        issues.push(`Too many agents: ${plan.agents.length} > ${TEAM_MAX_AGENTS}`);
-    }
-    if (plan.totalTokenBudget <= 0) {
-        issues.push("Total token budget must be positive");
-    }
-    // Check for duplicate IDs
-    const ids = plan.agents.map((a) => a.agentId);
-    const uniqueIds = new Set(ids);
-    if (uniqueIds.size !== ids.length) {
-        issues.push("Duplicate agent IDs in team plan");
-    }
-    // Check dependency references
-    for (const agent of plan.agents) {
-        for (const dep of agent.dependsOn) {
-            if (!uniqueIds.has(dep)) {
-                issues.push(`Agent "${agent.agentId}" depends on non-existent agent "${dep}"`);
-            }
-            if (dep === agent.agentId) {
-                issues.push(`Agent "${agent.agentId}" depends on itself`);
-            }
-        }
-    }
-    // Pipeline mode must have linear dependencies
-    if (plan.mode === "pipeline") {
-        for (let i = 1; i < plan.agents.length; i++) {
-            if (!plan.agents[i].dependsOn.includes(plan.agents[i - 1].agentId)) {
-                issues.push(`Pipeline mode requires linear dependencies; agent "${plan.agents[i].agentId}" doesn't depend on previous`);
-            }
-        }
-    }
-    return issues;
-}
-/**
- * Determine if a team execution should be cancelled early based on current state.
- */
-export function shouldCancelTeam(params) {
-    const { plan, results, elapsedMs } = params;
-    // Timeout check
-    if (plan.timeoutMs > 0 && elapsedMs > plan.timeoutMs) {
-        return { cancel: true, reason: "team_timeout" };
-    }
-    // Fail-fast: any failure causes cancel
-    if (plan.failFast && results.some((r) => r.status === "failed")) {
-        return { cancel: true, reason: "fail_fast" };
-    }
-    // All agents completed or failed — no need to cancel, just aggregate
-    if (results.length >= plan.agents.length) {
-        return { cancel: false, reason: "" };
-    }
-    // Budget exhaustion
-    const usedTokens = results.reduce((sum, r) => sum + r.tokenUsage.prompt + r.tokenUsage.completion, 0);
-    if (usedTokens >= plan.totalTokenBudget * 0.95) {
-        return { cancel: true, reason: "budget_exhausted" };
-    }
-    return { cancel: false, reason: "" };
-}
-/**
- * Build the task prompt for a specific agent, incorporating shared context
- * and outputs from dependency agents.
- */
-export function buildAgentTaskPrompt(params) {
-    const { agent, plan, dependencyResults } = params;
-    const parts = [];
-    // Shared context
-    if (plan.sharedContext) {
-        parts.push(`[Shared Context]\n${plan.sharedContext}`);
-    }
-    // Dependency outputs
-    if (dependencyResults.length > 0) {
-        const depSection = dependencyResults
-            .filter((r) => r.status === "completed")
-            .map((r) => `[From ${r.agentId} (${r.role})]\n${r.output}`)
-            .join("\n\n");
-        if (depSection) {
-            parts.push(`[Prior Results]\n${depSection}`);
-        }
-    }
-    // Agent-specific task
-    parts.push(`[Your Task]\n${agent.taskDescription}`);
-    // Role-specific guidance
-    parts.push(`[Your Role: ${agent.role}]\n${getRoleGuidance(agent.role)}`);
-    return parts.join("\n\n---\n\n");
-}
-function getRoleGuidance(role) {
-    switch (role) {
-        case "planner":
-            return "You are the planner. Break down the task, identify dependencies, and create a clear execution plan. Do NOT execute actions yourself.";
-        case "executor":
-            return "You are the executor. Follow the plan and use tools to accomplish the task. Report what you did and any issues encountered.";
-        case "reviewer":
-            return "You are the reviewer. Examine the execution results for correctness, completeness, and quality. Point out any issues or improvements needed.";
-        case "researcher":
-            return "You are the researcher. Gather information, search for relevant context, and provide evidence-based findings. Do NOT modify any files.";
-        case "custom":
-            return "Complete the assigned task to the best of your ability.";
-    }
-}

package/dist/orchestration/team-tool-loop-wiring.d.ts

@@ -1,92 +0,0 @@
-/**
- * Team Tool Loop Wiring — Connects team orchestration to the tool loop.
- *
- * When the LLM invokes `team_create`, this module:
- * 1. Validates the team plan
- * 2. Maps team agents to fork contexts
- * 3. Coordinates execution according to the team execution mode
- * 4. Aggregates results according to the aggregation policy
- * 5. Returns the aggregated result as a tool_result
- *
- * This bridges the gap between the pure strategy layer (team-orchestration.ts)
- * and the Hub's tool loop.
- */
-import type { AgentRole, TeamExecutionMode, TeamAggregationPolicy, TeamLifecycleState } from "./team-orchestration.js";
-import type { AgentDefinition } from "./agent-registry.js";
-import type { ForkResult } from "./fork-subagent.js";
-export interface TeamToolRequest {
-    /** Team name for identification. */
-    name: string;
-    /** Agent specs for the team. */
-    agents: TeamAgentRequest[];
-    /** Execution mode. */
-    mode: TeamExecutionMode;
-    /** How to aggregate results. */
-    aggregation: TeamAggregationPolicy;
-}
-export interface TeamAgentRequest {
-    /** Role within the team. */
-    role: AgentRole;
-    /** Agent type from built-in registry. */
-    agentType: string;
-    /** Task prompt for this agent. */
-    prompt: string;
-    /** Max turns override. */
-    maxTurns?: number;
-    /** Dependencies (agent IDs that must complete before this one). */
-    dependsOn?: string[];
-}
-export interface TeamExecutionPlan {
-    /** Ordered batches for execution. */
-    batches: TeamExecutionBatch[];
-    /** Total estimated token budget. */
-    totalBudget: number;
-    /** Lifecycle state. */
-    state: TeamLifecycleState;
-}
-export interface TeamExecutionBatch {
-    /** Agents in this batch (run in parallel within a batch). */
-    agents: TeamAgentRequest[];
-    /** Batch mode (parallel or sequential within the batch). */
-    mode: "parallel" | "serial";
-}
-/**
- * Resolve the execution plan for a team request.
- * Validates the request, resolves dependencies into ordered batches,
- * and determines the execution topology.
- */
-export declare function resolveTeamExecutionPlan(request: TeamToolRequest): TeamExecutionPlan;
-export interface TeamAggregatedResult {
-    /** Whether the team execution succeeded overall. */
-    ok: boolean;
-    /** Aggregated output text. */
-    output: string;
-    /** Individual agent results. */
-    agentResults: Array<{
-        agentId: string;
-        role: AgentRole;
-        result: ForkResult;
-    }>;
-    /** Total tokens consumed by all agents. */
-    totalTokensUsed: number;
-    /** Lifecycle state after aggregation. */
-    finalState: TeamLifecycleState;
-}
-/**
- * Aggregate results from team agents according to the aggregation policy.
- */
-export declare function aggregateTeamToolResults(results: Array<{
-    agentId: string;
-    role: AgentRole;
-    result: ForkResult;
-}>, policy: TeamAggregationPolicy): TeamAggregatedResult;
-/**
- * Map a team tool_call into the format needed for the tool loop to dispatch.
- * Returns the list of fork configs the tool loop should execute.
- */
-export declare function mapTeamRequestToForkConfigs(request: TeamToolRequest, agentRegistry: (name: string) => AgentDefinition | undefined): Array<{
-    agentDef: AgentDefinition;
-    prompt: string;
-    maxTurns?: number;
-    role: AgentRole;
-}>;