qlogicagent 0.2.1 → 0.4.0

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.d.ts

@@ -1,54 +0,0 @@
-import type { RuntimeToolEligibilityContract } from "qlogicagent-runtime-contracts";
-export type ToolChoiceLike = "auto" | "none" | "required" | {
-    type: "function";
-    function?: {
-        name?: string;
-    };
-} | Record<string, unknown> | undefined;
-export interface ToolChoiceToolLike {
-    type?: string;
-    function?: {
-        name?: string;
-        description?: string;
-        parameters?: Record<string, unknown>;
-    };
-    name?: string;
-    description?: string;
-    requiresApproval?: boolean;
-}
-export type ToolEligibilityLike = RuntimeToolEligibilityContract;
-export interface ToolChoiceCompatibilityPolicy {
-    allowNamedToolChoice?: boolean;
-    allowRequiredToolChoice?: boolean;
-    requiredFallback?: "required" | "auto" | "none";
-    namedFallback?: "required" | "auto" | "none";
-    requireAutoWhenThinking?: boolean;
-}
-export interface ApplyToolChoicePolicyInput<TTool extends ToolChoiceToolLike> {
-    tools: readonly TTool[];
-    toolChoice: ToolChoiceLike;
-    eligibility?: readonly ToolEligibilityLike[];
-    thinkingEnabled?: boolean;
-    compatibility?: ToolChoiceCompatibilityPolicy;
-}
-export interface ApplyToolChoicePolicyResult<TTool extends ToolChoiceToolLike> {
-    tools: TTool[];
-    normalizedToolChoice?: ToolChoiceLike;
-    extraSystemPrompt?: string;
-    warnings: string[];
-}
-export declare function filterEligibleTools<TTool extends ToolChoiceToolLike>(params: {
-    tools: readonly TTool[];
-    eligibility?: readonly ToolEligibilityLike[];
-}): TTool[];
-export declare function normalizeAnthropicFunctionToolDefinition(tool: unknown): Record<string, unknown> | undefined;
-export declare function normalizeAnthropicToolChoice(toolChoice: unknown): unknown;
-export declare function applyToolChoiceCompatibility(params: {
-    toolChoice: ToolChoiceLike;
-    thinkingEnabled?: boolean;
-    compatibility?: ToolChoiceCompatibilityPolicy;
-}): {
-    normalizedToolChoice?: ToolChoiceLike;
-    warnings: string[];
-};
-export declare function applyToolChoicePolicy<TTool extends ToolChoiceToolLike>(params: ApplyToolChoicePolicyInput<TTool>): ApplyToolChoicePolicyResult<TTool>;

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 };
-}

package/dist/orchestration/tool-loop-state.d.ts

@@ -1,50 +0,0 @@
-import { type ConversationRepairOptions, type OpenAiChatMessageLike, type OpenAiResponsesItemLike } from "./conversation-repair.js";
-export interface ToolLoopState<TMessage = unknown> {
-    round: number;
-    maxRounds: number;
-    pendingToolCallIds: string[];
-    completedToolCallIds: string[];
-    lastStopReason?: string;
-    replayMessages: TMessage[];
-}
-export interface ToolLoopRepairAction {
-    kind: "strip-forced-stop-tool-metadata" | "inject-placeholder-tool-result" | "drop-orphan-tool-result" | "rewrite-openai-function-call-pair" | "drop-trailing-reasoning";
-    detail?: string;
-}
-export interface RepairToolLoopStateResult<TMessage> {
-    state: ToolLoopState<TMessage>;
-    recoveryActions: ToolLoopRepairAction[];
-}
-export declare function createToolLoopState<TMessage>(params: {
-    maxRounds: number;
-    replayMessages?: readonly TMessage[];
-    round?: number;
-    pendingToolCallIds?: readonly string[];
-    completedToolCallIds?: readonly string[];
-    lastStopReason?: string;
-}): ToolLoopState<TMessage>;
-export declare function advanceToolLoopState<TMessage>(state: ToolLoopState<TMessage>, params: {
-    replayMessages?: readonly TMessage[];
-    pendingToolCallIds?: readonly string[];
-    completedToolCallIds?: readonly string[];
-    lastStopReason?: string;
-}): ToolLoopState<TMessage>;
-export declare function settleToolLoopState<TMessage>(state: ToolLoopState<TMessage>, params: {
-    replayMessages?: readonly TMessage[];
-    completedToolCallIds?: readonly string[];
-    lastStopReason?: string;
-}): ToolLoopState<TMessage>;
-export declare function recoverToolLoopStateFromChatConversation<TMessage extends OpenAiChatMessageLike>(params: {
-    maxRounds: number;
-    replayMessages: readonly TMessage[];
-    round?: number;
-    lastStopReason?: string;
-    options?: ConversationRepairOptions;
-}): RepairToolLoopStateResult<TMessage>;
-export declare function recoverToolLoopStateFromResponsesItems<TItem extends OpenAiResponsesItemLike>(params: {
-    maxRounds: number;
-    replayItems: readonly TItem[];
-    round?: number;
-    lastStopReason?: string;
-    options?: ConversationRepairOptions;
-}): RepairToolLoopStateResult<TItem>;

