qlogicagent 0.2.1 → 0.4.0

package/dist/orchestration/approval-aware-tool-plan.js

@@ -1,87 +0,0 @@
-function formatToolList(toolNames) {
-    if (toolNames.length === 0) {
-        return "no tools";
-    }
-    if (toolNames.length === 1) {
-        return toolNames[0];
-    }
-    if (toolNames.length === 2) {
-        return `${toolNames[0]} and ${toolNames[1]}`;
-    }
-    return `${toolNames.slice(0, -1).join(", ")}, and ${toolNames.at(-1)}`;
-}
-function requiresInteractiveApproval(capability) {
-    if (!capability) {
-        return false;
-    }
-    return capability.requiresApproval === true || capability.approvalMode === "user-confirm";
-}
-function buildEligibilityMap(eligibility) {
-    return new Map((eligibility ?? []).map((entry) => [entry.toolName, entry]));
-}
-function requiresApprovalForTool(params) {
-    const eligibility = params.eligibilityMap.get(params.toolName);
-    if (eligibility?.approvalRequired !== undefined) {
-        return eligibility.approvalRequired;
-    }
-    return requiresInteractiveApproval(params.capabilityMap.get(params.toolName));
-}
-export function summarizeApprovalAwareToolPlan(params) {
-    const capabilityMap = new Map(params.toolCapabilities.map((capability) => [capability.name, capability]));
-    const eligibilityMap = buildEligibilityMap(params.eligibility);
-    const stepCount = params.batches.length;
-    return params.batches.map((batch, index) => {
-        const toolNames = batch.calls.map((call) => call.function.name);
-        const approvalToolNames = batch.calls
-            .map((call) => requiresApprovalForTool({
-            toolName: call.function.name,
-            capabilityMap,
-            eligibilityMap,
-        }) ? call.function.name : null)
-            .filter((toolName) => Boolean(toolName));
-        const approvalRequired = approvalToolNames.length > 0;
-        const headline = batch.mode === "parallel"
-            ? `Step ${index + 1}/${stepCount}: run ${toolNames.length} tools in parallel: ${formatToolList(toolNames)}.`
-            : approvalRequired
-                ? `Step ${index + 1}/${stepCount}: approval-gated execution for ${formatToolList(approvalToolNames)}.`
-                : `Step ${index + 1}/${stepCount}: run ${formatToolList(toolNames)} serially.`;
-        const detail = approvalRequired
-            ? stepCount > index + 1
-                ? "This step must be approved before later steps continue."
-                : "This is the final planned step and requires approval before execution."
-            : batch.mode === "parallel"
-                ? "Parallel-safe tools are grouped to avoid unnecessary waiting."
-                : "This step stays serial because the tool is not parallel-safe.";
-        return {
-            stepIndex: index + 1,
-            stepCount,
-            mode: batch.mode,
-            callIds: batch.calls.map((call) => call.id),
-            toolNames,
-            approvalRequired,
-            approvalToolNames,
-            summary: `${headline} ${detail}`,
-        };
-    });
-}
-export function buildApprovalAwareReason(params) {
-    if (!params.step) {
-        return `semantic turn requested local tool: ${params.toolName}`;
-    }
-    const suffix = params.step.approvalRequired
-        ? params.step.approvalToolNames.length > 1
-            ? ` Approval is currently blocking ${formatToolList(params.step.approvalToolNames)}.`
-            : " Approval is required before this step can continue."
-        : "";
-    return `${params.step.summary}${suffix}`;
-}
-export function buildApprovalStepContext(step) {
-    if (!step) {
-        return {};
-    }
-    return {
-        stepIndex: step.stepIndex,
-        stepTotal: step.stepCount,
-        stepSummary: step.summary,
-    };
-}

package/dist/orchestration/context-compression.d.ts

