@almadar/agent 1.6.4 → 2.0.1

package/dist/index-DZn69no8.d.ts

@@ -1,1014 +0,0 @@
-import { LLMProvider } from '@almadar/llm';
-import { S as SubagentEventCallback, O as OrbitalCompleteCallback, a as DomainOrbitalCompleteCallback } from './orbital-subagent-BdFuf77p.js';
-import { BaseCheckpointSaver } from '@langchain/langgraph-checkpoint';
-import { P as PersistenceMode, b as FirestoreDb$1, S as SessionMetadata, e as SessionRecord } from './firestore-checkpointer-CkNKXoun.js';
-import { OrbitalSchema } from '@almadar/core';
-import { BaseMessage } from '@langchain/core/messages';
-import '@langchain/langgraph';
-
-/**
- * Context Compaction for DeepAgent
- *
- * Provides middleware to manage context length in long-running agent sessions.
- * Uses @langchain/core's trimMessages to keep context within token limits.
- *
- * @packageDocumentation
- */
-
-/**
- * Configuration for context compaction.
- */
-interface ContextCompactionConfig {
-    /**
-     * Maximum number of tokens before triggering compaction.
-     * Default: 150000 (leaves headroom for Claude's 200K context)
-     */
-    maxTokens?: number;
-    /**
-     * Number of recent messages to always keep.
-     * Default: 10
-     */
-    keepRecentMessages?: number;
-    /**
-     * Whether to include the system message in trimming.
-     * Default: false (system message is always kept)
-     */
-    includeSystem?: boolean;
-    /**
-     * Strategy for trimming: 'first' keeps first messages, 'last' keeps last messages.
-     * Default: 'last'
-     */
-    strategy?: 'first' | 'last';
-}
-/**
- * Default configuration for context compaction.
- */
-declare const DEFAULT_COMPACTION_CONFIG: Required<ContextCompactionConfig>;
-/**
- * Check if messages need compaction based on estimated token count.
- */
-declare function needsCompaction(messages: BaseMessage[], threshold?: number): boolean;
-/**
- * Create a message summarizer prompt for compacting old context.
- */
-declare function createSummaryPrompt(messages: BaseMessage[]): string;
-/**
- * Estimate token count for messages using character-based heuristic.
- */
-declare function estimateTokens(messages: BaseMessage[]): number;
-
-/**
- * Memory System Types
- *
- * Additional types for the memory system beyond the core orbital types.
- */
-/**
- * User feedback on a generation session
- */
-interface UserFeedback {
-    /** Unique feedback ID */
-    feedbackId: string;
-    /** Session this feedback is for */
-    sessionId: string;
-    /** User who gave the feedback */
-    userId: string;
-    /** Type of feedback */
-    type: 'positive' | 'negative' | 'correction' | 'suggestion';
-    /** Optional comment */
-    comment?: string;
-    /** Suggested correction or improvement */
-    suggestion?: string;
-    /** Timestamp of feedback */
-    timestamp: Date;
-}
-/**
- * Pattern affinity - tracks how well patterns work for a user
- */
-interface PatternAffinity {
-    /** User ID */
-    userId: string;
-    /** Pattern ID */
-    patternId: string;
-    /** How many times used */
-    usageCount: number;
-    /** Successful uses */
-    successCount: number;
-    /** Failed uses */
-    failureCount: number;
-    /** Contexts where this pattern was used */
-    contexts?: {
-        entityType?: string;
-        useCase?: string;
-    }[];
-    /** Last time this pattern was used */
-    lastUsedAt: Date;
-    /** When tracking started */
-    createdAt: Date;
-}
-/**
- * Checkpoint record - tracks checkpoint history for learning
- */
-interface CheckpointRecord {
-    /** Unique checkpoint ID */
-    checkpointId: string;
-    /** Thread/session ID */
-    threadId: string;
-    /** User who owns this checkpoint */
-    userId: string;
-    /** Parent checkpoint ID (for rollback tracking) */
-    parentCheckpointId?: string;
-    /** Checkpoint metadata */
-    metadata: {
-        step?: number;
-        skill?: string;
-        status?: string;
-        [key: string]: unknown;
-    };
-    /** When checkpoint was created */
-    createdAt: Date;
-    /** Number of times rolled back to this checkpoint */
-    rollbackCount: number;
-    /** Whether this checkpoint was a successful outcome */
-    wasSuccessful: boolean;
-}
-/**
- * Interrupt record - tracks human-in-the-loop decisions
- */
-interface InterruptRecord {
-    /** Unique interrupt ID */
-    interruptId: string;
-    /** Session this interrupt occurred in */
-    sessionId: string;
-    /** User who made the decision */
-    userId: string;
-    /** Tool that was interrupted */
-    toolName: string;
-    /** Tool arguments that were being executed */
-    toolArgs: Record<string, unknown>;
-    /** User's decision: approved, rejected, or modified */
-    decision: 'approved' | 'rejected' | 'modified';
-    /** Modified arguments if decision was 'modified' */
-    modifiedArgs?: Record<string, unknown>;
-    /** Reason for the decision */
-    reason?: string;
-    /** Timestamp of the interrupt */
-    timestamp: Date;
-}
-/**
- * Tool approval preferences - learned from interrupt history
- */
-interface ToolApprovalPreference {
-    /** User ID */
-    userId: string;
-    /** Tool name */
-    toolName: string;
-    /** Auto-approve this tool in the future */
-    autoApprove: boolean;
-    /** Confidence in this preference (0-1) */
-    confidence: number;
-    /** Number of times this tool has been approved */
-    approvedCount: number;
-    /** Number of times this tool has been rejected */
-    rejectedCount: number;
-    /** Last decision timestamp */
-    lastDecisionAt: Date;
-}
-
-/**
- * Memory Orbital Schema
- *
- * Defines the structure for agent memory using Orbital types.
- * This is an OrbitalSchema that represents user memory, preferences,
- * and generation history.
- *
- * @packageDocumentation
- */
-
-/**
- * The complete Memory Orbital Schema
- * This defines the structure for storing agent memory
- */
-declare const MemoryOrbitalSchema: OrbitalSchema;
-type UserPreference = {
-    id: string;
-    userId: string;
-    namingConvention: 'PascalCase' | 'camelCase' | 'snake_case';
-    validationStyle: 'strict' | 'minimal' | 'none';
-    preferredPatterns: string[];
-    commonEntities: string[];
-    commonTraits: string[];
-    learnedAt: Date;
-    confidence: number;
-};
-type GenerationSession = {
-    id: string;
-    userId: string;
-    threadId: string;
-    prompt: string;
-    skill: string;
-    generatedSchema?: Record<string, unknown>;
-    entities: string[];
-    patterns: string[];
-    validationResult?: {
-        valid: boolean;
-        errors: unknown[];
-    };
-    createdAt: Date;
-    completedAt?: Date;
-    success: boolean;
-};
-type ProjectContext = {
-    id: string;
-    appId: string;
-    userId: string;
-    projectName?: string;
-    description?: string;
-    existingEntities: string[];
-    conventions: string[];
-    domain: 'business' | 'ecommerce' | 'cms' | 'dashboard' | 'workflow';
-    lastUpdatedAt: Date;
-};
-
-/**
- * Memory Manager - GAP-001: Orbital Memory System
- *
- * Manages user memory and preferences using Firestore persistence.
- * Provides the foundation for personalized AI assistance by learning
- * from user interactions and feedback.
- */
-
-/**
- * Minimal Firestore interface to avoid importing firebase-admin.
- * These match the interfaces defined in firestore-checkpointer.ts
- */
-interface FirestoreDb {
-    collection(path: string): FirestoreCollectionRef;
-    batch(): FirestoreBatch;
-}
-interface FirestoreCollectionRef {
-    doc(id: string): FirestoreDocRef;
-    where(field: string, op: string, value: unknown): FirestoreQuery;
-    orderBy(field: string, direction?: string): FirestoreQuery;
-    limit(n: number): FirestoreQuery;
-}
-interface FirestoreDocRef {
-    set(data: unknown): Promise<unknown>;
-    get(): Promise<FirestoreDocSnapshot>;
-    update(data: unknown): Promise<unknown>;
-    delete(): Promise<unknown>;
-}
-interface FirestoreDocSnapshot {
-    exists: boolean;
-    data(): Record<string, unknown> | undefined;
-}
-interface FirestoreQuery {
-    where(field: string, op: string, value: unknown): FirestoreQuery;
-    orderBy(field: string, direction?: string): FirestoreQuery;
-    limit(n: number): FirestoreQuery;
-    startAfter(doc: unknown): FirestoreQuery;
-    get(): Promise<FirestoreQuerySnapshot>;
-}
-interface FirestoreQuerySnapshot {
-    empty: boolean;
-    docs: FirestoreQueryDocSnapshot[];
-    size: number;
-}
-interface FirestoreQueryDocSnapshot {
-    data(): Record<string, unknown>;
-}
-interface FirestoreBatch {
-    set(ref: unknown, data: unknown): void;
-    delete(ref: unknown): void;
-    commit(): Promise<unknown>;
-}
-/**
- * Options for MemoryManager
- */
-interface MemoryManagerOptions {
-    /**
-     * Firestore database instance (injected)
-     */
-    db: FirestoreDb;
-    /**
-     * Collection name for user preferences
-     * @default 'agent_memory_users'
-     */
-    usersCollection?: string;
-    /**
-     * Collection name for generation sessions
-     * @default 'agent_memory_generations'
-     */
-    generationsCollection?: string;
-    /**
-     * Collection name for project context
-     * @default 'agent_memory_projects'
-     */
-    projectsCollection?: string;
-    /**
-     * Collection name for pattern affinity
-     * @default 'agent_memory_patterns'
-     */
-    patternsCollection?: string;
-    /**
-     * Collection name for user feedback
-     * @default 'agent_memory_feedback'
-     */
-    feedbackCollection?: string;
-    /**
-     * Collection name for interrupt records
-     * @default 'agent_memory_interrupts'
-     */
-    interruptsCollection?: string;
-    /**
-     * Collection name for tool approval preferences
-     * @default 'agent_memory_tool_preferences'
-     */
-    toolPreferencesCollection?: string;
-    /**
-     * Collection name for checkpoint records
-     * @default 'agent_memory_checkpoints'
-     */
-    checkpointsCollection?: string;
-}
-declare class MemoryManager {
-    private db;
-    private usersCollection;
-    private generationsCollection;
-    private projectsCollection;
-    private patternsCollection;
-    private feedbackCollection;
-    private interruptsCollection;
-    private toolPreferencesCollection;
-    private checkpointsCollection;
-    constructor(options: MemoryManagerOptions);
-    /**
-     * Get user preferences with defaults
-     */
-    getUserPreferences(userId: string): Promise<UserPreference | null>;
-    /**
-     * Update user preferences
-     */
-    updateUserPreferences(userId: string, preferences: Partial<Omit<UserPreference, 'id' | 'userId' | 'learnedAt'>>): Promise<void>;
-    /**
-     * Record a new generation session
-     */
-    recordGeneration(userId: string, session: Omit<GenerationSession, 'id' | 'userId' | 'createdAt'>): Promise<string>;
-    /**
-     * Get a specific generation session
-     */
-    getGenerationSession(sessionId: string): Promise<GenerationSession | null>;
-    /**
-     * Get generation history for a user
-     */
-    getUserGenerationHistory(userId: string, limit?: number): Promise<GenerationSession[]>;
-    /**
-     * Update generation session status
-     */
-    updateGenerationStatus(sessionId: string, status: GenerationSession['success'], validationResult?: GenerationSession['validationResult']): Promise<void>;
-    /**
-     * Get project context
-     */
-    getProjectContext(appId: string): Promise<ProjectContext | null>;
-    /**
-     * Update project context with new information
-     */
-    updateProjectContext(appId: string, update: Partial<Omit<ProjectContext, 'id' | 'appId'>>): Promise<void>;
-    /**
-     * Update pattern affinity based on usage
-     */
-    updatePatternAffinity(userId: string, patternId: string, outcome: 'success' | 'failure' | 'partial', context?: {
-        entityType?: string;
-        useCase?: string;
-    }): Promise<void>;
-    /**
-     * Get pattern affinity for a user
-     */
-    getPatternAffinity(userId: string, patternId: string): Promise<PatternAffinity | null>;
-    /**
-     * Get all patterns used by a user
-     */
-    getUserPatterns(userId: string): Promise<PatternAffinity[]>;
-    /**
-     * Record user feedback on a generation
-     */
-    recordFeedback(sessionId: string, feedback: Omit<UserFeedback, 'feedbackId' | 'sessionId' | 'timestamp'>): Promise<void>;
-    /**
-     * Get feedback for a session
-     */
-    getSessionFeedback(sessionId: string): Promise<UserFeedback[]>;
-    private parsePreference;
-    private serializePreference;
-    private parseSession;
-    private serializeSession;
-    private parseContext;
-    private serializeContext;
-    /**
-     * Record an interrupt decision for learning
-     */
-    recordInterruptDecision(sessionId: string, userId: string, interruptData: {
-        toolName: string;
-        toolArgs: Record<string, unknown>;
-        decision: 'approved' | 'rejected' | 'modified';
-        modifiedArgs?: Record<string, unknown>;
-        reason?: string;
-    }): Promise<void>;
-    /**
-     * Get interrupt history for a session
-     */
-    getSessionInterrupts(sessionId: string): Promise<InterruptRecord[]>;
-    /**
-     * Get interrupt history for a user
-     */
-    getUserInterrupts(userId: string, limit?: number): Promise<InterruptRecord[]>;
-    /**
-     * Get tool approval preference for a user
-     */
-    getToolApprovalPreference(userId: string, toolName: string): Promise<ToolApprovalPreference | null>;
-    /**
-     * Update tool approval preference based on interrupt decisions
-     */
-    private updateToolApprovalPreference;
-    /**
-     * Get all tool approval preferences for a user
-     */
-    getUserToolPreferences(userId: string): Promise<ToolApprovalPreference[]>;
-    /**
-     * Check if a tool should be auto-approved for a user
-     */
-    shouldAutoApproveTool(userId: string, toolName: string): Promise<boolean>;
-    /**
-     * Record a checkpoint for learning
-     */
-    recordCheckpoint(userId: string, checkpointData: {
-        checkpointId: string;
-        threadId: string;
-        parentCheckpointId?: string;
-        metadata?: Record<string, unknown>;
-    }): Promise<void>;
-    /**
-     * Record a rollback to a checkpoint
-     */
-    recordRollback(userId: string, checkpointId: string, reason?: string): Promise<void>;
-    /**
-     * Mark a checkpoint as successful (terminal state)
-     */
-    markCheckpointSuccessful(userId: string, checkpointId: string): Promise<void>;
-    /**
-     * Get checkpoint history for a user
-     */
-    getUserCheckpoints(userId: string, limit?: number): Promise<CheckpointRecord[]>;
-    /**
-     * Get checkpoints for a thread
-     */
-    getThreadCheckpoints(threadId: string): Promise<CheckpointRecord[]>;
-    /**
-     * Get frequently rolled-back checkpoints (problem areas)
-     */
-    getProblemCheckpoints(userId: string, minRollbackCount?: number): Promise<CheckpointRecord[]>;
-    /**
-     * Get successful checkpoint patterns for learning
-     */
-    getSuccessfulCheckpoints(userId: string, limit?: number): Promise<CheckpointRecord[]>;
-}
-
-interface SessionManagerOptions {
-    /**
-     * Persistence mode.
-     * @default 'memory'
-     */
-    mode?: PersistenceMode;
-    /**
-     * Firestore database instance. Required when mode is 'firestore'.
-     */
-    firestoreDb?: FirestoreDb$1;
-    /**
-     * Memory manager for session-to-memory sync (GAP-002D).
-     * When provided, completed sessions are recorded to orbital memory.
-     */
-    memoryManager?: MemoryManager;
-    /**
-     * Context compaction configuration (GAP-005).
-     * When provided, enables automatic context length management.
-     */
-    compactionConfig?: ContextCompactionConfig;
-}
-/**
- * Unified session management for agent sessions.
- *
- * Handles both session metadata and LangGraph checkpointers.
- */
-declare class SessionManager {
-    private mode;
-    private memoryBackend;
-    private memoryCheckpointers;
-    private firestoreCheckpointer;
-    private firestoreSessionStore;
-    private memoryManager;
-    private compactionConfig;
-    constructor(options?: SessionManagerOptions);
-    /**
-     * Get the persistence mode.
-     */
-    getMode(): PersistenceMode;
-    /**
-     * Get or create a checkpointer for a session.
-     */
-    getCheckpointer(threadId: string): BaseCheckpointSaver<any>;
-    /**
-     * Store session metadata.
-     */
-    store(threadId: string, metadata: SessionMetadata): void;
-    /**
-     * Get session metadata (sync, memory only).
-     */
-    get(threadId: string): SessionMetadata | undefined;
-    /**
-     * Get session metadata (async, supports Firestore).
-     */
-    getAsync(threadId: string): Promise<SessionMetadata | undefined>;
-    /**
-     * Clear a session's checkpointer and metadata.
-     */
-    clear(threadId: string): boolean;
-    /**
-     * List all sessions (sync, memory only).
-     */
-    list(): SessionRecord[];
-    /**
-     * List all sessions (async, supports Firestore).
-     */
-    listAsync(): Promise<SessionRecord[]>;
-    /**
-     * Sync a completed session to orbital memory.
-     * This enables the agent to learn from past sessions.
-     *
-     * @param threadId - The session thread ID
-     * @param userId - The user ID for memory association
-     * @param sessionData - Additional session data to record
-     * @returns Promise that resolves when sync is complete
-     */
-    syncSessionToMemory(threadId: string, userId: string, sessionData: {
-        appId: string;
-        inputDescription: string;
-        generatedOrbital?: string;
-        patternsUsed?: string[];
-        entities?: string[];
-        success: boolean;
-        errorMessage?: string;
-    }): Promise<void>;
-    /**
-     * Record an interrupt decision to memory.
-     * This enables learning from HITL (Human-in-the-Loop) decisions.
-     *
-     * @param sessionId - The session thread ID
-     * @param userId - The user who made the decision
-     * @param interruptData - The interrupt decision data
-     * @returns Promise that resolves when sync is complete
-     */
-    recordInterruptDecision(sessionId: string, userId: string, interruptData: {
-        toolName: string;
-        toolArgs: Record<string, unknown>;
-        decision: 'approved' | 'rejected' | 'modified';
-        modifiedArgs?: Record<string, unknown>;
-        reason?: string;
-    }): Promise<void>;
-    /**
-     * Get interrupt history for a session.
-     */
-    getSessionInterrupts(sessionId: string): Promise<InterruptRecord[]>;
-    /**
-     * Check if a tool should be auto-approved for a user.
-     */
-    shouldAutoApproveTool(userId: string, toolName: string): Promise<boolean>;
-    /**
-     * Record a checkpoint to memory for learning.
-     *
-     * @param userId - The user who owns this checkpoint
-     * @param checkpointData - Checkpoint information
-     * @returns Promise that resolves when checkpoint is recorded
-     */
-    recordCheckpoint(userId: string, checkpointData: {
-        checkpointId: string;
-        threadId: string;
-        parentCheckpointId?: string;
-        metadata?: Record<string, unknown>;
-    }): Promise<void>;
-    /**
-     * Record a rollback to a checkpoint.
-     *
-     * @param userId - The user who performed the rollback
-     * @param checkpointId - The checkpoint rolled back to
-     * @param reason - Optional reason for rollback
-     * @returns Promise that resolves when rollback is recorded
-     */
-    recordRollback(userId: string, checkpointId: string, reason?: string): Promise<void>;
-    /**
-     * Mark a checkpoint as successful (terminal state).
-     *
-     * @param userId - The user who owns this checkpoint
-     * @param checkpointId - The checkpoint that was successful
-     * @returns Promise that resolves when success is recorded
-     */
-    markCheckpointSuccessful(userId: string, checkpointId: string): Promise<void>;
-    /**
-     * Get checkpoint history for a thread.
-     *
-     * @param threadId - The thread to get checkpoints for
-     * @returns Array of checkpoint records
-     */
-    getThreadCheckpoints(threadId: string): Promise<CheckpointRecord[]>;
-    /**
-     * Get frequently rolled-back checkpoints (problem areas).
-     *
-     * @param userId - The user to get problem checkpoints for
-     * @param minRollbackCount - Minimum rollback count (default: 2)
-     * @returns Array of checkpoint records with rollback issues
-     */
-    getProblemCheckpoints(userId: string, minRollbackCount?: number): Promise<CheckpointRecord[]>;
-    /**
-     * Get the context compaction configuration.
-     * @returns The compaction configuration or null if not configured.
-     */
-    getCompactionConfig(): ContextCompactionConfig | null;
-    /**
-     * Check if a session's messages need compaction based on token count.
-     * Uses character-based estimation for quick checks.
-     *
-     * @param messages - Array of messages to check
-     * @returns True if compaction is recommended
-     */
-    shouldCompactMessages(messages: {
-        content: string | unknown;
-    }[]): boolean;
-    /**
-     * Record a compaction event for a session.
-     * This helps track when and why compaction occurs.
-     *
-     * @param threadId - The session thread ID
-     * @param originalMessageCount - Number of messages before compaction
-     * @param compactedMessageCount - Number of messages after compaction
-     * @param reason - Reason for compaction
-     */
-    recordCompaction(threadId: string, originalMessageCount: number, compactedMessageCount: number, reason?: string): Promise<void>;
-    /**
-     * Get compaction history for a session.
-     *
-     * @param threadId - The session thread ID
-     * @returns Array of compaction events
-     */
-    getCompactionHistory(threadId: string): Array<{
-        timestamp: number;
-        originalMessageCount: number;
-        compactedMessageCount: number;
-        reason: string;
-    }>;
-}
-
-/**
- * Skill-Based DeepAgent Factory
- *
- * Creates DeepAgent instances that use skills as the primary prompt source.
- * No custom system prompts - all agent behavior is defined through skills.
- *
- * Uses deepagents library primitives:
- * - createDeepAgent() for agent creation
- * - FilesystemBackend for file operations
- *
- * Skill loading is injected via SkillLoader functions, keeping this package
- * independent of any specific skill registry location.
- */
-
-/**
- * Skill definition loaded by the consumer.
- */
-interface Skill {
-    name: string;
-    description: string;
-    content: string;
-    allowedTools?: string[];
-    version?: string;
-    references: string[];
-    path?: string;
-}
-/**
- * Function to load a skill by name.
- */
-type SkillLoader = (name: string) => Skill | null;
-/**
- * Function to load a skill reference by skill name and ref name.
- */
-type SkillRefLoader = (skillName: string, refName: string) => string | null;
-/**
- * Options for creating a skill agent.
- */
-interface SkillAgentOptions {
-    /** Required: The skill(s) to use. Can be a single skill or array of skills. */
-    skill: string | string[];
-    /** Required: Working directory for the agent */
-    workDir: string;
-    /** Required: Function to load skills */
-    skillLoader: SkillLoader;
-    /** Optional: Function to load skill references */
-    skillRefLoader?: SkillRefLoader;
-    /** Optional: Thread ID for session continuity */
-    threadId?: string;
-    /** Optional: LLM provider for main agent */
-    provider?: LLMProvider;
-    /** Optional: Model name for main agent */
-    model?: string;
-    /** Optional: LLM provider for subagents (orbital, trait, domain generation). Defaults to 'anthropic' */
-    subagentProvider?: LLMProvider;
-    /** Optional: Model name for subagents. Defaults to 'claude-sonnet-4-20250514' */
-    subagentModel?: string;
-    /** Optional: Enable verbose logging */
-    verbose?: boolean;
-    /** Optional: Disable human-in-the-loop interrupts (for eval/testing) */
-    noInterrupt?: boolean;
-    /** Optional: Callback for subagent events (orbital generation) */
-    onSubagentEvent?: SubagentEventCallback;
-    /** Optional: Session manager instance (shared across requests) */
-    sessionManager?: SessionManager;
-    /** Optional: Extracted requirements from analysis phase (for orbital skill) */
-    requirements?: {
-        entities?: string[];
-        states?: string[];
-        events?: string[];
-        guards?: string[];
-        pages?: string[];
-        effects?: string[];
-        rawRequirements?: string[];
-    };
-    /** Optional: GitHub integration configuration */
-    githubConfig?: {
-        /** GitHub personal access token */
-        token: string;
-        /** Repository owner (e.g., 'octocat') */
-        owner?: string;
-        /** Repository name (e.g., 'hello-world') */
-        repo?: string;
-    };
-    /** Optional: Memory manager for user/project memory (GAP-001) */
-    memoryManager?: MemoryManager;
-    /** Optional: User ID for memory lookup */
-    userId?: string;
-    /** Optional: App ID for project context */
-    appId?: string;
-    /** Optional: Tool wrapper for workflow execution (adds retry, telemetry) */
-    toolWrapper?: <T extends {
-        name: string;
-        invoke: (...args: any[]) => Promise<any>;
-    }>(tool: T) => T;
-    /** Optional: Use orchestrated generation/fixing with complexity-based routing */
-    useOrchestration?: boolean;
-}
-/**
- * Agent interface with stream method (simplified from DeepAgent)
- */
-interface SkillAgent {
-    stream: (input: {
-        messages: Array<{
-            role: string;
-            content: string;
-        }>;
-    }, config: {
-        configurable: {
-            thread_id: string;
-        };
-    }) => Promise<AsyncIterable<{
-        events?: Array<{
-            type: string;
-            [key: string]: unknown;
-        }>;
-        model_request?: {
-            messages?: Array<{
-                kwargs?: {
-                    content?: Array<{
-                        type: string;
-                    }>;
-                };
-            }>;
-        };
-    }>>;
-}
-/**
- * Result from creating a skill agent.
- */
-interface SkillAgentResult {
-    /** The agent instance (from deepagents library) */
-    agent: SkillAgent;
-    /** Thread ID for session resumption */
-    threadId: string;
-    /** The loaded skill(s) - primary skill when single, all skills when multiple */
-    skill: Skill;
-    /** All loaded skills (same as skill when single) */
-    skills: Skill[];
-    /** Working directory */
-    workDir: string;
-    /** Orbital tool setter for wiring SSE callback (if orbital tool enabled) */
-    setOrbitalEventCallback?: (callback: SubagentEventCallback) => void;
-    /** Orbital tool setter for wiring persistence callback */
-    setOrbitalCompleteCallback?: (callback: OrbitalCompleteCallback) => void;
-    /** Domain orbital callback for lean skill Firestore persistence */
-    setDomainCompleteCallback?: (callback: DomainOrbitalCompleteCallback) => void;
-    /** User preferences loaded from memory (GAP-001) */
-    userPreferences?: UserPreference | null;
-    /** Project context loaded from memory (GAP-001) */
-    projectContext?: ProjectContext | null;
-    /** Memory manager instance (GAP-001) */
-    memoryManager?: MemoryManager;
-}
-/**
- * Create a skill-based DeepAgent.
- *
- * Uses the specified skill's content as the system prompt.
- * When multiple skills are provided, the agent sees all skill descriptions
- * and can choose the appropriate one based on the user's request.
- *
- * @throws Error if any skill is not found
- */
-declare function createSkillAgent(options: SkillAgentOptions): Promise<SkillAgentResult>;
-/**
- * Resume a skill agent session.
- *
- * Loads the skill from session metadata and creates agent with same threadId.
- *
- * @throws Error if session not found
- */
-declare function resumeSkillAgent(threadId: string, options: {
-    verbose?: boolean;
-    noInterrupt?: boolean;
-    skillLoader: SkillLoader;
-    skillRefLoader?: SkillRefLoader;
-    sessionManager?: SessionManager;
-}): Promise<SkillAgentResult>;
-
-/**
- * Event Budget Configuration
- *
- * Prevents runaway agent loops with soft/hard event limits per skill.
- */
-/**
- * Event budget limits for different skills.
- * - soft: Warning threshold (agent reminded to finish up)
- * - hard: Maximum events before forced completion
- */
-declare const EVENT_BUDGETS: Record<string, {
-    soft: number;
-    hard: number;
-}>;
-/**
- * Get event budget for a skill.
- */
-declare function getEventBudget(skillName: string): {
-    soft: number;
-    hard: number;
-};
-/**
- * Generate a budget warning message to inject into the agent.
- */
-declare function getBudgetWarningMessage(eventCount: number, budget: {
-    soft: number;
-    hard: number;
-}): string | null;
-
-/**
- * Interrupt Configuration
- *
- * Human-in-the-loop configuration for agent tools.
- *
- * Threshold-gated actions (require k-of-n approval):
- *
- * | Action                                       | Risk                  | Gate  |
- * |----------------------------------------------|-----------------------|-------|
- * | pnpm publish / npm publish                   | Irreversible registry | 2-of-2 |
- * | git push to main / production deploy         | Live users affected   | 2-of-2 |
- * | rm -rf / destructive file ops                | Data loss             | 2-of-2 |
- * | Database migration / persist delete-all      | Production data       | 2-of-2 |
- * | Read/write .env, secrets, service accounts   | Credential exposure   | 2-of-2 |
- * | Cross-user data operations                   | Privacy violation     | 2-of-2 |
- * | Schema deploy to production orbital          | Breaking change risk  | 1-of-2 |
- *
- * Routine actions (no gate): compile, validate, read files, npm install.
- */
-/**
- * Skill metadata (minimal interface for interrupt config).
- */
-interface SkillMeta {
-    name: string;
-    allowedTools?: string[];
-}
-/** Risk level of an agent action. */
-type ActionGate = 'none' | 'sensitive' | 'critical';
-/**
- * Maps tool names / command patterns to their required approval gate.
- * Used by the security layer to decide when ThresholdAuthorizer is needed.
- */
-declare const TOOL_GATES: Record<string, ActionGate>;
-/**
- * Command patterns that classify a shell command as critical.
- * Matched against the command string before execution.
- */
-declare const CRITICAL_COMMAND_PATTERNS: RegExp[];
-/**
- * Classify a shell command's risk level.
- * Returns 'critical' if the command matches any CRITICAL_COMMAND_PATTERNS,
- * 'sensitive' otherwise.
- */
-declare function classifyCommand(command: string): ActionGate;
-/**
- * Get interrupt configuration for a skill.
- *
- * Default: require approval for execute tool.
- * Skills can override via frontmatter (future enhancement).
- */
-declare function getInterruptConfig(_skill: SkillMeta): Record<string, boolean>;
-
-/**
- * Workflow Tool Wrapper
- *
- * Wraps tool execution with workflow capabilities:
- * - Retry on failure with exponential backoff
- * - Per-tool telemetry (duration, retries, success/failure)
- * - Timeout handling
- *
- * Usage:
- * ```typescript
- * const wrapper = createWorkflowToolWrapper({ maxRetries: 3 });
- *
- * const { agent } = await createSkillAgent({
- *   skill: 'kflow-orbitals',
- *   toolWrapper: wrapper.wrap,
- * });
- *
- * // After execution
- * const telemetry = wrapper.getTelemetry();
- * ```
- */
-interface WorkflowToolWrapperOptions {
-    /** Max retry attempts per tool (default: 3) */
-    maxRetries?: number;
-    /** Enable telemetry collection (default: true) */
-    enableTelemetry?: boolean;
-    /** Max execution time per tool in ms (default: 60000) */
-    timeoutMs?: number;
-    /** Initial backoff in ms (default: 1000) */
-    backoffMs?: number;
-}
-interface ToolTelemetry {
-    toolName: string;
-    durationMs: number;
-    retries: number;
-    success: boolean;
-    error?: string;
-}
-interface WorkflowToolWrapper {
-    /** Wrap a tool with retry/telemetry */
-    wrap<T extends {
-        name: string;
-        invoke: (...args: any[]) => Promise<any>;
-    }>(tool: T): T;
-    /** Get collected telemetry */
-    getTelemetry(): ToolTelemetry[];
-    /** Reset telemetry */
-    resetTelemetry(): void;
-}
-/**
- * Create a workflow tool wrapper
- *
- * @param options - Wrapper configuration
- * @returns Wrapper with wrap() and getTelemetry() methods
- *
- * @example
- * ```typescript
- * const workflow = createWorkflowToolWrapper({ maxRetries: 3 });
- *
- * const { agent } = await createSkillAgent({
- *   skill: 'kflow-orbitals',
- *   toolWrapper: workflow.wrap,
- * });
- *
- * // Run agent...
- *
- * // Get results
- * console.log(workflow.getTelemetry());
- * // [{ toolName: 'generate_orbital', durationMs: 5000, retries: 1, success: true }]
- * ```
- */
-declare function createWorkflowToolWrapper(options?: WorkflowToolWrapperOptions): WorkflowToolWrapper;
-/**
- * Create a workflow wrapper specifically for evaluation comparison
- *
- * This wrapper logs telemetry to console for debugging
- */
-declare function createEvalWorkflowWrapper(options?: WorkflowToolWrapperOptions): {
-    wrap: <T extends {
-        name: string;
-        invoke: (...args: any[]) => Promise<any>;
-    }>(tool: T) => T;
-    /** Get collected telemetry */
-    getTelemetry(): ToolTelemetry[];
-    /** Reset telemetry */
-    resetTelemetry(): void;
-};
-
-export { type ActionGate as A, resumeSkillAgent as B, CRITICAL_COMMAND_PATTERNS as C, DEFAULT_COMPACTION_CONFIG as D, EVENT_BUDGETS as E, type SkillAgent as F, type GenerationSession as G, type InterruptRecord as I, MemoryManager as M, type PatternAffinity as P, SessionManager as S, TOOL_GATES as T, type UserPreference as U, type WorkflowToolWrapper as W, type CheckpointRecord as a, type ContextCompactionConfig as b, type MemoryManagerOptions as c, MemoryOrbitalSchema as d, type ProjectContext as e, type SessionManagerOptions as f, type Skill as g, type SkillAgentOptions as h, type SkillAgentResult as i, type SkillLoader as j, type SkillMeta as k, type SkillRefLoader as l, type ToolApprovalPreference as m, type ToolTelemetry as n, type UserFeedback as o, type WorkflowToolWrapperOptions as p, classifyCommand as q, createEvalWorkflowWrapper as r, createSkillAgent as s, createSummaryPrompt as t, createWorkflowToolWrapper as u, estimateTokens as v, getBudgetWarningMessage as w, getEventBudget as x, getInterruptConfig as y, needsCompaction as z };