qlogicagent 0.2.1 → 0.3.0

package/dist/orchestration/failover-error.js

@@ -1,198 +0,0 @@
-import { classifyFailoverReason, classifyFailoverReasonFromHttpStatus, isTimeoutErrorMessage, } from "./failover-classification.js";
-const ABORT_TIMEOUT_RE = /request was aborted|request aborted/i;
-function readErrorName(err) {
-    if (!err || typeof err !== "object") {
-        return undefined;
-    }
-    const candidate = err.name;
-    return typeof candidate === "string" && candidate.trim() ? candidate.trim() : undefined;
-}
-function getStatusCode(err) {
-    if (!err || typeof err !== "object") {
-        return undefined;
-    }
-    const candidate = err.status ??
-        err.statusCode;
-    if (typeof candidate === "number") {
-        return candidate;
-    }
-    if (typeof candidate === "string" && /^\d+$/.test(candidate)) {
-        return Number(candidate);
-    }
-    return undefined;
-}
-function getErrorCode(err) {
-    if (!err || typeof err !== "object") {
-        return undefined;
-    }
-    const candidate = err.code;
-    if (typeof candidate !== "string") {
-        return undefined;
-    }
-    const trimmed = candidate.trim();
-    return trimmed ? trimmed : undefined;
-}
-function getErrorMessage(err) {
-    if (err instanceof Error) {
-        return err.message;
-    }
-    if (typeof err === "string") {
-        return err;
-    }
-    if (typeof err === "number" || typeof err === "boolean" || typeof err === "bigint") {
-        return String(err);
-    }
-    if (typeof err === "symbol") {
-        return err.description ?? "";
-    }
-    if (err && typeof err === "object") {
-        const message = err.message;
-        if (typeof message === "string") {
-            return message;
-        }
-    }
-    return "";
-}
-function hasTimeoutHint(err) {
-    if (!err) {
-        return false;
-    }
-    if (readErrorName(err) === "TimeoutError") {
-        return true;
-    }
-    const message = getErrorMessage(err);
-    return Boolean(message && isTimeoutErrorMessage(message));
-}
-export class FailoverError extends Error {
-    reason;
-    provider;
-    model;
-    profileId;
-    status;
-    code;
-    constructor(message, params) {
-        super(message, { cause: params.cause });
-        this.name = "FailoverError";
-        this.reason = params.reason;
-        this.provider = params.provider;
-        this.model = params.model;
-        this.profileId = params.profileId;
-        this.status = params.status;
-        this.code = params.code;
-    }
-}
-export function isFailoverError(err) {
-    return err instanceof FailoverError;
-}
-export function resolveFailoverStatus(reason) {
-    switch (reason) {
-        case "billing":
-            return 402;
-        case "rate_limit":
-            return 429;
-        case "overloaded":
-            return 503;
-        case "auth":
-            return 401;
-        case "auth_permanent":
-            return 403;
-        case "timeout":
-            return 408;
-        case "format":
-            return 400;
-        case "model_not_found":
-            return 404;
-        case "session_expired":
-            return 410;
-        default:
-            return undefined;
-    }
-}
-export function isTimeoutError(err) {
-    if (hasTimeoutHint(err)) {
-        return true;
-    }
-    if (!err || typeof err !== "object") {
-        return false;
-    }
-    if (readErrorName(err) !== "AbortError") {
-        return false;
-    }
-    const message = getErrorMessage(err);
-    if (message && ABORT_TIMEOUT_RE.test(message)) {
-        return true;
-    }
-    const cause = "cause" in err ? err.cause : undefined;
-    const reason = "reason" in err ? err.reason : undefined;
-    return hasTimeoutHint(cause) || hasTimeoutHint(reason);
-}
-export function resolveFailoverReasonFromError(err) {
-    if (isFailoverError(err)) {
-        return err.reason;
-    }
-    const status = getStatusCode(err);
-    const message = getErrorMessage(err);
-    const statusReason = classifyFailoverReasonFromHttpStatus(status, message);
-    if (statusReason) {
-        return statusReason;
-    }
-    const code = (getErrorCode(err) ?? "").toUpperCase();
-    if ([
-        "ETIMEDOUT",
-        "ESOCKETTIMEDOUT",
-        "ECONNRESET",
-        "ECONNABORTED",
-        "ECONNREFUSED",
-        "ENETUNREACH",
-        "EHOSTUNREACH",
-        "ENETRESET",
-        "EAI_AGAIN",
-    ].includes(code)) {
-        return "timeout";
-    }
-    if (isTimeoutError(err)) {
-        return "timeout";
-    }
-    if (!message) {
-        return null;
-    }
-    return classifyFailoverReason(message);
-}
-export function describeFailoverError(err) {
-    if (isFailoverError(err)) {
-        return {
-            message: err.message,
-            reason: err.reason,
-            status: err.status,
-            code: err.code,
-        };
-    }
-    const message = getErrorMessage(err) || String(err);
-    return {
-        message,
-        reason: resolveFailoverReasonFromError(err) ?? undefined,
-        status: getStatusCode(err),
-        code: getErrorCode(err),
-    };
-}
-export function coerceToFailoverError(err, context) {
-    if (isFailoverError(err)) {
-        return err;
-    }
-    const reason = resolveFailoverReasonFromError(err);
-    if (!reason) {
-        return null;
-    }
-    const message = getErrorMessage(err) || String(err);
-    const status = getStatusCode(err) ?? resolveFailoverStatus(reason);
-    const code = getErrorCode(err);
-    return new FailoverError(message, {
-        reason,
-        provider: context?.provider,
-        model: context?.model,
-        profileId: context?.profileId,
-        status,
-        code,
-        cause: err instanceof Error ? err : undefined,
-    });
-}

