@multi-agent/sdk/dist/index.d.ts

AI Agents SDK for creating, using and sharing intelligent agents

import * as _grpc_grpc_js from '@grpc/grpc-js';
import * as _langchain_langgraph from '@langchain/langgraph';
import { BaseChatModel } from '@langchain/core/language_models/chat_models';

interface AgentCore {
    getAgentCard(): AgentCard;
    createTask(taskId: string, message: any): Promise<Task>;
    processTaskAsync(task: Task): Promise<void>;
    processTaskStream(taskId: string, message: any): AsyncGenerator<TaskUpdate, void, unknown>;
    getTaskStatus(taskId: string): Promise<Task>;
    handleMessage(fromAgentId: string, message: any): Promise<boolean>;
}
interface AgentCard {
    id: string;
    name: string;
    description: string;
    version: string;
    capabilities: string[];
    endpoints: {
        grpcEndpoint?: string;
        httpEndpoint?: string;
        grpcAddress: string;
        grpcPort: number;
        httpAddress?: string;
        httpPort?: number;
    };
    metadata: {
        author?: string;
        tags?: string[];
        supportedLanguages?: string[];
        maxConcurrentTasks?: number;
        [key: string]: any;
    };
}
interface Task {
    id: string;
    agentId: string;
    fromAgentId?: string;
    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
    message: any;
    artifacts: any[];
    progress: number;
    createdAt: number;
    updatedAt: number;
    startedAt?: number;
    completedAt?: number;
    errorMessage?: string;
}
interface TaskUpdate {
    taskId: string;
    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
    progress: number;
    newArtifacts?: any[];
    message?: string;
    timestamp: number;
    errorMessage?: string;
    metadata?: Record<string, any>;
}
declare const createA2AServer: (agentCore: AgentCore) => {
    server: _grpc_grpc_js.Server;
    listen: (port: number, address?: string) => Promise<void>;
    close: () => Promise<void>;
};

interface A2AClientConfig {
    endpoint?: string;
    agentAddress?: string;
    agentPort?: number;
    timeout?: number;
    retryAttempts?: number;
    keepaliveTime?: number;
}
declare const createA2AClient: (config: A2AClientConfig) => {
    getAgentCard: () => Promise<AgentCard>;
    sendTask: (taskId: string, message: any, metadata?: Record<string, string>) => Promise<{
        taskId: string;
        status: string;
        message: string;
    }>;
    getTaskStatus: (taskId: string) => Promise<Task>;
    streamTaskUpdates: (taskId: string, message: any, metadata?: Record<string, string>) => AsyncGenerator<TaskUpdate, void, unknown>;
    sendMessage: (fromAgentId: string, toAgentId: string, message: any, correlationId?: string) => Promise<{
        success: boolean;
        messageId: string;
        message: string;
    }>;
    healthCheck: () => Promise<{
        status: string;
        message: string;
        details: Record<string, string>;
    }>;
    close: () => void;
    getConnectionInfo: () => {
        target: string;
        agentAddress: string;
        agentPort: number;
        timeout: number;
        retryAttempts: number;
    };
};
declare const createAgentDiscovery: () => {
    discoverAgent: (endpoint: string) => Promise<AgentCard | null>;
    discoverAgents: (endpoints: string[]) => Promise<AgentCard[]>;
    getDiscoveredAgents: () => AgentCard[];
    findAgentsByCapability: (capability: string) => AgentCard[];
};

interface SessionState {
    sessionId: string;
    agentId: string;
    userId?: string;
    createdAt: string;
    lastAccessedAt: string;
    expiresAt: string;
    isActive: boolean;
    metadata: Record<string, any>;
    stateSize: number;
}
interface MemoryItem {
    id: string;
    sessionId: string;
    type: 'checkpoint' | 'conversation' | 'artifact' | 'tool_result' | 'custom';
    data: any;
    timestamp: string;
    size: number;
    compressed: boolean;
    ttl?: number;
    metadata?: Record<string, any>;
}
interface MemoryStats {
    totalSessions: number;
    activeSessions: number;
    expiredSessions: number;
    totalMemoryUsage: number;
    averageSessionSize: number;
    itemsByType: Record<string, number>;
    compressionRatio: number;
}

interface MCPTool {
    name: string;
    description: string;
    inputSchema: {
        type: 'object';
        properties: Record<string, any>;
        required?: string[];
    };
}