package/dist/orchestration/tool-loop-state.js

@@ -1,133 +0,0 @@
-import { injectDanglingToolCallPlaceholders, repairOpenAiResponsesItems, stripForcedStopAssistantToolMetadata, sanitizeOpenAiChatMessages, } from "./conversation-repair.js";
-function collectChatPendingToolCallIds(messages) {
-    const called = new Set();
-    const completed = new Set();
-    for (const message of messages) {
-        if (message.role === "assistant" && Array.isArray(message.tool_calls)) {
-            for (const toolCall of message.tool_calls) {
-                if (typeof toolCall.id === "string" && toolCall.id) {
-                    called.add(toolCall.id);
-                }
-            }
-        }
-        if (message.role === "tool" && typeof message.tool_call_id === "string" && message.tool_call_id) {
-            completed.add(message.tool_call_id);
-        }
-    }
-    return [...called].filter((callId) => !completed.has(callId));
-}
-function collectChatCompletedToolCallIds(messages) {
-    const completed = new Set();
-    for (const message of messages) {
-        if (message.role === "tool" && typeof message.tool_call_id === "string" && message.tool_call_id) {
-            completed.add(message.tool_call_id);
-        }
-    }
-    return [...completed];
-}
-function collectResponsesPendingToolCallIds(items) {
-    const called = new Set();
-    const completed = new Set();
-    for (const item of items) {
-        if (item.type === "function_call") {
-            const callId = typeof item.call_id === "string" && item.call_id
-                ? item.call_id
-                : typeof item.id === "string"
-                    ? item.id
-                    : "";
-            if (callId) {
-                called.add(callId);
-            }
-        }
-        if (item.type === "function_call_output" && typeof item.call_id === "string" && item.call_id) {
-            completed.add(item.call_id);
-        }
-    }
-    return [...called].filter((callId) => !completed.has(callId));
-}
-function collectResponsesCompletedToolCallIds(items) {
-    const completed = new Set();
-    for (const item of items) {
-        if (item.type === "function_call_output" && typeof item.call_id === "string" && item.call_id) {
-            completed.add(item.call_id);
-        }
-    }
-    return [...completed];
-}
-export function createToolLoopState(params) {
-    return {
-        round: params.round ?? 0,
-        maxRounds: params.maxRounds,
-        pendingToolCallIds: [...(params.pendingToolCallIds ?? [])],
-        completedToolCallIds: [...(params.completedToolCallIds ?? [])],
-        lastStopReason: params.lastStopReason,
-        replayMessages: [...(params.replayMessages ?? [])],
-    };
-}
-export function advanceToolLoopState(state, params) {
-    return {
-        round: state.round + 1,
-        maxRounds: state.maxRounds,
-        pendingToolCallIds: [...(params.pendingToolCallIds ?? state.pendingToolCallIds)],
-        completedToolCallIds: [...(params.completedToolCallIds ?? state.completedToolCallIds)],
-        lastStopReason: params.lastStopReason ?? state.lastStopReason,
-        replayMessages: [...(params.replayMessages ?? state.replayMessages)],
-    };
-}
-export function settleToolLoopState(state, params) {
-    return {
-        round: state.round,
-        maxRounds: state.maxRounds,
-        pendingToolCallIds: [],
-        completedToolCallIds: [...(params.completedToolCallIds ?? state.completedToolCallIds)],
-        lastStopReason: params.lastStopReason ?? state.lastStopReason,
-        replayMessages: [...(params.replayMessages ?? state.replayMessages)],
-    };
-}
-export function recoverToolLoopStateFromChatConversation(params) {
-    const recoveryActions = [];
-    const sanitizedMessages = sanitizeOpenAiChatMessages(params.replayMessages);
-    if (sanitizedMessages.length !== params.replayMessages.length) {
-        recoveryActions.push({ kind: "drop-orphan-tool-result", detail: "Removed orphan tool results or invalid assistant tool calls." });
-    }
-    const strippedMessages = stripForcedStopAssistantToolMetadata(sanitizedMessages, params.options);
-    if (strippedMessages.some((message, index) => message !== sanitizedMessages[index])) {
-        recoveryActions.push({ kind: "strip-forced-stop-tool-metadata", detail: "Removed assistant tool-call metadata after forced stop." });
-    }
-    const repairedMessages = injectDanglingToolCallPlaceholders(strippedMessages, params.options);
-    if (repairedMessages.length > strippedMessages.length) {
-        recoveryActions.push({ kind: "inject-placeholder-tool-result", detail: "Injected placeholder tool result for pending tool calls." });
-    }
-    return {
-        state: createToolLoopState({
-            maxRounds: params.maxRounds,
-            round: params.round,
-            lastStopReason: params.lastStopReason,
-            replayMessages: repairedMessages,
-            pendingToolCallIds: collectChatPendingToolCallIds(repairedMessages),
-            completedToolCallIds: collectChatCompletedToolCallIds(repairedMessages),
-        }),
-        recoveryActions,
-    };
-}
-export function recoverToolLoopStateFromResponsesItems(params) {
-    const repairedItems = repairOpenAiResponsesItems(params.replayItems, params.options);
-    const recoveryActions = [];
-    if (repairedItems.length !== params.replayItems.length) {
-        recoveryActions.push({ kind: "drop-trailing-reasoning", detail: "Dropped dangling reasoning blocks or injected missing function_call_output items." });
-    }
-    if (repairedItems.some((item, index) => item !== params.replayItems[index] && item.type === "function_call")) {
-        recoveryActions.push({ kind: "rewrite-openai-function-call-pair", detail: "Rewrote OpenAI function_call pairing ids for replay compatibility." });
-    }
-    return {
-        state: createToolLoopState({
-            maxRounds: params.maxRounds,
-            round: params.round,
-            lastStopReason: params.lastStopReason,
-            replayMessages: repairedItems,
-            pendingToolCallIds: collectResponsesPendingToolCallIds(repairedItems),
-            completedToolCallIds: collectResponsesCompletedToolCallIds(repairedItems),
-        }),
-        recoveryActions,
-    };
-}