@@ -1,220 +0,0 @@
-export interface CompressibleMessage {
-    role: string;
-    content?: string | unknown;
-    tool_call_id?: string;
-    tool_calls?: unknown;
-    name?: string;
-}
-export interface CompressionResult {
-    messages: CompressibleMessage[];
-    droppedCount: number;
-    strategy: string;
-    /** Phase 4: optional metrics from the compression pass */
-    metrics?: CompressionMetrics;
-}
-export interface CompressionMetrics {
-    tokensBefore: number;
-    tokensAfter: number;
-    compressionRatio: number;
-    /** ms elapsed for this strategy pass */
-    latencyMs: number;
-    /** Whether an LLM call was made during this pass */
-    usedLlm: boolean;
-    /** Whether prompt cache was invalidated by compression */
-    cacheInvalidated?: boolean;
-}
-export interface CompressionStrategy {
-    compress(messages: CompressibleMessage[], budget: number): CompressionResult;
-}
-/**
- * Async compression strategy — required for LLM-based summarization.
- * Falls back to sync `compress` when the caller doesn't support async.
- */
-export interface AsyncCompressionStrategy extends CompressionStrategy {
-    compressAsync(messages: CompressibleMessage[], budget: number): Promise<CompressionResult>;
-}
-export declare function isAsyncCompressionStrategy(s: CompressionStrategy): s is AsyncCompressionStrategy;
-/** Caller-provided LLM summarization function (wired by Hub). */
-export type SummarizeFn = (messages: CompressibleMessage[], instruction: string) => Promise<string>;
-export declare class SlidingWindowStrategy implements CompressionStrategy {
-    private estimateTokens;
-    constructor(estimateTokens: (msg: CompressibleMessage) => number);
-    compress(messages: CompressibleMessage[], budget: number): CompressionResult;
-}
-export declare class SummarizeOldStrategy implements CompressionStrategy {
-    private recentCount;
-    private summarize;
-    constructor(recentCount: number, summarize: (messages: CompressibleMessage[]) => string);
-    compress(messages: CompressibleMessage[], _budget: number): CompressionResult;
-}
-export declare class ToolResultTrimStrategy implements CompressionStrategy {
-    private maxToolResultChars;
-    constructor(maxToolResultChars?: number);
-    compress(messages: CompressibleMessage[], _budget: number): CompressionResult;
-}
-export declare function composeStrategies(...strategies: CompressionStrategy[]): CompressionStrategy;
-/**
- * Compose strategies with async support — if any strategy is async,
- * the pipeline becomes async.
- */
-export declare function composeAsyncStrategies(...strategies: CompressionStrategy[]): AsyncCompressionStrategy;
-/**
- * Build the structured 9-section summary instruction for the LLM.
- * Based on Claude Code's Full Compact mode, adapted for Hub.
- */
-export declare function buildStructuredSummaryPrompt(messagesToSummarize: CompressibleMessage[], opts?: {
-    taskContext?: string;
-}): string;
-export interface HeadTailProtectionConfig {
-    /** Number of initial user-assistant exchanges to protect (default: 1) */
-    protectedHeadExchanges: number;
-    /** Number of recent messages to always keep (default: 8 = ~4 exchanges) */
-    protectedTailMessages: number;
-    /** The summarization callback */
-    summarize: SummarizeFn;
-    /** Optional token estimator */
-    estimateTokens?: (msg: CompressibleMessage) => number;
-    /** Optional extra context for the summary prompt */
-    taskContext?: string;
-}
-/**
- * Phase 2.2: Head/Tail protected summarization.
- *
- * Protects: system messages + first exchange + last N messages.
- * Compresses: middle section via LLM summarization.
- */
-export declare class HeadTailProtectedStrategy implements AsyncCompressionStrategy {
-    private config;
-    constructor(config: HeadTailProtectionConfig);
-    compress(messages: CompressibleMessage[], _budget: number): CompressionResult;
-    compressAsync(messages: CompressibleMessage[], budget: number): Promise<CompressionResult>;
-}
-export interface IncrementalCompactConfig {
-    /** Messages newer than this count are never summarized (default: 12) */
-    preserveRecentCount: number;
-    /** Summarization callback */
-    summarize: SummarizeFn;
-    /** Token estimator */
-    estimateTokens?: (msg: CompressibleMessage) => number;
-}
-/**
- * Phase 2.3: Incremental (partial) compaction.
- *
- * Only summarizes the oldest messages beyond the preserve window.
- * Avoids repeatedly re-summarizing already-compressed content.
- * If a previous summary marker exists, only new old messages are compressed.
- */
-export declare class IncrementalCompactStrategy implements AsyncCompressionStrategy {
-    private config;
-    constructor(config: IncrementalCompactConfig);
-    compress(messages: CompressibleMessage[], _budget: number): CompressionResult;
-    compressAsync(messages: CompressibleMessage[], budget: number): Promise<CompressionResult>;
-}
-export interface CacheAwareCompressionConfig {
-    /** The inner strategy to delegate to */
-    inner: CompressionStrategy;
-    /** Token estimator */
-    estimateTokens?: (msg: CompressibleMessage) => number;
-    /**
-     * Callback: notify when prompt cache was invalidated by compression.
-     * Hub uses this to set pendingPostCompaction and track cache miss rate.
-     */
-    onCacheInvalidated?: (info: {
-        droppedCount: number;
-        strategy: string;
-    }) => void;
-}
-/**
- * Phase 3: Cache-aware wrapper.
- *
- * Wraps any strategy and tracks whether compression invalidated the
- * provider prompt cache. System prompt prefix stability is preserved
- * by never modifying system[0] (the original system prompt).
- */
-export declare class CacheAwareCompressionStrategy implements AsyncCompressionStrategy {
-    private config;
-    constructor(config: CacheAwareCompressionConfig);
-    compress(messages: CompressibleMessage[], budget: number): CompressionResult;
-    compressAsync(messages: CompressibleMessage[], budget: number): Promise<CompressionResult>;
-}
-export interface AdaptiveBudgetConfig {
-    /** Model context window size in tokens */
-    modelContextWindow: number;
-    /** Target usage ratio (0.0–1.0, default 0.75) — trigger compaction at this fraction */
-    targetUsageRatio: number;
-    /** Minimum guaranteed budget in tokens */
-    minBudget: number;
-    /** Maximum budget (usually = modelContextWindow) */
-    maxBudget: number;
-}
-export declare const DEFAULT_ADAPTIVE_BUDGET_CONFIG: AdaptiveBudgetConfig;
-/**
- * Compute the adaptive token budget for a given model + message history.
- *
- * Adjusts based on model context window, and uses the target ratio
- * so compression triggers before hitting the hard limit.
- */
-export declare function computeAdaptiveBudget(config?: Partial<AdaptiveBudgetConfig>): number;
-/**
- * Decide which compression tier to use based on current token count vs budget.
- */
-export type CompressionTier = "none" | "trim-only" | "sliding-window" | "llm-summarize";
-export declare function selectCompressionTier(currentTokens: number, budget: number): CompressionTier;
-export interface CompressionEvent {
-    timestamp: number;
-    strategy: string;
-    tokensBefore: number;
-    tokensAfter: number;
-    droppedCount: number;
-    latencyMs: number;
-    usedLlm: boolean;
-    cacheInvalidated: boolean;
-    tier: CompressionTier;
-}
-export interface CompressionMetricsSnapshot {
-    totalCompressions: number;
-    totalLlmCalls: number;
-    totalCacheInvalidations: number;
-    averageCompressionRatio: number;
-    averageLatencyMs: number;
-    totalTokensSaved: number;
-    recentEvents: CompressionEvent[];
-}
-export declare class CompressionMetricsCollector {
-    private events;
-    private maxEvents;
-    constructor(maxEvents?: number);
-    record(event: CompressionEvent): void;
-    snapshot(): CompressionMetricsSnapshot;
-    reset(): void;
-}
-/**
- * A pluggable context engine. Only one can be active at a time.
- * The default engine uses the 4-layer compression funnel.
- */
-export interface ContextEngine {
-    /** Unique engine identifier */
-    readonly id: string;
-    /** Human-readable label */
-    readonly label: string;
-    /** Compress messages for a turn */
-    compressAsync(messages: CompressibleMessage[], budget: number, context?: {
-        model?: string;
-        sessionId?: string;
-    }): Promise<CompressionResult>;
-}
-/**
- * Registry for context engines. Enforces single-active constraint.
- */
-export declare class ContextEngineRegistry {
-    private engines;
-    private activeId;
-    register(engine: ContextEngine): void;
-    activate(id: string): boolean;
-    getActive(): ContextEngine | undefined;
-    listEngines(): Array<{
-        id: string;
-        label: string;
-        active: boolean;
-    }>;
-}