qlogicagent 0.2.1 → 0.3.0

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.js

@@ -1,147 +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.
- */
-/**
- * Resolve the execution plan for a team request.
- * Validates the request, resolves dependencies into ordered batches,
- * and determines the execution topology.
- */
-export function resolveTeamExecutionPlan(request) {
-    const agents = request.agents;
-    if (agents.length === 0) {
-        return { batches: [], totalBudget: 0, state: "planning" };
-    }
-    if (agents.length > 8) {
-        throw new Error(`Team cannot have more than 8 agents (got ${agents.length})`);
-    }
-    // For "parallel" mode — single batch with all agents
-    if (request.mode === "parallel") {
-        return {
-            batches: [{ agents, mode: "parallel" }],
-            totalBudget: agents.length * 50000,
-            state: "spawning",
-        };
-    }
-    // For "sequential" or "pipeline" — one agent per batch
-    if (request.mode === "sequential" || request.mode === "pipeline") {
-        return {
-            batches: agents.map((a) => ({ agents: [a], mode: "serial" })),
-            totalBudget: agents.length * 50000,
-            state: "spawning",
-        };
-    }
-    // "adaptive" — planner first, then remaining in parallel
-    const planners = agents.filter((a) => a.role === "planner");
-    const rest = agents.filter((a) => a.role !== "planner");
-    const batches = [];
-    if (planners.length > 0) {
-        batches.push({ agents: planners, mode: "serial" });
-    }
-    if (rest.length > 0) {
-        batches.push({ agents: rest, mode: "parallel" });
-    }
-    return {
-        batches,
-        totalBudget: agents.length * 50000,
-        state: "spawning",
-    };
-}
-/**
- * Aggregate results from team agents according to the aggregation policy.
- */
-export function aggregateTeamToolResults(results, policy) {
-    const totalTokens = results.reduce((sum, r) => sum + r.result.tokensUsed, 0);
-    const allOk = results.every((r) => r.result.ok);
-    const anyOk = results.some((r) => r.result.ok);
-    switch (policy) {
-        case "first-success": {
-            const first = results.find((r) => r.result.ok);
-            return {
-                ok: !!first,
-                output: first?.result.output || "(No agent succeeded)",
-                agentResults: results,
-                totalTokensUsed: totalTokens,
-                finalState: first ? "completed" : "failed",
-            };
-        }
-        case "merge-all": {
-            const outputs = results.map((r) => `### ${r.role} (${r.agentId})\n${r.result.output || "(no output)"}`);
-            return {
-                ok: anyOk,
-                output: outputs.join("\n\n---\n\n"),
-                agentResults: results,
-                totalTokensUsed: totalTokens,
-                finalState: anyOk ? "completed" : "failed",
-            };
-        }
-        case "reviewer-gate": {
-            const reviewer = results.find((r) => r.role === "reviewer");
-            const executors = results.filter((r) => r.role !== "reviewer");
-            const executorOutput = executors.map((r) => r.result.output).filter(Boolean).join("\n\n");
-            if (reviewer && reviewer.result.ok) {
-                return {
-                    ok: true,
-                    output: `## Reviewed Output\n${executorOutput}\n\n## Review\n${reviewer.result.output}`,
-                    agentResults: results,
-                    totalTokensUsed: totalTokens,
-                    finalState: "completed",
-                };
-            }
-            return {
-                ok: false,
-                output: `Review failed: ${reviewer?.result.output || "no reviewer result"}`,
-                agentResults: results,
-                totalTokensUsed: totalTokens,
-                finalState: "failed",
-            };
-        }
-        case "planner-sync": {
-            // Planner agent's output is the consolidated result
-            const planner = results.find((r) => r.role === "planner");
-            if (planner) {
-                return {
-                    ok: planner.result.ok,
-                    output: planner.result.output,
-                    agentResults: results,
-                    totalTokensUsed: totalTokens,
-                    finalState: planner.result.ok ? "completed" : "failed",
-                };
-            }
-            // Fallback to merge-all
-            return aggregateTeamToolResults(results, "merge-all");
-        }
-        case "majority-vote":
-        default: {
-            // Simple: all outputs merged
-            return aggregateTeamToolResults(results, "merge-all");
-        }
-    }
-}
-/**
- * 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 function mapTeamRequestToForkConfigs(request, agentRegistry) {
-    return request.agents.map((agent) => {
-        const def = agentRegistry(agent.agentType);
-        if (!def) {
-            throw new Error(`Unknown agent type "${agent.agentType}" in team request`);
-        }
-        return {
-            agentDef: def,
-            prompt: agent.prompt,
-            maxTurns: agent.maxTurns,
-            role: agent.role,
-        };
-    });
-}

package/dist/orchestration/tool-choice-policy.js

@@ -1,164 +0,0 @@
-function resolveToolName(tool) {
-    if (tool.function && typeof tool.function === "object" && typeof tool.function.name === "string") {
-        return tool.function.name.trim();
-    }
-    if (typeof tool.name === "string") {
-        return tool.name.trim();
-    }
-    return "";
-}
-function isEligibleStatus(status) {
-    return status === "enabled-eligible" || status === "installed-awaiting-approval";
-}
-function buildEligibilityMap(eligibility) {
-    return new Map((eligibility ?? []).map((entry) => [entry.toolName, entry]));
-}
-export function filterEligibleTools(params) {
-    if (!params.eligibility?.length) {
-        return [...params.tools];
-    }
-    const eligibilityMap = buildEligibilityMap(params.eligibility);
-    return params.tools.filter((tool) => {
-        const name = resolveToolName(tool);
-        if (!name) {
-            return false;
-        }
-        const eligibility = eligibilityMap.get(name);
-        return !eligibility || isEligibleStatus(eligibility.status);
-    });
-}
-export function normalizeAnthropicFunctionToolDefinition(tool) {
-    if (!tool || typeof tool !== "object" || Array.isArray(tool)) {
-        return undefined;
-    }
-    const toolRecord = tool;
-    if (toolRecord.function && typeof toolRecord.function === "object") {
-        return toolRecord;
-    }
-    const name = typeof toolRecord.name === "string" ? toolRecord.name.trim() : "";
-    if (!name) {
-        return toolRecord;
-    }
-    const functionSpec = {
-        name,
-        parameters: toolRecord.input_schema && typeof toolRecord.input_schema === "object"
-            ? toolRecord.input_schema
-            : toolRecord.parameters && typeof toolRecord.parameters === "object"
-                ? toolRecord.parameters
-                : { type: "object", properties: {} },
-    };
-    if (typeof toolRecord.description === "string" && toolRecord.description.trim()) {
-        functionSpec.description = toolRecord.description;
-    }
-    if (typeof toolRecord.strict === "boolean") {
-        functionSpec.strict = toolRecord.strict;
-    }
-    return {
-        type: "function",
-        function: functionSpec,
-    };
-}
-export function normalizeAnthropicToolChoice(toolChoice) {
-    if (!toolChoice || typeof toolChoice !== "object" || Array.isArray(toolChoice)) {
-        return toolChoice;
-    }
-    const choice = toolChoice;
-    if (choice.type === "auto") {
-        return "auto";
-    }
-    if (choice.type === "none") {
-        return "none";
-    }
-    if (choice.type === "required" || choice.type === "any") {
-        return "required";
-    }
-    if (choice.type === "tool" && typeof choice.name === "string" && choice.name.trim()) {
-        return {
-            type: "function",
-            function: { name: choice.name.trim() },
-        };
-    }
-    return toolChoice;
-}
-export function applyToolChoiceCompatibility(params) {
-    const warnings = [];
-    const compatibility = params.compatibility ?? {};
-    let normalizedToolChoice = params.toolChoice;
-    if (params.thinkingEnabled && compatibility.requireAutoWhenThinking) {
-        const type = typeof normalizedToolChoice === "object" && normalizedToolChoice && !Array.isArray(normalizedToolChoice)
-            ? String(normalizedToolChoice.type ?? "")
-            : normalizedToolChoice;
-        if (type && type !== "auto" && type !== "none") {
-            warnings.push("tool_choice downgraded to auto because thinking mode requires auto/none compatibility.");
-            normalizedToolChoice = "auto";
-        }
-    }
-    if (normalizedToolChoice === "required" && compatibility.allowRequiredToolChoice === false) {
-        const fallback = compatibility.requiredFallback ?? "auto";
-        warnings.push(`tool_choice=required is not supported by this provider; downgraded to ${fallback}.`);
-        normalizedToolChoice = fallback;
-    }
-    if (normalizedToolChoice
-        && typeof normalizedToolChoice === "object"
-        && !Array.isArray(normalizedToolChoice)
-        && normalizedToolChoice.type === "function"
-        && compatibility.allowNamedToolChoice === false) {
-        const fallback = compatibility.namedFallback ?? "required";
-        warnings.push(`named tool_choice is not supported by this provider; downgraded to ${fallback}.`);
-        normalizedToolChoice = fallback;
-    }
-    return { normalizedToolChoice, warnings };
-}
-export function applyToolChoicePolicy(params) {
-    const compatibilityResult = applyToolChoiceCompatibility({
-        toolChoice: params.toolChoice,
-        thinkingEnabled: params.thinkingEnabled,
-        compatibility: params.compatibility,
-    });
-    const toolChoice = compatibilityResult.normalizedToolChoice;
-    const warnings = [...compatibilityResult.warnings];
-    const tools = filterEligibleTools({
-        tools: params.tools,
-        eligibility: params.eligibility,
-    });
-    if (!toolChoice || toolChoice === "auto") {
-        return { tools, normalizedToolChoice: toolChoice, warnings };
-    }
-    if (toolChoice === "none") {
-        return { tools: [], normalizedToolChoice: "none", warnings };
-    }
-    if (toolChoice === "required") {
-        if (tools.length === 0) {
-            throw new Error("tool_choice=required but no tools were provided");
-        }
-        return {
-            tools,
-            normalizedToolChoice: "required",
-            extraSystemPrompt: "You must call one of the available tools before responding.",
-            warnings,
-        };
-    }
-    if (typeof toolChoice === "object" && !Array.isArray(toolChoice) && toolChoice.type === "function") {
-        const functionChoice = (toolChoice.function ?? undefined);
-        const targetName = typeof functionChoice?.name === "string"
-            ? functionChoice.name.trim()
-            : "";
-        if (!targetName) {
-            throw new Error("tool_choice.function.name is required");
-        }
-        const matchedTools = tools.filter((tool) => resolveToolName(tool) === targetName);
-        if (matchedTools.length === 0) {
-            throw new Error(`tool_choice requested unknown tool: ${targetName}`);
-        }
-        return {
-            tools: matchedTools,
-            normalizedToolChoice: {
-                type: "function",
-                function: { name: targetName },
-            },
-            extraSystemPrompt: `You must call the ${targetName} tool before responding.`,
-            warnings,
-        };
-    }
-    return { tools, normalizedToolChoice: toolChoice, warnings };
-}