type AgentType = 'intelligent' | 'tool' | 'service' | 'host' | 'analyst' | 'architect' | 'coder' | 'checker' | 'mcp' | 'webcontainer' | 'registry';
type AgentStatus = 'online' | 'offline' | 'busy' | 'error';
type LoadBalanceStrategy = 'round-robin' | 'least-loaded' | 'random';

interface UnifiedToolDefinition {
    name: string;
    description: string;
    parameters: {
        type: 'object';
        properties: Record<string, {
            type: string;
            description: string;
            enum?: string[];
            required?: boolean;
        }>;
        required?: string[];
    };
    toolType: 'mcp' | 'agent' | 'local';
    autonomyLevel: 'low' | 'medium' | 'high';
    category?: 'webcontainer' | 'search' | 'langfuse' | 'file' | 'ai' | 'general';
    priority?: number;
    isLocal?: boolean;
    executionTime?: number;
    metadata?: {
        agentType?: AgentType;
        address?: string;
        port?: number;
        serverName?: string;
        protocolVersion?: string;
        isBuiltIn?: boolean;
        version?: string;
    };
}
interface UnifiedToolExecutionResult {
    success: boolean;
    result?: any;
    error?: string;
    metadata?: {
        toolType: 'mcp' | 'agent' | 'local';
        autonomyLevel: 'low' | 'medium' | 'high';
        executionTime?: number;
        agentTrace?: string;
        mcpServerName?: string;
        [key: string]: any;
    };
    executionTime?: number;
    toolName: string;
    args: Record<string, any>;
}
type ToolDefinition = UnifiedToolDefinition;
type ToolExecutionResult = UnifiedToolExecutionResult;
interface LocalToolHandler {
    (args: Record<string, any>): Promise<UnifiedToolExecutionResult>;
}
interface ToolCallContext {
    sessionId?: string;
    userId?: string;
    parentTaskId?: string;
    priority?: 'low' | 'medium' | 'high' | 'critical';
    timeout?: number;
    metadata?: Record<string, any>;
}
interface ToolExecutionStats {
    totalCalls: number;
    successfulCalls: number;
    failedCalls: number;
    averageExecutionTime: number;
    callsByTool: Record<string, number>;
    callsByCategory: Record<string, number>;
    errorsByTool: Record<string, number>;
}

interface SpecialistAgentConfig {
    agentType: 'analyst' | 'architect' | 'coder' | 'checker';
    llm: BaseChatModel;
    grpcPort: number;
    capabilities: string[];
    toolConfigs?: {
        enableWebContainer?: boolean;
        enableSearch?: boolean;
        enableLangfuse?: boolean;
    };
    memoryConfig?: {
        maxSessionSize?: number;
        sessionTimeout?: number;
    };
    prompts?: {
        systemPrompt: string;
        taskPrompt: string;
    };
}

