@almadar/agent 1.6.1 → 1.6.3

package/dist/agent/index.d.ts

@@ -1,741 +1,13 @@
-import { M as MemoryManager } from '../workflow-tool-wrapper-CXD0A7l3.js';
-export { E as EVENT_BUDGETS, S as SessionManager, a as SessionManagerOptions, b as Skill, c as SkillAgent, d as SkillAgentOptions, e as SkillAgentResult, f as SkillLoader, g as SkillMeta, h as SkillRefLoader, T as ToolTelemetry, W as WorkflowToolWrapper, i as WorkflowToolWrapperOptions, j as createEvalWorkflowWrapper, k as createSkillAgent, l as createWorkflowToolWrapper, m as getBudgetWarningMessage, n as getEventBudget, o as getInterruptConfig, r as resumeSkillAgent } from '../workflow-tool-wrapper-CXD0A7l3.js';
+export { E as EVENT_BUDGETS, S as SessionManager, f as SessionManagerOptions, g as Skill, F as SkillAgent, h as SkillAgentOptions, i as SkillAgentResult, j as SkillLoader, k as SkillMeta, l as SkillRefLoader, n as ToolTelemetry, W as WorkflowToolWrapper, p as WorkflowToolWrapperOptions, r as createEvalWorkflowWrapper, s as createSkillAgent, u as createWorkflowToolWrapper, w as getBudgetWarningMessage, x as getEventBudget, y as getInterruptConfig, B as resumeSkillAgent } from '../index-DZn69no8.js';
 export { Command } from '@langchain/langgraph';
-export { P as PersistenceMode, S as SessionMetadata, a as SessionRecord } from '../firestore-checkpointer-BkFR-sZM.js';
+export { P as PersistenceMode, S as SessionMetadata, e as SessionRecord } from '../firestore-checkpointer-CkNKXoun.js';
 import '@almadar/llm';
-import '../orbital-subagent-CHEeQQr_.js';
+import '../orbital-subagent-BdFuf77p.js';
 import '@langchain/core/tools';
 import 'zod';
-import '../api-types-Bj2jeOU7.js';
+import '../api-types-CXrq-fts.js';
 import '@almadar/core/types';
 import '@langchain/langgraph-checkpoint';
 import '@almadar/core';
 import '@langchain/core/messages';
 import '@langchain/core/runnables';