package/dist/orchestration/tool-schema.d.ts

@@ -1,39 +0,0 @@
-import type { OpenAiToolCall } from "./conversation-repair.js";
-export type ToolSchemaProvider = {
-    modelProvider?: string;
-    modelId?: string;
-};
-export interface FunctionToolSource {
-    name: string;
-    description?: string;
-    parameters?: Record<string, unknown>;
-}
-export interface FunctionToolDefinition {
-    type: "function";
-    function: {
-        name: string;
-        description?: string;
-        parameters: Record<string, unknown>;
-    };
-}
-export interface CapabilityToolManifestLike {
-    name: string;
-    description?: string;
-    requiredParameters?: string[];
-}
-export declare function isXaiProvider(modelProvider?: string, modelId?: string): boolean;
-export declare function normalizeFunctionToolParameters(parameters: Record<string, unknown> | undefined, options?: ToolSchemaProvider): Record<string, unknown>;
-export declare function convertFunctionTools(tools: readonly FunctionToolSource[], options?: ToolSchemaProvider): FunctionToolDefinition[];
-export declare function convertCapabilityToolManifestsToFunctionTools(tools: readonly CapabilityToolManifestLike[]): FunctionToolDefinition[];
-export declare function normalizeMessageTextContent(content: unknown): string;
-export declare function parseOpenAiToolCallsFromChatResponse(responseBody: string): {
-    toolCalls: OpenAiToolCall[];
-    responseText: string;
-};
-export declare function buildAssistantToolCallMessage(toolCalls: OpenAiToolCall[]): Record<string, unknown>;
-export declare function buildToolResultMessage(callId: string, result: {
-    ok: boolean;
-    payload?: unknown;
-    error?: string;
-}): Record<string, unknown>;
-export declare function cleanToolSchemaForGemini(schema: Record<string, unknown>): unknown;