type A2AClient = ReturnType<typeof createA2AClient>;
interface AgentRegistration {
    id: string;
    name: string;
    capabilities: string[];
    address: string;
    port: number;
    lastHeartbeat: Date;
    status: AgentStatus;
    loadScore: number;
    errorCount: number;
    metadata: Record<string, any>;
    agentType: AgentType;
}
interface AgentRegistrationConfig {
    agentCard: AgentCard;
    address: string;
    port: number;
    agentType?: AgentType;
    metadata?: Record<string, any>;
}
interface AgentRegistryConfig {
    heartbeatInterval: number;
    healthCheckInterval: number;
    maxRetries: number;
    timeout: number;
    loadBalanceStrategy: LoadBalanceStrategy;
}
interface AgentDiscoveryQuery {
    capabilities?: string[];
    excludeIds?: string[];
    maxLoadScore?: number;
    status?: 'online' | 'busy';
    agentType?: AgentType;
}
interface AgentRegistryEvents {
    'agent-registered': (registration: AgentRegistration) => void;
    'agent-unregistered': (agentId: string) => void;
    'agent-status-changed': (agentId: string, oldStatus: string, newStatus: string) => void;
    'agent-failed': (agentId: string, error: Error) => void;
    'registry-stats': (stats: RegistryStats) => void;
}
interface RegistryStats {
    totalAgents: number;
    onlineAgents: number;
    busyAgents: number;
    offlineAgents: number;
    errorAgents: number;
    averageLoadScore: number;
    topCapabilities: string[];
}
declare const createAgentRegistry: (config?: Partial<AgentRegistryConfig>) => {
    registerAgent: (config: AgentRegistrationConfig) => Promise<void>;
    unregisterAgent: (agentId: string) => Promise<void>;
    updateAgentStatus: (agentId: string, status: AgentRegistration["status"], loadScore?: number) => Promise<void>;
    discoverAgents: (query?: AgentDiscoveryQuery) => Promise<AgentRegistration[]>;
    selectBestAgent: (query?: AgentDiscoveryQuery) => Promise<AgentRegistration | null>;
    getAgentClient: (agentId: string) => Promise<A2AClient>;
    delegateTask: (task: Task, targetCapability: string) => Promise<void>;
    performHealthCheck: () => Promise<void>;
    getRegistryStats: () => RegistryStats;
    startPeriodicTasks: () => void;
    shutdown: () => Promise<void>;
    on: <K extends keyof AgentRegistryEvents>(event: K, listener: AgentRegistryEvents[K]) => void;
    off: <K extends keyof AgentRegistryEvents>(event: K, listener: AgentRegistryEvents[K]) => void;
    config: {
        heartbeatInterval: number;
        healthCheckInterval: number;
        maxRetries: number;
        timeout: number;
        loadBalanceStrategy: LoadBalanceStrategy;
    };
    readonly agentCount: number;
    readonly agents: AgentRegistration[];
};
type AgentRegistry = ReturnType<typeof createAgentRegistry>;