-
-/**
- * ReAct + Reflection Pattern - Phase 2.2
- *
- * Self-correcting agent loops with explicit reasoning states.
- * Implements: REASON → ACT → REFLECT → OBSERVE
- *
- * @packageDocumentation
- */
-
-type ReActState = 'REASONING' | 'ACTING' | 'REFLECTING' | 'OBSERVING' | 'CORRECTING' | 'COMPLETE';
-interface ReActStep {
-    stepNumber: number;
-    state: ReActState;
-    thought: string;
-    action?: string;
-    actionInput?: Record<string, unknown>;
-    observation?: string;
-    reflection?: string;
-    timestamp: Date;
-    error?: string;
-}
-interface ReflectionResult {
-    shouldCorrect: boolean;
-    correctionStrategy?: string;
-    confidence: number;
-    notes: string;
-}
-interface ReActSession {
-    sessionId: string;
-    userRequest: string;
-    currentStep: number;
-    steps: ReActStep[];
-    maxIterations: number;
-    state: ReActState;
-}
-interface ReActOptions {
-    maxIterations?: number;
-    enableReflection?: boolean;
-    enableAutoCorrect?: boolean;
-    memoryManager?: MemoryManager;
-    onStep?: (step: ReActStep) => void;
-    onError?: (error: Error, step: ReActStep) => void;
-}
-declare class ReActEngine {
-    private options;
-    private sessions;
-    constructor(options?: ReActOptions);
-    /**
-     * Start a new ReAct session
-     */
-    startSession(userRequest: string): ReActSession;
-    /**
-     * Execute REASON step
-     */
-    reason(sessionId: string, context: {
-        request: string;
-        previousSteps?: ReActStep[];
-    }): Promise<ReActStep>;
-    /**
-     * Execute ACT step
-     */
-    act(sessionId: string, action: string, actionInput: Record<string, unknown>): Promise<ReActStep>;
-    /**
-     * Execute OBSERVE step
-     */
-    observe(sessionId: string, observation: string): Promise<ReActStep>;
-    /**
-     * Execute REFLECT step
-     */
-    reflect(sessionId: string, result: unknown): Promise<{
-        step: ReActStep;
-        reflection: ReflectionResult;
-    }>;
-    /**
-     * Execute CORRECT step (auto-correction)
-     */
-    correct(sessionId: string, correctionAction: string, correctionInput: Record<string, unknown>): Promise<ReActStep>;
-    /**
-     * Handle errors with context preservation
-     */
-    handleError(sessionId: string, error: Error, context: Record<string, unknown>): Promise<ReActStep>;
-    /**
-     * Get session by ID
-     */
-    getSession(sessionId: string): ReActSession;
-    /**
-     * Get reflection metrics
-     */
-    getReflectionMetrics(sessionId: string): {
-        totalSteps: number;
-        corrections: number;
-        errors: number;
-        averageConfidence: number;
-    };
-    private generateThought;
-    private performReflection;
-    private storeCorrection;
-    private storeError;
-}
-declare function createReActEngine(options?: ReActOptions): ReActEngine;
-
-/**
- * Human-in-the-Loop v2 - Phase 2.3
- *
- * Structured interrupts with memory and time-travel debugging.
- * Interrupt types: confirm, edit, select, text
- *
- * @packageDocumentation
- */
-
-type InterruptType = 'confirm' | 'edit' | 'select' | 'text';
-interface InterruptRequest<T = unknown> {
-    interruptId: string;
-    sessionId: string;
-    type: InterruptType;
-    title: string;
-    description: string;
-    context: InterruptContext;
-    payload: T;
-    timeoutMs?: number;
-    createdAt: Date;
-}
-interface InterruptContext {
-    checkpointId: string;
-    currentState: string;
-    previousActions: string[];
-    relevantMemory?: string[];
-}
-interface InterruptResponse<T = unknown> {
-    interruptId: string;
-    response: T;
-    respondedAt: Date;
-    userId?: string;
-}
-interface ConfirmPayload {
-    question: string;
-    defaultValue?: boolean;
-    severity: 'info' | 'warning' | 'critical';
-}
-interface EditPayload {
-    content: string;
-    format: 'json' | 'text' | 'code';
-    schema?: Record<string, unknown>;
-    validationRules?: string[];
-}
-interface SelectPayload {
-    options: Array<{
-        id: string;
-        label: string;
-        description?: string;
-        disabled?: boolean;
-    }>;
-    multiple?: boolean;
-    maxSelections?: number;
-}
-interface TextPayload {
-    placeholder?: string;
-    multiline?: boolean;
-    maxLength?: number;
-    validation?: 'email' | 'url' | 'regex';
-    validationRegex?: string;
-}
-interface HITLv2Options {
-    memoryManager?: MemoryManager;
-    defaultTimeoutMs?: number;
-    onInterrupt?: (request: InterruptRequest) => void;
-    onResponse?: (request: InterruptRequest, response: InterruptResponse) => void;
-}
-declare class HITLv2Manager {
-    private options;
-    private pendingInterrupts;
-    private responses;
-    private checkpoints;
-    constructor(options?: HITLv2Options);
-    /**
-     * Create a confirmation interrupt
-     */
-    confirm(sessionId: string, question: string, options?: {
-        severity?: 'info' | 'warning' | 'critical';
-        defaultValue?: boolean;
-        timeoutMs?: number;
-        context?: Partial<InterruptContext>;
-    }): Promise<boolean>;
-    /**
-     * Create an edit interrupt
-     */
-    edit(sessionId: string, content: string, options?: {
-        format?: 'json' | 'text' | 'code';
-        title?: string;
-        description?: string;
-        schema?: Record<string, unknown>;
-        timeoutMs?: number;
-        context?: Partial<InterruptContext>;
-    }): Promise<string>;
-    /**
-     * Create a selection interrupt
-     */
-    select<T extends string>(sessionId: string, options: Array<{
-        id: T;
-        label: string;
-        description?: string;
-    }>, config?: {
-        title?: string;
-        description?: string;
-        multiple?: boolean;
-        timeoutMs?: number;
-        context?: Partial<InterruptContext>;
-    }): Promise<T | T[]>;
-    /**
-     * Create a text input interrupt
-     */
-    text(sessionId: string, options?: {
-        title?: string;
-        description?: string;
-        placeholder?: string;
-        multiline?: boolean;
-        maxLength?: number;
-        timeoutMs?: number;
-        context?: Partial<InterruptContext>;
-    }): Promise<string>;
-    /**
-     * Submit a response to an interrupt
-     */
-    submitResponse<T>(interruptId: string, response: T, userId?: string): Promise<void>;
-    /**
-     * Cancel an interrupt
-     */
-    cancelInterrupt(interruptId: string, reason?: string): void;
-    /**
-     * Save a checkpoint for time-travel
-     */
-    saveCheckpoint(checkpointId: string, state: unknown): void;
-    /**
-     * Restore a checkpoint
-     */
-    restoreCheckpoint<T>(checkpointId: string): T | null;
-    /**
-     * List available checkpoints
-     */
-    listCheckpoints(): string[];
-    /**
-     * Rewind to checkpoint and continue
-     */
-    rewindToCheckpoint<T>(checkpointId: string, sessionId: string, modifyFn?: (state: T) => T): Promise<T | null>;
-    /**
-     * Get interrupt statistics
-     */
-    getStats(): {
-        pendingCount: number;
-        totalHandled: number;
-        checkpointsCount: number;
-        averageResponseTimeMs: number;
-    };
-    /**
-     * Get pending interrupts for a session
-     */
-    getPendingForSession(sessionId: string): InterruptRequest[];
-    private createInterrupt;
-    private waitForResponse;
-    private storeInteraction;
-}
-declare function createHITLv2Manager(options?: HITLv2Options): HITLv2Manager;
-
-/**
- * Memory System Integration - Phase 2.1
- *
- * Integrates episodic, semantic, and procedural memory with agent operations.
- * Provides memory-aware agent capabilities.
- *
- * @packageDocumentation
- */
-
-interface MemoryIntegrationOptions {
-    memoryManager: MemoryManager;
-    userId: string;
-    projectId?: string;
-    enableEpisodic?: boolean;
-    enableSemantic?: boolean;
-    enableProcedural?: boolean;
-}
-interface SimilarSession {
-    sessionId: string;
-    request: string;
-    schema: unknown;
-    success: boolean;
-    similarity: number;
-}
-interface MemoryContext {
-    userPreferences: {
-        namingConvention: string;
-        preferredPatterns: string[];
-        commonEntities: string[];
-    };
-    similarSessions: SimilarSession[];
-    projectContext?: {
-        domain: 'business' | 'ecommerce' | 'cms' | 'dashboard' | 'workflow';
-        existingEntities: string[];
-        conventions: string[];
-    };
-    learnedPatterns: Array<{
-        pattern: string;
-        confidence: number;
-        useCount: number;
-    }>;
-}
-interface MemoryQualityMetrics {
-    recallAccuracy: number;
-    precision: number;
-    latencyMs: number;
-    cacheHitRate: number;
-}
-declare class MemoryIntegrationEngine {
-    private options;
-    private searchEngine;
-    private preferenceLearner;
-    private metrics;
-    constructor(options: MemoryIntegrationOptions);
-    /**
-     * Retrieve similar past generation sessions
-     */
-    retrieveSimilarSessions(request: string, limit?: number): Promise<SimilarSession[]>;
-    /**
-     * Record a new generation session to episodic memory
-     */
-    recordSession(request: string, result: {
-        schema: unknown;
-        success: boolean;
-        validationResult?: {
-            valid: boolean;
-            errors: string[];
-        };
-    }): Promise<void>;
-    /**
-     * Get learned user preferences
-     */
-    getUserPreferences(): Promise<MemoryContext['userPreferences']>;
-    /**
-     * Learn from user feedback
-     */
-    learnFromFeedback(feedback: {
-        pattern: string;
-        outcome: 'success' | 'failure';
-        entityType?: string;
-    }): Promise<void>;
-    /**
-     * Infer preferences from usage patterns
-     */
-    inferPreferences(): Promise<{
-        namingConvention?: string;
-        validationStyle?: string;
-        confidence: number;
-    }>;
-    /**
-     * Get project context (domain-specific knowledge)
-     */
-    getProjectContext(): Promise<MemoryContext['projectContext'] | undefined>;
-    /**
-     * Update project context with new conventions
-     */
-    updateProjectContext(update: {
-        domain?: 'business' | 'ecommerce' | 'cms' | 'dashboard' | 'workflow';
-        conventions?: string[];
-        existingEntities?: string[];
-    }): Promise<void>;
-    /**
-     * Build complete memory context for a generation request
-     */
-    buildContext(request: string): Promise<MemoryContext>;
-    /**
-     * Get memory quality metrics
-     */
-    getMetrics(): MemoryQualityMetrics;
-    private recordMetrics;
-}
-declare function createMemoryIntegration(options: MemoryIntegrationOptions): MemoryIntegrationEngine;
-
-/**
- * Workflow action definition for ReAct
- */
-interface WorkflowAction {
-    /** Action name */
-    name: string;
-    /** Workflow definition */
-    workflow: {
-        steps: Array<{
-            id: string;
-            tool: string;
-            input: Record<string, unknown>;
-            dependsOn?: string[];
-        }>;
-        parallel?: string[][];
-        condition?: {
-            stepId: string;
-            predicate: (context: unknown) => boolean;
-            then: string;
-            else: string;
-        };
-        retry?: {
-            stepId: string;
-            maxAttempts: number;
-            backoffMs: number;
-        };
-    };
-    /** Expected output schema */
-    outputSchema?: Record<string, unknown>;
-}
-/**
- * Workflow action result
- */
-interface WorkflowActionResult {
-    success: boolean;
-    output: unknown;
-    stepsExecuted: number;
-    durationMs: number;
-    retries: number;
-    errors: string[];
-}
-/**
- * ReAct workflow executor options
- */
-interface ReActWorkflowOptions {
-    /** Tool executor */
-    toolExecutor: {
-        execute(tool: string, input: Record<string, unknown>): Promise<unknown>;
-    };
-    /** Memory manager for storing workflow results */
-    memoryManager?: MemoryManager;
-    /** Enable workflow telemetry */
-    enableTelemetry?: boolean;
-    /** Max workflow execution time */
-    maxExecutionMs?: number;
-}
-/**
- * Workflow telemetry event
- */
-interface WorkflowTelemetryEvent {
-    sessionId: string;
-    actionName: string;
-    stepId: string;
-    tool: string;
-    durationMs: number;
-    success: boolean;
-    retryCount: number;
-    timestamp: number;
-}
-declare class ReActWorkflowExecutor {
-    private workflowEngine;
-    private options;
-    private telemetry;
-    constructor(options: ReActWorkflowOptions);
-    /**
-     * Execute a workflow action within a ReAct session
-     * This replaces simple tool calls with full workflows
-     */
-    executeWorkflowAction(session: ReActSession, action: WorkflowAction, context: Record<string, unknown>): Promise<WorkflowActionResult>;
-    /**
-     * Execute workflow with timeout
-     */
-    private executeWithTimeout;
-    /**
-     * Store workflow result in memory for learning
-     */
-    private storeWorkflowResult;
-    /**
-     * Record telemetry for a workflow step
-     */
-    recordTelemetry(event: WorkflowTelemetryEvent): void;
-    /**
-     * Get telemetry for analysis
-     */
-    getTelemetry(sessionId?: string): WorkflowTelemetryEvent[];
-    /**
-     * Get workflow performance metrics
-     */
-    getMetrics(): {
-        totalWorkflows: number;
-        successRate: number;
-        avgDurationMs: number;
-        avgRetries: number;
-        toolUsage: Record<string, number>;
-    };
-}
-interface ExtendedReActOptions {
-    /** Base ReAct options */
-    reactOptions: ConstructorParameters<typeof ReActEngine>[0];
-    /** Workflow executor options */
-    workflowOptions: ReActWorkflowOptions;
-}
-/**
- * Extended ReAct engine with workflow integration
- */
-declare class ReActWorkflowEngine {
-    private reactEngine;
-    private workflowExecutor;
-    constructor(options: ExtendedReActOptions);
-    /**
-     * Start a new session
-     */
-    startSession(userRequest: string): ReActSession;
-    /**
-     * Execute REASON step
-     */
-    reason(sessionId: string, context: {
-        request: string;
-        previousSteps?: ReActStep[];
-    }): Promise<ReActStep>;
-    /**
-     * Execute ACT step with workflow support
-     *
-     * This is the key integration point - replaces simple tool calls
-     * with full workflows that have retry, parallel execution, etc.
-     */
-    act(sessionId: string, action: string, actionInput: Record<string, unknown>, workflowAction?: WorkflowAction): Promise<{
-        step: ReActStep;
-        workflowResult?: WorkflowActionResult;
-    }>;
-    /**
-     * Execute OBSERVE step
-     */
-    observe(sessionId: string, observation: string): Promise<ReActStep>;
-    /**
-     * Execute REFLECT step
-     */
-    reflect(sessionId: string, result: unknown): Promise<{
-        step: ReActStep;
-        reflection: ReflectionResult;
-    }>;
-    /**
-     * Execute CORRECT step
-     */
-    correct(sessionId: string, correctionAction: string, correctionInput: Record<string, unknown>): Promise<ReActStep>;
-    /**
-     * Get session
-     */
-    getSession(sessionId: string): ReActSession;
-    /**
-     * Get workflow metrics
-     */
-    getWorkflowMetrics(): ReturnType<ReActWorkflowExecutor['getMetrics']>;
-}
-declare function createReActWorkflowExecutor(options: ReActWorkflowOptions): ReActWorkflowExecutor;
-declare function createReActWorkflowEngine(options: ExtendedReActOptions): ReActWorkflowEngine;
-
-/**
- * HITL Workflow Integration - Phase 3.4
- *
- * Human-in-the-Loop with workflow-based conditional branching.
- * Enables complex approval flows with human gates.
- *
- * @packageDocumentation
- */
-
-/**
- * Human gate types
- */
-type HumanGateType = 'approval' | 'edit' | 'select' | 'custom';
-/**
- * Human gate configuration
- */
-interface HumanGate {
-    /** Gate ID */
-    id: string;
-    /** Gate type */
-    type: HumanGateType;
-    /** Display title */
-    title: string;
-    /** Description */
-    description: string;
-    /** Gate condition - when to show */
-    condition?: (context: unknown) => boolean;
-    /** Timeout in ms */
-    timeoutMs?: number;
-    /** Auto-approve if condition met */
-    autoApprove?: {
-        condition: (context: unknown) => boolean;
-        reason: string;
-    };
-    /** Gate-specific payload */
-    payload?: Record<string, unknown>;
-}
-/**
- * Human gate result
- */
-interface HumanGateResult {
-    gateId: string;
-    approved: boolean;
-    response: unknown;
-    respondedAt: number;
-    userId?: string;
-    autoApproved: boolean;
-}
-/**
- * Workflow branch definition
- */
-interface WorkflowBranch {
-    /** Branch ID */
-    id: string;
-    /** Branch condition */
-    condition: (context: unknown) => boolean;
-    /** Steps to execute */
-    steps: Array<{
-        tool: string;
-        input: Record<string, unknown>;
-    }>;
-    /** Human gate before branch */
-    gate?: HumanGate;
-}
-/**
- * HITL workflow definition
- */
-interface HITLWorkflowDefinition {
-    /** Workflow name */
-    name: string;
-    /** Initial steps (before any gates) */
-    initialSteps: Array<{
-        tool: string;
-        input: Record<string, unknown>;
-    }>;
-    /** Human gates with conditional branches */
-    gates: HumanGate[];
-    /** Branches based on gate outcomes */
-    branches: WorkflowBranch[];
-    /** Fallback if no branches match */
-    fallbackBranch?: WorkflowBranch;
-}
-/**
- * HITL workflow result
- */
-interface HITLWorkflowResult {
-    success: boolean;
-    output: unknown;
-    gatesPassed: HumanGateResult[];
-    branchesTaken: string[];
-    durationMs: number;
-    wasInterrupted: boolean;
-}
-/**
- * HITL workflow options
- */
-interface HITLWorkflowOptions {
-    /** HITL manager */
-    hitlManager: HITLv2Manager;
-    /** Tool executor */
-    toolExecutor: {
-        execute(tool: string, input: Record<string, unknown>): Promise<unknown>;
-    };
-    /** Memory manager */
-    memoryManager?: MemoryManager;
-    /** Default gate timeout */
-    defaultTimeoutMs?: number;
-    /** Enable auto-approval learning */
-    enableAutoApprove?: boolean;
-}
-declare class HITLWorkflowEngine {
-    private workflowEngine;
-    private hitlManager;
-    private options;
-    private gateHistory;
-    constructor(options: HITLWorkflowOptions);
-    /**
-     * Execute a workflow with human gates
-     */
-    executeWorkflow(sessionId: string, workflow: HITLWorkflowDefinition, initialContext: Record<string, unknown>): Promise<HITLWorkflowResult>;
-    /**
-     * Execute initial workflow steps
-     */
-    private executeInitialSteps;
-    /**
-     * Execute a human gate
-     */
-    private executeHumanGate;
-    /**
-     * Execute approval gate
-     */
-    private executeApprovalGate;
-    /**
-     * Execute edit gate
-     */
-    private executeEditGate;
-    /**
-     * Execute select gate
-     */
-    private executeSelectGate;
-    /**
-     * Execute custom gate
-     */
-    private executeCustomGate;
-    /**
-     * Execute branch steps
-     */
-    private executeBranchSteps;
-    /**
-     * Wait for interrupt response
-     */
-    private waitForResponse;
-    /**
-     * Interpolate input with context
-     */
-    private interpolateInput;
-    /**
-     * Get value from path
-     */
-    private getValueFromPath;
-    /**
-     * Get gate history for a session
-     */
-    getGateHistory(sessionId: string): HumanGateResult[];
-    /**
-     * Clear gate history
-     */
-    clearGateHistory(sessionId?: string): void;
-}
-/**
- * Schema generation with human review
- */
-declare function createSchemaGenerationHITLWorkflow(complexity: 'simple' | 'medium' | 'complex'): HITLWorkflowDefinition;
-/**
- * Multi-stage approval workflow
- */
-declare function createMultiStageApprovalWorkflow(stages: Array<{
-    name: string;
-    approver: string;
-}>): HITLWorkflowDefinition;
-declare function createHITLWorkflowEngine(options: HITLWorkflowOptions): HITLWorkflowEngine;
-
-export { type ConfirmPayload, type EditPayload, type ExtendedReActOptions, type HITLWorkflowDefinition, HITLWorkflowEngine, type HITLWorkflowOptions, type HITLWorkflowResult, HITLv2Manager, type HITLv2Options, type HumanGate, type HumanGateResult, type InterruptContext, type InterruptRequest, type InterruptResponse, type InterruptType, type MemoryContext, MemoryIntegrationEngine, type MemoryIntegrationOptions, type MemoryQualityMetrics, ReActEngine, type ReActOptions, type ReActSession, type ReActState, type ReActStep, ReActWorkflowEngine, ReActWorkflowExecutor, type ReActWorkflowOptions, type ReflectionResult, type SelectPayload, type SimilarSession, type TextPayload, type WorkflowAction, type WorkflowActionResult, type WorkflowBranch, type WorkflowTelemetryEvent, createHITLWorkflowEngine, createHITLv2Manager, createMemoryIntegration, createMultiStageApprovalWorkflow, createReActEngine, createReActWorkflowEngine, createReActWorkflowExecutor, createSchemaGenerationHITLWorkflow };