package/dist/orchestration/fork-subagent.js

@@ -1,98 +0,0 @@
-/**
- * Fork Sub-Agent — CC-aligned fork mechanism for spawning child agents.
- *
- * Core design principles (aligned with Claude Code):
- * 1. Child agent shares parent's message prefix (prompt cache hit)
- * 2. Fork uses placeholder results to ensure byte-identical prefix across children
- * 3. Child has independent tool context (doesn't pollute parent state)
- * 4. Results flow back via AsyncGenerator (streaming backflow)
- * 5. Depth control via in-memory counter (not DB-based)
- */
-/** Sentinel tag injected into fork children to prevent recursive forking. */
-export const FORK_SENTINEL_TAG = "<fork-child-context>";
-/** Placeholder text used for all tool_results in shared prefix (ensures byte-identical prefix). */
-export const FORK_PLACEHOLDER_RESULT = "Fork started \u2014 processing in background";
-/** Maximum fork depth for in-memory agents (more permissive than DB sidechain). */
-export const MAX_FORK_DEPTH = 4;
-/** Maximum fork depth for DB-backed sidechains (more conservative). */
-export const MAX_SIDECHAIN_DB_DEPTH = 2;
-/**
- * Check if current context is inside a fork child (prevents recursive forking).
- */
-export function isInForkChild(messages) {
-    return JSON.stringify(messages).includes(FORK_SENTINEL_TAG);
-}
-/**
- * Check if fork depth allows spawning another child.
- */
-export function canForkAtDepth(currentDepth, mode = "in-memory") {
-    const maxDepth = mode === "in-memory" ? MAX_FORK_DEPTH : MAX_SIDECHAIN_DB_DEPTH;
-    return currentDepth < maxDepth;
-}
-/**
- * Build forked messages that ensure byte-identical prefix across all fork children.
- *
- * Strategy (aligned with CC's buildForkedMessages):
- * 1. Keep full parent message history (all tool_use blocks, thinking, text)
- * 2. Replace all pending tool_results with FORK_PLACEHOLDER_RESULT
- * 3. Append a single user message with the child-specific directive
- * → All children share the same prefix up to the directive → maximum cache hits.
- */
-export function buildForkedMessages(context, childConfig) {
-    const messages = [...context.parentMessages];
-    // Inject fork sentinel + child task as the unique tail
-    const childDirective = {
-        role: "user",
-        content: [
-            { type: "text", text: `${FORK_SENTINEL_TAG}\n\nYou are the "${childConfig.agent.name}" agent.\n\n${childConfig.taskPrompt}` },
-        ],
-    };
-    messages.push(childDirective);
-    return messages;
-}
-/**
- * Build placeholder tool results for the shared prefix.
- * When parent has pending tool_calls, replace them all with identical placeholder text
- * so all fork children produce byte-identical API request prefix.
- */
-export function buildForkPlaceholderResults(pendingToolCallIds) {
-    return pendingToolCallIds.map((id) => ({
-        role: "tool",
-        tool_call_id: id,
-        content: FORK_PLACEHOLDER_RESULT,
-    }));
-}
-/**
- * Resolve the effective tool set for a fork child.
- * CC pattern: useExactTools=true → child gets parent's full tool pool,
- * then filtered by agent definition.
- */
-export function resolveForkChildTools(parentTools, agent) {
-    if (agent.allowedTools && agent.allowedTools.length > 0) {
-        const allowed = new Set(agent.allowedTools);
-        return parentTools.filter((t) => allowed.has(t));
-    }
-    if (agent.toolAccessMode === "none")
-        return [];
-    if (agent.toolAccessMode === "read-only") {
-        const writeTools = new Set([
-            "file_edit", "create_file", "write_file", "replace_string_in_file",
-            "multi_replace_string_in_file", "create_directory", "delete_file",
-            "rename_file", "move_file", "exec", "run_in_terminal", "run_command",
-            "git_commit", "git_push", "patch",
-        ]);
-        return parentTools.filter((t) => !writeTools.has(t));
-    }
-    // full access — remove agent_tool if canFork=false
-    if (!agent.canFork) {
-        return parentTools.filter((t) => t !== "agent_tool");
-    }
-    return [...parentTools];
-}
-/**
- * Generate a unique agent ID for a fork child.
- */
-export function generateForkChildAgentId(parentAgentId, agentName, depth) {
-    const ts = Date.now().toString(36);
-    return `${parentAgentId}:fork:${agentName}:d${depth}:${ts}`;
-}