declare const ReActState: _langchain_langgraph.AnnotationRoot<{
    input: {
        (): _langchain_langgraph.LastValue<string>;
        (annotation: _langchain_langgraph.SingleReducer<string, string>): _langchain_langgraph.BinaryOperatorAggregate<string, string>;
        Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
    };
    goal: {
        (): _langchain_langgraph.LastValue<string>;
        (annotation: _langchain_langgraph.SingleReducer<string, string>): _langchain_langgraph.BinaryOperatorAggregate<string, string>;
        Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
    };
    thoughts: {
        (): _langchain_langgraph.LastValue<string[]>;
        (annotation: _langchain_langgraph.SingleReducer<string[], string[]>): _langchain_langgraph.BinaryOperatorAggregate<string[], string[]>;
        Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
    };
    actions: {
        (): _langchain_langgraph.LastValue<{
            id: string;
            type: string;
            targetAgent: string;
            capability: string;
            args: Record<string, any>;
            timestamp: string;
        }[]>;
        (annotation: _langchain_langgraph.SingleReducer<{
            id: string;
            type: string;
            targetAgent: string;
            capability: string;
            args: Record<string, any>;
            timestamp: string;
        }[], {
            id: string;
            type: string;
            targetAgent: string;
            capability: string;
            args: Record<string, any>;
            timestamp: string;
        }[]>): _langchain_langgraph.BinaryOperatorAggregate<{
            id: string;
            type: string;
            targetAgent: string;
            capability: string;
            args: Record<string, any>;
            timestamp: string;
        }[], {
            id: string;
            type: string;
            targetAgent: string;
            capability: string;
            args: Record<string, any>;
            timestamp: string;
        }[]>;
        Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
    };
    observations: {
        (): _langchain_langgraph.LastValue<{
            id: string;
            actionId: string;
            result: any;
            isSuccess: boolean;
            timestamp: string;
        }[]>;
        (annotation: _langchain_langgraph.SingleReducer<{
            id: string;
            actionId: string;
            result: any;
            isSuccess: boolean;
            timestamp: string;
        }[], {
            id: string;
            actionId: string;
            result: any;
            isSuccess: boolean;
            timestamp: string;
        }[]>): _langchain_langgraph.BinaryOperatorAggregate<{
            id: string;
            actionId: string;
            result: any;
            isSuccess: boolean;
            timestamp: string;
        }[], {
            id: string;
            actionId: string;
            result: any;
            isSuccess: boolean;
            timestamp: string;
        }[]>;
        Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
    };
    currentThought: {
        (): _langchain_langgraph.LastValue<string>;
        (annotation: _langchain_langgraph.SingleReducer<string, string>): _langchain_langgraph.BinaryOperatorAggregate<string, string>;
        Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
    };
    currentAction: {
        (): _langchain_langgraph.LastValue<any>;
        (annotation: _langchain_langgraph.SingleReducer<any, any>): _langchain_langgraph.BinaryOperatorAggregate<any, any>;
        Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
    };
    currentObservation: {
        (): _langchain_langgraph.LastValue<any>;
        (annotation: _langchain_langgraph.SingleReducer<any, any>): _langchain_langgraph.BinaryOperatorAggregate<any, any>;
        Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
    };
    isComplete: {
        (): _langchain_langgraph.LastValue<boolean>;
        (annotation: _langchain_langgraph.SingleReducer<boolean, boolean>): _langchain_langgraph.BinaryOperatorAggregate<boolean, boolean>;
        Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
    };
    needsMoreThinking: {
        (): _langchain_langgraph.LastValue<boolean>;
        (annotation: _langchain_langgraph.SingleReducer<boolean, boolean>): _langchain_langgraph.BinaryOperatorAggregate<boolean, boolean>;
        Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
    };
    maxIterations: {
        (): _langchain_langgraph.LastValue<number>;
        (annotation: _langchain_langgraph.SingleReducer<number, number>): _langchain_langgraph.BinaryOperatorAggregate<number, number>;
        Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
    };
    currentIteration: {
        (): _langchain_langgraph.LastValue<number>;
        (annotation: _langchain_langgraph.SingleReducer<number, number>): _langchain_langgraph.BinaryOperatorAggregate<number, number>;
        Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
    };
    finalAnswer: {
        (): _langchain_langgraph.LastValue<string>;
        (annotation: _langchain_langgraph.SingleReducer<string, string>): _langchain_langgraph.BinaryOperatorAggregate<string, string>;
        Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
    };
    errors: {
        (): _langchain_langgraph.LastValue<string[]>;
        (annotation: _langchain_langgraph.SingleReducer<string[], string[]>): _langchain_langgraph.BinaryOperatorAggregate<string[], string[]>;
        Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
    };
    availableAgents: {
        (): _langchain_langgraph.LastValue<{
            agentId: string;
            agentType: string;
            capabilities: string[];
            description: string;
        }[]>;
        (annotation: _langchain_langgraph.SingleReducer<{
            agentId: string;
            agentType: string;
            capabilities: string[];
            description: string;
        }[], {
            agentId: string;
            agentType: string;
            capabilities: string[];
            description: string;
        }[]>): _langchain_langgraph.BinaryOperatorAggregate<{
            agentId: string;
            agentType: string;
            capabilities: string[];
            description: string;
        }[], {
            agentId: string;
            agentType: string;
            capabilities: string[];
            description: string;
        }[]>;
        Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
    };
    metadata: {
        (): _langchain_langgraph.LastValue<Record<string, any>>;
        (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
        Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
    };
}>;
type ReActStateType = typeof ReActState.State;

interface IndependentExpertConfig {
    agentType: 'analyst' | 'architect' | 'coder' | 'checker';
    grpcPort: number;
    grpcAddress?: string;
    llm: any;
    agentConfig?: Partial<SpecialistAgentConfig>;
    prompts?: {
        systemPrompt: string;
        taskPrompt: string;
    };
}
declare const createIndependentExpertAgent: (config: IndependentExpertConfig) => {
    agentType: "analyst" | "architect" | "coder" | "checker";
    expertAgentCore: AgentCore;
    expertServer: {
        server: _grpc_grpc_js.Server;
        listen: (port: number, address?: string) => Promise<void>;
        close: () => Promise<void>;
    };
    specialistCore: {
        start: () => Promise<void>;
        stop: () => Promise<void>;
        getStatus: () => {
            agentId: string;
            agentType: "analyst" | "architect" | "coder" | "checker";
            port: number;
            capabilities: string[];
            memoryStats: MemoryStats;
            toolStats: ToolExecutionStats;
        };
        getComponents: () => {
            agentCore: AgentCore;
            a2aServer: {
                server: _grpc_grpc_js.Server;
                listen: (port: number, address?: string) => Promise<void>;
                close: () => Promise<void>;
            };
            toolLayer: {
                initialize: () => Promise<void>;
                registerLocalTool: (name: string, definition: ToolDefinition, handler: LocalToolHandler) => void;
                callTool: (toolName: string, args: Record<string, any>, context?: ToolCallContext) => Promise<ToolExecutionResult>;
                getAllTools: () => ToolDefinition[];
                searchTools: (query: string) => ToolDefinition[];
                getExecutionStats: () => ToolExecutionStats;
                healthCheck: () => Promise<{
                    status: "healthy" | "degraded" | "unhealthy";
                    details: {
                        localTools: number;
                        mcpTools: number;
                        mcpServers: any;
                        activeCalls: number;
                        totalCalls: number;
                        successRate: number;
                    };
                }>;
                cleanup: () => void;
                getProtocolBridge: () => {
                    initialize: () => Promise<void>;
                    createMCPEnabledAgentCore: (baseAgentCore: Partial<AgentCore>) => AgentCore;
                    getAvailableTools: () => (MCPTool & {
                        serverName: string;
                    })[];
                    searchTools: (query: string) => (MCPTool & {
                        serverName: string;
                    })[];
                    healthCheck: () => Promise<Record<string, boolean>>;
                    getStats: () => {
                        mcpServers: number;
                        totalTools: number;
                        cacheSize: number;
                        cacheEnabled: boolean;
                        toolsByServer: {
                            name: string;
                            toolCount: number;
                            isConnected: any;
                        }[];
                    };
                    clearCache: () => void;
                };
            };
            memoryManager: {
                initialize: () => void;
                createSession: (agentId: string, userId?: string, metadata?: Record<string, any>) => string;
                getSession: (sessionId: string) => SessionState | null;
                storeMemoryItem: (sessionId: string, type: MemoryItem["type"], data: any, options?: {
                    ttl?: number;
                    metadata?: Record<string, any>;
                }) => Promise<string>;
                getMemoryItem: (itemId: string) => Promise<any | null>;
                getSessionMemoryItems: (sessionId: string, type?: MemoryItem["type"]) => MemoryItem[];
                deleteMemoryItem: (itemId: string) => boolean;
                updateMemoryItem: (itemId: string, newData: any) => Promise<boolean>;
                clearSession: (sessionId: string) => boolean;
                getMemoryStats: () => MemoryStats;
                getCheckpointManager: () => {
                    saveCheckpoint: (sessionId: string, checkpoint: any) => Promise<string>;
                    getCheckpoint: (checkpointId: string) => Promise<any>;
                    listCheckpoints: (sessionId: string) => Array<{
                        id: string;
                        timestamp: string;
                    }>;
                    deleteCheckpoint: (checkpointId: string) => boolean;
                };
                getMemorySaver: () => _langchain_langgraph.MemorySaver;
                exportSessionData: (sessionId: string) => Promise<any>;
                importSessionData: (exportedData: any) => Promise<string>;
                shutdown: () => void;
            };
            reactFramework: {
                execute: (input: string, goal?: string, config?: {
                    thread_id?: string;
                }) => Promise<ReActStateType>;
                executeStream: (input: string, goal?: string, config?: {
                    thread_id?: string;
                }) => AsyncGenerator<{
                    step: string;
                    state: Partial<ReActStateType>;
                }, void, unknown>;
            };
            workflow: _langchain_langgraph.CompiledStateGraph<_langchain_langgraph.StateType<{
                agentType: {
                    (): _langchain_langgraph.LastValue<"analyst" | "architect" | "coder" | "checker">;
                    (annotation: _langchain_langgraph.SingleReducer<"analyst" | "architect" | "coder" | "checker", "analyst" | "architect" | "coder" | "checker">): _langchain_langgraph.BinaryOperatorAggregate<"analyst" | "architect" | "coder" | "checker", "analyst" | "architect" | "coder" | "checker">;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                agentId: {
                    (): _langchain_langgraph.LastValue<string>;
                    (annotation: _langchain_langgraph.SingleReducer<string, string>): _langchain_langgraph.BinaryOperatorAggregate<string, string>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                sessionId: {
                    (): _langchain_langgraph.LastValue<string>;
                    (annotation: _langchain_langgraph.SingleReducer<string, string>): _langchain_langgraph.BinaryOperatorAggregate<string, string>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                currentTask: {
                    (): _langchain_langgraph.LastValue<Task>;
                    (annotation: _langchain_langgraph.SingleReducer<Task, Task>): _langchain_langgraph.BinaryOperatorAggregate<Task, Task>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                taskContext: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                analysisResults: {
                    (): _langchain_langgraph.LastValue<any>;
                    (annotation: _langchain_langgraph.SingleReducer<any, any>): _langchain_langgraph.BinaryOperatorAggregate<any, any>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                workingMemory: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                generatedArtifacts: {
                    (): _langchain_langgraph.LastValue<{
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[]>;
                    (annotation: _langchain_langgraph.SingleReducer<{
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[], {
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[]>): _langchain_langgraph.BinaryOperatorAggregate<{
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[], {
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[]>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                collaborationData: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                sharedContext: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                isComplete: {
                    (): _langchain_langgraph.LastValue<boolean>;
                    (annotation: _langchain_langgraph.SingleReducer<boolean, boolean>): _langchain_langgraph.BinaryOperatorAggregate<boolean, boolean>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                needsCollaboration: {
                    (): _langchain_langgraph.LastValue<boolean>;
                    (annotation: _langchain_langgraph.SingleReducer<boolean, boolean>): _langchain_langgraph.BinaryOperatorAggregate<boolean, boolean>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                errors: {
                    (): _langchain_langgraph.LastValue<string[]>;
                    (annotation: _langchain_langgraph.SingleReducer<string[], string[]>): _langchain_langgraph.BinaryOperatorAggregate<string[], string[]>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                metadata: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
            }>, _langchain_langgraph.UpdateType<{
                agentType: {
                    (): _langchain_langgraph.LastValue<"analyst" | "architect" | "coder" | "checker">;
                    (annotation: _langchain_langgraph.SingleReducer<"analyst" | "architect" | "coder" | "checker", "analyst" | "architect" | "coder" | "checker">): _langchain_langgraph.BinaryOperatorAggregate<"analyst" | "architect" | "coder" | "checker", "analyst" | "architect" | "coder" | "checker">;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                agentId: {
                    (): _langchain_langgraph.LastValue<string>;
                    (annotation: _langchain_langgraph.SingleReducer<string, string>): _langchain_langgraph.BinaryOperatorAggregate<string, string>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                sessionId: {
                    (): _langchain_langgraph.LastValue<string>;
                    (annotation: _langchain_langgraph.SingleReducer<string, string>): _langchain_langgraph.BinaryOperatorAggregate<string, string>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                currentTask: {
                    (): _langchain_langgraph.LastValue<Task>;
                    (annotation: _langchain_langgraph.SingleReducer<Task, Task>): _langchain_langgraph.BinaryOperatorAggregate<Task, Task>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                taskContext: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                analysisResults: {
                    (): _langchain_langgraph.LastValue<any>;
                    (annotation: _langchain_langgraph.SingleReducer<any, any>): _langchain_langgraph.BinaryOperatorAggregate<any, any>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                workingMemory: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                generatedArtifacts: {
                    (): _langchain_langgraph.LastValue<{
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[]>;
                    (annotation: _langchain_langgraph.SingleReducer<{
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[], {
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[]>): _langchain_langgraph.BinaryOperatorAggregate<{
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[], {
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[]>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                collaborationData: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                sharedContext: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                isComplete: {
                    (): _langchain_langgraph.LastValue<boolean>;
                    (annotation: _langchain_langgraph.SingleReducer<boolean, boolean>): _langchain_langgraph.BinaryOperatorAggregate<boolean, boolean>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                needsCollaboration: {
                    (): _langchain_langgraph.LastValue<boolean>;
                    (annotation: _langchain_langgraph.SingleReducer<boolean, boolean>): _langchain_langgraph.BinaryOperatorAggregate<boolean, boolean>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                errors: {
                    (): _langchain_langgraph.LastValue<string[]>;
                    (annotation: _langchain_langgraph.SingleReducer<string[], string[]>): _langchain_langgraph.BinaryOperatorAggregate<string[], string[]>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                metadata: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
            }>, "__start__" | "analyze_task" | "perform_work" | "finalize", {
                agentType: {
                    (): _langchain_langgraph.LastValue<"analyst" | "architect" | "coder" | "checker">;
                    (annotation: _langchain_langgraph.SingleReducer<"analyst" | "architect" | "coder" | "checker", "analyst" | "architect" | "coder" | "checker">): _langchain_langgraph.BinaryOperatorAggregate<"analyst" | "architect" | "coder" | "checker", "analyst" | "architect" | "coder" | "checker">;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                agentId: {
                    (): _langchain_langgraph.LastValue<string>;
                    (annotation: _langchain_langgraph.SingleReducer<string, string>): _langchain_langgraph.BinaryOperatorAggregate<string, string>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                sessionId: {
                    (): _langchain_langgraph.LastValue<string>;
                    (annotation: _langchain_langgraph.SingleReducer<string, string>): _langchain_langgraph.BinaryOperatorAggregate<string, string>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                currentTask: {
                    (): _langchain_langgraph.LastValue<Task>;
                    (annotation: _langchain_langgraph.SingleReducer<Task, Task>): _langchain_langgraph.BinaryOperatorAggregate<Task, Task>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                taskContext: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                analysisResults: {
                    (): _langchain_langgraph.LastValue<any>;
                    (annotation: _langchain_langgraph.SingleReducer<any, any>): _langchain_langgraph.BinaryOperatorAggregate<any, any>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                workingMemory: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                generatedArtifacts: {
                    (): _langchain_langgraph.LastValue<{
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[]>;
                    (annotation: _langchain_langgraph.SingleReducer<{
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[], {
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[]>): _langchain_langgraph.BinaryOperatorAggregate<{
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[], {
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[]>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                collaborationData: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                sharedContext: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                isComplete: {
                    (): _langchain_langgraph.LastValue<boolean>;
                    (annotation: _langchain_langgraph.SingleReducer<boolean, boolean>): _langchain_langgraph.BinaryOperatorAggregate<boolean, boolean>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                needsCollaboration: {
                    (): _langchain_langgraph.LastValue<boolean>;
                    (annotation: _langchain_langgraph.SingleReducer<boolean, boolean>): _langchain_langgraph.BinaryOperatorAggregate<boolean, boolean>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                errors: {
                    (): _langchain_langgraph.LastValue<string[]>;
                    (annotation: _langchain_langgraph.SingleReducer<string[], string[]>): _langchain_langgraph.BinaryOperatorAggregate<string[], string[]>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                metadata: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
            }, {
                agentType: {
                    (): _langchain_langgraph.LastValue<"analyst" | "architect" | "coder" | "checker">;
                    (annotation: _langchain_langgraph.SingleReducer<"analyst" | "architect" | "coder" | "checker", "analyst" | "architect" | "coder" | "checker">): _langchain_langgraph.BinaryOperatorAggregate<"analyst" | "architect" | "coder" | "checker", "analyst" | "architect" | "coder" | "checker">;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                agentId: {
                    (): _langchain_langgraph.LastValue<string>;
                    (annotation: _langchain_langgraph.SingleReducer<string, string>): _langchain_langgraph.BinaryOperatorAggregate<string, string>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                sessionId: {
                    (): _langchain_langgraph.LastValue<string>;
                    (annotation: _langchain_langgraph.SingleReducer<string, string>): _langchain_langgraph.BinaryOperatorAggregate<string, string>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                currentTask: {
                    (): _langchain_langgraph.LastValue<Task>;
                    (annotation: _langchain_langgraph.SingleReducer<Task, Task>): _langchain_langgraph.BinaryOperatorAggregate<Task, Task>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                taskContext: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                analysisResults: {
                    (): _langchain_langgraph.LastValue<any>;
                    (annotation: _langchain_langgraph.SingleReducer<any, any>): _langchain_langgraph.BinaryOperatorAggregate<any, any>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                workingMemory: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                generatedArtifacts: {
                    (): _langchain_langgraph.LastValue<{
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[]>;
                    (annotation: _langchain_langgraph.SingleReducer<{
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[], {
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[]>): _langchain_langgraph.BinaryOperatorAggregate<{
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[], {
                        id: string;
                        type: string;
                        name: string;
                        content: string;
                        metadata: Record<string, any>;
                    }[]>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                collaborationData: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                sharedContext: {
                    (): _langchain_langgraph.LastValue<Record<string, any>>;
                    (annotation: _langchain_langgraph.SingleReducer<Record<string, any>, Record<string, any>>): _langchain_langgraph.BinaryOperatorAggregate<Record<string, any>, Record<string, any>>;
                    Root: <S extends _langchain_langgraph.StateDefinition>(sd: S) => _langchain_langgraph.AnnotationRoot<S>;
                };
                isComplete: {
                    (): _langchain_langgra