package/dist/orchestration/index.js

@@ -1,267 +0,0 @@
-export { buildAssistantToolCallMessage, buildToolResultMessage, cleanToolSchemaForGemini, convertCapabilityToolManifestsToFunctionTools, convertFunctionTools, isXaiProvider, normalizeMessageTextContent, normalizeFunctionToolParameters, parseOpenAiToolCallsFromChatResponse, } from "./tool-schema.js";
-export { classifyError, classifyErrorFromReason, getRetryStrategy, } from "./error-classification.js";
-export { composeStrategies, composeAsyncStrategies, SlidingWindowStrategy, SummarizeOldStrategy, ToolResultTrimStrategy, HeadTailProtectedStrategy, IncrementalCompactStrategy, CacheAwareCompressionStrategy, CompressionMetricsCollector, ContextEngineRegistry, buildStructuredSummaryPrompt, computeAdaptiveBudget, isAsyncCompressionStrategy, selectCompressionTier, DEFAULT_ADAPTIVE_BUDGET_CONFIG, } from "./context-compression.js";
-export { buildSkillInstruction, shouldCreateSkill, shouldImproveSkill, } from "./skill-improvement.js";
-export { buildSkillCandidateEffectivenessSummary, buildSkillCandidateEvidencePayload, buildSkillCandidateImprovementEvidenceBundle, buildSkillCandidateLatestReview, createDefaultSkillImprovementPolicy, normalizeSkillImprovementPolicy, } from "./skill-candidate.js";
-export const SIDECHAIN_TYPE_VALUES = ["research", "planner", "plan-repair", "code-repair", "media-prep"];
-const SIDECHAIN_TYPE_POLICY_MAP = {
-    research: {
-        type: "research",
-        label: "Research",
-        description: "Independent retrieval or evidence gathering branches.",
-        mergePolicy: "summary-only",
-        budgetTier: "medium",
-        budgetWeight: 2,
-        preferFullContext: false,
-        preserveConversationHistory: true,
-        toolAccessMode: "read-only",
-    },
-    planner: {
-        type: "planner",
-        label: "Planner",
-        description: "Planning and tool orchestration branches that may return structured context.",
-        mergePolicy: "append-messages",
-        budgetTier: "high",
-        budgetWeight: 3,
-        preferFullContext: true,
-        preserveConversationHistory: true,
-        toolAccessMode: "none",
-    },
-    "plan-repair": {
-        type: "plan-repair",
-        label: "Plan Repair",
-        description: "Failure repair or fallback branches that re-plan tool choice, ordering, or approval strategy.",
-        mergePolicy: "replace-context",
-        budgetTier: "medium",
-        budgetWeight: 2,
-        preferFullContext: true,
-        preserveConversationHistory: false,
-        toolAccessMode: "none",
-    },
-    "code-repair": {
-        type: "code-repair",
-        label: "Code Repair",
-        description: "Recovery branches focused on file edits, patch validation, or workspace mutation repair.",
-        mergePolicy: "replace-context",
-        budgetTier: "high",
-        budgetWeight: 3,
-        preferFullContext: true,
-        preserveConversationHistory: false,
-        toolAccessMode: "full",
-    },
-    "media-prep": {
-        type: "media-prep",
-        label: "Media Prep",
-        description: "Preparation branches for media generation, normalization, or staging.",
-        mergePolicy: "summary-only",
-        budgetTier: "low",
-        budgetWeight: 1,
-        preferFullContext: false,
-        preserveConversationHistory: false,
-        toolAccessMode: "read-only",
-    },
-};
-export const SIDECHAIN_TOOL_DENY_ALWAYS = [
-    "gateway",
-    "agents_list",
-    "whatsapp_login",
-    "session_status",
-    "cron",
-    "memory_query",
-    "sessions_send",
-];
-export const SIDECHAIN_TOOL_DENY_LEAF = [
-    "sessions_list",
-    "sessions_history",
-    "sessions_spawn",
-];
-/** Tools that perform write/mutation operations — denied in read-only sidechain types. */
-export const SIDECHAIN_TOOL_DENY_WRITE = [
-    "file_edit",
-    "create_file",
-    "replace_string_in_file",
-    "multi_replace_string_in_file",
-    "create_directory",
-    "run_in_terminal",
-    "run_command",
-    "delete_file",
-    "rename_file",
-    "move_file",
-    "git_commit",
-    "git_push",
-    "manage_todo_list",
-];
-export function resolveSidechainToolAccessPolicy(params = {}) {
-    const maxDepth = Math.max(1, Math.floor(params.maxDepth ?? 2));
-    const depth = typeof params.depth === "number" && Number.isFinite(params.depth)
-        ? Math.max(0, Math.floor(params.depth))
-        : maxDepth;
-    const isLeaf = params.role ? params.role === "leaf" : depth >= maxDepth;
-    const deniedTools = isLeaf
-        ? [...SIDECHAIN_TOOL_DENY_ALWAYS, ...SIDECHAIN_TOOL_DENY_LEAF]
-        : [...SIDECHAIN_TOOL_DENY_ALWAYS];
-    const deniedSet = new Set(deniedTools);
-    const toolNames = Array.isArray(params.toolNames)
-        ? params.toolNames
-        : params.toolNames
-            ? Array.from(params.toolNames)
-            : [];
-    const tools = Array.from(new Set(toolNames.map((toolName) => toolName.trim()).filter(Boolean))).map((toolName) => {
-        const denied = deniedSet.has(toolName);
-        return {
-            toolName,
-            decision: denied ? "denied" : "allowed",
-            inheritance: denied ? "shrink" : "inherit",
-            reason: denied
-                ? SIDECHAIN_TOOL_DENY_ALWAYS.includes(toolName)
-                    ? "always-deny"
-                    : "leaf-deny"
-                : "default-allow",
-        };
-    });
-    return {
-        deniedTools,
-        canSpawnChildren: !isLeaf,
-        defaultDecision: "allowed",
-        defaultInheritance: "inherit",
-        tools,
-    };
-}
-/**
- * Resolve tool access policy for a specific sidechain type.
- * Combines depth-based deny lists with type-specific access mode:
- * - "full": only depth-based denials apply
- * - "read-only": depth-based + all write/mutation tools denied
- * - "none": all tools denied
- */
-export function resolveSidechainToolAccessByType(params) {
-    const policy = resolveSidechainTypePolicy(params.type);
-    const basePolicy = resolveSidechainToolAccessPolicy({
-        depth: params.depth,
-        maxDepth: params.maxDepth,
-        role: params.role,
-        toolNames: params.toolNames,
-    });
-    if (policy.toolAccessMode === "full") {
-        return basePolicy;
-    }
-    if (policy.toolAccessMode === "none") {
-        const allToolNames = Array.isArray(params.toolNames)
-            ? params.toolNames
-            : params.toolNames ? Array.from(params.toolNames) : [];
-        const uniqueNames = [...new Set(allToolNames.map((n) => n.trim()).filter(Boolean))];
-        return {
-            deniedTools: uniqueNames,
-            canSpawnChildren: false,
-            defaultDecision: "allowed",
-            defaultInheritance: "inherit",
-            tools: uniqueNames.map((toolName) => ({
-                toolName,
-                decision: "denied",
-                inheritance: "shrink",
-                reason: "always-deny",
-            })),
-        };
-    }
-    // "read-only": add write tools to deny list
-    const writeSet = new Set(SIDECHAIN_TOOL_DENY_WRITE);
-    const combinedDenied = [...new Set([...basePolicy.deniedTools, ...SIDECHAIN_TOOL_DENY_WRITE])];
-    return {
-        ...basePolicy,
-        deniedTools: combinedDenied,
-        tools: basePolicy.tools.map((rule) => {
-            if (rule.decision === "denied")
-                return rule;
-            if (writeSet.has(rule.toolName)) {
-                return { ...rule, decision: "denied", inheritance: "shrink", reason: "always-deny" };
-            }
-            return rule;
-        }),
-    };
-}
-/**
- * Filter tool_calls against a resolved access policy.
- * Returns allowed calls and denied calls with reasons.
- * T must have at least { id: string; function: { name: string } }.
- */
-export function filterToolCallsByAccessPolicy(toolCalls, policy) {
-    const deniedSet = new Set(policy.deniedTools);
-    const ruleMap = new Map(policy.tools.map((r) => [r.toolName, r]));
-    const allowed = [];
-    const denied = [];
-    for (const tc of toolCalls) {
-        const name = tc.function.name;
-        const rule = ruleMap.get(name);
-        if (rule?.decision === "denied") {
-            denied.push({ toolCall: tc, reason: `tool "${name}" denied by sidechain policy: ${rule.reason}` });
-        }
-        else if (deniedSet.has(name)) {
-            denied.push({ toolCall: tc, reason: `tool "${name}" is in sidechain deny list` });
-        }
-        else {
-            allowed.push(tc);
-        }
-    }
-    return { allowed, denied };
-}
-export function listSidechainTypePolicies() {
-    return SIDECHAIN_TYPE_VALUES.map((type) => SIDECHAIN_TYPE_POLICY_MAP[type]);
-}
-export function resolveSidechainTypePolicy(type) {
-    return SIDECHAIN_TYPE_POLICY_MAP[type];
-}
-export function resolveRepairSidechainType(params = {}) {
-    if (params.preferCodeRepair) {
-        return "code-repair";
-    }
-    const trigger = typeof params.trigger === "string" ? params.trigger.trim().toLowerCase() : "";
-    if (trigger.includes("code") || trigger.includes("patch") || trigger.includes("workspace")) {
-        return "code-repair";
-    }
-    const toolNames = Array.from(params.toolNames ?? []).map((toolName) => toolName.trim().toLowerCase()).filter(Boolean);
-    const codeRepairHints = ["code", "edit", "patch", "diff", "file", "workspace", "git", "terminal"];
-    return toolNames.some((toolName) => codeRepairHints.some((hint) => toolName.includes(hint)))
-        ? "code-repair"
-        : "plan-repair";
-}
-export function resolveSidechainMergePolicyByType(type, overrides = {}) {
-    const policy = resolveSidechainTypePolicy(type);
-    return resolveSidechainMergePolicy({
-        forceManualReview: overrides.forceManualReview,
-        preferFullContext: overrides.preferFullContext ?? policy.preferFullContext,
-        preserveConversationHistory: overrides.preserveConversationHistory ?? policy.preserveConversationHistory,
-    });
-}
-export function resolveSidechainMergePolicy(params = {}) {
-    if (params.forceManualReview) {
-        return "manual";
-    }
-    if (params.preferFullContext) {
-        return params.preserveConversationHistory ? "append-messages" : "replace-context";
-    }
-    return "summary-only";
-}
-export { applyToolChoiceCompatibility, applyToolChoicePolicy, filterEligibleTools, normalizeAnthropicFunctionToolDefinition, normalizeAnthropicToolChoice, } from "./tool-choice-policy.js";
-export { downgradeOpenAiFunctionCallReasoningPairs, downgradeOpenAiReasoningBlocks, ensureAssistantReasoningContent, injectDanglingToolCallPlaceholders, repairOpenAiChatConversation, repairOpenAiResponsesItems, sanitizeOpenAiChatMessages, stripForcedStopAssistantToolMetadata, } from "./conversation-repair.js";
-export { classifyFailoverReason, classifyFailoverReasonFromHttpStatus, isCloudflareOrHtmlErrorPage, isFailoverErrorMessage, isModelNotFoundErrorMessage, isTimeoutErrorMessage, isTransientHttpError, } from "./failover-classification.js";
-export { FailoverError, coerceToFailoverError, describeFailoverError, isFailoverError, isTimeoutError, resolveFailoverReasonFromError, resolveFailoverStatus, } from "./failover-error.js";
-export { repairToolCallInputs, repairToolUseResultPairing, sanitizeToolCallInputs, sanitizeToolUseResultPairing, stripToolResultDetails, stripTransientErrorMessages, } from "./transcript-repair.js";
-export { normalizeParallelToolCallsPreference, resolveParallelToolCallScheduling, } from "./parallel-tool-calls.js";
-export { advanceToolLoopState, createToolLoopState, recoverToolLoopStateFromChatConversation, recoverToolLoopStateFromResponsesItems, settleToolLoopState, } from "./tool-loop-state.js";
-export { MEMORY_OBSERVATION_HOOK_VALUES, MEMORY_OBSERVATION_SOURCE_VALUES, MEMORY_WRITE_ACCESS_VALUES, } from "./memory-provider.js";
-export { hasAlreadyFlushedForCurrentCompaction, resolveMemoryFlushProjection, resolveMemoryFlushReadPlan, shouldRunMemoryFlush, } from "./memory-flush-policy.js";
-export { executeBoundedRetryLoop, resolveScaledRetryIterations, } from "./retry-loop.js";
-export { buildAssistantFailoverErrorDetails, pickFallbackThinkingLevel, resolveAssistantFailureActionDecision, resolveAuthProfileFailoverReason, resolveFallbackThinkingDecision, resolvePromptErrorPolicy, resolvePromptFailureActionDecision, resolveRetryableFailureReason, shouldAttemptAssistantFailureRotation, shouldAttemptPromptFailureRotation, } from "./embedded-failover-policy.js";
-export { buildApprovalAwareReason, buildApprovalStepContext, summarizeApprovalAwareToolPlan, } from "./approval-aware-tool-plan.js";
-export { resolveWebBrowserPolicy, } from "./web-browser-policy.js";
-export { applyCacheMarkers, computeCacheBreakpoints, createCacheBreakDetectionState, DEFAULT_PROMPT_CACHE_POLICY, detectCacheBreaks, estimateCacheSavingsRatio, quickHash, resolveForkCacheMarkerIndex, } from "./prompt-cache-strategy.js";
-export { computeLifecycleTransitions, DEFAULT_CURATOR_SCHEDULE_POLICY, INITIAL_CURATOR_STATE, selectReviewCandidates, shouldRunCurator, } from "./curator-scheduler.js";
-export { buildConsolidationPrompt, buildCuratorRunSummary, detectPrefixClusters, parseConsolidationOutput, reconcileConsolidationPlan, } from "./skill-consolidation.js";
-export { bigramSimilarity, computeSimilarity, decideSimilarityAction, DEFAULT_SKILL_SIMILARITY_POLICY, findSimilarSkills, stepCountProximity, toolSetJaccard, } from "./skill-similarity.js";
-export { aggregateTeamResults, allocateTokenBudgets, buildAgentTaskPrompt, inferAggregationPolicy, inferExecutionMode, mapRoleToSidechainType, resolveAgentToolAccess, resolveExecutionOrder, resolveTeamPlan, shouldCancelTeam, TEAM_MAX_AGENTS, TEAM_MAX_DEPTH, validateTeamPlan, } from "./team-orchestration.js";
-export { canDispatchDuringStreaming, createStreamingToolExecutor, } from "./streaming-tool-executor.js";
-export { canForkAtDepth, buildForkedMessages, buildForkPlaceholderResults, FORK_PLACEHOLDER_RESULT, FORK_SENTINEL_TAG, generateForkChildAgentId, isInForkChild, MAX_FORK_DEPTH, MAX_SIDECHAIN_DB_DEPTH, resolveForkChildTools, } from "./fork-subagent.js";
-export { getBuiltInAgent, getBuiltInAgents, isBuiltInAgent, resolveAgentToolSet, } from "./agent-registry.js";
-export { calculateTokenWarningState, createTurnLoopGuardState, resolveApiErrorRecovery, resolveOutputTokenEscalation, shouldAbortTurn, } from "./turn-loop-guard.js";
-export { buildPostCompactRestorationMessage, computeToolDelta, createReactiveCompactState, DEFAULT_REACTIVE_COMPACT_CONFIG, shouldAttemptReactiveCompact, } from "./reactive-compact.js";
-export { aggregateTeamToolResults, mapTeamRequestToForkConfigs, resolveTeamExecutionPlan, } from "./team-tool-loop-wiring.js";

package/dist/orchestration/memory-flush-policy.js

@@ -1,85 +0,0 @@
-export function hasAlreadyFlushedForCurrentCompaction(entry) {
-    const compactionCount = entry.compactionCount ?? 0;
-    const lastFlushAt = entry.memoryFlushCompactionCount;
-    return typeof lastFlushAt === "number" && lastFlushAt === compactionCount;
-}
-export function shouldRunMemoryFlush(params) {
-    if (!params.entry) {
-        return false;
-    }
-    const override = params.tokenCount;
-    const overrideTokens = typeof override === "number" && Number.isFinite(override) && override > 0
-        ? Math.floor(override)
-        : undefined;
-    const totalTokens = overrideTokens ?? params.resolveFreshSessionTotalTokens(params.entry);
-    if (!totalTokens || totalTokens <= 0) {
-        return false;
-    }
-    const contextWindow = Math.max(1, Math.floor(params.contextWindowTokens));
-    const reserveTokens = Math.max(0, Math.floor(params.reserveTokensFloor));
-    const softThreshold = Math.max(0, Math.floor(params.softThresholdTokens));
-    const threshold = Math.max(0, contextWindow - reserveTokens - softThreshold);
-    if (threshold <= 0 || totalTokens < threshold) {
-        return false;
-    }
-    if (hasAlreadyFlushedForCurrentCompaction(params.entry)) {
-        return false;
-    }
-    return true;
-}
-export function resolveMemoryFlushReadPlan(params) {
-    const canAttemptFlush = params.memoryFlushWritable && !params.isHeartbeat && !params.isCli;
-    const flushThreshold = params.contextWindowTokens - params.reserveTokensFloor - params.softThresholdTokens;
-    const shouldReadTranscriptForOutput = canAttemptFlush &&
-        params.hasSessionEntry &&
-        params.hasFreshPersistedPromptTokens &&
-        typeof params.promptTokenEstimate === "number" &&
-        Number.isFinite(params.promptTokenEstimate) &&
-        flushThreshold > 0 &&
-        (params.persistedPromptTokens ?? 0) + params.promptTokenEstimate >=
-            flushThreshold - params.transcriptOutputReadBufferTokens;
-    const shouldReadTranscript = Boolean(canAttemptFlush &&
-        params.hasSessionEntry &&
-        (!params.hasFreshPersistedPromptTokens || shouldReadTranscriptForOutput));
-    const shouldCheckTranscriptSizeForForcedFlush = Boolean(canAttemptFlush &&
-        params.hasSessionEntry &&
-        Number.isFinite(params.forceFlushTranscriptBytes) &&
-        params.forceFlushTranscriptBytes > 0);
-    return {
-        canAttemptFlush,
-        flushThreshold,
-        shouldReadTranscriptForOutput,
-        shouldReadTranscript,
-        shouldCheckTranscriptSizeForForcedFlush,
-        shouldReadSessionLog: shouldReadTranscript || shouldCheckTranscriptSizeForForcedFlush,
-    };
-}
-export function resolveMemoryFlushProjection(params) {
-    const shouldForceFlushByTranscriptSize = typeof params.transcriptByteSize === "number" &&
-        params.transcriptByteSize >= params.forceFlushTranscriptBytes;
-    const hasReliableTranscriptPromptTokens = typeof params.transcriptPromptTokens === "number" &&
-        Number.isFinite(params.transcriptPromptTokens) &&
-        params.transcriptPromptTokens > 0;
-    const shouldPersistTranscriptPromptTokens = hasReliableTranscriptPromptTokens &&
-        (!params.hasFreshPersistedPromptTokens ||
-            (params.transcriptPromptTokens ?? 0) > (params.persistedPromptTokens ?? 0));
-    const promptTokensSnapshot = Math.max(params.hasFreshPersistedPromptTokens ? (params.persistedPromptTokens ?? 0) : 0, hasReliableTranscriptPromptTokens ? (params.transcriptPromptTokens ?? 0) : 0);
-    const hasFreshPromptTokensSnapshot = promptTokensSnapshot > 0 &&
-        (params.hasFreshPersistedPromptTokens || hasReliableTranscriptPromptTokens);
-    const projectedTokenCount = hasFreshPromptTokensSnapshot
-        ? params.resolveEffectivePromptTokens(promptTokensSnapshot, params.transcriptOutputTokens, params.promptTokenEstimate)
-        : undefined;
-    const tokenCountForFlush = typeof projectedTokenCount === "number" &&
-        Number.isFinite(projectedTokenCount) &&
-        projectedTokenCount > 0
-        ? projectedTokenCount
-        : undefined;
-    return {
-        shouldForceFlushByTranscriptSize,
-        shouldPersistTranscriptPromptTokens,
-        promptTokensSnapshot,
-        hasFreshPromptTokensSnapshot,
-        projectedTokenCount,
-        tokenCountForFlush,
-    };
-}

package/dist/orchestration/memory-provider.js

@@ -1,2 +0,0 @@
-import { MEMORY_OBSERVATION_HOOK_VALUES, MEMORY_OBSERVATION_SOURCE_VALUES, MEMORY_WRITE_ACCESS_VALUES, } from "qlogicagent-runtime-contracts";
-export { MEMORY_OBSERVATION_HOOK_VALUES, MEMORY_OBSERVATION_SOURCE_VALUES, MEMORY_WRITE_ACCESS_VALUES, };